1.0.107

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@gitea.lossless.digital/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @shipzone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @gitzone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitignore

@@ -15,8 +15,6 @@ node_modules/
 
 # builds
 dist/
-dist_web/
+dist_*/
-dist_serve/
-dist_ts_web/
 
 # custom

.gitlab-ci.yml

@@ -1,126 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-# ====================
-# security stage
-# ====================
-mirror:
-  stage: security
-  script:
-    - npmci git mirror
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-snyk:
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install -g snyk
-    - npmci command npm install --ignore-scripts
-    - npmci command snyk test
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - lossless
-    - docker
-    - priv
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  script:
-    - npmci command npm install -g tslint typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install lts
-    - npmci command npm install -g @gitzone/tsdoc
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command tsdoc
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true

.snyk

@@ -1,4 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.5
-ignore: {}
-patch: {}

.vscode/launch.json

@@ -2,28 +2,10 @@
   "version": "0.2.0",
   "configurations": [
     {
-      "name": "current file",
+      "command": "npm test",
-      "type": "node",
+      "name": "Run npm test",
       "request": "launch",
-      "args": [
+      "type": "node-terminal"
-        "${relativeFile}"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
-    },
-    {
-      "name": "test.ts",
-      "type": "node",
-      "request": "launch",
-      "args": [
-        "test/test.ts"
-      ],
-      "runtimeArgs": ["-r", "@gitzone/tsrun"],
-      "cwd": "${workspaceRoot}",
-      "protocol": "inspector",
-      "internalConsoleOptions": "openOnSessionStart"
     }
   ]
 }

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

npmextra.json

@@ -1,11 +1,12 @@
 {
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
-      "gitscope": "pushrocks",
+      "gitscope": "push.rocks",
       "gitrepo": "smartuniverse",
-      "shortDescription": "messaging service for micro services",
+      "description": "messaging service for micro services",
-      "npmPackagename": "@pushrocks/smartuniverse",
+      "npmPackagename": "@push.rocks/smartuniverse",
       "license": "MIT",
       "projectDomain": "push.rocks"
     }

package.json

@@ -1,53 +1,55 @@
 {
-  "name": "@pushrocks/smartuniverse",
+  "name": "@push.rocks/smartuniverse",
-  "version": "1.0.96",
+  "version": "1.0.107",
   "private": false,
   "description": "messaging service for your micro services",
-  "main": "dist/index.js",
+  "main": "dist_ts/index.js",
-  "typings": "dist/index.d.ts",
+  "typings": "dist_ts/index.d.ts",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
     "test": "(tstest test/)",
     "testManual": "(tsrun test/test.ts)",
-    "build": "(tsbuild)",
+    "build": "(tsbuild --allowimplicitany && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)",
-    "format": "(gitzone format)"
+    "format": "(gitzone format)",
+    "buildDocs": "tsdoc"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.17",
+    "@gitzone/tsbuild": "^2.1.66",
-    "@gitzone/tstest": "^1.0.28",
+    "@gitzone/tsbundle": "^2.0.8",
-    "@pushrocks/tapbundle": "^3.0.13",
+    "@gitzone/tsrun": "^1.2.44",
-    "@types/node": "^12.12.7",
+    "@gitzone/tstest": "^1.0.77",
-    "tslint": "^5.20.1",
+    "@push.rocks/tapbundle": "^5.0.12",
-    "tslint-config-prettier": "^1.18.0"
+    "@types/node": "^20.4.4"
-  },
-  "peerDependencies": {
-    "rxjs": "*"
   },
   "dependencies": {
-    "@apiglobal/typedrequest-interfaces": "^1.0.7",
+    "@apiglobal/typedrequest-interfaces": "^2.0.1",
-    "@pushrocks/lik": "^3.0.11",
+    "@apiglobal/typedserver": "^2.0.65",
-    "@pushrocks/smartdelay": "^2.0.6",
+    "@push.rocks/isohash": "^2.0.1",
-    "@pushrocks/smartexpress": "^3.0.52",
+    "@push.rocks/isounique": "^1.0.5",
-    "@pushrocks/smartfile": "^7.0.6",
+    "@push.rocks/lik": "^6.0.3",
-    "@pushrocks/smarthash": "^2.0.6",
+    "@push.rocks/smartdelay": "^3.0.5",
-    "@pushrocks/smartlog": "^2.0.21",
+    "@push.rocks/smartlog": "^3.0.3",
-    "@pushrocks/smartpromise": "^3.0.6",
+    "@push.rocks/smartpromise": "^4.0.2",
-    "@pushrocks/smartrequest": "^1.1.42",
+    "@push.rocks/smartrx": "^3.0.6",
-    "@pushrocks/smartrx": "^2.0.5",
+    "@push.rocks/smartsocket": "^2.0.20",
-    "@pushrocks/smartsocket": "^1.1.58",
+    "@push.rocks/smarttime": "^4.0.4",
-    "@pushrocks/smarttime": "^3.0.12",
+    "@push.rocks/smarturl": "^3.0.7"
-    "@pushrocks/smartunique": "^3.0.1"
   },
   "files": [
     "ts/**/*",
     "ts_web/**/*",
     "dist/**/*",
-    "dist_web/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
     "npmextra.json",
     "readme.md"
-  ]
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "type": "module"
 }

readme.md

@@ -1,20 +1,26 @@
-# @pushrocks/smartuniverse
+# @push.rocks/smartuniverse
 messaging service for micro services
 
 ## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartuniverse)
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@push.rocks/smartuniverse)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/smartuniverse)
+* [gitlab.com (source)](https://gitlab.com/push.rocks/smartuniverse)
-* [github.com (source mirror)](https://github.com/pushrocks/smartuniverse)
+* [github.com (source mirror)](https://github.com/push.rocks/smartuniverse)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartuniverse/)
+* [docs (typedoc)](https://push.rocks.gitlab.io/smartuniverse/)
 
 ## Status for master
-[![build status](https://gitlab.com/pushrocks/smartuniverse/badges/master/build.svg)](https://gitlab.com/pushrocks/smartuniverse/commits/master)
+
-[![coverage report](https://gitlab.com/pushrocks/smartuniverse/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartuniverse/commits/master)
+Status Category | Status Badge
-[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartuniverse.svg)](https://www.npmjs.com/package/@pushrocks/smartuniverse)
+-- | --
-[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartuniverse/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartuniverse)
+GitLab Pipelines | [![pipeline status](https://gitlab.com/push.rocks/smartuniverse/badges/master/pipeline.svg)](https://lossless.cloud)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/smartuniverse/badges/master/coverage.svg)](https://lossless.cloud)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@push.rocks/smartuniverse)](https://lossless.cloud)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/push.rocks/smartuniverse)](https://lossless.cloud)
+TypeScript Support | [![TypeScript](https://badgen.net/badge/TypeScript/>=%203.x/blue?icon=typescript)](https://lossless.cloud)
+node Support | [![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+Code Style | [![Code Style](https://badgen.net/badge/style/prettier/purple)](https://lossless.cloud)
+PackagePhobia (total standalone install weight) | [![PackagePhobia](https://badgen.net/packagephobia/install/@push.rocks/smartuniverse)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@push.rocks/smartuniverse)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@push.rocks/smartuniverse)](https://lossless.cloud)
 
 ## Usage
 
@@ -33,7 +39,7 @@ Think Kafka, but without Kafka.
 import * as smartuniverse from '@pushrocks/smartuniverse';
 
 const myUniverse = new smartuniverse.Universe({
-  messageExpiryInMilliseconds: 60000 // the standard time in milliseconds until a message expires
+  messageExpiryInMilliseconds: 60000, // the standard time in milliseconds until a message expires
 });
 
 // create as many channels as you like
@@ -53,7 +59,6 @@ We are always happy for code contributions. If you are not the code contributing
 
 For further information read the linked docs at the top of this readme.
 
-> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+## Legal
+> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
 | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
-
-[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.ts

@@ -1,8 +1,6 @@
 // tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
+import { expect, tap } from '@push.rocks/tapbundle';
-import * as smartuniverse from '../ts/index';
+import * as smartuniverse from '../ts/index.js';
-
-import { Observable } from 'rxjs';
 
 let testUniverse: smartuniverse.Universe;
 let testClientUniverse: smartuniverse.ClientUniverse;
@@ -10,17 +8,17 @@ let testClientUniverse2: smartuniverse.ClientUniverse;
 let testClientChannel: smartuniverse.ClientUniverseChannel;
 
 const testServerData = {
-  serverAddress: 'http://localhost:8765'
+  serverAddress: 'http://localhost:8765',
 };
 
 const testChannelData = {
   channelName: 'awesomeTestChannel',
-  channelPass: 'awesomeChannelPass'
+  channelPass: 'awesomeChannelPass',
 };
 
 tap.test('first test', async () => {
   testUniverse = new smartuniverse.Universe({
-    messageExpiryInMilliseconds: 1000
+    messageExpiryInMilliseconds: 1000,
   });
 });
 
@@ -32,9 +30,9 @@ tap.test('add a message to the SmartUniverse', async () => {
 tap.test('create smartuniverse client', async () => {
   testClientUniverse = new smartuniverse.ClientUniverse({
     serverAddress: testServerData.serverAddress,
-    autoReconnect: true
+    autoReconnect: true,
   });
-  expect(testClientUniverse).to.be.instanceof(smartuniverse.ClientUniverse);
+  expect(testClientUniverse).toBeInstanceOf(smartuniverse.ClientUniverse);
 });
 
 tap.test('should add a channel to the universe', async () => {
@@ -51,41 +49,41 @@ tap.test('should start the ClientUniverse', async () => {
 
 tap.test('should get a observable correctly', async () => {
   testClientChannel = testClientUniverse.getChannel(testChannelData.channelName);
-  expect(testClientChannel).to.be.instanceof(smartuniverse.ClientUniverseChannel);
+  expect(testClientChannel).toBeInstanceOf(smartuniverse.ClientUniverseChannel);
 });
 
 tap.test('should send a message correctly', async () => {
-  await testClientUniverse.getChannel(testChannelData.channelName).sendMessage({
+  await testClientUniverse.getChannel(testChannelData.channelName).postMessage({
-    messageText: 'hello'
+    messageText: 'hello',
   });
 });
 
 tap.test('universe should contain the sent message', async () => {
-  expect(testUniverse.universeCache.messageMap.getArray()[0].messageText).to.equal('hello');
+  expect(testUniverse.universeCache.messageMap.getArray()[0].messageText).toEqual('hello');
 });
 
 tap.test('a second client should be able to subscibe', async () => {
   testClientUniverse2 = new smartuniverse.ClientUniverse({
     serverAddress: testServerData.serverAddress,
-    autoReconnect: true
+    autoReconnect: true,
   });
 
   testClientUniverse2.addChannel(testChannelData.channelName, testChannelData.channelPass);
   await testClientUniverse2.start();
 });
 
-tap.test('should receive a message correctly', async tools => {
+tap.test('should receive a message correctly', async (tools) => {
   const done = tools.defer();
   const testChannel = testClientUniverse.getChannel(testChannelData.channelName);
   const testChannel2 = testClientUniverse2.getChannel(testChannelData.channelName);
-  const subscription = testChannel2.subscribe(messageArg => {
+  const subscription = testChannel2.subscribe((messageArg) => {
     if (messageArg.messageText === 'hellothere') {
       console.log('Yay##########');
       done.resolve();
     }
   });
-  await testChannel.sendMessage({
+  await testChannel.postMessage({
-    messageText: 'hellothere'
+    messageText: 'hellothere',
   });
   await done.promise;
 });
@@ -103,33 +101,33 @@ interface IDemoReqRes {
 tap.test('ReactionRequest and ReactionResponse should work', async () => {
   const reactionResponse = new smartuniverse.ReactionResponse<IDemoReqRes>({
     channels: [testUniverse.getChannel(testChannelData.channelName)],
-    funcDef: async reqData => {
+    funcDef: async (reqData) => {
       console.log(reqData);
       return {
-        hereso: 'Hello there'
+        hereso: 'Hello there',
       };
     },
-    method: 'demo'
+    method: 'demo',
   });
   const reactionRequest = new smartuniverse.ReactionRequest<IDemoReqRes>({
-    method: 'demo'
+    method: 'demo',
   });
   const reactionResult = await reactionRequest.fire(
     [testClientUniverse2.getChannel(testChannelData.channelName)],
     {
-      wowso: 'wowza'
+      wowso: 'wowza',
     }
   );
   const result = await reactionResult.getFirstResult();
   console.log(result);
 });
 
-tap.test('should disconnect the client correctly', async tools => {
+tap.test('should disconnect the client correctly', async (tools) => {
   await testClientUniverse.stop();
   await testClientUniverse2.stop();
 });
 
-tap.test('should end the server correctly', async tools => {
+tap.test('should end the server correctly', async (tools) => {
   await testUniverse.stopServer();
 });
 

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/smartuniverse',
+  version: '1.0.107',
+  description: 'messaging service for your micro services'
+}

ts/index.ts

@@ -1,16 +1,16 @@
 // Client classes
-export * from './smartuniverse.classes.clientuniverse';
+export * from './smartuniverse.classes.client.universe.js';
-export * from './smartuniverse.classes.clientuniversechannel';
+export * from './smartuniverse.classes.client.universechannel.js';
-export * from './smartuniverse.classes.clientuniversemessage';
+export * from './smartuniverse.classes.client.universemessage.js';
 
 // Server classes
-export * from './smartuniverse.classes.universe';
+export * from './smartuniverse.classes.universe.js';
-export * from './smartuniverse.classes.universecache';
+export * from './smartuniverse.classes.universecache.js';
-export * from './smartuniverse.classes.universechannel';
+export * from './smartuniverse.classes.universechannel.js';
-export * from './smartuniverse.classes.universemessage';
+export * from './smartuniverse.classes.universemessage.js';
 
 // Reaction Response
-export * from './smartuniverse.classes.reactionrequest';
+export * from './smartuniverse.classes.event.reactionrequest.js';
-export * from './smartuniverse.classes.reactionresponse';
+export * from './smartuniverse.classes.event.reactionresponse.js';
 
-export * from './interfaces';
+export * from './interfaces/index.js';

ts/interfaces/index.ts

@@ -1,5 +1,5 @@
-export * from './http.interfaces';
+export * from './http.interfaces.js';
-export * from './socketfunctionrequests';
+export * from './socketfunctionrequests.js';
-export * from './universechannel.interfaces';
+export * from './universechannel.interfaces.js';
-export * from './universemessage.interfaces';
+export * from './universemessage.interfaces.js';
-export * from './universeactions.interfaces';
+export * from './universeactions.interfaces.js';

ts/interfaces/socketfunctionrequests.ts

@@ -1,4 +1,4 @@
-import * as interfaces from './index';
+import * as interfaces from './index.js';
 
 export interface ISocketRequest_SubscribeChannel {
   method: 'subscribeChannel';

ts/smartuniverse.classes.broadcastevent.ts

@@ -1,8 +0,0 @@
-import * as plugins from './smartuniverse.plugins';
-
-/**
- * broadcasts an event to multiple channels
- */
-export class BroadcastEvent<T> {
-  fire() {}
-}

ts/smartuniverse.classes.broadcastsubscription.ts

@@ -1,5 +0,0 @@
-import * as plugins from './smartuniverse.plugins';
-
-export class BroadcastSubscription {
-  
-}

ts/smartuniverse.classes.client.universe.ts

@@ -1,14 +1,11 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
+import { Smartsocket, SmartsocketClient } from '@push.rocks/smartsocket';
 
-import { Objectmap } from '@pushrocks/lik';
+import * as interfaces from './interfaces/index.js';
-import { Observable } from 'rxjs';
-import { Smartsocket, SmartsocketClient } from '@pushrocks/smartsocket';
-import * as url from 'url';
 
-import * as interfaces from './interfaces';
+import { ClientUniverseChannel, ClientUniverseMessage } from './index.js';
-
+import { ClientUniverseCache } from './smartuniverse.classes.client.universecache.js';
-import { ClientUniverseChannel, ClientUniverseMessage } from './';
+import { logger } from './smartuniverse.logging.js';
-import { ClientUniverseCache } from './smartuniverse.classes.clientuniversecache';
 
 export interface IClientOptions {
   serverAddress: string;
@@ -25,6 +22,8 @@ export class ClientUniverse {
   public messageRxjsSubject = new plugins.smartrx.rxjs.Subject<ClientUniverseMessage<any>>();
   public clientUniverseCache = new ClientUniverseCache();
 
+  public autoReconnectStatus: 'on' | 'off' = 'off';
+
   constructor(optionsArg: IClientOptions) {
     this.options = optionsArg;
   }
@@ -55,7 +54,7 @@ export class ClientUniverse {
    * @param passphraseArg
    */
   public getChannel(channelName: string): ClientUniverseChannel {
-    const clientUniverseChannel = this.clientUniverseCache.channelMap.find(channel => {
+    const clientUniverseChannel = this.clientUniverseCache.channelMap.findSync((channel) => {
       return channel.name === channelName;
     });
     return clientUniverseChannel;
@@ -66,18 +65,22 @@ export class ClientUniverse {
    * @param messageArg
    */
   public removeChannel(channelNameArg, notifyServer = true) {
-    const clientUniverseChannel = this.clientUniverseCache.channelMap.findOneAndRemove(
+    const clientUniverseChannel = this.clientUniverseCache.channelMap.findOneAndRemoveSync(
-      channelItemArg => {
+      (channelItemArg) => {
         return channelItemArg.name === channelNameArg;
       }
     );
   }
 
   public async start() {
+    if (this.options.autoReconnect) {
+      this.autoReconnectStatus = 'on';
+    }
     await this.checkConnection();
   }
 
   public async stop() {
+    this.autoReconnectStatus = 'off';
     await this.disconnect('triggered');
   }
 
@@ -85,19 +88,17 @@ export class ClientUniverse {
    * checks the connection towards a universe server
    * since password validation is done through other means, a connection should always be possible
    */
-  public async checkConnection(): Promise<void> {
+  private async checkConnection(): Promise<void> {
     if (!this.smartsocketClient) {
-      const parsedURL = url.parse(this.options.serverAddress);
+      const parsedURL = plugins.smarturl.Smarturl.createFromUrl(this.options.serverAddress);
       const socketConfig: plugins.smartsocket.ISmartsocketClientOptions = {
         alias: 'universeclient',
-        password: 'UniverseClient',
         port: parseInt(parsedURL.port, 10),
-        role: 'UniverseClient',
+        url: parsedURL.protocol + '//' + parsedURL.hostname,
-        url: parsedURL.protocol + '//' + parsedURL.hostname
       };
       this.smartsocketClient = new SmartsocketClient(socketConfig);
 
-      this.smartsocketClient.eventSubject.subscribe(async eventArg => {
+      this.smartsocketClient.eventSubject.subscribe(async (eventArg) => {
         switch (eventArg) {
           case 'disconnected':
             this.disconnect('upstreamEvent');
@@ -111,73 +112,75 @@ export class ClientUniverse {
        */
       const socketFunctionUnsubscribe = new plugins.smartsocket.SocketFunction({
         funcName: 'unsubscribe',
-        allowedRoles: [],
         funcDef: async (dataArg: interfaces.IServerUnsubscribeActionPayload) => {
-          const channel = this.clientUniverseCache.channelMap.find(channelArg => {
+          const channel = this.clientUniverseCache.channelMap.findSync((channelArg) => {
             return channelArg.name === dataArg.name;
           });
           if (channel) {
             channel.unsubscribe();
           }
           return {};
-        }
+        },
       });
 
       /**
        * handles message reception
        */
-      const socketFunctionProcessMessage = new plugins.smartsocket.SocketFunction<
+      const socketFunctionProcessMessage =
-        interfaces.ISocketRequest_ProcessMessage
+        new plugins.smartsocket.SocketFunction<interfaces.ISocketRequest_ProcessMessage>({
-      >({
+          funcName: 'processMessage',
-        funcName: 'processMessage',
+          funcDef: async (messageDescriptorArg) => {
-        allowedRoles: [],
+            logger.log('info', 'Got message from server');
-        funcDef: async messageDescriptorArg => {
+            const clientUniverseMessage =
-          plugins.smartlog.defaultLogger.log('info', 'Got message from server');
+              ClientUniverseMessage.createMessageFromMessageDescriptor(messageDescriptorArg);
-          const clientUniverseMessage = ClientUniverseMessage.createMessageFromMessageDescriptor(
+            this.messageRxjsSubject.next(clientUniverseMessage);
-            messageDescriptorArg
-          );
-          this.messageRxjsSubject.next(clientUniverseMessage);
 
-          // lets find the corresponding channel
+            // lets find the corresponding channel
-          const targetChannel = this.getChannel(clientUniverseMessage.targetChannelName);
+            const targetChannel = this.getChannel(clientUniverseMessage.targetChannelName);
-          if (targetChannel) {
+            if (targetChannel) {
-            await targetChannel.emitMessageLocally(clientUniverseMessage);
+              await targetChannel.emitMessageLocally(clientUniverseMessage);
-            return {
+              return {
-              messageStatus: 'ok'
+                messageStatus: 'ok',
-            };
+              };
-          } else {
+            } else {
-            return {
+              return {
-              messageStatus: 'channel not found'
+                messageStatus: 'channel not found',
-            };
+              };
-          }
+            }
-        }
+          },
-      });
+        });
 
       // add functions
       this.smartsocketClient.addSocketFunction(socketFunctionUnsubscribe);
       this.smartsocketClient.addSocketFunction(socketFunctionProcessMessage);
 
       await this.smartsocketClient.connect();
-      plugins.smartlog.defaultLogger.log('info', 'universe client connected successfully');
+      logger.log('info', 'universe client connected successfully');
-      await this.clientUniverseCache.channelMap.forEach(async clientUniverseChannelArg => {
+      await this.clientUniverseCache.channelMap.forEach(async (clientUniverseChannelArg) => {
         await clientUniverseChannelArg.populateSubscriptionToServer();
       });
     }
   }
 
-  public async disconnect(
+  private async disconnect(
     reason: 'upstreamEvent' | 'triggered' = 'triggered',
     tryReconnect = false
   ) {
-    if (reason === 'triggered') {
+    const instructDisconnect = async () => {
-      const smartsocketToDisconnect = this.smartsocketClient;
+      if (this.smartsocketClient) {
-      this.smartsocketClient = null; // making sure the upstreamEvent does  not interfere
+        const smartsocketToDisconnect = this.smartsocketClient;
-      await smartsocketToDisconnect.disconnect();
+        this.smartsocketClient = null; // making sure the upstreamEvent does  not interfere
+        await smartsocketToDisconnect.disconnect();
+      }
+    };
+
+    if (reason === 'triggered' && this.smartsocketClient) {
+      await instructDisconnect();
     }
-    if (this.options.autoReconnect && reason === 'upstreamEvent' && this.smartsocketClient) {
+    if (this.autoReconnectStatus === 'on' && reason === 'upstreamEvent') {
+      await instructDisconnect();
       await plugins.smartdelay.delayForRandom(5000, 20000);
-      this.smartsocketClient = null;
+      await this.checkConnection();
-      this.checkConnection();
     }
   }
 }

ts/smartuniverse.classes.client.universecache.ts

@@ -1,5 +1,5 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
-import { ClientUniverseChannel } from './smartuniverse.classes.clientuniversechannel';
+import { ClientUniverseChannel } from './smartuniverse.classes.client.universechannel.js';
 
 /**
  * a cache for clients
@@ -7,5 +7,5 @@ import { ClientUniverseChannel } from './smartuniverse.classes.clientuniversecha
  * good for deduplication in mesh environments
  */
 export class ClientUniverseCache {
-  public channelMap = new plugins.lik.Objectmap<ClientUniverseChannel>();
+  public channelMap = new plugins.lik.ObjectMap<ClientUniverseChannel>();
 }

ts/smartuniverse.classes.client.universechannel.ts

@@ -1,10 +1,10 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
 
-import { ClientUniverse } from './';
+import { ClientUniverse } from './index.js';
-import { ClientUniverseMessage } from './smartuniverse.classes.clientuniversemessage';
+import { ClientUniverseMessage } from './smartuniverse.classes.client.universemessage.js';
-import { ReactionRequest } from './smartuniverse.classes.reactionrequest';
+import { ReactionRequest } from './smartuniverse.classes.event.reactionrequest.js';
-import { ReactionResponse } from './smartuniverse.classes.reactionresponse';
+import { ReactionResponse } from './smartuniverse.classes.event.reactionresponse.js';
 
 export class ClientUniverseChannel implements interfaces.IUniverseChannel {
   // ======
@@ -55,10 +55,10 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
    */
   public subscribe(observingFunctionArg: (messageArg: ClientUniverseMessage<any>) => void) {
     return this.subject.subscribe(
-      messageArg => {
+      (messageArg) => {
         observingFunctionArg(messageArg);
       },
-      error => console.log(error)
+      (error) => console.log(error)
     );
   }
 
@@ -69,12 +69,14 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
   public async populateSubscriptionToServer() {
     // lets make sure the channel is connected
     if (this.status === 'unsubscribed') {
-      const response = await this.clientUniverseRef.smartsocketClient.serverCall<
+      const response =
-        interfaces.ISocketRequest_SubscribeChannel
+        await this.clientUniverseRef.smartsocketClient.serverCall<interfaces.ISocketRequest_SubscribeChannel>(
-      >('subscribeChannel', {
+          'subscribeChannel',
-        name: this.name,
+          {
-        passphrase: this.passphrase
+            name: this.name,
-      });
+            passphrase: this.passphrase,
+          }
+        );
       this.status = response.subscriptionStatus;
     }
   }
@@ -87,15 +89,15 @@ export class ClientUniverseChannel implements interfaces.IUniverseChannel {
    * sends a message towards the server
    * @param messageArg
    */
-  public async sendMessage(messageArg: interfaces.IMessageCreator) {
+  public async postMessage(messageArg: interfaces.IMessageCreator) {
-    await this.clientUniverseRef.checkConnection();
+    await this.clientUniverseRef.start(); // its ok to call this multiple times
     const universeMessageToSend: interfaces.IUniverseMessage = {
-      id: plugins.smartunique.shortId(),
+      id: plugins.isounique.uni(),
       timestamp: Date.now(),
       passphrase: this.passphrase,
       targetChannelName: this.name,
       messageText: messageArg.messageText,
-      payload: messageArg.payload
+      payload: messageArg.payload,
     };
     await this.clientUniverseRef.smartsocketClient.serverCall(
       'processMessage',

ts/smartuniverse.classes.client.universemessage.ts

@@ -1,6 +1,6 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
 
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
 
 export class ClientUniverseMessage<T> implements interfaces.IUniverseMessage {
   // ======

ts/smartuniverse.classes.event.broadcastevent.ts

@@ -0,0 +1,17 @@
+import * as plugins from './smartuniverse.plugins.js';
+
+/**
+ * broadcasts an event to multiple channels
+ * also handles subscription
+ */
+export class BroadcastEvent<T extends plugins.typedrequestInterfaces.ITypedEvent<any>> {
+  public eventSubject = new plugins.smartrx.rxjs.Subject<T['payload']>();
+
+  constructor() {}
+
+  public fire(eventPayloadArg: T['payload']) {}
+
+  public subscribe(funcArg: (nextArg: T['payload']) => void): plugins.smartrx.rxjs.Subscription {
+    return this.eventSubject.subscribe(funcArg);
+  }
+}

ts/smartuniverse.classes.event.reactionrequest.ts

@@ -1,9 +1,9 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
-import { ClientUniverseChannel } from './smartuniverse.classes.clientuniversechannel';
+import { ClientUniverseChannel } from './smartuniverse.classes.client.universechannel.js';
-import { ReactionResult } from './smartuniverse.classes.reactionresult';
+import { ReactionResult } from './smartuniverse.classes.event.reactionresult.js';
-import { UniverseMessage } from './smartuniverse.classes.universemessage';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';
-import { ClientUniverseMessage } from './smartuniverse.classes.clientuniversemessage';
+import { ClientUniverseMessage } from './smartuniverse.classes.client.universemessage.js';
 
 export interface IReactionRequestConstructorOptions<
   T extends plugins.typedrequestInterfaces.ITypedRequest
@@ -35,9 +35,9 @@ export class ReactionRequest<T extends plugins.typedrequestInterfaces.ITypedRequ
     requestDataArg: T['request'],
     timeoutMillisArg = 5000
   ) {
-    const subscriptionMap = new plugins.lik.Objectmap<plugins.smartrx.rxjs.Subscription>();
+    const subscriptionMap = new plugins.lik.ObjectMap<plugins.smartrx.rxjs.Subscription>();
     const reactionResult = new ReactionResult<T>();
-    const requestId = plugins.smartunique.shortId();
+    const requestId = plugins.isounique.uni();
     for (const channel of channelsArg) {
       subscriptionMap.add(
         channel.subscribe(
@@ -64,16 +64,16 @@ export class ReactionRequest<T extends plugins.typedrequestInterfaces.ITypedRequ
         typedRequestPayload: {
           method: this.method,
           request: requestDataArg,
-          response: null
+          response: null,
-        }
+        },
       };
-      channel.sendMessage({
+      channel.postMessage({
         messageText: 'reactionRequest',
-        payload
+        payload,
       });
     }
     plugins.smartdelay.delayFor(timeoutMillisArg).then(async () => {
-      await subscriptionMap.forEach(subscriptionArg => {
+      await subscriptionMap.forEach((subscriptionArg) => {
         subscriptionArg.unsubscribe();
       });
       reactionResult.complete();

ts/smartuniverse.classes.event.reactionresponse.ts

@@ -1,10 +1,10 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
 
-import { ICombinatorPayload } from './smartuniverse.classes.reactionrequest';
+import { type ICombinatorPayload } from './smartuniverse.classes.event.reactionrequest.js';
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
-import { ClientUniverseChannel } from './smartuniverse.classes.clientuniversechannel';
+import { ClientUniverseChannel } from './smartuniverse.classes.client.universechannel.js';
-import { UniverseMessage } from './smartuniverse.classes.universemessage';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';
-import { ClientUniverseMessage } from './smartuniverse.classes.clientuniversemessage';
+import { ClientUniverseMessage } from './smartuniverse.classes.client.universemessage.js';
 
 export type TReactionResponseFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (
   dataArg: T['request']
@@ -20,7 +20,7 @@ export interface IReactionResponseConstructorOptions<
 
 export class ReactionResponse<T extends plugins.typedrequestInterfaces.ITypedRequest> {
   public method: T['method'];
-  public channels = new plugins.lik.Objectmap<UniverseChannel | ClientUniverseChannel>();
+  public channels = new plugins.lik.ObjectMap<UniverseChannel | ClientUniverseChannel>();
   public funcDef: TReactionResponseFuncDef<T>;
 
   constructor(optionsArg: IReactionResponseConstructorOptions<T>) {
@@ -28,7 +28,7 @@ export class ReactionResponse<T extends plugins.typedrequestInterfaces.ITypedReq
     this.channels.addArray(optionsArg.channels);
     this.funcDef = optionsArg.funcDef;
     for (const channel of this.channels.getArray()) {
-      channel.subscribe(messageArg => {
+      channel.subscribe((messageArg) => {
         this.processMessageForReaction(channel, messageArg);
       });
     }
@@ -51,12 +51,12 @@ export class ReactionResponse<T extends plugins.typedrequestInterfaces.ITypedReq
         ...messageArg.payload,
         typedRequestPayload: {
           ...messageArg.payload.typedRequestPayload,
-          response
+          response,
-        }
+        },
       };
-      channelArg.sendMessage({
+      channelArg.postMessage({
         messageText: 'reactionResponse',
-        payload
+        payload,
       });
     }
   }

ts/smartuniverse.classes.event.reactionresult.ts

@@ -1,5 +1,5 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
-import { ReactionResponse } from './smartuniverse.classes.reactionresponse';
+import { ReactionResponse } from './smartuniverse.classes.event.reactionresponse.js';
 
 export class ReactionResult<T extends plugins.typedrequestInterfaces.ITypedRequest> {
   private resultReplaySubject = new plugins.smartrx.rxjs.ReplaySubject<T['response']>();
@@ -7,7 +7,7 @@ export class ReactionResult<T extends plugins.typedrequestInterfaces.ITypedReque
   private completeDeferred = plugins.smartpromise.defer<Array<T['response']>>();
 
   constructor() {
-    this.resultSubscribe(responseArg => {
+    this.resultSubscribe((responseArg) => {
       this.endResult.push(responseArg);
     });
   }
@@ -29,7 +29,7 @@ export class ReactionResult<T extends plugins.typedrequestInterfaces.ITypedReque
    */
   public async getFirstResult() {
     const done = plugins.smartpromise.defer<T['response']>();
-    const subscription = this.resultReplaySubject.subscribe(result => {
+    const subscription = this.resultReplaySubject.subscribe((result) => {
       done.resolve(result);
       subscription.unsubscribe();
     });

ts/smartuniverse.classes.universe.ts

@@ -1,16 +1,15 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
+import * as pluginsTyped from './smartuniverse.pluginstyped.js';
 
-import { Handler, Route, Server } from '@pushrocks/smartexpress';
+import { UniverseCache, UniverseChannel, UniverseMessage } from './index.js';
-import { UniverseCache, UniverseChannel, UniverseMessage } from './';
 
-import * as paths from './smartuniverse.paths';
+import * as interfaces from './interfaces/index.js';
-
+import { UniverseConnection } from './smartuniverse.classes.universeconnection.js';
-import * as interfaces from './interfaces';
+import { logger } from './smartuniverse.logging.js';
-import { UniverseConnection } from './smartuniverse.classes.universeconnection';
 
 export interface ISmartUniverseConstructorOptions {
   messageExpiryInMilliseconds: number;
-  externalServer?: plugins.smartexpress.Server;
+  externalServer?: pluginsTyped.typedserver.servertools.Server;
 }
 
 /**
@@ -26,7 +25,7 @@ export class Universe {
   /**
    * the smartexpress server used
    */
-  private smartexpressServer: plugins.smartexpress.Server;
+  private server: pluginsTyped.typedserver.servertools.Server;
 
   /**
    * the smartsocket used
@@ -47,7 +46,7 @@ export class Universe {
   /**
    * get the currently running version of smartuniverse
    */
-  public getUniverseVersion() {
+  /* public getUniverseVersion() {
     if (this.universeVersionStore) {
       return this.universeVersionStore;
     } else {
@@ -55,7 +54,7 @@ export class Universe {
       this.universeVersionStore = packageJson.version;
       return this.universeVersionStore;
     }
-  }
+  } */
 
   /**
    * adds a channel to the Universe
@@ -69,7 +68,7 @@ export class Universe {
    * returns a channel
    */
   public getChannel(channelNameArg: string) {
-    return this.universeCache.channelMap.find(channelArg => {
+    return this.universeCache.channelMap.findSync((channelArg) => {
       return channelArg.name === channelNameArg;
     });
   }
@@ -77,77 +76,61 @@ export class Universe {
   /**
    * initiates a server
    */
-  public async start(portArg: number) {
+  public async start(portArg?: number) {
-    // lets create the base smartexpress server
+    if (!this.options.externalServer && !portArg) {
-    if (!this.options.externalServer) {
+      throw new Error(`You supplied an external error. You need to specify a portArg to start on.`);
-      this.smartexpressServer = new plugins.smartexpress.Server({
-        cors: true,
-        defaultAnswer: async () => {
-          return `smartuniverse server ${this.getUniverseVersion()}`;
-        },
-        forceSsl: false,
-        port: portArg
-      });
-    } else {
-      console.log('Universe is using externally supplied server');
-      this.smartexpressServer = this.options.externalServer;
     }
 
+    portArg = portArg || 3000; // TODO: remove
+
     // add websocket upgrade
-    this.smartsocket = new plugins.smartsocket.Smartsocket({});
+    this.smartsocket = new plugins.smartsocket.Smartsocket({
-
+      alias: 'smartuniverse',
-    // add a role for the clients
+      port: portArg,
-    const ClientRole = new plugins.smartsocket.SocketRole({
-      name: 'UniverseClient',
-      passwordHash: plugins.smarthash.sha256FromStringSync('UniverseClient') // authentication happens on another level
     });
 
-    // add the role to smartsocket
+    // lets create the base smartexpress server
-    this.smartsocket.addSocketRoles([ClientRole]);
+    if (this.options.externalServer) {
+      console.log('Universe is using externally supplied server');
+      this.smartsocket.setExternalServer('smartexpress', this.options.externalServer);
+    }
 
-    const socketFunctionSubscription = new plugins.smartsocket.SocketFunction<
-      interfaces.ISocketRequest_SubscribeChannel
-    >({
-      allowedRoles: [ClientRole], // there is only one client role, Authentication happens on another level
-      funcName: 'subscribeChannel',
-      funcDef: async (dataArg, socketConnectionArg) => {
-        const universeConnection = new UniverseConnection({
-          universe: this,
-          socketConnection: socketConnectionArg,
-          authenticationRequests: [dataArg]
-        });
-        await UniverseConnection.addConnectionToCache(this, universeConnection);
-        return {
-          subscriptionStatus: 'subscribed'
-        };
-      }
-    });
 
-    const socketFunctionProcessMessage = new plugins.smartsocket.SocketFunction({
+    const socketFunctionSubscription =
-      allowedRoles: [ClientRole], // there is only one client role, Authentication happens on another level
+      new plugins.smartsocket.SocketFunction<interfaces.ISocketRequest_SubscribeChannel>({
+        funcName: 'subscribeChannel',
+        funcDef: async (dataArg, socketConnectionArg) => {
+          const universeConnection = new UniverseConnection({
+            universe: this,
+            socketConnection: socketConnectionArg,
+            authenticationRequests: [dataArg],
+          });
+          await UniverseConnection.addConnectionToCache(this, universeConnection);
+          return {
+            subscriptionStatus: 'subscribed',
+          };
+        },
+      });
+
+    const socketFunctionProcessMessage = new plugins.smartsocket.SocketFunction<any>({
+      // TODO proper ITypedRequest here instead of any
       funcName: 'processMessage',
-      funcDef: async (dataArg: interfaces.IUniverseMessage, socketConnectionArg) => {
+      funcDef: async (messageDataArg: interfaces.IUniverseMessage, socketConnectionArg) => {
         const universeConnection = UniverseConnection.findUniverseConnectionBySocketConnection(
           this.universeCache,
           socketConnectionArg
         );
         if (universeConnection) {
-          plugins.smartlog.defaultLogger.log(
+          logger.log('ok', 'found UniverseConnection for socket for incoming message');
-            'ok',
-            'found UniverseConnection for socket for incoming message'
-          );
         } else {
-          plugins.smartlog.defaultLogger.log(
+          logger.log('warn', 'found no Authorized channel for incoming message');
-            'warn',
-            'found no Authorized channel for incoming message'
-          );
           return {
-            error: 'You need to authenticate for a channel'
+            error: 'You need to authenticate for a channel',
           };
         }
         const unauthenticatedMessage = UniverseMessage.createMessageFromPayload(
           socketConnectionArg,
-          dataArg
+          messageDataArg
         );
         const foundChannel = await UniverseChannel.authorizeAMessageForAChannel(
           this.universeCache,
@@ -157,22 +140,16 @@ export class Universe {
           const authenticatedMessage = unauthenticatedMessage;
           await this.universeCache.addMessage(authenticatedMessage);
         }
-      }
+      },
     });
 
     // add socket functions
     this.smartsocket.addSocketFunction(socketFunctionSubscription);
     this.smartsocket.addSocketFunction(socketFunctionProcessMessage);
 
-    // start the server
-    if (!this.options.externalServer) {
-      await this.smartexpressServer.start();
-    }
-
     // add smartsocket to the running smartexpress app
-    await this.smartsocket.setExternalServer('smartexpress', this.smartexpressServer);
     await this.smartsocket.start();
-    plugins.smartlog.defaultLogger.log('success', 'started universe');
+    logger.log('success', 'started universe');
   }
 
   /**
@@ -180,8 +157,5 @@ export class Universe {
    */
   public async stopServer() {
     await this.smartsocket.stop();
-    if (!this.options.externalServer) {
-      await this.smartexpressServer.stop();
-    }
   }
 }

ts/smartuniverse.classes.universecache.ts

@@ -1,15 +1,11 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
 
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
-import { UniverseMessage } from './smartuniverse.classes.universemessage';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';
 
-import { Objectmap } from '@pushrocks/lik';
+import { ObjectMap } from '@push.rocks/lik';
-
+import { UniverseConnection } from './smartuniverse.classes.universeconnection.js';
-import { Observable, from } from 'rxjs';
+import { Universe } from './smartuniverse.classes.universe.js';
-import { filter } from 'rxjs/operators';
-import { rxjs } from '@pushrocks/smartrx';
-import { UniverseConnection } from './smartuniverse.classes.universeconnection';
-import { Universe } from './smartuniverse.classes.universe';
 
 /**
  * universe store handles the creation, storage and retrieval of messages.
@@ -24,17 +20,17 @@ export class UniverseCache {
   /**
    * stores messages for this instance
    */
-  public messageMap = new Objectmap<UniverseMessage<any>>();
+  public messageMap = new ObjectMap<UniverseMessage<any>>();
 
   /**
    * stores the channels that are available within the universe
    */
-  public channelMap = new Objectmap<UniverseChannel>();
+  public channelMap = new ObjectMap<UniverseChannel>();
 
   /**
    * stores all connections
    */
-  public connectionMap = new plugins.lik.Objectmap<UniverseConnection>();
+  public connectionMap = new plugins.lik.ObjectMap<UniverseConnection>();
 
   /**
    * allows messages to be processed in a blacklist mode for further analysis
@@ -58,7 +54,7 @@ export class UniverseCache {
     messageArg.setUniverseCache(this);
     UniverseChannel.authorizeAMessageForAChannel(this, messageArg);
     this.messageMap.add(messageArg);
-    messageArg.universeChannelList.forEach(universeChannel => {
+    messageArg.universeChannelList.forEach((universeChannel) => {
       universeChannel.push(messageArg);
     });
   }
@@ -69,9 +65,9 @@ export class UniverseCache {
   public readMessagesYoungerThan(
     unixTimeArg?: number,
     channelName?: string
-  ): Observable<UniverseMessage<any>> {
+  ): plugins.smartrx.rxjs.Observable<UniverseMessage<any>> {
-    const messageObservable = from(this.messageMap.getArray()).pipe(
+    const messageObservable = plugins.smartrx.rxjs.from(this.messageMap.getArray()).pipe(
-      filter(messageArg => {
+      plugins.smartrx.rxjs.ops.filter((messageArg) => {
         return messageArg.smartTimestamp.isYoungerThanMilliSeconds(this.destructionTime);
       })
     );

ts/smartuniverse.classes.universechannel.ts

@@ -1,10 +1,11 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
 
-import { UniverseCache } from './smartuniverse.classes.universecache';
+import { UniverseCache } from './smartuniverse.classes.universecache.js';
-import { UniverseMessage } from './smartuniverse.classes.universemessage';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';
-import { UniverseConnection } from './smartuniverse.classes.universeconnection';
+import { UniverseConnection } from './smartuniverse.classes.universeconnection.js';
-import { Universe } from './smartuniverse.classes.universe';
+import { Universe } from './smartuniverse.classes.universe.js';
+import { logger } from './smartuniverse.logging.js';
 
 /**
  * enables messages to stay within a certain scope.
@@ -33,7 +34,7 @@ export class UniverseChannel {
    * returns boolean wether certain channel exists
    */
   public static async doesChannelExists(universeCacheArg: UniverseCache, channelNameArg: string) {
-    const channel = universeCacheArg.channelMap.find(channelArg => {
+    const channel = universeCacheArg.channelMap.findSync((channelArg) => {
       return channelArg.name === channelNameArg;
     });
     if (channel) {
@@ -54,25 +55,25 @@ export class UniverseChannel {
     universeCacheArg: UniverseCache,
     universeMessageArg: UniverseMessage<any>
   ): UniverseChannel {
-    const foundChannel = universeCacheArg.channelMap.find(universeChannel => {
+    const foundChannel = universeCacheArg.channelMap.findSync((universeChannel) => {
       const result = universeChannel.authenticate(universeMessageArg);
       return result;
     });
     if (foundChannel) {
       universeMessageArg.authenticated = true;
       universeMessageArg.universeChannelList.add(foundChannel);
-      plugins.smartlog.defaultLogger.log('ok', 'message authorized');
+      logger.log('ok', 'message authorized');
       return foundChannel;
     } else {
       universeMessageArg.authenticated = false;
       universeMessageArg.universeChannelList.add(universeCacheArg.blackListChannel);
-      plugins.smartlog.defaultLogger.log('warn', 'message not valid');
+      logger.log('warn', 'message not valid');
       return null;
     }
   }
 
   public static getUniverseChannelByName(universeRef: Universe, universeChannelName: string) {
-    return universeRef.universeCache.channelMap.find(channelArg => {
+    return universeRef.universeCache.channelMap.findSync((channelArg) => {
       return channelArg.name === universeChannelName;
     });
   }
@@ -117,7 +118,7 @@ export class UniverseChannel {
   public async push(messageArg: UniverseMessage<any>) {
     this.subject.next(messageArg);
     const universeConnectionsWithChannelAccess: UniverseConnection[] = [];
-    await this.universeRef.universeCache.connectionMap.forEach(async socketConnection => {
+    await this.universeRef.universeCache.connectionMap.forEach(async (socketConnection) => {
       if (socketConnection.authenticatedChannels.includes(this)) {
         universeConnectionsWithChannelAccess.push(socketConnection);
       }
@@ -131,7 +132,7 @@ export class UniverseChannel {
         passphrase: messageArg.passphrase,
         targetChannelName: this.name,
         messageText: messageArg.messageText,
-        payload: messageArg.payload
+        payload: messageArg.payload,
       };
       smartsocket.clientCall(
         'processMessage',
@@ -144,24 +145,24 @@ export class UniverseChannel {
   // functions to interact with a channel locally
   public subscribe(observingFunctionArg: (messageArg: UniverseMessage<any>) => void) {
     return this.subject.subscribe(
-      messageArg => {
+      (messageArg) => {
         observingFunctionArg(messageArg);
       },
-      error => console.log(error)
+      (error) => console.log(error)
     );
   }
 
   /**
    * sends a message to the channel
    */
-  public async sendMessage(messageDescriptor: interfaces.IMessageCreator) {
+  public async postMessage(messageDescriptor: interfaces.IMessageCreator) {
     const messageToSend = new UniverseMessage({
-      id: plugins.smartunique.shortId(),
+      id: plugins.isounique.uni(),
       messageText: messageDescriptor.messageText,
       payload: messageDescriptor.payload,
       targetChannelName: this.name,
       passphrase: this.passphrase,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     });
     this.universeRef.universeCache.addMessage(messageToSend);
   }

ts/smartuniverse.classes.universeconnection.ts

@@ -1,8 +1,8 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
-import { UniverseCache } from './smartuniverse.classes.universecache';
+import { UniverseCache } from './smartuniverse.classes.universecache.js';
-import { Universe } from './smartuniverse.classes.universe';
+import { Universe } from './smartuniverse.classes.universe.js';
 
 /**
  * represents a connection to the universe
@@ -37,7 +37,7 @@ export class UniverseConnection {
     universeConnectionArg: UniverseConnection
   ): Promise<UniverseConnection> {
     let connectionToReturn: UniverseConnection;
-    universeCache.connectionMap.forEach(async existingConnection => {
+    universeCache.connectionMap.forEach(async (existingConnection) => {
       if (existingConnection.socketConnection === universeConnectionArg.socketConnection) {
         connectionToReturn = await this.mergeUniverseConnections(
           existingConnection,
@@ -87,7 +87,7 @@ export class UniverseConnection {
     universeCache: UniverseCache,
     socketConnectionArg: plugins.smartsocket.SocketConnection
   ): UniverseConnection {
-    const universeConnection = universeCache.connectionMap.find(universeConnectionArg => {
+    const universeConnection = universeCache.connectionMap.findSync((universeConnectionArg) => {
       return universeConnectionArg.socketConnection === socketConnectionArg;
     });
     return universeConnection;
@@ -124,7 +124,7 @@ export class UniverseConnection {
     this.universeRef = optionsArg.universe;
     this.authenticationRequests = optionsArg.authenticationRequests;
     this.socketConnection = optionsArg.socketConnection;
-    this.socketConnection.eventSubject.subscribe(async eventArg => {
+    this.socketConnection.eventSubject.subscribe(async (eventArg) => {
       switch (eventArg) {
         case 'disconnected':
           await this.disconnect('upstreamevent');

ts/smartuniverse.classes.universemessage.ts

@@ -1,13 +1,10 @@
-import * as plugins from './smartuniverse.plugins';
+import * as plugins from './smartuniverse.plugins.js';
-import * as interfaces from './interfaces';
+import * as interfaces from './interfaces/index.js';
-
+import { Universe } from './smartuniverse.classes.universe.js';
-import { Objectmap } from '@pushrocks/lik';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
-
+import { UniverseCache } from './smartuniverse.classes.universecache.js';
-import { Timer, TimeStamp } from '@pushrocks/smarttime';
+import { SocketConnection } from '@push.rocks/smartsocket';
-import { Universe } from './smartuniverse.classes.universe';
+import { logger } from './smartuniverse.logging.js';
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
-import { UniverseCache } from './smartuniverse.classes.universecache';
-import { SocketConnection } from '@pushrocks/smartsocket';
 
 /**
  * represents a message within a universe
@@ -25,7 +22,7 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
 
   public id: string;
   public timestamp: number;
-  public smartTimestamp: TimeStamp;
+  public smartTimestamp: plugins.smarttime.TimeStamp;
   public messageText: string;
   public passphrase: string;
   public payload: T;
@@ -40,7 +37,7 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
   /**
    * enables unprotected grouping of messages for efficiency purposes.
    */
-  public universeChannelList = new Objectmap<UniverseChannel>();
+  public universeChannelList = new plugins.lik.ObjectMap<UniverseChannel>();
 
   /**
    * wether the message is authenticated
@@ -50,7 +47,7 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
   /**
    * a destruction timer for this message
    */
-  public destructionTimer: Timer; // a timer to take care of message destruction
+  public destructionTimer: plugins.smarttime.Timer; // a timer to take care of message destruction
 
   /**
    * the constructor to create a universe message
@@ -58,7 +55,7 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
    * @param attachedPayloadArg
    */
   constructor(messageDescriptor: interfaces.IUniverseMessage) {
-    this.smartTimestamp = new TimeStamp(this.timestamp);
+    this.smartTimestamp = new plugins.smarttime.TimeStamp(this.timestamp);
     this.messageText = messageDescriptor.messageText;
     this.targetChannelName = messageDescriptor.targetChannelName;
     this.passphrase = messageDescriptor.passphrase;
@@ -75,14 +72,14 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
 
   public setDestructionTimer(selfdestructAfterArg?: number) {
     if (selfdestructAfterArg) {
-      this.destructionTimer = new Timer(selfdestructAfterArg);
+      this.destructionTimer = new plugins.smarttime.Timer(selfdestructAfterArg);
       this.destructionTimer.start();
       // set up self destruction by removing this from the parent messageCache
       this.destructionTimer.completed
         .then(async () => {
           this.universeCache.messageMap.remove(this);
         })
-        .catch(err => {
+        .catch((err) => {
           console.log(err);
           console.log(this);
         });
@@ -99,6 +96,6 @@ export class UniverseMessage<T> implements interfaces.IUniverseMessage {
    * handles bad messages for further analysis
    */
   public handleAsBadMessage() {
-    plugins.smartlog.defaultLogger.log('warn', 'received a bad message');
+    logger.log('warn', 'received a bad message');
   }
 }

ts/smartuniverse.logging.ts

@@ -0,0 +1,2 @@
+import * as plugins from './smartuniverse.plugins.js';
+export const logger = new plugins.smartlog.ConsoleLog();

ts/smartuniverse.paths.ts

@@ -1,3 +0,0 @@
-import * as plugins from './smartuniverse.plugins';
-
-export const packageJson = plugins.path.join(__dirname, '../package.json');

ts/smartuniverse.plugins.ts

@@ -1,38 +1,29 @@
-// node native
-import * as path from 'path';
-
-export { path };
-
 // apiglobal scope
 import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
 
 export { typedrequestInterfaces };
 
 // pushrocks scope
-import * as lik from '@pushrocks/lik';
+import * as lik from '@push.rocks/lik';
-import * as smarthash from '@pushrocks/smarthash';
+import * as isohash from '@push.rocks/isohash';
-import * as smartdelay from '@pushrocks/smartdelay';
+import * as isounique from '@push.rocks/isounique';
-import * as smartexpress from '@pushrocks/smartexpress';
+import * as smartdelay from '@push.rocks/smartdelay';
-import * as smartfile from '@pushrocks/smartfile';
+import * as smartlog from '@push.rocks/smartlog';
-import * as smartlog from '@pushrocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
-import * as smartrequest from '@pushrocks/smartrequest';
+import * as smartsocket from '@push.rocks/smartsocket';
-import * as smartrx from '@pushrocks/smartrx';
+import * as smarttime from '@push.rocks/smarttime';
-import * as smartsocket from '@pushrocks/smartsocket';
+import * as smarturl from '@push.rocks/smarturl';
-import * as smarttime from '@pushrocks/smarttime';
-import * as smartunique from '@pushrocks/smartunique';
 
 export {
   lik,
-  smarthash,
+  isohash,
+  isounique,
   smartdelay,
-  smartexpress,
-  smartfile,
   smartlog,
   smartpromise,
   smartrx,
-  smartrequest,
   smartsocket,
   smarttime,
-  smartunique
+  smarturl,
 };

ts/smartuniverse.pluginstyped.ts

@@ -0,0 +1,5 @@
+import type * as typedserver from '@apiglobal/typedserver';
+
+export type {
+  typedserver
+};

tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true,
+  }
+}

tslint.json

@@ -1,17 +0,0 @@
-{
-  "extends": ["tslint:latest", "tslint-config-prettier"],
-  "rules": {
-    "semicolon": [true, "always"],
-    "no-console": false,
-    "ordered-imports": false,
-    "object-literal-sort-keys": false,
-    "member-ordering": {
-      "options":{
-        "order": [
-          "static-method"
-        ]
-      }
-    }
-  },
-  "defaultSeverity": "warning"
-}