1.0.107

fix(core): update
1.0.106
2023-07-25 11:33:14 +02:00 · 2023-07-25 11:33:13 +02:00 · 2021-01-26 01:59:07 +00:00 · 2021-01-26 01:59:06 +00:00 · 2020-09-30 17:39:30 +00:00 · 2020-09-30 17:39:29 +00:00
38 changed files with 5198 additions and 3548 deletions
--- a/.gitea/workflows/default_nottags.yaml
+++ b/.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
--- a/.gitea/workflows/default_tags.yaml
+++ b/.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
--- a/.gitignore
+++ b/.gitignore
@ -15,8 +15,6 @@ node_modules/

 # builds
 dist/
-dist_web/
-dist_serve/
-dist_ts_web/
+dist_*/

 # custom
--- a/.gitlab-ci.yml
+++ b/.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
--- a/.snyk
+++ b/.snyk
@ -1,4 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.5
-ignore: {}
-patch: {}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -2,28 +2,10 @@
  "version": "0.2.0",
  "configurations": [
    {
-      "name": "current file",
-      "type": "node",
+      "command": "npm test",
+      "name": "Run npm test",
      "request": "launch",
-      "args": [
-        "${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"
+      "type": "node-terminal"
    }
  ]
 }
--- a/.vscode/settings.json
+++ b/.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"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}
--- a/npmextra.json
+++ b/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",
-      "npmPackagename": "@pushrocks/smartuniverse",
+      "description": "messaging service for micro services",
+      "npmPackagename": "@push.rocks/smartuniverse",
      "license": "MIT",
      "projectDomain": "push.rocks"
    }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,53 +1,55 @@
 {
-  "name": "@pushrocks/smartuniverse",
-  "version": "1.0.96",
+  "name": "@push.rocks/smartuniverse",
+  "version": "1.0.107",
  "private": false,
  "description": "messaging service for your micro services",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
  "author": "Lossless GmbH",
  "license": "MIT",
  "scripts": {
    "test": "(tstest test/)",
    "testManual": "(tsrun test/test.ts)",
-    "build": "(tsbuild)",
-    "format": "(gitzone format)"
+    "build": "(tsbuild --allowimplicitany && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)",
+    "format": "(gitzone format)",
+    "buildDocs": "tsdoc"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.17",
-    "@gitzone/tstest": "^1.0.28",
-    "@pushrocks/tapbundle": "^3.0.13",
-    "@types/node": "^12.12.7",
-    "tslint": "^5.20.1",
-    "tslint-config-prettier": "^1.18.0"
-  },
-  "peerDependencies": {
-    "rxjs": "*"
+    "@gitzone/tsbuild": "^2.1.66",
+    "@gitzone/tsbundle": "^2.0.8",
+    "@gitzone/tsrun": "^1.2.44",
+    "@gitzone/tstest": "^1.0.77",
+    "@push.rocks/tapbundle": "^5.0.12",
+    "@types/node": "^20.4.4"
  },
  "dependencies": {
-    "@apiglobal/typedrequest-interfaces": "^1.0.7",
-    "@pushrocks/lik": "^3.0.11",
-    "@pushrocks/smartdelay": "^2.0.6",
-    "@pushrocks/smartexpress": "^3.0.52",
-    "@pushrocks/smartfile": "^7.0.6",
-    "@pushrocks/smarthash": "^2.0.6",
-    "@pushrocks/smartlog": "^2.0.21",
-    "@pushrocks/smartpromise": "^3.0.6",
-    "@pushrocks/smartrequest": "^1.1.42",
-    "@pushrocks/smartrx": "^2.0.5",
-    "@pushrocks/smartsocket": "^1.1.58",
-    "@pushrocks/smarttime": "^3.0.12",
-    "@pushrocks/smartunique": "^3.0.1"
+    "@apiglobal/typedrequest-interfaces": "^2.0.1",
+    "@apiglobal/typedserver": "^2.0.65",
+    "@push.rocks/isohash": "^2.0.1",
+    "@push.rocks/isounique": "^1.0.5",
+    "@push.rocks/lik": "^6.0.3",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartlog": "^3.0.3",
+    "@push.rocks/smartpromise": "^4.0.2",
+    "@push.rocks/smartrx": "^3.0.6",
+    "@push.rocks/smartsocket": "^2.0.20",
+    "@push.rocks/smarttime": "^4.0.4",
+    "@push.rocks/smarturl": "^3.0.7"
  },
  "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"
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.md
+++ b/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)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/smartuniverse)
-* [github.com (source mirror)](https://github.com/pushrocks/smartuniverse)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartuniverse/)
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@push.rocks/smartuniverse)
+* [gitlab.com (source)](https://gitlab.com/push.rocks/smartuniverse)
+* [github.com (source mirror)](https://github.com/push.rocks/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)
-[![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)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/push.rocks/smartuniverse/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/smartuniverse/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@push.rocks/smartuniverse)](https://lossless.cloud)
+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 | **&copy;** [Lossless GmbH](https://lossless.gmbh)
+## Legal
+> MIT licensed | **&copy;** [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)
--- a/test/test.ts
+++ b/test/test.ts
@ -1,8 +1,6 @@
 // tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
-import * as smartuniverse from '../ts/index';
-
-import { Observable } from 'rxjs';
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as smartuniverse from '../ts/index.js';

 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({
-    messageText: 'hello'
+  await testClientUniverse.getChannel(testChannelData.channelName).postMessage({
+    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({
-    messageText: 'hellothere'
+  await testChannel.postMessage({
+    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();
 });

--- a/ts/00_commitinfo_data.ts
+++ b/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'
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,16 +1,16 @@
 // Client classes
-export * from './smartuniverse.classes.clientuniverse';
-export * from './smartuniverse.classes.clientuniversechannel';
-export * from './smartuniverse.classes.clientuniversemessage';
+export * from './smartuniverse.classes.client.universe.js';
+export * from './smartuniverse.classes.client.universechannel.js';
+export * from './smartuniverse.classes.client.universemessage.js';

 // Server classes
-export * from './smartuniverse.classes.universe';
-export * from './smartuniverse.classes.universecache';
-export * from './smartuniverse.classes.universechannel';
-export * from './smartuniverse.classes.universemessage';
+export * from './smartuniverse.classes.universe.js';
+export * from './smartuniverse.classes.universecache.js';
+export * from './smartuniverse.classes.universechannel.js';
+export * from './smartuniverse.classes.universemessage.js';

 // Reaction Response
-export * from './smartuniverse.classes.reactionrequest';
-export * from './smartuniverse.classes.reactionresponse';
+export * from './smartuniverse.classes.event.reactionrequest.js';
+export * from './smartuniverse.classes.event.reactionresponse.js';

-export * from './interfaces';
+export * from './interfaces/index.js';
--- a/ts/interfaces/index.ts
+++ b/ts/interfaces/index.ts
@ -1,5 +1,5 @@
-export * from './http.interfaces';
-export * from './socketfunctionrequests';
-export * from './universechannel.interfaces';
-export * from './universemessage.interfaces';
-export * from './universeactions.interfaces';
+export * from './http.interfaces.js';
+export * from './socketfunctionrequests.js';
+export * from './universechannel.interfaces.js';
+export * from './universemessage.interfaces.js';
+export * from './universeactions.interfaces.js';
--- a/ts/interfaces/socketfunctionrequests.ts
+++ b/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';
--- a/ts/smartuniverse.classes.broadcastevent.ts
+++ b/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() {}
-}
--- a/ts/smartuniverse.classes.broadcastsubscription.ts
+++ b/ts/smartuniverse.classes.broadcastsubscription.ts
@ -1,5 +0,0 @@
-import * as plugins from './smartuniverse.plugins';
-
-export class BroadcastSubscription {
-  
-}
--- a/ts/smartuniverse.classes.client.universe.ts
+++ b/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 { Observable } from 'rxjs';
-import { Smartsocket, SmartsocketClient } from '@pushrocks/smartsocket';
-import * as url from 'url';
+import * as interfaces from './interfaces/index.js';

-import * as interfaces from './interfaces';
-
-import { ClientUniverseChannel, ClientUniverseMessage } from './';
-import { ClientUniverseCache } from './smartuniverse.classes.clientuniversecache';
+import { ClientUniverseChannel, ClientUniverseMessage } from './index.js';
+import { ClientUniverseCache } from './smartuniverse.classes.client.universecache.js';
+import { logger } from './smartuniverse.logging.js';

 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(
-      channelItemArg => {
+    const clientUniverseChannel = this.clientUniverseCache.channelMap.findOneAndRemoveSync(
+      (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,31 +112,27 @@ 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<
-        interfaces.ISocketRequest_ProcessMessage
-      >({
+      const socketFunctionProcessMessage =
+        new plugins.smartsocket.SocketFunction<interfaces.ISocketRequest_ProcessMessage>({
          funcName: 'processMessage',
-        allowedRoles: [],
-        funcDef: async messageDescriptorArg => {
-          plugins.smartlog.defaultLogger.log('info', 'Got message from server');
-          const clientUniverseMessage = ClientUniverseMessage.createMessageFromMessageDescriptor(
-            messageDescriptorArg
-          );
+          funcDef: async (messageDescriptorArg) => {
+            logger.log('info', 'Got message from server');
+            const clientUniverseMessage =
+              ClientUniverseMessage.createMessageFromMessageDescriptor(messageDescriptorArg);
            this.messageRxjsSubject.next(clientUniverseMessage);

            // lets find the corresponding channel
@ -143,14 +140,14 @@ export class ClientUniverse {
            if (targetChannel) {
              await targetChannel.emitMessageLocally(clientUniverseMessage);
              return {
-              messageStatus: 'ok'
+                messageStatus: 'ok',
              };
            } else {
              return {
-              messageStatus: 'channel not found'
+                messageStatus: 'channel not found',
              };
            }
-        }
+          },
        });

      // add functions
@ -158,26 +155,32 @@ export class ClientUniverse {
      this.smartsocketClient.addSocketFunction(socketFunctionProcessMessage);

      await this.smartsocketClient.connect();
-      plugins.smartlog.defaultLogger.log('info', 'universe client connected successfully');
-      await this.clientUniverseCache.channelMap.forEach(async clientUniverseChannelArg => {
+      logger.log('info', 'universe client connected successfully');
+      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 () => {
+      if (this.smartsocketClient) {
        const smartsocketToDisconnect = this.smartsocketClient;
        this.smartsocketClient = null; // making sure the upstreamEvent does  not interfere
        await smartsocketToDisconnect.disconnect();
      }
-    if (this.options.autoReconnect && reason === 'upstreamEvent' && this.smartsocketClient) {
+    };
+
+    if (reason === 'triggered' && this.smartsocketClient) {
+      await instructDisconnect();
+    }
+    if (this.autoReconnectStatus === 'on' && reason === 'upstreamEvent') {
+      await instructDisconnect();
      await plugins.smartdelay.delayForRandom(5000, 20000);
-      this.smartsocketClient = null;
-      this.checkConnection();
+      await this.checkConnection();
    }
  }
 }
--- a/ts/smartuniverse.classes.client.universecache.ts
+++ b/ts/smartuniverse.classes.client.universecache.ts
@ -1,5 +1,5 @@
-import * as plugins from './smartuniverse.plugins';
-import { ClientUniverseChannel } from './smartuniverse.classes.clientuniversechannel';
+import * as plugins from './smartuniverse.plugins.js';
+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>();
 }
--- a/ts/smartuniverse.classes.client.universechannel.ts
+++ b/ts/smartuniverse.classes.client.universechannel.ts
@ -1,10 +1,10 @@
-import * as plugins from './smartuniverse.plugins';
-import * as interfaces from './interfaces';
+import * as plugins from './smartuniverse.plugins.js';
+import * as interfaces from './interfaces/index.js';

-import { ClientUniverse } from './';
-import { ClientUniverseMessage } from './smartuniverse.classes.clientuniversemessage';
-import { ReactionRequest } from './smartuniverse.classes.reactionrequest';
-import { ReactionResponse } from './smartuniverse.classes.reactionresponse';
+import { ClientUniverse } from './index.js';
+import { ClientUniverseMessage } from './smartuniverse.classes.client.universemessage.js';
+import { ReactionRequest } from './smartuniverse.classes.event.reactionrequest.js';
+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<
-        interfaces.ISocketRequest_SubscribeChannel
-      >('subscribeChannel', {
+      const response =
+        await this.clientUniverseRef.smartsocketClient.serverCall<interfaces.ISocketRequest_SubscribeChannel>(
+          'subscribeChannel',
+          {
            name: this.name,
-        passphrase: this.passphrase
-      });
+            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) {
-    await this.clientUniverseRef.checkConnection();
+  public async postMessage(messageArg: interfaces.IMessageCreator) {
+    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',
--- a/ts/smartuniverse.classes.client.universemessage.ts
+++ b/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 {
  // ======
--- a/ts/smartuniverse.classes.event.broadcastevent.ts
+++ b/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);
+  }
+}
--- a/ts/smartuniverse.classes.event.reactionrequest.ts
+++ b/ts/smartuniverse.classes.event.reactionrequest.ts
@ -1,9 +1,9 @@
-import * as plugins from './smartuniverse.plugins';
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
-import { ClientUniverseChannel } from './smartuniverse.classes.clientuniversechannel';
-import { ReactionResult } from './smartuniverse.classes.reactionresult';
-import { UniverseMessage } from './smartuniverse.classes.universemessage';
-import { ClientUniverseMessage } from './smartuniverse.classes.clientuniversemessage';
+import * as plugins from './smartuniverse.plugins.js';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
+import { ClientUniverseChannel } from './smartuniverse.classes.client.universechannel.js';
+import { ReactionResult } from './smartuniverse.classes.event.reactionresult.js';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';
+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();
--- a/ts/smartuniverse.classes.event.reactionresponse.ts
+++ b/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 { UniverseChannel } from './smartuniverse.classes.universechannel';
-import { ClientUniverseChannel } from './smartuniverse.classes.clientuniversechannel';
-import { UniverseMessage } from './smartuniverse.classes.universemessage';
-import { ClientUniverseMessage } from './smartuniverse.classes.clientuniversemessage';
+import { type ICombinatorPayload } from './smartuniverse.classes.event.reactionrequest.js';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
+import { ClientUniverseChannel } from './smartuniverse.classes.client.universechannel.js';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';
+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,
      });
    }
  }
--- a/ts/smartuniverse.classes.event.reactionresult.ts
+++ b/ts/smartuniverse.classes.event.reactionresult.ts
@ -1,5 +1,5 @@
-import * as plugins from './smartuniverse.plugins';
-import { ReactionResponse } from './smartuniverse.classes.reactionresponse';
+import * as plugins from './smartuniverse.plugins.js';
+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();
    });
--- a/ts/smartuniverse.classes.universe.ts
+++ b/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 './';
+import { UniverseCache, UniverseChannel, UniverseMessage } from './index.js';

-import * as paths from './smartuniverse.paths';
-
-import * as interfaces from './interfaces';
-import { UniverseConnection } from './smartuniverse.classes.universeconnection';
+import * as interfaces from './interfaces/index.js';
+import { UniverseConnection } from './smartuniverse.classes.universeconnection.js';
+import { logger } from './smartuniverse.logging.js';

 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) {
-    // lets create the base smartexpress server
-    if (!this.options.externalServer) {
-      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;
+  public async start(portArg?: number) {
+    if (!this.options.externalServer && !portArg) {
+      throw new Error(`You supplied an external error. You need to specify a portArg to start on.`);
    }

-    // add websocket upgrade
-    this.smartsocket = new plugins.smartsocket.Smartsocket({});
+    portArg = portArg || 3000; // TODO: remove

-    // add a role for the clients
-    const ClientRole = new plugins.smartsocket.SocketRole({
-      name: 'UniverseClient',
-      passwordHash: plugins.smarthash.sha256FromStringSync('UniverseClient') // authentication happens on another level
+    // add websocket upgrade
+    this.smartsocket = new plugins.smartsocket.Smartsocket({
+      alias: 'smartuniverse',
+      port: portArg,
    });

-    // add the role to smartsocket
-    this.smartsocket.addSocketRoles([ClientRole]);
+    // lets create the base smartexpress server
+    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
+
+    const socketFunctionSubscription =
+      new plugins.smartsocket.SocketFunction<interfaces.ISocketRequest_SubscribeChannel>({
        funcName: 'subscribeChannel',
        funcDef: async (dataArg, socketConnectionArg) => {
          const universeConnection = new UniverseConnection({
            universe: this,
            socketConnection: socketConnectionArg,
-          authenticationRequests: [dataArg]
+            authenticationRequests: [dataArg],
          });
          await UniverseConnection.addConnectionToCache(this, universeConnection);
          return {
-          subscriptionStatus: 'subscribed'
+            subscriptionStatus: 'subscribed',
          };
-      }
+        },
      });

-    const socketFunctionProcessMessage = new plugins.smartsocket.SocketFunction({
-      allowedRoles: [ClientRole], // there is only one client role, Authentication happens on another level
+    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(
-            'ok',
-            'found UniverseConnection for socket for incoming message'
-          );
+          logger.log('ok', 'found UniverseConnection for socket for incoming message');
        } else {
-          plugins.smartlog.defaultLogger.log(
-            'warn',
-            'found no Authorized channel for incoming message'
-          );
+          logger.log('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();
-    }
  }
 }
--- a/ts/smartuniverse.classes.universecache.ts
+++ b/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 { UniverseMessage } from './smartuniverse.classes.universemessage';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';

-import { Objectmap } from '@pushrocks/lik';
-
-import { Observable, from } from 'rxjs';
-import { filter } from 'rxjs/operators';
-import { rxjs } from '@pushrocks/smartrx';
-import { UniverseConnection } from './smartuniverse.classes.universeconnection';
-import { Universe } from './smartuniverse.classes.universe';
+import { ObjectMap } from '@push.rocks/lik';
+import { UniverseConnection } from './smartuniverse.classes.universeconnection.js';
+import { Universe } from './smartuniverse.classes.universe.js';

 /**
 * 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>> {
-    const messageObservable = from(this.messageMap.getArray()).pipe(
-      filter(messageArg => {
+  ): plugins.smartrx.rxjs.Observable<UniverseMessage<any>> {
+    const messageObservable = plugins.smartrx.rxjs.from(this.messageMap.getArray()).pipe(
+      plugins.smartrx.rxjs.ops.filter((messageArg) => {
        return messageArg.smartTimestamp.isYoungerThanMilliSeconds(this.destructionTime);
      })
    );
--- a/ts/smartuniverse.classes.universechannel.ts
+++ b/ts/smartuniverse.classes.universechannel.ts
@ -1,10 +1,11 @@
-import * as plugins from './smartuniverse.plugins';
-import * as interfaces from './interfaces';
+import * as plugins from './smartuniverse.plugins.js';
+import * as interfaces from './interfaces/index.js';

-import { UniverseCache } from './smartuniverse.classes.universecache';
-import { UniverseMessage } from './smartuniverse.classes.universemessage';
-import { UniverseConnection } from './smartuniverse.classes.universeconnection';
-import { Universe } from './smartuniverse.classes.universe';
+import { UniverseCache } from './smartuniverse.classes.universecache.js';
+import { UniverseMessage } from './smartuniverse.classes.universemessage.js';
+import { UniverseConnection } from './smartuniverse.classes.universeconnection.js';
+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);
  }
--- a/ts/smartuniverse.classes.universeconnection.ts
+++ b/ts/smartuniverse.classes.universeconnection.ts
@ -1,8 +1,8 @@
-import * as plugins from './smartuniverse.plugins';
-import * as interfaces from './interfaces';
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
-import { UniverseCache } from './smartuniverse.classes.universecache';
-import { Universe } from './smartuniverse.classes.universe';
+import * as plugins from './smartuniverse.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
+import { UniverseCache } from './smartuniverse.classes.universecache.js';
+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');
--- a/ts/smartuniverse.classes.universemessage.ts
+++ b/ts/smartuniverse.classes.universemessage.ts
@ -1,13 +1,10 @@
-import * as plugins from './smartuniverse.plugins';
-import * as interfaces from './interfaces';
-
-import { Objectmap } from '@pushrocks/lik';
-
-import { Timer, TimeStamp } from '@pushrocks/smarttime';
-import { Universe } from './smartuniverse.classes.universe';
-import { UniverseChannel } from './smartuniverse.classes.universechannel';
-import { UniverseCache } from './smartuniverse.classes.universecache';
-import { SocketConnection } from '@pushrocks/smartsocket';
+import * as plugins from './smartuniverse.plugins.js';
+import * as interfaces from './interfaces/index.js';
+import { Universe } from './smartuniverse.classes.universe.js';
+import { UniverseChannel } from './smartuniverse.classes.universechannel.js';
+import { UniverseCache } from './smartuniverse.classes.universecache.js';
+import { SocketConnection } from '@push.rocks/smartsocket';
+import { logger } from './smartuniverse.logging.js';

 /**
 * 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');
  }
 }
--- a/ts/smartuniverse.logging.ts
+++ b/ts/smartuniverse.logging.ts
@ -0,0 +1,2 @@
+import * as plugins from './smartuniverse.plugins.js';
+export const logger = new plugins.smartlog.ConsoleLog();
--- a/ts/smartuniverse.paths.ts
+++ b/ts/smartuniverse.paths.ts
@ -1,3 +0,0 @@
-import * as plugins from './smartuniverse.plugins';
-
-export const packageJson = plugins.path.join(__dirname, '../package.json');
--- a/ts/smartuniverse.plugins.ts
+++ b/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 smarthash from '@pushrocks/smarthash';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartexpress from '@pushrocks/smartexpress';
-import * as smartfile from '@pushrocks/smartfile';
-import * as smartlog from '@pushrocks/smartlog';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartrequest from '@pushrocks/smartrequest';
-import * as smartrx from '@pushrocks/smartrx';
-import * as smartsocket from '@pushrocks/smartsocket';
-import * as smarttime from '@pushrocks/smarttime';
-import * as smartunique from '@pushrocks/smartunique';
+import * as lik from '@push.rocks/lik';
+import * as isohash from '@push.rocks/isohash';
+import * as isounique from '@push.rocks/isounique';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartsocket from '@push.rocks/smartsocket';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smarturl from '@push.rocks/smarturl';

 export {
  lik,
-  smarthash,
+  isohash,
+  isounique,
  smartdelay,
-  smartexpress,
-  smartfile,
  smartlog,
  smartpromise,
  smartrx,
-  smartrequest,
  smartsocket,
  smarttime,
-  smartunique
+  smarturl,
 };
--- a/ts/smartuniverse.pluginstyped.ts
+++ b/ts/smartuniverse.pluginstyped.ts
@ -0,0 +1,5 @@
+import type * as typedserver from '@apiglobal/typedserver';
+
+export type {
+  typedserver
+};
--- a/tsconfig.json
+++ b/tsconfig.json
@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "nodenext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true,
+  }
+}
--- a/tslint.json
+++ b/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"
-}
Author	SHA1	Message	Date
Philipp Kunz	b26f4076ab	1.0.107	2023-07-25 11:33:14 +02:00
Philipp Kunz	4ccbc004db	fix(core): update	2023-07-25 11:33:13 +02:00
Phil Kunz	b5fcefa93b	1.0.106	2021-01-26 01:59:07 +00:00
Phil Kunz	67f60187ae	fix(core): update	2021-01-26 01:59:06 +00:00
Phil Kunz	176c6ba261	1.0.105	2020-09-30 17:39:30 +00:00
Phil Kunz	af6c634deb	fix(core): update	2020-09-30 17:39:29 +00:00
Phil Kunz	a5ce7b18e8	1.0.104	2020-09-30 00:50:44 +00:00
Phil Kunz	b6b482f7db	fix(core): update	2020-09-30 00:50:43 +00:00
Phil Kunz	39ed2dbd73	1.0.103	2020-09-30 00:33:58 +00:00
Phil Kunz	b1defd95a3	fix(core): update	2020-09-30 00:33:57 +00:00
Phil Kunz	a4ad33a0ee	1.0.102	2020-09-30 00:13:15 +00:00
Phil Kunz	18fad25b8c	fix(core): update	2020-09-30 00:13:14 +00:00
Phil Kunz	82f4413064	1.0.101	2020-09-29 19:39:13 +00:00
Phil Kunz	71bccf54f1	fix(core): update	2020-09-29 19:39:13 +00:00
Phil Kunz	78ee8f2592	1.0.100	2020-09-24 18:17:53 +00:00
Phil Kunz	820ce76fe3	fix(core): update	2020-09-24 18:17:52 +00:00
Phil Kunz	5d8c2064e0	1.0.99	2020-09-24 18:13:49 +00:00
Phil Kunz	9d1fc94e06	fix(core): update	2020-09-24 18:13:48 +00:00
Phil Kunz	c4640a3bc7	1.0.98	2019-11-10 16:55:18 +01:00
Phil Kunz	b6392ec6ba	fix(core): update	2019-11-10 16:55:17 +01:00
Phil Kunz	bd4897f392	1.0.97	2019-11-09 18:44:34 +01:00
Phil Kunz	dbdc8a2811	fix(core): update	2019-11-09 18:44:33 +01:00