2.0.21

fix(core): update
2.0.20
2023-08-06 16:09:28 +02:00 · 2023-08-06 16:09:28 +02:00 · 2023-07-21 03:53:41 +02:00 · 2023-07-21 03:53:41 +02:00 · 2023-03-29 19:02:35 +02:00 · 2023-03-29 19:02:34 +02:00
34 changed files with 5932 additions and 3988 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
@ -1,4 +1,20 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
+public/
 pages/

+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,125 +0,0 @@
-# gitzone standard
-image: 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:
-  - 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:
-  - docker
-  - notpriv
-
-# ====================
-# test stage
-# ====================
-
-testLTS:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-    
-testSTABLE:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-
-release:
-  stage: release
-  script:
-  - npmci node install stable
-  - npmci npm publish
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  image: docker:stable
-  allow_failure: true
-  services:
-    - docker:stable-dind
-  script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
-  tags:
-  - docker
-  - priv
-
-trigger:
-  stage: metadata
-  script:
-  - npmci trigger
-  only:
-  - tags
-  tags:
-  - docker
-  - notpriv
-
-pages:
-  image: hosttoday/ht-docker-node:npmci
-  stage: metadata
-  script:
-    - npmci command npm install -g typedoc typescript
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
-  tags:
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-    - public
-  allow_failure: true
--- a/.snyk
+++ b/.snyk
@ -1,13 +0,0 @@
-# Snyk (https://snyk.io) policy file, patches or ignores known vulnerabilities.
-version: v1.13.5
-# ignores vulnerabilities until expiry date; change duration by modifying expiry date
-ignore:
-  SNYK-JS-JSYAML-173999:
-    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
-        reason: None given
-        expires: '2019-05-24T15:16:11.291Z'
-  SNYK-JS-JSYAML-174129:
-    - '@pushrocks/smartexpress > @pushrocks/smartfile > js-yaml':
-        reason: None given
-        expires: '2019-05-24T15:16:11.291Z'
-patch: {}
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "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": "smartsocket",
-      "shortDescription": "easy and secure websocket communication",
-      "npmPackagename": "@pushrocks/smartsocket",
+      "description": "easy and secure websocket communication",
+      "npmPackagename": "@push.rocks/smartsocket",
      "license": "MIT",
      "projectDomain": "push.rocks"
    }
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,12 +1,14 @@
 {
-  "name": "@pushrocks/smartsocket",
-  "version": "1.1.35",
+  "name": "@push.rocks/smartsocket",
+  "version": "2.0.21",
  "description": "easy and secure websocket communication",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
  "scripts": {
-    "test": "tstest test/",
-    "build": "tsbuild"
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --allowimplicitany && tsbundle --from ./ts/index.ts --to dist_bundle/bundle.js)",
+    "buildDocs": "tsdoc"
  },
  "repository": {
    "type": "git",
@ -19,27 +21,44 @@
  },
  "homepage": "https://gitlab.com/pushrocks/smartsocket#README",
  "dependencies": {
-    "@pushrocks/lik": "^3.0.5",
-    "@pushrocks/smartdelay": "^2.0.3",
-    "@pushrocks/smartexpress": "^3.0.19",
-    "@pushrocks/smarthash": "^2.0.4",
-    "@pushrocks/smartlog": "^2.0.19",
-    "@pushrocks/smartpromise": "^3.0.2",
-    "@types/shortid": "0.0.29",
-    "@types/socket.io": "^2.1.2",
-    "@types/socket.io-client": "^1.4.32",
-    "shortid": "^2.2.14",
-    "socket.io": "^2.2.0",
-    "socket.io-client": "^2.2.0"
+    "@apiglobal/typedrequest-interfaces": "^2.0.1",
+    "@apiglobal/typedserver": "^2.0.65",
+    "@push.rocks/isohash": "^2.0.0",
+    "@push.rocks/isounique": "^1.0.5",
+    "@push.rocks/lik": "^6.0.3",
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartenv": "^5.0.5",
+    "@push.rocks/smartjson": "^5.0.1",
+    "@push.rocks/smartlog": "^3.0.3",
+    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/smartrx": "^3.0.6",
+    "@push.rocks/smarttime": "^4.0.4",
+    "engine.io": "6.3.1",
+    "socket.io": "4.5.4",
+    "socket.io-client": "4.5.4"
  },
  "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.8",
-    "@gitzone/tsrun": "^1.2.5",
-    "@gitzone/tstest": "^1.0.20",
-    "@pushrocks/tapbundle": "^3.0.9",
-    "@types/node": "^11.13.7",
-    "tslint": "^5.16.0",
-    "tslint-config-prettier": "^1.18.0"
+    "@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.8"
  },
-  "private": false
+  "private": false,
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.md
+++ b/readme.md
@ -1,20 +1,26 @@
-# @pushrocks/smartsocket
+# @push.rocks/smartsocket
 easy and secure websocket communication

 ## Availabililty and Links
-* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smartsocket)
-* [gitlab.com (source)](https://gitlab.com/pushrocks/smartsocket)
-* [github.com (source mirror)](https://github.com/pushrocks/smartsocket)
-* [docs (typedoc)](https://pushrocks.gitlab.io/smartsocket/)
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@push.rocks/smartsocket)
+* [gitlab.com (source)](https://gitlab.com/push.rocks/smartsocket)
+* [github.com (source mirror)](https://github.com/push.rocks/smartsocket)
+* [docs (typedoc)](https://push.rocks.gitlab.io/smartsocket/)

 ## Status for master
-[![build status](https://gitlab.com/pushrocks/smartsocket/badges/master/build.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
-[![coverage report](https://gitlab.com/pushrocks/smartsocket/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smartsocket/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smartsocket.svg)](https://www.npmjs.com/package/@pushrocks/smartsocket)
-[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smartsocket/badge.svg)](https://snyk.io/test/npm/@pushrocks/smartsocket)
-[![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/smartsocket/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/smartsocket/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@push.rocks/smartsocket)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/push.rocks/smartsocket)](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/smartsocket)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@push.rocks/smartsocket)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@push.rocks/smartsocket)](https://lossless.cloud)

 ## Usage

@ -30,7 +36,7 @@ import * as q from q; // q is a promise library

 // The "Smartsocket" listens on a port and can receive new "SocketConnection" requests.
 let mySmartsocket = new smartsocket.Smartsocket({
-  port: 3000 // the port smartsocket will listen on
+  port: 3000, // the port smartsocket will listen on
 });

 // optional:
@ -43,7 +49,7 @@ mySmartsocket.setServer(someExpressServer);
 // "SocketFunction"s know which "SocketRole"s are allowed to execute them
 let mySocketRole = new smartsocket.SocketRole({
  name: 'someRoleName',
-  passwordHash: 'someHashedString'
+  passwordHash: 'someHashedString',
 });

 // A "SocketFunction" executes a referenced function and passes in any data of the corresponding "SocketRequest".
@ -51,10 +57,10 @@ let mySocketRole = new smartsocket.SocketRole({
 // Any "SocketRequest" carries a unique identifier. If the referenced function's promise resolved any passed on argument will be returned to the requesting party
 let testSocketFunction1 = new smartsocket.SocketFunction({
  funcName: 'testSocketFunction1',
-  funcDef: data => {
+  funcDef: (data) => {
    console.log('testSocketFunction1 executed successfully!');
  },
-  allowedRoles: [mySocketRole] // all roles that have access to a specific function
+  allowedRoles: [mySocketRole], // all roles that have access to a specific function
 });

 // A "Smartsocket" exposes a .clientCall() that gets
@ -62,7 +68,7 @@ let testSocketFunction1 = new smartsocket.SocketFunction({
 // 2. the data to pass in
 // 3. And a target "SocketConnection" (there can be multiple connections at once)
 // any unique id association is done internally
-mySmartsocket.clientCall('restart', data, someTargetConnection).then(responseData => {});
+mySmartsocket.clientCall('restart', data, someTargetConnection).then((responseData) => {});
 ```

 #### Client side
@ -77,7 +83,7 @@ let testSmartsocketClient = new smartsocket.SmartsocketClient({
  url: 'http://localhost',
  password: 'testPassword',
  alias: 'testClient1',
-  role: 'testRole1'
+  role: 'testRole1',
 });

 // You can .connect() and .disconnect() from a "Smartsocket"
@ -88,12 +94,12 @@ testSmartsocketClient.connect().then(() => {
 // The client can also specify "SocketFunction"s. It can also specify "SocketRole"s in case a client connects to multiple servers at once
 let testSocketFunction2 = new smartsocket.SocketFunction({
  funcName: 'testSocketFunction2',
-  funcDef: data => {}, // the function to execute, has to return promise
-  allowedRoles: []
+  funcDef: (data) => {}, // the function to execute, has to return promise
+  allowedRoles: [],
 });

 // A "SmartsocketClient" can call functions on the serverside using .serverCall() analog to the "Smartsocket"'s .clientCall method.
-mySmartsocketClient.serverCall('function', functionCallData).then(functionResponseData => {
+mySmartsocketClient.serverCall('function', functionCallData).then((functionResponseData) => {
  // the functionResponseData comes from the server... awesome, right?
 });
 ```
@ -103,9 +109,12 @@ mySmartsocketClient.serverCall('function', functionCallData).then(functionRespon
 > `data` is always a js object that you can design for your specific needs.  
 > It supports buffers for large binary data network exchange.

+## Contribution
+
+We are always happy for code contributions. If you are not the code contributing type that is ok. Still, maintaining Open Source repositories takes considerable time and thought. If you like the quality of what we do and our modules are useful to you we would appreciate a little monthly contribution: You can [contribute one time](https://lossless.link/contribute-onetime) or [contribute monthly](https://lossless.link/contribute). :)
+
 For further information read the linked docs at the top of this readme.

-> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
-| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
-
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)
+## 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)
--- a/test/test.expressserver.ts
+++ b/test/test.expressserver.ts
@ -1,34 +1,31 @@
 // tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
+import { expect, expectAsync, tap } from '@push.rocks/tapbundle';

-import * as smarthash from '@pushrocks/smarthash';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as smartexpress from '@pushrocks/smartexpress';
+import * as isohash from '@push.rocks/isohash';
+import * as smartexpress from '@apiglobal/typedserver';

-import socketIoClient = require('socket.io-client');
-import smartsocket = require('../ts/index');
+import * as smartsocket from '../ts/index.js';

 let testSmartsocket: smartsocket.Smartsocket;
 let testSmartsocketClient: smartsocket.SmartsocketClient;
-let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
-let myseServer: smartexpress.Server;
+let testSocketFunction1: smartsocket.SocketFunction<any>;
+let myseServer: smartexpress.servertools.Server;

 const testConfig = {
-  port: 3000
+  port: 3000,
 };

 // class smartsocket
 tap.test('should create a new smartsocket', async () => {
-  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
-  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver', port: testConfig.port });
+  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);
 });

 tap.test('Should accept an smartExpressServer as server', async () => {
-  myseServer = new smartexpress.Server({
+  myseServer = new smartexpress.servertools.Server({
    cors: true,
    forceSsl: false,
-    port: testConfig.port
+    port: testConfig.port,
  });

  testSmartsocket.setExternalServer('smartexpress', myseServer);
@ -36,60 +33,37 @@ tap.test('Should accept an smartExpressServer as server', async () => {
  await myseServer.start();
 });

+// class SocketFunction
+tap.test('should register a new Function', async () => {
+  testSocketFunction1 = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunction1);
+  console.log(testSmartsocket.socketFunctions);
+});
+
 tap.test('should start listening when .started is called', async () => {
  await testSmartsocket.start();
 });

-// class socketrole
-tap.test('should add a socketrole', async () => {
-  testSocketRole1 = new smartsocket.SocketRole({
-    name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword')
-  });
-  testSmartsocket.addSocketRoles([testSocketRole1]);
-});
-
-// class SocketFunction
-tap.test('should register a new Function', async () => {
-  testSocketFunction1 = new smartsocket.SocketFunction({
-    allowedRoles: [testSocketRole1],
-    funcDef: async dataArg => {
-      return dataArg;
-    },
-    funcName: 'testFunction1'
-  });
-});
-
 // class SmartsocketClient
 tap.test('should react to a new websocket connection from client', async () => {
-  const done = smartpromise.defer();
  testSmartsocketClient = new smartsocket.SmartsocketClient({
    port: testConfig.port,
    url: 'http://localhost',
-    password: 'testPassword',
    alias: 'testClient1',
-    role: 'testRole1'
  });
-  testSmartsocketClient.connect().then(() => {
-    done.resolve();
-  });
-  await done.promise;
+  testSmartsocketClient.addSocketFunction(testSocketFunction1);
+  await testSmartsocketClient.connect();
 });
-tap.test('client should disconnect and reconnect', async () => {
-  let done = smartpromise.defer();
-  testSmartsocketClient
-    .disconnect()
-    .then(() => {
-      let done = smartpromise.defer();
-      setTimeout(() => {
-        testSmartsocketClient.connect().then(done.resolve);
-      }, 0);
-      return done.promise;
-    })
-    .then(() => {
-      done.resolve();
-    });
-  await done.promise;
+
+tap.test('client should disconnect and reconnect', async (tools) => {
+  await testSmartsocketClient.disconnect();
+  await tools.delayFor(100);
+  await testSmartsocketClient.connect();
 });

 tap.test('2 clients should connect in parallel', async () => {
@ -97,38 +71,28 @@ tap.test('2 clients should connect in parallel', async () => {
 });

 tap.test('should be able to make a functionCall from client to server', async () => {
-  let done = smartpromise.defer();
-  testSmartsocketClient
-    .serverCall('testFunction1', {
-      value1: 'hello'
-    })
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
+  const totalCycles = 20000;
+  let counter = 0;
+  let startTime = Date.now();
+  while (counter < totalCycles) {
+    const randomString = `hello ${Math.random()}`;
+    const response: any = await testSmartsocketClient.serverCall('testFunction1', {
+      value1: randomString,
    });
-  await done.promise;
+    expect(response.value1).toEqual(randomString);
+    if (counter % 100 === 0) {
+      console.log(
+        `processed 100 more messages in ${Date.now() - startTime}ms. ${
+          totalCycles - counter
+        } messages to go.`
+      );
+      startTime = Date.now();
+    }
+    counter++;
+  }
 });

-tap.test('should be able to make a functionCall from server to client', async () => {
-  let done = smartpromise.defer();
-  let targetSocket = (() => {
-    return smartsocket.allSocketConnections.find(socketConnectionArg => {
-      return socketConnectionArg.alias === 'testClient1';
-    });
-  })();
-  testSmartsocket
-    .clientCall(
-      'testFunction1',
-      {
-        value1: 'helloFromServer'
-      },
-      targetSocket
-    )
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-});
+tap.test('should be able to make a functionCall from server to client', async () => {});

 // terminate
 tap.test('should close the server', async () => {
--- a/test/test.reconnect.ts
+++ b/test/test.reconnect.ts
@ -0,0 +1,152 @@
+// tslint:disable-next-line:no-implicit-dependencies
+import { expect, tap } from '@push.rocks/tapbundle';
+
+import * as smartsocket from '../ts/index.js';
+
+let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketFunctionForServer: smartsocket.SocketFunction<any>;
+let testSocketFunctionClient: smartsocket.SocketFunction<any>;
+
+export interface IReqResClient {
+  method: 'testFunction1';
+  request: {
+    value1: string;
+  };
+  response: {
+    value1: string;
+  };
+}
+
+export interface IReqResServer {
+  method: 'testFunction2';
+  request: {
+    hi: string;
+  };
+  response: {
+    hi: string;
+  };
+}
+
+const testConfig = {
+  port: 3000,
+};
+
+// class smartsocket
+tap.test('should create a new smartsocket', async () => {
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver1', port: testConfig.port });
+  await testSmartsocket.start();
+});
+
+// class SocketFunction
+tap.test('should register a new Function', async () => {
+  testSocketFunctionForServer = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+
+  testSocketFunctionClient = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction2',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+});
+
+// class SmartsocketClient
+tap.test('should react to a new websocket connection from client', async () => {
+  testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: 'http://localhost',
+    alias: 'testClient1',
+    autoReconnect: true,
+  });
+  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
+  await testSmartsocketClient.connect();
+});
+
+tap.test('should be able to tag a connection from client', async (tools) => {
+  await testSmartsocketClient.addTag({
+    id: 'awesome',
+    payload: 'yes',
+  });
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
+tap.test('should be able to tag a connection from server', async (tools) => {
+  await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .addTag({
+      id: 'awesome2',
+      payload: 'absolutely',
+    });
+  const tagOnClientSide = await testSmartsocketClient.socketConnection.getTagById('awesome2');
+  expect(tagOnClientSide.payload).toEqual('absolutely');
+});
+
+tap.test('should be able to make a functionCall from client to server', async () => {
+  const response = await testSmartsocketClient.serverCall<IReqResClient>('testFunction1', {
+    value1: 'hello',
+  });
+  console.log(response);
+  expect(response.value1).toEqual('hello');
+});
+
+tap.test('should be able to make a functionCall from server to client', async () => {
+  const response = await testSmartsocket.clientCall<IReqResServer>(
+    'testFunction2',
+    {
+      hi: 'hi there from server',
+    },
+    testSmartsocket.socketConnections.findSync((socketConnection) => {
+      return true;
+    })
+  );
+  console.log(response);
+  expect(response.hi).toEqual('hi there from server');
+});
+
+tap.test('client should disconnect and reconnect', async (toolsArg) => {
+  await testSmartsocketClient.disconnect();
+  await testSmartsocketClient.connect();
+  await toolsArg.delayFor(2000);
+  expect(testSmartsocket.socketConnections.getArray().length).toEqual(1);
+});
+
+// class smartsocket
+tap.test('should be able to switch to a new server', async (toolsArg) => {
+  await testSmartsocket.stop();
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver2', port: testConfig.port });
+  await testSmartsocket.start();
+  await toolsArg.delayFor(30000);
+});
+
+tap.test('should be able to locate a connection tag after reconnect', async (tools) => {
+  expect(testSmartsocket.socketConnections.getArray().length).toEqual(1);
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
+// terminate
+tap.test('should close the server', async (tools) => {
+  await testSmartsocketClient.stop();
+  await testSmartsocket.stop();
+  tools.delayFor(1000).then(() => process.exit(0));
+});
+
+tap.start();
--- a/test/test.tagging.ts
+++ b/test/test.tagging.ts
@ -0,0 +1,147 @@
+// tslint:disable-next-line:no-implicit-dependencies
+import { expect, tap } from '@push.rocks/tapbundle';
+
+import * as smartsocket from '../ts/index.js';
+
+let testSmartsocket: smartsocket.Smartsocket;
+let testSmartsocketClient: smartsocket.SmartsocketClient;
+let testSocketFunctionForServer: smartsocket.SocketFunction<any>;
+let testSocketFunctionClient: smartsocket.SocketFunction<any>;
+
+export interface IReqResClient {
+  method: 'testFunction1';
+  request: {
+    value1: string;
+  };
+  response: {
+    value1: string;
+  };
+}
+
+export interface IReqResServer {
+  method: 'testFunction2';
+  request: {
+    hi: string;
+  };
+  response: {
+    hi: string;
+  };
+}
+
+const testConfig = {
+  port: 3000,
+};
+
+// class smartsocket
+tap.test('should create a new smartsocket', async () => {
+  testSmartsocket = new smartsocket.Smartsocket({ alias: 'testserver2', port: testConfig.port });
+  expect(testSmartsocket).toBeInstanceOf(smartsocket.Smartsocket);
+});
+
+// class SocketFunction
+tap.test('should register a new Function', async () => {
+  testSocketFunctionForServer = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction1',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+
+  testSocketFunctionClient = new smartsocket.SocketFunction({
+    funcDef: async (dataArg, socketConnectionArg) => {
+      return dataArg;
+    },
+    funcName: 'testFunction2',
+  });
+  testSmartsocket.addSocketFunction(testSocketFunctionForServer);
+});
+
+tap.test('should start listening when .started is called', async () => {
+  await testSmartsocket.start();
+});
+
+// class SmartsocketClient
+tap.test('should react to a new websocket connection from client', async () => {
+  testSmartsocketClient = new smartsocket.SmartsocketClient({
+    port: testConfig.port,
+    url: 'http://localhost',
+    alias: 'testClient1',
+  });
+  testSmartsocketClient.addSocketFunction(testSocketFunctionClient);
+  await testSmartsocketClient.connect();
+});
+
+tap.test('should be able to tag a connection from client', async (tools) => {
+  await testSmartsocketClient.addTag({
+    id: 'awesome',
+    payload: 'yes',
+  });
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
+tap.test('should be able to tag a connection from server', async (tools) => {
+  await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .addTag({
+      id: 'awesome2',
+      payload: 'absolutely',
+    });
+  const tagOnClientSide = await testSmartsocketClient.socketConnection.getTagById('awesome2');
+  expect(tagOnClientSide.payload).toEqual('absolutely');
+});
+
+tap.test('2 clients should connect in parallel', async () => {
+  // TODO: implement parallel test
+});
+
+tap.test('should be able to make a functionCall from client to server', async () => {
+  const response = await testSmartsocketClient.serverCall<IReqResClient>('testFunction1', {
+    value1: 'hello',
+  });
+  console.log(response);
+  expect(response.value1).toEqual('hello');
+});
+
+tap.test('should be able to make a functionCall from server to client', async () => {
+  const response = await testSmartsocket.clientCall<IReqResServer>(
+    'testFunction2',
+    {
+      hi: 'hi there from server',
+    },
+    testSmartsocket.socketConnections.findSync((socketConnection) => {
+      return true;
+    })
+  );
+  console.log(response);
+  expect(response.hi).toEqual('hi there from server');
+});
+
+tap.test('client should disconnect and reconnect', async (tools) => {
+  await testSmartsocketClient.disconnect();
+  await testSmartsocketClient.connect();
+});
+
+tap.test('should be able to locate a connection tag after reconnect', async (tools) => {
+  console.log(testSmartsocket.socketConnections.getArray().length);
+  const tagOnServerSide = await testSmartsocket.socketConnections
+    .findSync((socketConnection) => {
+      return true;
+    })
+    .getTagById('awesome');
+  expect(tagOnServerSide.payload).toEqual('yes');
+});
+
+// terminate
+tap.test('should close the server', async () => {
+  await testSmartsocket.stop();
+});
+
+tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@ -1,124 +0,0 @@
-// tslint:disable-next-line:no-implicit-dependencies
-import { expect, tap } from '@pushrocks/tapbundle';
-
-import * as smarthash from '@pushrocks/smarthash';
-import * as smartpromise from '@pushrocks/smartpromise';
-
-import socketIoClient = require('socket.io-client');
-import smartsocket = require('../ts/index');
-
-let testSmartsocket: smartsocket.Smartsocket;
-let testSmartsocketClient: smartsocket.SmartsocketClient;
-let testSocketRole1: smartsocket.SocketRole;
-let testSocketFunction1: smartsocket.SocketFunction;
-
-const testConfig = {
-  port: 3000
-};
-
-// class smartsocket
-tap.test('should create a new smartsocket', async () => {
-  testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
-  expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
-});
-
-tap.test('should start listening when .started is called', async () => {
-  await testSmartsocket.start();
-});
-
-// class socketrole
-tap.test('should add a socketrole', async () => {
-  testSocketRole1 = new smartsocket.SocketRole({
-    name: 'testRole1',
-    passwordHash: smarthash.sha256FromStringSync('testPassword')
-  });
-  testSmartsocket.addSocketRoles([testSocketRole1]);
-});
-
-// class SocketFunction
-tap.test('should register a new Function', async () => {
-  testSocketFunction1 = new smartsocket.SocketFunction({
-    allowedRoles: [testSocketRole1],
-    funcDef: async dataArg => {
-      return dataArg;
-    },
-    funcName: 'testFunction1'
-  });
-});
-
-// class SmartsocketClient
-tap.test('should react to a new websocket connection from client', async () => {
-  const done = smartpromise.defer();
-  testSmartsocketClient = new smartsocket.SmartsocketClient({
-    port: testConfig.port,
-    url: 'http://localhost',
-    password: 'testPassword',
-    alias: 'testClient1',
-    role: 'testRole1'
-  });
-  testSmartsocketClient.connect().then(() => {
-    done.resolve();
-  });
-  await done.promise;
-});
-tap.test('client should disconnect and reconnect', async () => {
-  let done = smartpromise.defer();
-  testSmartsocketClient
-    .disconnect()
-    .then(() => {
-      let done = smartpromise.defer();
-      setTimeout(() => {
-        testSmartsocketClient.connect().then(done.resolve);
-      }, 0);
-      return done.promise;
-    })
-    .then(() => {
-      done.resolve();
-    });
-  await done.promise;
-});
-
-tap.test('2 clients should connect in parallel', async () => {
-  // TODO: implement parallel test
-});
-
-tap.test('should be able to make a functionCall from client to server', async () => {
-  let done = smartpromise.defer();
-  testSmartsocketClient
-    .serverCall('testFunction1', {
-      value1: 'hello'
-    })
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-  await done.promise;
-});
-
-tap.test('should be able to make a functionCall from server to client', async () => {
-  let done = smartpromise.defer();
-  let targetSocket = (() => {
-    return smartsocket.allSocketConnections.find(socketConnectionArg => {
-      return socketConnectionArg.alias === 'testClient1';
-    });
-  })();
-  testSmartsocket
-    .clientCall(
-      'testFunction1',
-      {
-        value1: 'helloFromServer'
-      },
-      targetSocket
-    )
-    .then(dataArg => {
-      console.log(dataArg);
-      done.resolve();
-    });
-});
-
-// terminate
-tap.test('should close the server', async () => {
-  await testSmartsocket.stop();
-});
-
-tap.start();
--- 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/smartsocket',
+  version: '2.0.21',
+  description: 'easy and secure websocket communication'
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,10 +1,10 @@
-import * as plugins from './smartsocket.plugins';
-
 // export main classes
-export * from './smartsocket.classes.smartsocket';
-export * from './smartsocket.classes.smartsocketclient';
+export * from './smartsocket.classes.smartsocket.js';
+export * from './smartsocket.classes.smartsocketclient.js';

 // export further classes and objects
-export * from './smartsocket.classes.socketfunction';
-export * from './smartsocket.classes.socketrole';
-export * from './smartsocket.classes.socketconnection';
+export * from './smartsocket.classes.socketfunction.js';
+export * from './smartsocket.classes.socketconnection.js';
+
+// export types so they can be referred to
+export * from './interfaces/index.js';
--- a/ts/interfaces/connection.ts
+++ b/ts/interfaces/connection.ts
@ -0,0 +1,11 @@
+export interface IRequestAuthPayload {
+  serverAlias: string;
+}
+
+export type TConnectionStatus =
+  | 'new'
+  | 'connecting'
+  | 'connected'
+  | 'disconnecting'
+  | 'disconnected'
+  | 'timedOut';
--- a/ts/interfaces/index.ts
+++ b/ts/interfaces/index.ts
@ -0,0 +1,2 @@
+export * from './connection.js';
+export * from './tag.js';
--- a/ts/interfaces/tag.ts
+++ b/ts/interfaces/tag.ts
@ -0,0 +1,6 @@
+export interface ITag<T = any> {
+  id: string;
+  payload: T;
+}
+
+export type TTagStore = { [key: string]: ITag };
--- a/ts/smartsocket.classes.smartsocket.ts
+++ b/ts/smartsocket.classes.smartsocket.ts
@ -1,34 +1,45 @@
-import * as plugins from './smartsocket.plugins';
-import * as helpers from './smartsocket.helpers';
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';

 // classes
-import { Objectmap } from '@pushrocks/lik';
-import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
-import { SocketRequest } from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
-import { SocketServer } from './smartsocket.classes.socketserver';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import {
+  type ISocketFunctionCallDataRequest,
+  SocketFunction,
+  type ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction.js';
+import { SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { SocketServer } from './smartsocket.classes.socketserver.js';

-// socket.io
-import * as SocketIO from 'socket.io';
+import { logger } from './smartsocket.logging.js';

 export interface ISmartsocketConstructorOptions {
+  alias: string;
  port?: number;
 }

 export class Smartsocket {
+  /**
+   * a unique id to detect server restarts
+   */
+  public alias: string;
+  public smartenv = new plugins.smartenv.Smartenv();
  public options: ISmartsocketConstructorOptions;
-  public io: SocketIO.Server;
-  public openSockets = new Objectmap<SocketConnection>();
-  public socketRoles = new Objectmap<SocketRole>();
+  public io: pluginsTyped.socketIo.Server;
+  public socketConnections = new plugins.lik.ObjectMap<SocketConnection>();
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
+
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();

  private socketServer = new SocketServer(this);

  constructor(optionsArg: ISmartsocketConstructorOptions) {
    this.options = optionsArg;
+    this.alias = plugins.isounique.uni(this.options.alias);
  }

-  // tslint:disable-next-line:member-ordering
  public async setExternalServer(serverType: 'smartexpress', serverArg: any) {
    await this.socketServer.setExternalServer(serverType, serverArg);
  }
@ -37,9 +48,16 @@ export class Smartsocket {
   * starts smartsocket
   */
  public async start() {
-    this.io = plugins.socketIo(this.socketServer.getServerForSocketIo());
+    const socketIoModule = await this.smartenv.getSafeNodeModule('socket.io');
+    this.io = new socketIoModule.Server(await this.socketServer.getServerForSocketIo(), {
+      cors: {
+        allowedHeaders: '*',
+        methods: '*',
+        origin: '*',
+      },
+    });
    await this.socketServer.start();
-    this.io.on('connection', socketArg => {
+    this.io.on('connection', (socketArg) => {
      this._handleSocketConnection(socketArg);
    });
  }
@ -49,14 +67,16 @@ export class Smartsocket {
   */
  public async stop() {
    await plugins.smartdelay.delayFor(1000);
-    this.openSockets.forEach((socketObjectArg: SocketConnection) => {
-      plugins.smartlog.defaultLogger.log(
-        'info',
-        `disconnect socket with >>alias ${socketObjectArg.alias}`
-      );
-      socketObjectArg.socket.disconnect();
+    this.socketConnections.forEach((socketObjectArg: SocketConnection) => {
+      if (socketObjectArg) {
+        logger.log(
+          'info',
+          `disconnecting socket with >>alias ${socketObjectArg.alias} due to server stop...`
+        );
+        socketObjectArg.disconnect();
+      }
    });
-    this.openSockets.wipe();
+    this.socketConnections.wipe();
    this.io.close();

    // stop the corresponging server
@ -68,59 +88,50 @@ export class Smartsocket {
  /**
   * allows call to specific client.
   */
-  public async clientCall(
-    functionNameArg: string,
-    dataArg: any,
+  public async clientCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
+    functionNameArg: T['method'],
+    dataArg: T['request'],
    targetSocketConnectionArg: SocketConnection
-  ) {
-    const done = plugins.smartpromise.defer();
-    const socketRequest = new SocketRequest({
+  ): Promise<T['response']> {
+    const socketRequest = new SocketRequest<T>(this, {
      funcCallData: {
        funcDataArg: dataArg,
-        funcName: functionNameArg
+        funcName: functionNameArg,
      },
      originSocketConnection: targetSocketConnectionArg,
-      shortId: plugins.shortid.generate(),
-      side: 'requesting'
+      shortId: plugins.isounique.uni(),
+      side: 'requesting',
    });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
-      done.resolve(dataArg.funcDataArg);
-    });
-    const result = await done.promise;
+    const response: ISocketFunctionCallDataResponse<T> = await socketRequest.dispatch();
+    const result = response.funcDataArg;
    return result;
  }

-  /**
-   * adds socketRoles
-   */
-  public addSocketRoles(socketRolesArray: SocketRole[]): void {
-    for (const socketRole of socketRolesArray) {
-      this.socketRoles.add(socketRole);
-    }
-    return;
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
  }

  /**
   * the standard handler for new socket connections
   */
-  private _handleSocketConnection(socketArg) {
+  private async _handleSocketConnection(socketArg: pluginsTyped.socketIo.Socket) {
    const socketConnection: SocketConnection = new SocketConnection({
      alias: undefined,
      authenticated: false,
-      role: undefined,
      side: 'server',
      smartsocketHost: this,
-      socket: socketArg
+      socket: socketArg,
    });
-    plugins.smartlog.defaultLogger.log('info', 'Socket connected. Trying to authenticate...');
-    this.openSockets.add(socketConnection);
-    socketConnection
-      .authenticate()
-      .then(() => {
-        return socketConnection.listenToFunctionRequests();
-      })
-      .catch(err => {
-        console.log(err);
-      });
+    logger.log('info', 'Socket connected. Trying to authenticate...');
+    this.socketConnections.add(socketConnection);
+    const disconnectSubscription = socketConnection.eventSubject.subscribe((eventArg) => {
+      if (eventArg === 'disconnected') {
+        this.socketConnections.remove(socketConnection);
+        disconnectSubscription.unsubscribe();
+      }
+    });
+    await socketConnection.authenticate();
+    await socketConnection.listenToFunctionRequests();
+    await socketConnection.socket.emit('serverFullyReactive');
  }
 }
--- a/ts/smartsocket.classes.smartsocketclient.ts
+++ b/ts/smartsocket.classes.smartsocketclient.ts
@ -1,8 +1,14 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';

-import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { ISocketFunctionCall, SocketFunction } from './smartsocket.classes.socketfunction';
-import { ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import {
+  type ISocketFunctionCallDataRequest,
+  SocketFunction,
+} from './smartsocket.classes.socketfunction.js';
+import { type ISocketRequestDataObject, SocketRequest } from './smartsocket.classes.socketrequest.js';
+import { logger } from './smartsocket.logging.js';

 /**
 * interface for class SmartsocketClient
@ -11,80 +17,250 @@ export interface ISmartsocketClientOptions {
  port: number;
  url: string;
  alias: string; // an alias makes it easier to identify this client in a multo client environment
-  role: string;
-  password: string; // by setting a password access to functions can be limited
+  autoReconnect?: boolean;
 }

 export class SmartsocketClient {
-  alias: string;
-  role: string;
-  socketConnection: SocketConnection;
-  serverUrl: string;
-  serverPort: number;
-  serverPassword: string;
+  // a unique id
+  public shortId = plugins.isounique.uni();
+
+  // the shortId of the remote we connect to
+  public remoteShortId: string = null;
+
+  public alias: string;
+  public socketConnection: SocketConnection;
+  public serverUrl: string;
+  public serverPort: number;
+  public autoReconnect: boolean;
+
+  // status handling
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
+  public socketFunctions = new plugins.lik.ObjectMap<SocketFunction<any>>();
+  public socketRequests = new plugins.lik.ObjectMap<SocketRequest<any>>();
+
+  // tagStore
+  private tagStore: { [key: string]: interfaces.ITag } = {};
+  private tagStoreSubscription: plugins.smartrx.rxjs.Subscription;
+
+  /**
+   * adds a tag to a connection
+   */
+  public async addTag(tagArg: interfaces.ITag) {
+    if (this.socketConnection) {
+      await this.socketConnection.addTag(tagArg);
+    } else {
+      this.tagStore[tagArg.id] = tagArg;
+    }
+  }
+
+  /**
+   * gets a tag by id
+   * @param tagIdArg
+   */
+  public async getTagById(tagIdArg: interfaces.ITag['id']) {
+    return this.tagStore[tagIdArg];
+  }
+
+  /**
+   * removes a tag from a connection
+   */
+  public async removeTagById(tagIdArg: interfaces.ITag['id']) {
+    if (this.socketConnection) {
+      this.socketConnection.removeTagById(tagIdArg);
+    } else {
+      delete this.tagStore[tagIdArg];
+    }
+  }
+
  constructor(optionsArg: ISmartsocketClientOptions) {
    this.alias = optionsArg.alias;
-    this.role = optionsArg.role;
    this.serverUrl = optionsArg.url;
    this.serverPort = optionsArg.port;
-    this.serverPassword = optionsArg.password;
+    this.autoReconnect = optionsArg.autoReconnect;
+  }
+
+  public addSocketFunction(socketFunction: SocketFunction<any>) {
+    this.socketFunctions.add(socketFunction);
  }

  /**
   * connect the client to the server
   */
-  connect() {
-    let done = plugins.smartpromise.defer();
-    plugins.smartlog.defaultLogger.log('info', 'trying to connect...');
-    let socketUrl = `${this.serverUrl}:${this.serverPort}`;
+  public async connect() {
+    const done = plugins.smartpromise.defer();
+    const smartenvInstance = new plugins.smartenv.Smartenv();
+    const socketIoClient: any = await smartenvInstance.getEnvAwareModule({
+      nodeModuleName: 'socket.io-client',
+      webUrlArg: 'https://cdn.jsdelivr.net/npm/socket.io-client@4/dist/socket.io.js',
+      getFunction: () => {
+        const socketIoBrowserModule = (globalThis as any).io;
+        // console.log('loaded socket.io for browser');
+        return socketIoBrowserModule;
+      },
+    });
+    // console.log(socketIoClient);
+    logger.log('info', 'trying to connect...');
+    const socketUrl = `${this.serverUrl}:${this.serverPort}`;
    this.socketConnection = new SocketConnection({
      alias: this.alias,
      authenticated: false,
-      role: undefined,
      side: 'client',
-      smartsocketHost: null,
-      socket: plugins.socketIoClient(socketUrl, { multiplex: false })
+      smartsocketHost: this,
+      socket: await socketIoClient
+        .connect(socketUrl, {
+          multiplex: true,
+          rememberUpgrade: true,
+          autoConnect: false,
+          reconnectionAttempts: 0,
+          rejectUnauthorized: socketUrl.startsWith('https://localhost') ? false : true,
+        })
+        .open(),
    });
-    this.socketConnection.socket.on('requestAuth', () => {
-      console.log('server requested authentication');
-      this.socketConnection.socket.emit('dataAuth', {
-        role: this.role,
-        password: this.serverPassword,
-        alias: this.alias
-      });
-      this.socketConnection.socket.on('authenticated', () => {
-        console.log('client is authenticated');
+
+    const timer = new plugins.smarttime.Timer(5000);
+    timer.start();
+    timer.completed.then(() => {
+      this.updateStatus('timedOut');
+      logger.log('warn', 'connection to server timed out.');
+      this.disconnect(true);
+    });
+
+    // authentication flow
+    this.socketConnection.socket.on('requestAuth', (dataArg: interfaces.IRequestAuthPayload) => {
+      timer.reset();
+      logger.log('info', `server ${dataArg.serverAlias} requested authentication`);
+
+      // lets register the authenticated event
+      this.socketConnection.socket.on('authenticated', async () => {
+        this.remoteShortId = dataArg.serverAlias;
+        logger.log('info', 'client is authenticated');
        this.socketConnection.authenticated = true;
-        this.socketConnection.listenToFunctionRequests();
+        await this.socketConnection.listenToFunctionRequests();
+      });
+
+      this.socketConnection.socket.on('serverFullyReactive', async () => {
+        // lets take care of retagging
+        const oldTagStore = this.tagStore;
+        this.tagStoreSubscription?.unsubscribe();
+        for (const keyArg of Object.keys(this.tagStore)) {
+          this.socketConnection.addTag(this.tagStore[keyArg]);
+        }
+        this.tagStoreSubscription = this.socketConnection.tagStoreObservable.subscribe(
+          (tagStoreArg) => {
+            this.tagStore = tagStoreArg;
+          }
+        );
+
+        for (const tag of Object.keys(oldTagStore)) {
+          await this.addTag(oldTagStore[tag]);
+        }
+        this.updateStatus('connected');
        done.resolve();
      });
+
+      // lets register the forbidden event
+      this.socketConnection.socket.on('forbidden', async () => {
+        logger.log('warn', `disconnecting due to being forbidden to use the ressource`);
+        await this.disconnect();
+      });
+
+      // lets provide the actual auth data
+      this.socketConnection.socket.emit('dataAuth', {
+        alias: this.alias,
+      });
+    });
+
+    // handle connection
+    this.socketConnection.socket.on('connect', async () => {});
+
+    // handle disconnection and errors
+    this.socketConnection.socket.on('disconnect', async () => {
+      await this.disconnect(true);
+    });
+
+    this.socketConnection.socket.on('reconnect_failed', async () => {
+      await this.disconnect(true);
+    });
+    this.socketConnection.socket.on('connect_error', async () => {
+      await this.disconnect(true);
    });
    return done.promise;
  }

-  disconnect() {
-    let done = plugins.smartpromise.defer();
-    this.socketConnection.socket.disconnect();
-    this.socketConnection = undefined;
-    plugins.smartlog.defaultLogger.log('ok', 'disconnected!');
-    done.resolve();
-    return done.promise;
+  private disconnectRunning = false;
+
+  /**
+   * disconnect from the server
+   */
+  public async disconnect(useAutoReconnectSetting = false) {
+    if (this.disconnectRunning) {
+      return;
+    }
+    this.disconnectRunning = true;
+    this.updateStatus('disconnecting');
+    this.tagStoreSubscription?.unsubscribe();
+    if (this.socketConnection) {
+      await this.socketConnection.disconnect();
+      this.socketConnection = undefined;
+      logger.log('ok', 'disconnected socket!');
+    } else {
+      this.disconnectRunning = false;
+      logger.log('warn', 'tried to disconnect, without a SocketConnection');
+      return;
+    }
+
+    logger.log('warn', `disconnected from server ${this.remoteShortId}`);
+    this.remoteShortId = null;
+
+    if (this.autoReconnect && useAutoReconnectSetting && this.eventStatus !== 'connecting') {
+      this.updateStatus('connecting');
+      console.log('debounced reconnect!');
+      await plugins.smartdelay.delayForRandom(10000, 20000);
+      this.disconnectRunning = false;
+      await this.connect();
+    } else {
+      this.disconnectRunning = false;
+    }
  }

-  serverCall(functionNameArg: string, dataArg: any) {
-    let done = plugins.smartpromise.defer();
-    let socketRequest = new SocketRequest({
+  /**
+   * stops the client completely
+   */
+  public async stop() {
+    this.autoReconnect = false;
+    await this.disconnect();
+  }
+
+  /**
+   * dispatches a server call
+   * @param functionNameArg
+   * @param dataArg
+   */
+  public async serverCall<T extends plugins.typedrequestInterfaces.ITypedRequest>(
+    functionNameArg: T['method'],
+    dataArg: T['request']
+  ): Promise<T['response']> {
+    const done = plugins.smartpromise.defer();
+    const socketRequest = new SocketRequest<T>(this, {
      side: 'requesting',
      originSocketConnection: this.socketConnection,
-      shortId: plugins.shortid.generate(),
+      shortId: plugins.isounique.uni(),
      funcCallData: {
        funcName: functionNameArg,
-        funcDataArg: dataArg
-      }
+        funcDataArg: dataArg,
+      },
    });
-    socketRequest.dispatch().then((dataArg: ISocketFunctionCall) => {
-      done.resolve(dataArg.funcDataArg);
-    });
-    return done.promise;
+    const response = await socketRequest.dispatch();
+    const result = response.funcDataArg;
+    return result;
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
  }
 }
--- a/ts/smartsocket.classes.socketconnection.ts
+++ b/ts/smartsocket.classes.socketconnection.ts
@ -1,20 +1,15 @@
-import * as plugins from './smartsocket.plugins';
-import * as helpers from './smartsocket.helpers';
-
-import { Objectmap } from '@pushrocks/lik';
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';
+import * as interfaces from './interfaces/index.js';

 // import classes
-import { Smartsocket } from './smartsocket.classes.smartsocket';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
-import {
-  SocketRequest,
-  ISocketRequestDataObject,
-  allSocketRequests
-} from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SocketFunction } from './smartsocket.classes.socketfunction.js';
+import { SocketRequest, type ISocketRequestDataObject } from './smartsocket.classes.socketrequest.js';

 // socket.io
-import * as SocketIO from 'socket.io';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';
+import { logger } from './smartsocket.logging.js';

 // export interfaces

@ -29,85 +24,129 @@ export type TSocketConnectionSide = 'server' | 'client';
 export interface ISocketConnectionConstructorOptions {
  alias: string;
  authenticated: boolean;
-  role: SocketRole;
  side: TSocketConnectionSide;
-  smartsocketHost: Smartsocket;
-  socket: SocketIO.Socket | SocketIOClient.Socket;
+  smartsocketHost: Smartsocket | SmartsocketClient;
+  socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
 }

 /**
 * interface for authentication data
 */
 export interface ISocketConnectionAuthenticationObject {
-  role: 'coreflowContainer';
-  password: 'somePassword';
-  alias: 'coreflow1';
+  alias: string;
 }

 // export classes
-export let allSocketConnections = new Objectmap<SocketConnection>();
+export let allSocketConnections = new plugins.lik.ObjectMap<SocketConnection>();

 /**
 * class SocketConnection represents a websocket connection
 */
 export class SocketConnection {
-  alias: string;
-  side: TSocketConnectionSide;
-  authenticated: boolean = false;
-  role: SocketRole;
-  smartsocketHost: Smartsocket;
-  socket: any; // SocketIO.Socket | SocketIOClient.Socket
+  public alias: string;
+  public side: TSocketConnectionSide;
+  public authenticated: boolean = false;
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+  public socket: pluginsTyped.socketIo.Socket | pluginsTyped.socketIoClient.Socket;
+
+  public eventSubject = new plugins.smartrx.rxjs.Subject<interfaces.TConnectionStatus>();
+  public eventStatus: interfaces.TConnectionStatus = 'new';
+
+  private tagStore: interfaces.TTagStore = {};
+  public tagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+  public remoteTagStoreObservable = new plugins.smartrx.rxjs.Subject<interfaces.TTagStore>();
+
  constructor(optionsArg: ISocketConnectionConstructorOptions) {
    this.alias = optionsArg.alias;
    this.authenticated = optionsArg.authenticated;
-    this.role = optionsArg.role;
    this.side = optionsArg.side;
-    this.smartsocketHost = optionsArg.smartsocketHost;
+    this.smartsocketRef = optionsArg.smartsocketHost;
    this.socket = optionsArg.socket;

    // standard behaviour that is always true
    allSocketConnections.add(this);
-    this.socket.on('disconnect', () => {
-      plugins.smartlog.defaultLogger.log(
+
+    // handle connection
+    this.socket.on('connect', async () => {
+      this.updateStatus('connected');
+    });
+    this.socket.on('disconnect', async () => {
+      logger.log(
        'info',
        `SocketConnection with >alias ${this.alias} on >side ${this.side} disconnected`
      );
-      this.socket.disconnect();
+      await this.disconnect();
      allSocketConnections.remove(this);
+      this.eventSubject.next('disconnected');
    });
  }

+  /**
+   * adds a tag to a connection
+   */
+  public async addTag(tagArg: interfaces.ITag) {
+    const done = plugins.smartpromise.defer();
+    this.tagStore[tagArg.id] = tagArg;
+    this.tagStoreObservable.next(this.tagStore);
+    const remoteSubscription = this.remoteTagStoreObservable.subscribe((remoteTagStore) => {
+      if (!remoteTagStore[tagArg.id]) {
+        return;
+      }
+      const localTagString = plugins.smartjson.stringify(tagArg);
+      const remoteTagString = plugins.smartjson.stringify(remoteTagStore[tagArg.id]);
+      if (localTagString === remoteTagString) {
+        remoteSubscription.unsubscribe();
+        done.resolve();
+      }
+    });
+    this.socket.emit('updateTagStore', this.tagStore);
+    await done.promise;
+  }
+
+  /**
+   * gets a tag by id
+   * @param tagIdArg
+   */
+  public async getTagById(tagIdArg: interfaces.ITag['id']) {
+    return this.tagStore[tagIdArg];
+  }
+
+  /**
+   * removes a tag from a connection
+   */
+  public async removeTagById(tagIdArg: interfaces.ITag['id']) {
+    delete this.tagStore[tagIdArg];
+    this.tagStoreObservable.next(this.tagStore);
+    this.socket.emit('updateTagStore', this.tagStore);
+  }
+
  // authenticating --------------------------

  /**
   * authenticate the socket
   */
-  authenticate() {
-    let done = plugins.smartpromise.defer();
-    this.socket.on('dataAuth', (dataArg: ISocketConnectionAuthenticationObject) => {
-      plugins.smartlog.defaultLogger.log(
-        'info',
-        'received authentication data. now hashing and comparing...'
-      );
-      this.socket.removeListener('dataAuth', () => {});
-      if (helpers.checkPasswordForRole(dataArg, this.smartsocketHost)) {
+  public authenticate() {
+    const done = plugins.smartpromise.defer();
+    this.socket.on('dataAuth', async (dataArg: ISocketConnectionAuthenticationObject) => {
+      logger.log('info', 'received authentication data...');
+      this.socket.removeAllListeners('dataAuth');
+      if (dataArg.alias) {
        // TODO: authenticate password
        this.alias = dataArg.alias;
        this.authenticated = true;
-        this.role = helpers.getSocketRoleByName(dataArg.role, this.smartsocketHost);
        this.socket.emit('authenticated');
-        plugins.smartlog.defaultLogger.log(
-          'ok',
-          `socket with >>alias ${this.alias} >>role ${this.role} is authenticated!`
-        );
+        logger.log('ok', `socket with >>alias ${this.alias} is authenticated!`);
        done.resolve(this);
      } else {
        this.authenticated = false;
-        this.socket.disconnect();
-        done.reject('not authenticated');
+        await this.disconnect();
+        done.reject('a socket tried to connect, but could not authenticated.');
      }
    });
-    this.socket.emit('requestAuth');
+    const requestAuthPayload: interfaces.IRequestAuthPayload = {
+      serverAlias: this.smartsocketRef.alias,
+    };
+    this.socket.emit('requestAuth', requestAuthPayload);
    return done.promise;
  }

@ -116,53 +155,70 @@ export class SocketConnection {
  /**
   * listen to function requests
   */
-  listenToFunctionRequests() {
-    let done = plugins.smartpromise.defer();
+  public listenToFunctionRequests() {
+    const done = plugins.smartpromise.defer();
    if (this.authenticated) {
-      this.socket.on('function', (dataArg: ISocketRequestDataObject) => {
+      this.socket.on('function', (dataArg: ISocketRequestDataObject<any>) => {
        // check if requested function is available to the socket's scope
-        plugins.smartlog.defaultLogger.log('info', 'function request received');
-        let referencedFunction: SocketFunction = this.role.allowedFunctions.find(
-          socketFunctionArg => {
+        // logger.log('info', 'function request received');
+        const referencedFunction: SocketFunction<any> =
+          this.smartsocketRef.socketFunctions.findSync((socketFunctionArg) => {
            return socketFunctionArg.name === dataArg.funcCallData.funcName;
-          }
-        );
-        if (referencedFunction !== undefined) {
-          plugins.smartlog.defaultLogger.log('ok', 'function in access scope');
-          let localSocketRequest = new SocketRequest({
+          });
+        if (referencedFunction) {
+          // logger.log('ok', 'function in access scope');
+          const localSocketRequest = new SocketRequest(this.smartsocketRef, {
            side: 'responding',
            originSocketConnection: this,
            shortId: dataArg.shortId,
-            funcCallData: dataArg.funcCallData
+            funcCallData: dataArg.funcCallData,
          });
          localSocketRequest.createResponse(); // takes care of creating response and sending it back
        } else {
-          plugins.smartlog.defaultLogger.log(
-            'warn',
-            'function not existent or out of access scope'
-          );
+          logger.log('warn', 'function not existent or out of access scope');
        }
      });
-      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject) => {
-        plugins.smartlog.defaultLogger.log(
-          'info',
-          `received response for request with id ${dataArg.shortId}`
+      this.socket.on('functionResponse', (dataArg: ISocketRequestDataObject<any>) => {
+        // logger.log('info', `received response for request with id ${dataArg.shortId}`);
+        const targetSocketRequest = SocketRequest.getSocketRequestById(
+          this.smartsocketRef,
+          dataArg.shortId
        );
-        let targetSocketRequest = helpers.getSocketRequestById(dataArg.shortId);
        targetSocketRequest.handleResponse(dataArg);
      });
-      plugins.smartlog.defaultLogger.log(
+
+      this.socket.on('updateTagStore', async (tagStoreArg: interfaces.TTagStore) => {
+        if (!plugins.smartjson.deepEqualObjects(this.tagStore, tagStoreArg)) {
+          this.tagStore = tagStoreArg;
+          this.socket.emit('updateTagStore', this.tagStore);
+          this.tagStoreObservable.next(this.tagStore);
+        }
+        this.remoteTagStoreObservable.next(tagStoreArg);
+      });
+
+      logger.log(
        'info',
-        `now listening to function requests for ${this.alias}`
+        `now listening to function requests for ${this.alias} on side ${this.side}`
      );
      done.resolve(this);
    } else {
-      let errMessage: 'socket needs to be authenticated first';
-      plugins.smartlog.defaultLogger.log('error', errMessage);
+      const errMessage = 'socket needs to be authenticated first';
+      logger.log('error', errMessage);
      done.reject(errMessage);
    }
    return done.promise;
  }

-  // sending ----------------------
+  // disconnecting ----------------------
+  public async disconnect() {
+    this.socket.disconnect(true);
+    this.updateStatus('disconnected');
+  }
+
+  private updateStatus(statusArg: interfaces.TConnectionStatus) {
+    if (this.eventStatus !== statusArg) {
+      this.eventSubject.next(statusArg);
+    }
+    this.eventStatus = statusArg;
+  }
 }
--- a/ts/smartsocket.classes.socketfunction.ts
+++ b/ts/smartsocket.classes.socketfunction.ts
@ -1,84 +1,93 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';

 // import classes
-import { Objectmap } from '@pushrocks/lik';
-import { SocketRole } from './smartsocket.classes.socketrole';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';

 // export interfaces

 /**
 * interface of the contructor options of class SocketFunction
 */
-export interface ISocketFunctionConstructorOptions {
-  funcName: string;
-  funcDef: any;
-  allowedRoles: SocketRole[]; // all roles that are allowed to execute a SocketFunction
+export interface ISocketFunctionConstructorOptions<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDef: TFuncDef<T>;
 }

 /**
 * interface of the Socket Function call, in other words the object that routes a call to a function
 */
-export interface ISocketFunctionCall {
-  funcName: string;
-  funcDataArg: any;
+export interface ISocketFunctionCallDataRequest<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDataArg: T['request'];
+}
+
+/**
+ * interface of the Socket Function call, in other words the object that routes a call to a function
+ */
+export interface ISocketFunctionCallDataResponse<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
+  funcName: T['method'];
+  funcDataArg: T['response'];
 }

 /**
 * interface for function definition of SocketFunction
 */
-export interface IFuncDef {
-  (dataArg: any): PromiseLike<any>;
-}
-
-// export objects
-export let allSocketFunctions = new Objectmap<SocketFunction>();
+export type TFuncDef<T extends plugins.typedrequestInterfaces.ITypedRequest> = (
+  dataArg: T['request'],
+  connectionArg: SocketConnection
+) => PromiseLike<T['response']>;

 // export classes

 /**
 * class that respresents a function that can be transparently called using a SocketConnection
 */
-export class SocketFunction {
-  name: string;
-  funcDef: IFuncDef;
-  roles: SocketRole[];
+export class SocketFunction<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  // STATIC
+  public static getSocketFunctionByName<Q extends plugins.typedrequestInterfaces.ITypedRequest>(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    functionNameArg: string
+  ): SocketFunction<Q> {
+    return smartsocketRefArg.socketFunctions.findSync((socketFunctionArg) => {
+      return socketFunctionArg.name === functionNameArg;
+    });
+  }
+
+  // INSTANCE
+  public name: string;
+  public funcDef: TFuncDef<T>;

  /**
   * the constructor for SocketFunction
   */
-  constructor(optionsArg: ISocketFunctionConstructorOptions) {
+  constructor(optionsArg: ISocketFunctionConstructorOptions<T>) {
    this.name = optionsArg.funcName;
    this.funcDef = optionsArg.funcDef;
-    this.roles = optionsArg.allowedRoles;
-    for (let socketRoleArg of this.roles) {
-      this._notifyRole(socketRoleArg);
-    }
-    allSocketFunctions.add(this); // map instance with Objectmap
  }

  /**
   * invokes the function of this SocketFunction
   */
-  invoke(dataArg: ISocketFunctionCall): Promise<any> {
-    let done = plugins.smartpromise.defer();
+  public async invoke(
+    dataArg: ISocketFunctionCallDataRequest<T>,
+    socketConnectionArg: SocketConnection
+  ): Promise<ISocketFunctionCallDataResponse<T>> {
    if (dataArg.funcName === this.name) {
-      this.funcDef(dataArg.funcDataArg).then((resultData: any) => {
-        let funcResponseData: ISocketFunctionCall = {
-          funcName: this.name,
-          funcDataArg: resultData
-        };
-        done.resolve(funcResponseData);
-      });
+      const funcResponseData: ISocketFunctionCallDataResponse<T> = {
+        funcName: this.name,
+        funcDataArg: await this.funcDef(dataArg.funcDataArg, socketConnectionArg),
+      };
+      return funcResponseData;
    } else {
      throw new Error("SocketFunction.name does not match the data argument's .name!");
    }
-    return done.promise;
-  }
-
-  /**
-   * notifies a role about access to this SocketFunction
-   */
-  private _notifyRole(socketRoleArg: SocketRole) {
-    socketRoleArg.addSocketFunction(this);
  }
 }
--- a/ts/smartsocket.classes.socketrequest.ts
+++ b/ts/smartsocket.classes.socketrequest.ts
@ -1,14 +1,17 @@
-import * as plugins from './smartsocket.plugins';
-import * as helpers from './smartsocket.helpers';
+import * as plugins from './smartsocket.plugins.js';

 // import interfaces
-import { ISocketFunctionCall } from './smartsocket.classes.socketfunction';
+import {
+  SocketFunction,
+  type ISocketFunctionCallDataRequest,
+  type ISocketFunctionCallDataResponse,
+} from './smartsocket.classes.socketfunction.js';

 // import classes
-import { Objectmap } from '@pushrocks/lik';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
-import { SocketConnection } from './smartsocket.classes.socketconnection';
-import { defaultLogger } from '@pushrocks/smartlog';
+import { SocketConnection } from './smartsocket.classes.socketconnection.js';
+import { logger } from './smartsocket.logging.js';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { SmartsocketClient } from './smartsocket.classes.smartsocketclient.js';

 // export interfaces
 export type TSocketRequestStatus = 'new' | 'pending' | 'finished';
@ -17,39 +20,56 @@ export type TSocketRequestSide = 'requesting' | 'responding';
 /**
 * interface of constructor of class SocketRequest
 */
-export interface SocketRequestConstructorOptions {
+export interface ISocketRequestConstructorOptions<
+  T extends plugins.typedrequestInterfaces.ITypedRequest
+> {
  side: TSocketRequestSide;
  originSocketConnection: SocketConnection;
  shortId: string;
-  funcCallData?: ISocketFunctionCall;
+  funcCallData?: ISocketFunctionCallDataRequest<T>;
 }

 /**
 * request object that is sent initially and may or may not receive a response
 */
-export interface ISocketRequestDataObject {
-  funcCallData: ISocketFunctionCall;
+export interface ISocketRequestDataObject<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  funcCallData: ISocketFunctionCallDataRequest<T> | ISocketFunctionCallDataResponse<T>;
  shortId: string;
  responseTimeout?: number;
 }

-// export objects
-export let allSocketRequests = new Objectmap<SocketRequest>();
-
 // export classes
-export class SocketRequest {
-  status: TSocketRequestStatus = 'new';
-  side: TSocketRequestSide;
-  shortid: string;
-  originSocketConnection: SocketConnection;
-  funcCallData: ISocketFunctionCall;
-  done = plugins.smartpromise.defer();
-  constructor(optionsArg: SocketRequestConstructorOptions) {
+export class SocketRequest<T extends plugins.typedrequestInterfaces.ITypedRequest> {
+  // STATIC
+  public static getSocketRequestById(
+    smartsocketRef: Smartsocket | SmartsocketClient,
+    shortIdArg: string
+  ): SocketRequest<any> {
+    return smartsocketRef.socketRequests.findSync((socketRequestArg) => {
+      return socketRequestArg.shortid === shortIdArg;
+    });
+  }
+
+  // INSTANCE
+  public status: TSocketRequestStatus = 'new';
+  public side: TSocketRequestSide;
+  public shortid: string;
+  public originSocketConnection: SocketConnection;
+  public funcCallData: ISocketFunctionCallDataRequest<T>;
+  public done = plugins.smartpromise.defer<ISocketFunctionCallDataResponse<T>>();
+
+  public smartsocketRef: Smartsocket | SmartsocketClient;
+
+  constructor(
+    smartsocketRefArg: Smartsocket | SmartsocketClient,
+    optionsArg: ISocketRequestConstructorOptions<T>
+  ) {
+    this.smartsocketRef = smartsocketRefArg;
    this.side = optionsArg.side;
    this.shortid = optionsArg.shortId;
    this.funcCallData = optionsArg.funcCallData;
    this.originSocketConnection = optionsArg.originSocketConnection;
-    allSocketRequests.add(this);
+    this.smartsocketRef.socketRequests.add(this);
  }

  // requesting --------------------------
@ -57,10 +77,10 @@ export class SocketRequest {
  /**
   * dispatches a socketrequest from the requesting to the receiving side
   */
-  dispatch() {
-    let requestData: ISocketRequestDataObject = {
+  public dispatch(): Promise<ISocketFunctionCallDataResponse<T>> {
+    const requestData: ISocketRequestDataObject<T> = {
      funcCallData: this.funcCallData,
-      shortId: this.shortid
+      shortId: this.shortid,
    };
    this.originSocketConnection.socket.emit('function', requestData);
    return this.done.promise;
@ -69,10 +89,10 @@ export class SocketRequest {
  /**
   * handles the response that is received by the requesting side
   */
-  handleResponse(responseDataArg: ISocketRequestDataObject) {
-    plugins.smartlog.defaultLogger.log('info', 'handling response!');
+  public async handleResponse(responseDataArg: ISocketRequestDataObject<T>) {
+    // logger.log('info', 'handling response!');
    this.done.resolve(responseDataArg.funcCallData);
-    allSocketRequests.remove(this);
+    this.smartsocketRef.socketRequests.remove(this);
  }

  // responding --------------------------
@ -81,23 +101,26 @@ export class SocketRequest {
   * creates the response on the responding side
   */
  public async createResponse(): Promise<void> {
-    const targetSocketFunction: SocketFunction = helpers.getSocketFunctionByName(
+    const targetSocketFunction: SocketFunction<T> = SocketFunction.getSocketFunctionByName(
+      this.smartsocketRef,
      this.funcCallData.funcName
    );
+
    if (!targetSocketFunction) {
-      defaultLogger.log('warn', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
-      defaultLogger.log('warn', `So now response is being sent.`);
+      logger.log('error', `There is no SocketFunction defined for ${this.funcCallData.funcName}`);
      return;
    }
-    plugins.smartlog.defaultLogger.log('info', `invoking ${targetSocketFunction.name}`);
-    targetSocketFunction.invoke(this.funcCallData).then(resultData => {
-      plugins.smartlog.defaultLogger.log('info', 'got resultData. Sending it to requesting party.');
-      let requestData: ISocketRequestDataObject = {
-        funcCallData: resultData,
-        shortId: this.shortid
-      };
-      this.originSocketConnection.socket.emit('functionResponse', requestData);
-      allSocketRequests.remove(this);
-    });
+    // logger.log('info', `invoking ${targetSocketFunction.name}`);
+    targetSocketFunction
+      .invoke(this.funcCallData, this.originSocketConnection)
+      .then((resultData) => {
+        // logger.log('info', 'got resultData. Sending it to requesting party.');
+        const responseData: ISocketRequestDataObject<T> = {
+          funcCallData: resultData,
+          shortId: this.shortid,
+        };
+        this.originSocketConnection.socket.emit('functionResponse', responseData);
+        this.smartsocketRef.socketRequests.remove(this);
+      });
  }
 }
--- a/ts/smartsocket.classes.socketrole.ts
+++ b/ts/smartsocket.classes.socketrole.ts
@ -1,29 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-
-// import classes
-import { Objectmap } from '@pushrocks/lik';
-import { SocketFunction } from './smartsocket.classes.socketfunction';
-
-/**
- * interface for class SocketRole
- */
-export interface SocketRoleOptions {
-  name: string;
-  passwordHash: string;
-}
-
-/**
- * A socketrole defines access to certain routines.
- */
-export class SocketRole {
-  name: string;
-  passwordHash: string;
-  allowedFunctions = new Objectmap<SocketFunction>();
-  constructor(optionsArg: SocketRoleOptions) {
-    this.name = optionsArg.name;
-    this.passwordHash = optionsArg.passwordHash;
-  }
-  addSocketFunction(socketFunctionArg: SocketFunction) {
-    this.allowedFunctions.add(socketFunctionArg);
-  }
-}
--- a/ts/smartsocket.classes.socketserver.ts
+++ b/ts/smartsocket.classes.socketserver.ts
@ -1,8 +1,9 @@
-import * as plugins from './smartsocket.plugins';
+import * as plugins from './smartsocket.plugins.js';
+import * as pluginsTyped from './smartsocket.pluginstyped.js';

 // used in case no other server is supplied
-import * as http from 'http';
-import { Smartsocket } from './smartsocket.classes.smartsocket';
+import { Smartsocket } from './smartsocket.classes.smartsocket.js';
+import { logger } from './smartsocket.logging.js';

 /**
 * class socketServer
@ -10,10 +11,13 @@ import { Smartsocket } from './smartsocket.classes.smartsocket';
 */
 export class SocketServer {
  private smartsocket: Smartsocket;
-  private httpServer: http.Server;
-  // wether httpServer is standalone
+  private httpServerDeferred: plugins.smartpromise.Deferred<any>;
+  private httpServer: pluginsTyped.http.Server | pluginsTyped.https.Server;
+
+  /**
+   * wether httpServer is standalone
+   */
  private standaloneServer = false;
-  private expressServer: any;

  constructor(smartSocketInstance: Smartsocket) {
    this.smartsocket = smartSocketInstance;
@ -25,20 +29,26 @@ export class SocketServer {
   */
  public async setExternalServer(
    serverType: 'smartexpress',
-    serverArg: plugins.smartexpress.Server
+    serverArg: pluginsTyped.typedserver.servertools.Server
  ) {
+    this.httpServerDeferred = plugins.smartpromise.defer();
    await serverArg.startedPromise;
    this.httpServer = serverArg.httpServer;
+    this.httpServerDeferred.resolve();
  }

  /**
   * gets the server for socket.io
   */
-  public getServerForSocketIo() {
+  public async getServerForSocketIo() {
+    if (this.httpServerDeferred) {
+      await this.httpServerDeferred.promise;
+    }
    if (this.httpServer) {
      return this.httpServer;
    } else {
-      this.httpServer = new http.Server();
+      const httpModule = await this.smartsocket.smartenv.getSafeNodeModule('http');
+      this.httpServer = new httpModule.Server();
      this.standaloneServer = true;
      return this.httpServer;
    }
@ -54,11 +64,14 @@ export class SocketServer {
    // in case an external server has been set "this.standaloneServer" should be false
    if (this.httpServer && this.standaloneServer) {
      if (!this.smartsocket.options.port) {
-        console.log('there should be a port specifed for smartsocket!');
+        logger.log('error', 'there should be a port specifed for smartsocket!');
        throw new Error('there should be a port specified for smartsocket');
      }
      this.httpServer.listen(this.smartsocket.options.port, () => {
-        console.log(`Server started in standalone mode on ${this.smartsocket.options.port}`);
+        logger.log(
+          'success',
+          `Server started in standalone mode on ${this.smartsocket.options.port}`
+        );
        done.resolve();
      });
    } else {
@ -73,5 +86,9 @@ export class SocketServer {
  /**
   * closes the server
   */
-  public async stop() {}
+  public async stop() {
+    if (this.httpServer) {
+      this.httpServer.close();
+    }
+  }
 }
--- a/ts/smartsocket.helpers.ts
+++ b/ts/smartsocket.helpers.ts
@ -1,60 +0,0 @@
-import * as plugins from './smartsocket.plugins';
-
-// classes
-import { Smartsocket } from './smartsocket.classes.smartsocket';
-import { SocketFunction, allSocketFunctions } from './smartsocket.classes.socketfunction';
-import {
-  SocketConnection,
-  ISocketConnectionAuthenticationObject
-} from './smartsocket.classes.socketconnection';
-import {
-  SocketRequest,
-  allSocketRequests,
-  TSocketRequestSide
-} from './smartsocket.classes.socketrequest';
-import { SocketRole } from './smartsocket.classes.socketrole';
-
-// SocketConnection helpers
-export let checkPasswordForRole = (
-  dataArg: ISocketConnectionAuthenticationObject,
-  referenceSmartsocket: Smartsocket
-): boolean => {
-  let targetPasswordHash = getSocketRoleByName(dataArg.role, referenceSmartsocket).passwordHash;
-  let computedCompareHash = plugins.smarthash.sha256FromStringSync(dataArg.password);
-  return targetPasswordHash === computedCompareHash;
-};
-
-// SocketFunction helpers
-export let getSocketFunctionByName = (functionNameArg: string): SocketFunction => {
-  return allSocketFunctions.find(socketFunctionArg => {
-    return socketFunctionArg.name === functionNameArg;
-  });
-};
-
-// SocketRequest helpers
-
-/**
- * get corresponding Socketrequest instance by shortId
- */
-export let getSocketRequestById = (
-  shortIdArg: string,
-  requestSide?: TSocketRequestSide
-): SocketRequest => {
-  return allSocketRequests.find(socketRequestArg => {
-    return socketRequestArg.shortid === shortIdArg;
-  });
-};
-
-// SocketRole helpers
-
-/**
- * get corresponding SocketRole instance by name
- */
-export let getSocketRoleByName = (
-  socketRoleNameArg: string,
-  referenceSmartsocket: Smartsocket
-): SocketRole => {
-  return referenceSmartsocket.socketRoles.find(socketRoleArg => {
-    return socketRoleArg.name === socketRoleNameArg;
-  });
-};
--- a/ts/smartsocket.logging.ts
+++ b/ts/smartsocket.logging.ts
@ -0,0 +1,3 @@
+import * as plugins from './smartsocket.plugins.js';
+
+export const logger = new plugins.smartlog.ConsoleLog();
--- a/ts/smartsocket.plugins.ts
+++ b/ts/smartsocket.plugins.ts
@ -1,21 +1,29 @@
-import * as lik from '@pushrocks/lik';
-import * as smartlog from '@pushrocks/smartlog';
-import * as smarthash from '@pushrocks/smarthash';
-import * as smartdelay from '@pushrocks/smartdelay';
-import * as smartexpress from '@pushrocks/smartexpress';
-import * as smartpromise from '@pushrocks/smartpromise';
-import * as shortid from 'shortid';
-import * as socketIo from 'socket.io';
-import * as socketIoClient from 'socket.io-client';
+// apiglobal scope
+import * as typedrequestInterfaces from '@apiglobal/typedrequest-interfaces';
+
+export { typedrequestInterfaces };
+
+// pushrocks scope
+import * as isohash from '@push.rocks/isohash';
+import * as isounique from '@push.rocks/isounique';
+import * as lik from '@push.rocks/lik';
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartlog from '@push.rocks/smartlog';
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smarttime from '@push.rocks/smarttime';
+import * as smartrx from '@push.rocks/smartrx';

 export {
+  isohash,
+  isounique,
  lik,
+  smartenv,
+  smartjson,
  smartlog,
-  smarthash,
  smartdelay,
-  smartexpress,
  smartpromise,
-  shortid,
-  socketIo,
-  socketIoClient
+  smarttime,
+  smartrx,
 };
--- a/ts/smartsocket.pluginstyped.ts
+++ b/ts/smartsocket.pluginstyped.ts
@ -0,0 +1,23 @@
+// node native
+import type * as http from 'http';
+import type * as https from 'https';
+
+export type { http, https };
+
+// pushrocks scope
+import type * as typedserver from '@apiglobal/typedserver';
+
+export type { typedserver };
+
+// third party scope
+import type { Socket as ServerSocket, Server as ServerServer } from 'socket.io';
+import type { Socket as ClientSocket, connect as ClientIo } from 'socket.io-client';
+
+export namespace socketIo {
+  export type Socket = ServerSocket;
+  export type Server = ServerServer;
+}
+export namespace socketIoClient {
+  export type Socket = ClientSocket;
+  export type connect = typeof ClientIo;
+}
--- 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	61d5301de8	2.0.21	2023-08-06 16:09:28 +02:00
Philipp Kunz	72fa7f790c	fix(core): update	2023-08-06 16:09:28 +02:00
Philipp Kunz	dcc087c04d	2.0.20	2023-07-21 03:53:41 +02:00
Philipp Kunz	c8556355c0	fix(core): update	2023-07-21 03:53:41 +02:00
Philipp Kunz	9cfc41ace8	2.0.19	2023-03-29 19:02:35 +02:00
Philipp Kunz	2827a1676b	fix(core): update	2023-03-29 19:02:34 +02:00
Philipp Kunz	424ad80b60	2.0.18	2023-03-29 16:15:31 +02:00
Philipp Kunz	682a0c53ce	fix(core): update	2023-03-29 16:15:30 +02:00
Philipp Kunz	4fc09af779	2.0.17	2023-03-29 16:07:54 +02:00
Philipp Kunz	f73d973383	fix(core): update	2023-03-29 16:07:54 +02:00
Philipp Kunz	d87a942ab3	2.0.16	2023-03-20 18:51:02 +01:00
Philipp Kunz	60e8657467	fix(core): update	2023-03-20 18:51:02 +01:00
Philipp Kunz	5215be946e	2.0.15	2023-02-07 12:32:48 +01:00
Philipp Kunz	b9c67666fa	fix(core): update	2023-02-07 12:32:48 +01:00
Philipp Kunz	4b0fb073e6	2.0.14	2022-12-29 13:28:11 +01:00
Philipp Kunz	fc458b6827	fix(core): update	2022-12-29 13:28:11 +01:00
Philipp Kunz	f27b9f8143	2.0.13	2022-12-29 11:18:16 +01:00
Philipp Kunz	38058aba57	fix(core): update	2022-12-29 11:18:15 +01:00
Philipp Kunz	ba38dae64f	2.0.12	2022-12-28 19:51:09 +01:00
Philipp Kunz	69e862a6cf	fix(core): update	2022-12-28 19:51:09 +01:00
Philipp Kunz	4562ac355b	2.0.11	2022-12-28 14:02:15 +01:00
Philipp Kunz	b029dc191e	fix(core): update	2022-12-28 14:02:14 +01:00
Philipp Kunz	2640275d04	2.0.10	2022-12-28 13:52:17 +01:00
Philipp Kunz	7bbcc91300	fix(core): update	2022-12-28 13:52:16 +01:00
Philipp Kunz	da39d52975	2.0.9	2022-12-28 13:51:41 +01:00
Philipp Kunz	307469312f	fix(core): update	2022-12-28 13:51:40 +01:00
Philipp Kunz	0f3ff2b611	2.0.8	2022-12-28 13:49:03 +01:00
Philipp Kunz	bce82d49b6	fix(core): update	2022-12-28 13:49:03 +01:00
Philipp Kunz	0b10913995	2.0.7	2022-08-01 15:00:07 +02:00
Philipp Kunz	7048585702	fix(core): update	2022-08-01 15:00:06 +02:00
Philipp Kunz	92697bad82	2.0.6	2022-03-25 00:30:31 +01:00
Philipp Kunz	e1475a3342	fix(core): update	2022-03-25 00:30:31 +01:00
Philipp Kunz	e3c58e7fc0	2.0.5	2022-03-24 23:29:04 +01:00
Philipp Kunz	32d60fff0d	fix(core): update	2022-03-24 23:29:03 +01:00
Philipp Kunz	f33b64d625	2.0.4	2022-03-24 21:56:26 +01:00
Philipp Kunz	6ee70ecafa	2.0.3	2022-03-24 20:26:03 +01:00
Philipp Kunz	6f3700adc0	2.0.2	2022-03-24 20:17:04 +01:00
Philipp Kunz	3648f12358	fix(core): update	2022-03-24 20:17:04 +01:00
Philipp Kunz	c239eaa9d5	2.0.1	2022-03-24 12:52:29 +01:00
Philipp Kunz	75bd7a9175	fix(core): update	2022-03-24 12:52:28 +01:00
Philipp Kunz	be9b47e73b	2.0.0	2022-03-14 22:40:56 +01:00
Philipp Kunz	966d953aff	BREAKING CHANGE(switch to esm): update	2022-03-14 22:40:55 +01:00
Philipp Kunz	7f73664970	1.2.22	2022-01-20 18:38:18 +01:00
Philipp Kunz	71452a293f	fix(core): update	2022-01-20 18:38:17 +01:00
Philipp Kunz	c5e60d804a	1.2.21	2022-01-20 18:33:47 +01:00
Philipp Kunz	c5d52013e6	fix(core): update	2022-01-20 18:33:46 +01:00
Philipp Kunz	64195e4c78	1.2.20	2022-01-20 17:14:12 +01:00
Philipp Kunz	01b5b3dc1a	fix(core): update	2022-01-20 17:14:11 +01:00
Philipp Kunz	b34d7faec2	1.2.19	2022-01-20 16:50:26 +01:00
Philipp Kunz	7c98e19988	fix(core): update	2022-01-20 16:50:25 +01:00
Philipp Kunz	608669ec44	1.2.18	2022-01-19 19:52:16 +01:00
Philipp Kunz	a7b14cd383	fix(core): update	2022-01-19 19:52:14 +01:00
Philipp Kunz	21dc933302	1.2.17	2022-01-19 19:05:45 +01:00
Philipp Kunz	4e7455fa26	fix(core): update	2022-01-19 19:05:44 +01:00
Philipp Kunz	c424d589ea	1.2.16	2022-01-19 18:36:14 +01:00
Philipp Kunz	9435796333	fix(core): update	2022-01-19 18:36:13 +01:00
Philipp Kunz	12d7310b90	1.2.15	2022-01-19 18:06:41 +01:00
Philipp Kunz	9fc4db1e35	fix(core): update	2022-01-19 18:06:39 +01:00
Philipp Kunz	895464115e	1.2.14	2022-01-19 16:37:46 +01:00
Philipp Kunz	00f22f9651	fix(core): update	2022-01-19 16:37:45 +01:00
Philipp Kunz	278b35c9c5	1.2.13	2022-01-19 15:34:53 +01:00
Philipp Kunz	da78da27e5	fix(core): update	2022-01-19 15:34:52 +01:00
Philipp Kunz	a8aeeaaa6c	1.2.12	2022-01-19 08:05:08 +01:00
Philipp Kunz	f9f6975b87	fix(core): update	2022-01-19 08:05:06 +01:00
Philipp Kunz	b9a6f1d5b0	1.2.11	2022-01-19 07:01:59 +01:00
Philipp Kunz	489ad9284b	fix(core): update	2022-01-19 07:01:58 +01:00
Philipp Kunz	6fdf0d9955	1.2.10	2022-01-18 18:54:30 +01:00
Philipp Kunz	499a1893f9	fix(core): update	2022-01-18 18:54:29 +01:00
Philipp Kunz	2754447aae	1.2.9	2022-01-18 17:10:47 +01:00
Philipp Kunz	544277cb8a	fix(core): update	2022-01-18 17:10:46 +01:00
Phil Kunz	9a23960d21	1.2.8	2021-02-01 22:36:38 +00:00
Phil Kunz	23cca6cce3	fix(core): update	2021-02-01 22:36:37 +00:00
Phil Kunz	2a9e58cc35	1.2.7	2021-01-28 12:39:32 +00:00
Phil Kunz	7d6a9921b5	fix(core): update	2021-01-28 12:39:31 +00:00
Phil Kunz	3ee46a31f7	1.2.6	2021-01-28 01:39:24 +00:00
Phil Kunz	d72310ce10	fix(core): update	2021-01-28 01:39:23 +00:00
Phil Kunz	1e14166ddb	1.2.5	2021-01-28 01:31:43 +00:00
Phil Kunz	be38e91548	fix(core): update	2021-01-28 01:31:42 +00:00
Phil Kunz	6c2057b119	1.2.4	2021-01-28 01:30:28 +00:00
Phil Kunz	08d7224016	fix(core): update	2021-01-28 01:30:27 +00:00
Phil Kunz	bfa3330eb6	1.2.3	2021-01-23 06:03:55 +00:00
Phil Kunz	644fa2a49d	fix(core): update	2021-01-23 06:03:54 +00:00
Phil Kunz	c0dad3a977	1.2.2	2021-01-23 05:50:02 +00:00
Phil Kunz	a921033cc4	fix(core): update	2021-01-23 05:50:02 +00:00
Phil Kunz	21e4712b04	1.2.1	2021-01-23 04:12:56 +00:00
Phil Kunz	df43bc2974	fix(core): update	2021-01-23 04:12:55 +00:00
Phil Kunz	564988185d	1.2.0	2020-12-26 18:06:23 +00:00
Phil Kunz	8442f3570f	feat(SmartsocketClient): socket client can now be stopped with .stop() addiditionally to .reconnect(), which will still try to re	2020-12-26 18:06:22 +00:00
Phil Kunz	196357c878	1.1.71	2020-12-26 17:43:20 +00:00
Phil Kunz	bc187b7e41	fix(core): update	2020-12-26 17:43:19 +00:00
Phil Kunz	0e54bf889f	1.1.70	2020-12-22 00:19:00 +00:00
Phil Kunz	4c211bc82e	fix(test): use @pushrocks/isohash instead of @pushrocks/smarthash in tests	2020-12-22 00:18:59 +00:00
Phil Kunz	a1be281670	1.1.69	2020-12-16 02:20:28 +00:00
Phil Kunz	1a44d2027c	fix(core): update	2020-12-16 02:20:28 +00:00
Phil Kunz	4bf5456a1d	1.1.68	2020-12-16 01:38:58 +00:00
Phil Kunz	57c748657a	fix(core): update	2020-12-16 01:38:57 +00:00
Phil Kunz	15df24bf68	1.1.67	2020-09-30 00:20:54 +00:00
Phil Kunz	ca7470eedf	fix(core): update	2020-09-30 00:20:53 +00:00
Phil Kunz	38f017934c	1.1.66	2020-09-29 19:43:10 +00:00
Phil Kunz	1980824540	fix(core): update	2020-09-29 19:43:10 +00:00
Phil Kunz	09dec2071e	1.1.65	2020-09-29 19:42:38 +00:00
Phil Kunz	a1443deafe	fix(core): update	2020-09-29 19:42:38 +00:00
Phil Kunz	9eac5ad336	1.1.64	2020-09-29 19:37:49 +00:00
Phil Kunz	cf607a79d5	fix(core): update	2020-09-29 19:37:49 +00:00
Phil Kunz	8426c976bf	1.1.63	2020-09-29 18:58:10 +00:00
Phil Kunz	1086065000	fix(core): update	2020-09-29 18:58:09 +00:00
Phil Kunz	72196ec383	1.1.62	2020-09-29 17:21:08 +00:00
Phil Kunz	c6ad490a6f	fix(core): update	2020-09-29 17:21:08 +00:00
Phil Kunz	a40a83f0bf	1.1.61	2020-09-29 08:35:27 +00:00
Phil Kunz	82fa029d05	fix(core): update	2020-09-29 08:35:26 +00:00
Phil Kunz	0d76e7f577	1.1.60	2020-09-24 18:04:12 +00:00
Phil Kunz	57e6f058be	fix(core): update	2020-09-24 18:04:11 +00:00
Phil Kunz	b0bf9d7c95	1.1.59	2020-09-24 18:03:02 +00:00
Phil Kunz	1fbc76ef30	fix(core): update	2020-09-24 18:03:01 +00:00
Phil Kunz	424d9cca91	1.1.58	2019-11-08 18:48:39 +01:00
Phil Kunz	d712270946	fix(core): update	2019-11-08 18:48:39 +01:00
Phil Kunz	f98c797ad8	1.1.57	2019-11-08 18:41:09 +01:00
Phil Kunz	a23e7349be	fix(core): update	2019-11-08 18:41:08 +01:00
Phil Kunz	c390881a4e	1.1.56	2019-11-08 17:31:04 +01:00
Phil Kunz	5e64f4ca25	fix(core): update	2019-11-08 17:31:04 +01:00
Phil Kunz	765bc73197	1.1.55	2019-11-08 17:11:41 +01:00
Phil Kunz	105acaf97b	fix(core): update	2019-11-08 17:11:41 +01:00
Phil Kunz	5139136af4	1.1.54	2019-11-07 00:26:47 +01:00
Phil Kunz	bcc4ce9a87	fix(core): update	2019-11-07 00:26:47 +01:00
Phil Kunz	20e7584eb9	1.1.53	2019-11-03 20:23:15 +01:00
Phil Kunz	59cbc343cc	fix(core): update	2019-11-03 20:23:15 +01:00
Phil Kunz	75aa1f6f0d	1.1.52	2019-11-03 19:17:26 +01:00
Phil Kunz	3f073ab9b3	fix(core): update	2019-11-03 19:17:26 +01:00
Phil Kunz	08c1618ea8	1.1.51	2019-11-03 18:33:46 +01:00
Phil Kunz	eb181fa2f6	fix(core): update	2019-11-03 18:33:46 +01:00
Phil Kunz	c901ab75d3	1.1.50	2019-11-03 16:48:35 +01:00
Phil Kunz	075c59ed2c	fix(core): update	2019-11-03 16:48:35 +01:00
Phil Kunz	8d358dd93d	1.1.49	2019-09-10 00:21:48 +02:00
Phil Kunz	e576d6058a	fix(core): update	2019-09-10 00:21:47 +02:00
Phil Kunz	6546da2394	1.1.48	2019-09-09 23:58:32 +02:00
Phil Kunz	29597daba1	fix(core): update	2019-09-09 23:58:32 +02:00
Phil Kunz	c8b647d2fd	1.1.47	2019-09-09 16:20:43 +02:00
Phil Kunz	1fa4aca049	fix(core): update	2019-09-09 16:20:43 +02:00
Phil Kunz	2d4695de22	1.1.46	2019-09-01 18:07:53 +02:00
Phil Kunz	a3f4dcbc2a	fix(core): update	2019-09-01 18:07:52 +02:00
Phil Kunz	d6e81288b4	1.1.45	2019-08-13 15:58:08 +02:00
Phil Kunz	c441d89596	fix(core): update	2019-08-13 15:58:08 +02:00
Phil Kunz	85b69e487a	1.1.44	2019-08-13 11:36:32 +02:00
Phil Kunz	0d94ed9345	fix(core): update	2019-08-13 11:36:31 +02:00
Phil Kunz	e188b18016	1.1.43	2019-08-13 09:37:23 +02:00
Phil Kunz	33c0fa3746	fix(core): update	2019-08-13 09:37:23 +02:00
Phil Kunz	52be1415ee	1.1.42	2019-08-12 22:46:57 +02:00
Phil Kunz	e75d5eabdb	fix(core): update	2019-08-12 22:46:57 +02:00
Phil Kunz	fb99848df1	1.1.41	2019-08-12 22:45:58 +02:00
Phil Kunz	1bd39d0755	fix(core): update	2019-08-12 22:45:58 +02:00
Phil Kunz	d24c5f628c	1.1.40	2019-08-12 22:31:41 +02:00
Phil Kunz	33fbabdd72	fix(core): update	2019-08-12 22:31:40 +02:00
Phil Kunz	9d26fff986	1.1.39	2019-08-12 18:16:26 +02:00
Phil Kunz	41151e5436	fix(core): update	2019-08-12 18:16:25 +02:00
Phil Kunz	109c5197f3	1.1.38	2019-06-07 08:40:24 +02:00
Phil Kunz	c3d47c1f50	fix(core): update	2019-06-07 08:40:24 +02:00
Phil Kunz	1b45fb45e9	1.1.37	2019-06-06 23:11:03 +02:00
Phil Kunz	c22adc9b57	fix(core): update	2019-06-06 23:11:03 +02:00
Phil Kunz	35e87306dd	1.1.36	2019-05-02 11:46:36 +02:00
Phil Kunz	1b20aa5992	fix(core): update	2019-05-02 11:46:36 +02:00