6.0.10

implement JSON methods for tree

See merge request pushrocks/lik!1

.gitea/workflows/default_nottags.yaml

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

.gitea/workflows/default_tags.yaml

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

.gitignore

@@ -1,4 +1,20 @@
-node_modules/
-docs/
+.nogit/
+
+# artifacts
 coverage/
-.nogit/
+public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+# custom

.gitlab-ci.yml

@@ -1,36 +0,0 @@
-image: hosttoday/ht-docker-node:npmts
-
-stages:
-- test
-- release
-
-testLEGACY:
-  stage: test
-  script:
-    - npmci test legacy
-  tags:
-    - docker
-
-testLTS:
-  stage: test
-  script:
-    - npmci test lts
-  tags:
-    - docker
-    
-testSTABLE:
-  stage: test
-  script:
-    - npmci test stable
-  tags:
-    - docker
-
-release:
-  stage: release
-  environment: npmjs-com_registry
-  script:
-    - npmci publish
-  only:
-    - tags
-  tags:
-    - docker

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

.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"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,13 +0,0 @@
-# lik
-light little helpers for node
-
-## Status
-[![build status](https://gitlab.com/pushrocks/lik/badges/master/build.svg)](https://gitlab.com/pushrocks/lik/commits/master)
-
-## Usage
-We recommend the use of TypeScript for good intellisense.
-
-```typescript
-// import any tool that you need from lik
-import {Stringmap} from "lik";
-```

dist/index.d.ts

@@ -1 +0,0 @@
-export * from "./lik.stringmap";

dist/index.js

@@ -1,7 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-// import modules
-__export(require("./lik.stringmap"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWlCO0FBRWpCLGlCQUFjLGlCQUFpQixDQUFDLEVBQUEifQ==

dist/lik.plugins.d.ts

@@ -1,3 +0,0 @@
-import "typings-global";
-export import q = require("q");
-export import minimatch = require("minimatch");

dist/lik.plugins.js

@@ -1,5 +0,0 @@
-"use strict";
-require("typings-global");
-exports.q = require("q");
-exports.minimatch = require("minimatch");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsUUFBTyxnQkFBZ0IsQ0FBQyxDQUFBO0FBQ1YsU0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDO0FBQ2pCLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUMifQ==

dist/lik.stringmap.d.ts

@@ -1,43 +0,0 @@
-/**
- * allows you to easily keep track of a bunch of strings;
- */
-export interface triggerFunction {
-    (): boolean;
-}
-export declare class Stringmap {
-    private _stringArray;
-    private _triggerUntilTrueFunctionArray;
-    constructor();
-    /**
-     * add a string to the Stringmap
-     */
-    addString(stringArg: string): void;
-    /**
-     * removes a string from Stringmap
-     */
-    removeString(stringArg: string): void;
-    /**
-     * wipes the Stringmap
-     */
-    wipe(): void;
-    /**
-     * check if string is in Stringmap
-     */
-    checkString(stringArg: string): boolean;
-    /**
-     * checks stringPresence with minimatch
-     */
-    checkMinimatch(miniMatchStringArg: string): boolean;
-    /**
-     * checks if the Stringmap is empty
-     */
-    checkIsEmpty(): boolean;
-    /**
-     * notifies triggers
-     */
-    private notifyTrigger();
-    /**
-     * register a new trigger
-     */
-    registerUntilTrue(functionArg: triggerFunction, doFunctionArg: any): void;
-}

dist/lik.stringmap.js

@@ -1,90 +0,0 @@
-"use strict";
-const plugins = require("./lik.plugins");
-class Stringmap {
-    constructor() {
-        this._stringArray = [];
-        this._triggerUntilTrueFunctionArray = [];
-    }
-    ;
-    /**
-     * add a string to the Stringmap
-     */
-    addString(stringArg) {
-        this._stringArray.push(stringArg);
-        this.notifyTrigger();
-    }
-    ;
-    /**
-     * removes a string from Stringmap
-     */
-    removeString(stringArg) {
-        for (let keyArg in this._stringArray) {
-            if (this._stringArray[keyArg] == stringArg) {
-                this._stringArray.splice(parseInt(keyArg), 1);
-            }
-            ;
-        }
-        ;
-        this.notifyTrigger();
-    }
-    /**
-     * wipes the Stringmap
-     */
-    wipe() {
-        this._stringArray = [];
-        this.notifyTrigger();
-    }
-    /**
-     * check if string is in Stringmap
-     */
-    checkString(stringArg) {
-        return this._stringArray.indexOf(stringArg) != -1;
-    }
-    /**
-     * checks stringPresence with minimatch
-     */
-    checkMinimatch(miniMatchStringArg) {
-        let foundMatch = false;
-        for (let stringItem of this._stringArray) {
-            if (plugins.minimatch(stringItem, miniMatchStringArg)) {
-                foundMatch = true;
-            }
-            ;
-        }
-        ;
-        return foundMatch;
-    }
-    ;
-    /**
-     * checks if the Stringmap is empty
-     */
-    checkIsEmpty() {
-        return (this._stringArray.length == 0);
-    }
-    // trigger registering
-    /**
-     * notifies triggers
-     */
-    notifyTrigger() {
-        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
-            return !functionArg();
-        });
-        this._triggerUntilTrueFunctionArray = filteredArray;
-    }
-    ;
-    /**
-     * register a new trigger
-     */
-    registerUntilTrue(functionArg, doFunctionArg) {
-        this._triggerUntilTrueFunctionArray.push(() => {
-            let result = functionArg();
-            if (result == true) {
-                doFunctionArg();
-            }
-            return result;
-        });
-        this.notifyTrigger();
-    }
-}
-exports.Stringmap = Stringmap;
-//# sourceMappingURL=data:application/json;base64,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

docs/index.md

@@ -0,0 +1,46 @@
+# lik
+
+light little helpers for node
+
+## Availabililty
+
+[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/lik)
+[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/lik)
+[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/lik)
+[![docs](https://pushrocks.gitlab.io/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/lik/)
+
+## Status for master
+
+[![build status](https://GitLab.com/pushrocks/lik/badges/master/build.svg)](https://GitLab.com/pushrocks/lik/commits/master)
+[![coverage report](https://GitLab.com/pushrocks/lik/badges/master/coverage.svg)](https://GitLab.com/pushrocks/lik/commits/master)
+[![npm downloads per month](https://img.shields.io/npm/dm/lik.svg)](https://www.npmjs.com/package/lik)
+[![Dependency Status](https://david-dm.org/pushrocks/lik.svg)](https://david-dm.org/pushrocks/lik)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/lik/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/lik/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/lik/badges/code.svg)](https://www.bithound.io/github/pushrocks/lik)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+```javascript
+// import any tool that you need from lik
+import { Stringmap, Objectmap, Observablemap } from 'lik';
+```
+
+### class Stringmap
+
+Stringmap allows you to keep track of strings. It allows you to register triggers for certain events
+like when a certain string is removed or added to the map
+
+### class Objectmap
+
+Sometimes you need to keep track of objects, but implementing logic for removing, finding or updating is tedious.
+Objectmap takes care of keeping track of objects for you.
+
+> MIT licensed | **©** [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://push.rocks)

npmextra.json

@@ -0,0 +1,17 @@
+{
+  "npmci": {
+    "npmGlobalTools": [],
+    "npmAccessLevel": "public"
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "push.rocks",
+      "gitrepo": "lik",
+      "description": "light little helpers for node",
+      "npmPackagename": "@push.rocks/lik",
+      "license": "MIT"
+    }
+  }
+}

package.json

@@ -1,11 +1,15 @@
 {
-  "name": "lik",
-  "version": "1.0.5",
+  "name": "@push.rocks/lik",
+  "version": "6.0.10",
+  "private": false,
   "description": "light little helpers for node",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
+  "type": "module",
   "scripts": {
-    "test": "(npmts)"
+    "test": "(tstest test/)",
+    "build": "(tsbuild --web --allowimplicitany && tsbundle npm)",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
@@ -18,14 +22,36 @@
   },
   "homepage": "https://gitlab.com/pushrocks/lik#README",
   "devDependencies": {
-    "npmts-g": "^5.2.6",
-    "should": "^10.0.0",
-    "typings-test": "^1.0.1"
+    "@git.zone/tsbuild": "^2.1.66",
+    "@git.zone/tsbundle": "^2.0.8",
+    "@git.zone/tsrun": "^1.2.44",
+    "@git.zone/tstest": "^1.0.77",
+    "@pushrocks/tapbundle": "^5.0.8",
+    "@types/node": "^20.9.0"
   },
   "dependencies": {
-    "@types/minimatch": "^2.0.28",
-    "@types/q": "^0.0.27",
-    "minimatch": "^3.0.2",
-    "q": "^1.4.1"
-  }
+    "@push.rocks/smartdelay": "^3.0.5",
+    "@push.rocks/smartmatch": "^2.0.0",
+    "@push.rocks/smartpromise": "^4.0.3",
+    "@push.rocks/smartrx": "^3.0.7",
+    "@push.rocks/smarttime": "^4.0.6",
+    "@types/minimatch": "^5.1.2",
+    "@types/symbol-tree": "^3.2.5",
+    "symbol-tree": "^3.2.4"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ]
 }

readme.md

@@ -0,0 +1,52 @@
+# @push.rocks/lik
+light little helpers for node
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@push.rocks/lik)
+* [gitlab.com (source)](https://gitlab.com/push.rocks/lik)
+* [github.com (source mirror)](https://github.com/push.rocks/lik)
+* [docs (typedoc)](https://push.rocks.gitlab.io/lik/)
+
+## Status for master
+
+Status Category | Status Badge
+-- | --
+GitLab Pipelines | [![pipeline status](https://gitlab.com/push.rocks/lik/badges/master/pipeline.svg)](https://lossless.cloud)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/push.rocks/lik/badges/master/coverage.svg)](https://lossless.cloud)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@push.rocks/lik)](https://lossless.cloud)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/push.rocks/lik)](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/lik)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@push.rocks/lik)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@push.rocks/lik)](https://lossless.cloud)
+
+## Usage
+
+Use TypeScript for best in class instellisense.
+
+```javascript
+// import any tool that you need from lik
+import { Stringmap, Objectmap, Observablemap } from 'lik';
+```
+
+### class Stringmap
+
+Stringmap allows you to keep track of strings. It allows you to register triggers for certain events
+like when a certain string is removed or added to the map
+
+### class Objectmap
+
+Sometimes you need to keep track of objects, but implementing logic for removing, finding or updating is tedious.
+Objectmap takes care of keeping track of objects for you.
+
+## 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.
+
+## Legal
+> MIT licensed | **©** [Task Venture Capital GmbH](https://task.vc)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)

test/test.asyncexecutionstack.both.ts

@@ -0,0 +1,29 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import * as lik from '../ts/index.js';
+
+let testAsyncExecutionStack: lik.AsyncExecutionStack;
+
+tap.test('should create a valid instance of AsyncExectionStack', async () => {
+  testAsyncExecutionStack = new lik.AsyncExecutionStack();
+  expect(testAsyncExecutionStack).toBeInstanceOf(lik.AsyncExecutionStack);
+});
+
+tap.test('should run in parallel', async (toolsArg) => {
+  await testAsyncExecutionStack.getExclusiveExecutionSlot(async () => {
+    await toolsArg.delayFor(2000);
+    console.log('should run first');
+  }, 2500);
+  testAsyncExecutionStack.getNonExclusiveExecutionSlot(async () => {
+    await toolsArg.delayFor(2000);
+    console.log('should run third');
+  }, 2500);
+  testAsyncExecutionStack.getNonExclusiveExecutionSlot(async () => {
+    await toolsArg.delayFor(1000);
+    console.log('should run second');
+  }, 2500);
+  await testAsyncExecutionStack.getExclusiveExecutionSlot(async () => {
+    console.log('should run fourth');
+  }, 0);
+});
+
+await tap.start();

test/test.d.ts

@@ -1,2 +0,0 @@
-import "typings-test";
-import "should";

test/test.fastmap.both.ts

@@ -0,0 +1,30 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import * as lik from '../ts/index.js';
+
+tap.test('should create a valid fastmap', async () => {
+  const fastmap = new lik.FastMap();
+  expect(fastmap).toBeInstanceOf(lik.FastMap);
+});
+
+tap.test('should find an entry', async () => {
+  const fastmap = new lik.FastMap<{
+    value1: string;
+    value2: string;
+  }>();
+  fastmap.addToMap('heythere', {
+    value1: 'heyho',
+    value2: 'heyho2',
+  });
+  fastmap.addToMap('heythere2', {
+    value1: 'heyho3',
+    value2: 'heyho4',
+  });
+
+  const result = await fastmap.find(async (itemArg) => {
+    return itemArg.value2 === 'heyho4';
+  });
+  expect(result.value1).toEqual('heyho3');
+});
+
+await tap.start();

test/test.interestmap.both.ts

@@ -0,0 +1,25 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import * as lik from '../ts/index.js';
+
+let testInterestmap: lik.InterestMap<number, number>;
+
+tap.test('should create an interestmap', async () => {
+  testInterestmap = new lik.InterestMap((numberArg) => {
+    return numberArg.toString();
+  });
+});
+
+tap.test('should create an interest', async () => {
+  testInterestmap.addInterest(3);
+  testInterestmap.addInterest(4);
+});
+
+tap.test('should return an already existing interest', async () => {
+  await testInterestmap.addInterest(3);
+});
+
+tap.test('should be able to inform about a lost interest', async () => {
+  testInterestmap.informLostInterest(3);
+});
+
+await tap.start();

test/test.js

@@ -1,41 +0,0 @@
-"use strict";
-require("typings-test");
-const lik = require("../dist/index");
-require("should");
-describe("lik", function () {
-    describe("Stringmap", function () {
-        let testStringmap;
-        let testString1 = "testString1";
-        let testString2 = "testString2";
-        let testString3 = "testString3";
-        it("should create an instance of Stringmap", function () {
-            testStringmap = new lik.Stringmap();
-            testStringmap.should.be.instanceof(lik.Stringmap);
-        });
-        it("should return false for an string not in Stringmap", function () {
-            testStringmap.checkString(testString1).should.be.false();
-        });
-        it("should add an string to Stringmap", function () {
-            testStringmap.addString(testString1);
-            testStringmap.addString(testString2);
-            testStringmap.addString(testString3);
-            testStringmap.checkString(testString1).should.be.true();
-            testStringmap.checkString(testString2).should.be.true();
-            testStringmap.checkString(testString3).should.be.true();
-            testStringmap.checkMinimatch("*String1").should.be.true();
-            testStringmap.checkMinimatch("*String2").should.be.true();
-            testStringmap.checkMinimatch("*String4").should.be.false();
-        });
-        it("should remove a string from Stringmap", function () {
-            testStringmap.removeString(testString2);
-            testStringmap.checkString(testString2).should.be.false();
-        });
-        it("should register a function to trigger when empty", function () {
-            testStringmap.registerUntilTrue(() => { return testStringmap.checkIsEmpty(); }, () => { console.log("Stringmap now is empty"); });
-        });
-        it("should remove wipe and then notify", function () {
-            testStringmap.wipe();
-        });
-    });
-});
-//# sourceMappingURL=data:application/json;base64,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

test/test.limitedarray.both.ts

@@ -0,0 +1,17 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import { LimitedArray } from '../ts/index.js';
+
+let testLimitedArray: LimitedArray<string>;
+
+tap.test('should create a LimitedArray', async () => {
+  testLimitedArray = new LimitedArray(6);
+  expect(testLimitedArray).toBeInstanceOf(LimitedArray);
+});
+
+tap.test('should never be longer than the set length', async () => {
+  testLimitedArray.addMany(['hi', 'this', 'is', 'quite', 'a', 'long', 'string', ':)']);
+  expect(testLimitedArray.array.length < 7).toBeTrue();
+});
+
+await tap.start();

test/test.looptracker.both.ts

@@ -0,0 +1,24 @@
+// import test framework
+import { expect, tap } from '@pushrocks/tapbundle';
+
+// import the module
+import * as lik from '../ts/index.js';
+
+let object1 = {};
+let object2 = {};
+let myLoopTracker: lik.LoopTracker<any>;
+
+// tests
+tap.test('should create a valid looptracker instance', async () => {
+  myLoopTracker = new lik.LoopTracker();
+  expect(myLoopTracker).toBeInstanceOf(lik.LoopTracker);
+});
+
+tap.test('should add objects once and return true', async () => {
+  expect(myLoopTracker.checkAndTrack(object1)).toBeTrue();
+  expect(myLoopTracker.checkAndTrack(object1)).toBeFalse();
+  expect(myLoopTracker.checkAndTrack(object2)).toBeTrue();
+  expect(myLoopTracker.checkAndTrack(object2)).toBeFalse();
+});
+
+await tap.start();

test/test.objectmap.both.ts

@@ -0,0 +1,76 @@
+// import test framework
+import { expect, tap } from '@pushrocks/tapbundle';
+
+// import the module
+import * as lik from '../ts/index.js';
+
+// Objectmap
+interface ITestObject {
+  propOne: string;
+  propTwo: string;
+}
+let testObjectmap: lik.ObjectMap<ITestObject>;
+let testObject1: ITestObject = {
+  propOne: 'hello',
+  propTwo: 'hello2',
+};
+let testObject2: ITestObject = {
+  propOne: 'hello',
+  propTwo: 'hello2',
+};
+
+tap.test('new lik.Objectmap() -> should correctly instantiate an Objectmap', async () => {
+  testObjectmap = new lik.ObjectMap<ITestObject>();
+  expect(testObjectmap).toBeInstanceOf(lik.ObjectMap);
+});
+
+tap.test('lik.Objectmap.add() -> should correctly add an object to Objectmap', async () => {
+  testObjectmap.add(testObject1);
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject1)).toBeTrue();
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject2)).toBeFalse();
+});
+
+tap.test('lik.Objectmap.remove() -> should correctly remove an object to Objectmap', async () => {
+  testObjectmap.add(testObject2);
+  testObjectmap.remove(testObject1);
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject1)).toBeFalse();
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject2)).toBeTrue();
+});
+
+tap.test('Objectmap.forEach -> should correctly run a function forEach map object', async () => {
+  testObjectmap.forEach((itemArg) => {
+    expect(itemArg).toHaveProperty('propOne');
+  });
+});
+
+tap.test('lik.Objectmap.find() -> should correctly find an object', async () => {
+  let myObject = { propOne: 'helloThere', propTwo: 'helloAnyway' };
+  testObjectmap.add(myObject);
+  let referenceObject = await testObjectmap.find(async (itemArg) => {
+    return itemArg.propOne === 'helloThere';
+  });
+  // tslint:disable-next-line:no-unused-expression
+  expect(myObject === referenceObject).toBeTrue();
+});
+
+tap.test('lik.Objectmap.getArray() -> should return a cloned array', async () => {
+  let myObject = { propOne: 'test1', propTwo: 'wow, how awesome' };
+  testObjectmap.add(myObject);
+  let clonedArray = testObjectmap.getArray();
+  expect(clonedArray[clonedArray.length - 1]).toEqual(myObject);
+});
+
+tap.test('should get one object and then remove it', async () => {
+  let originalLength = testObjectmap.getArray().length;
+  let oneObject = testObjectmap.getOneAndRemove();
+  // tslint:disable-next-line:no-unused-expression
+  expect(oneObject).not.toBeNull();
+  expect(testObjectmap.getArray().length).toEqual(originalLength - 1);
+  expect(testObjectmap.getArray()).not.toContain(oneObject);
+});
+
+await tap.start();

test/test.stringmap.both.ts

@@ -0,0 +1,86 @@
+// import test framework
+import { expect, tap } from '@pushrocks/tapbundle';
+
+// import the module
+import * as lik from '../ts/index.js';
+
+// testData
+let testStringmap: lik.Stringmap;
+let testString1 = 'testString1';
+let testString2 = 'testString2';
+let testString3 = 'testString3';
+let testString4 = 'testString4';
+let testString5 = 'testString5';
+let testString6 = 'testString6';
+
+// tests
+tap.test('new lik.Objectmap() -> should create an instance of Stringmap', async () => {
+  testStringmap = new lik.Stringmap();
+  expect(testStringmap).toBeInstanceOf(lik.Stringmap);
+});
+
+tap.test(
+  'lik.Stringmap.checkString -> should return false for an string not in Stringmap',
+  async () => {
+    // tslint:disable-next-line:no-unused-expression
+    expect(testStringmap.checkString(testString1)).toBeFalse();
+  }
+);
+
+tap.test('lik.Stringmap.addString -> should add an string to Stringmap', async () => {
+  testStringmap.addString(testString1);
+  testStringmap.addString(testString2);
+  testStringmap.addString(testString3);
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString1)).toBeTrue();
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString2)).toBeTrue();
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString3)).toBeTrue();
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String1')).toBeTrue();
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String2')).toBeTrue();
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String4')).toBeFalse();
+});
+
+tap.test('lik.Stringmap.addStringArray -> should add an array of strings', async () => {
+  testStringmap.addStringArray([testString4, testString5, testString6]);
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String4')).toBeTrue();
+});
+
+tap.test('lik.Stringmap.removeString -> should remove a string from Stringmap', async () => {
+  testStringmap.removeString(testString2);
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString2)).toBeFalse();
+});
+
+tap.test('lik.Stringmap.getStringArray() -> should return a copy of stringArray', async () => {
+  let clonedArray = testStringmap.getStringArray();
+  // tslint:disable-next-line:no-unused-expression
+  expect(clonedArray[0] === 'testString1').toBeTrue();
+  // tslint:disable-next-line:no-unused-expression
+  expect(clonedArray[0] === testString1).toBeTrue();
+});
+
+tap.test(
+  'lik.Stringmap.checkIsEmpty() -> should register a function to trigger when empty',
+  async () => {
+    testStringmap.registerUntilTrue(
+      () => {
+        return testStringmap.checkIsEmpty();
+      },
+      () => {
+        console.log('Stringmap now is empty');
+      }
+    );
+  }
+);
+
+tap.test('lik.Stringmap.empty() -> should remove wipe and then notify', async () => {
+  testStringmap.wipe();
+});
+
+await tap.start();

test/test.timedaggregator.both.ts

@@ -0,0 +1,23 @@
+// import test framework
+import { expect, tap } from '@pushrocks/tapbundle';
+
+// import the module
+import * as lik from '../ts/index.js';
+
+let testTimedAggregator: lik.TimedAggregtor<string>;
+
+tap.test('should create a timed aggregaotor', async (tools) => {
+  testTimedAggregator = new lik.TimedAggregtor<string>({
+    aggregationIntervalInMillis: 1000,
+    functionForAggregation: (aggregation) => {
+      console.log(aggregation);
+    },
+  });
+  testTimedAggregator.add('This');
+  testTimedAggregator.add('is a whole sentence.');
+  await tools.delayFor(1001);
+  testTimedAggregator.add('This one is another.');
+  await tools.delayFor(2000);
+});
+
+await tap.start();

test/test.tree.both.ts

@@ -0,0 +1,40 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import * as lik from '../ts/index.js';
+
+class TestClass {
+  constructor(public hey: string) {
+    // nothing here
+  }
+}
+
+let testTree = new lik.Tree<TestClass>();
+
+let testInstance = new TestClass('first');
+let testInstance2 = new TestClass('second');
+let testInstance3 = new TestClass('third');
+let testInstance4 = new TestClass('fourth');
+let testInstance5 = new TestClass('fifth');
+let testInstance6 = new TestClass('sixth');
+
+tap.test('create a valid tree instance', async () => {
+  testTree = new lik.Tree();
+  expect(testTree).toBeInstanceOf(lik.Tree);
+});
+
+tap.test('should insert an object', async () => {
+  testTree.initialize(testInstance);
+  let resultArray = testTree.treeToArray(testInstance, {});
+  expect(resultArray).toContain(testInstance);
+});
+
+tap.test('should add other objects in a hierachy', async () => {
+  testTree.appendChild(testInstance, testInstance2);
+  testTree.appendChild(testInstance, testInstance3);
+  testTree.appendChild(testInstance, testInstance4);
+});
+
+tap.test("should create a JSON object that reflects a tree's hierachy", async () => {
+  const jsonTreet = testTree.toJsonWithHierachy(testInstance);
+});
+
+await tap.start();

test/test.ts

@@ -1,43 +0,0 @@
-import "typings-test";
-import lik = require("../dist/index");
-import "should";
-
-describe("lik",function(){
-    describe("Stringmap",function(){
-        let testStringmap:lik.Stringmap;
-        let testString1 = "testString1";
-        let testString2 = "testString2";
-        let testString3 = "testString3";
-        it("should create an instance of Stringmap",function(){
-            testStringmap = new lik.Stringmap();
-            testStringmap.should.be.instanceof(lik.Stringmap);
-        });
-        it("should return false for an string not in Stringmap",function(){
-            testStringmap.checkString(testString1).should.be.false();
-        });
-        it("should add an string to Stringmap",function(){
-            testStringmap.addString(testString1);
-            testStringmap.addString(testString2);
-            testStringmap.addString(testString3);
-            testStringmap.checkString(testString1).should.be.true();
-            testStringmap.checkString(testString2).should.be.true();
-            testStringmap.checkString(testString3).should.be.true();
-            testStringmap.checkMinimatch("*String1").should.be.true();
-            testStringmap.checkMinimatch("*String2").should.be.true();
-            testStringmap.checkMinimatch("*String4").should.be.false();
-        });
-        it("should remove a string from Stringmap",function(){
-            testStringmap.removeString(testString2);
-            testStringmap.checkString(testString2).should.be.false();
-        });
-        it("should register a function to trigger when empty",function(){
-            testStringmap.registerUntilTrue(
-                () => {return testStringmap.checkIsEmpty()},
-                () => {console.log("Stringmap now is empty")}
-            );
-        });
-        it("should remove wipe and then notify",function(){
-            testStringmap.wipe();
-        })
-    })
-});

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/lik',
+  version: '6.0.10',
+  description: 'light little helpers for node'
+}

ts/backpressuredarray.ts

@@ -0,0 +1,46 @@
+import * as plugins from './lik.plugins.js';
+
+export class BackpressuredArray<T> {
+  public data: T[];
+  private highWaterMark: number;
+  public hasSpace = new plugins.smartrx.rxjs.Subject<'hasSpace'>();
+
+  constructor(highWaterMark: number = 16) {
+    this.data = [];
+    this.highWaterMark = highWaterMark;
+  }
+
+  push(item: T): boolean {
+    this.data.push(item);
+    const spaceAvailable = this.checkSpaceAvailable();
+    if (spaceAvailable) {
+      this.hasSpace.next('hasSpace');
+    }
+    return spaceAvailable
+  }
+
+  shift(): T | undefined {
+    const item = this.data.shift();
+    if (this.checkSpaceAvailable()) {
+      this.hasSpace.next('hasSpace');
+    }
+    return item;
+  }
+
+  checkSpaceAvailable(): boolean {
+    return this.data.length < this.highWaterMark;
+  }
+
+  waitForSpace(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      if (this.checkSpaceAvailable()) {
+        resolve();
+      } else {
+        const subscription = this.hasSpace.subscribe(() => {
+          subscription.unsubscribe();
+          resolve();
+        });
+      }
+    });
+  }
+}

ts/index.ts

@@ -1,5 +1,11 @@
-import * as plugins from "./lik.plugins";
-
-// import modules
-
-export * from "./lik.stringmap";
+export * from './lik.asyncexecutionstack.js';
+export * from './backpressuredarray.js';
+export * from './lik.fastmap.js';
+export * from './lik.interestmap.js';
+export * from './lik.interestmap.interest.js';
+export * from './lik.limitedarray.js';
+export * from './lik.looptracker.js';
+export * from './lik.objectmap.js';
+export * from './lik.stringmap.js';
+export * from './lik.timedaggregator.js';
+export * from './lik.tree.js';

ts/lik.asyncexecutionstack.ts

@@ -0,0 +1,110 @@
+import * as plugins from './lik.plugins.js';
+
+interface IExecutionSlot<T> {
+  executionDeferred: plugins.smartpromise.Deferred<T>;
+  funcToExecute: () => Promise<T>;
+  timeout?: number;
+  mode: 'exclusive' | 'nonexclusive';
+}
+
+export class AsyncExecutionStack {
+  private executionSlots: IExecutionSlot<any>[] = [];
+  private isProcessing = false;
+
+  public async getExclusiveExecutionSlot<T = any>(
+    funcArg: () => Promise<T>,
+    timeoutArg?: number
+  ): Promise<T> {
+    const executionDeferred = plugins.smartpromise.defer<T>();
+    const executionSlot: IExecutionSlot<T> = {
+      funcToExecute: funcArg,
+      executionDeferred,
+      timeout: timeoutArg,
+      mode: 'exclusive',
+    };
+    this.executionSlots.push(executionSlot);
+    this.processExecutionSlots();
+    return executionDeferred.promise;
+  }
+
+  public async getNonExclusiveExecutionSlot<T = any>(
+    funcArg: () => Promise<T>,
+    timeoutArg?: number
+  ): Promise<T> {
+    const executionDeferred = plugins.smartpromise.defer<T>();
+    const executionSlot: IExecutionSlot<T> = {
+      funcToExecute: funcArg,
+      executionDeferred,
+      timeout: timeoutArg,
+      mode: 'nonexclusive',
+    };
+    this.executionSlots.push(executionSlot);
+    this.processExecutionSlots();
+    return executionDeferred.promise;
+  }
+
+  private async processExecutionSlots() {
+    if (this.isProcessing) {
+      return;
+    }
+    this.isProcessing = true;
+
+    while (this.executionSlots.length > 0) {
+      const currentSlot = this.executionSlots[0];
+      if (currentSlot.mode === 'exclusive') {
+        await this.executeExclusiveSlot(currentSlot);
+        this.executionSlots.shift();
+      } else {
+        // Gather all non-exclusive slots at the front of the queue
+        const nonExclusiveSlots: IExecutionSlot<any>[] = [];
+        while (this.executionSlots.length > 0 && this.executionSlots[0].mode === 'nonexclusive') {
+          nonExclusiveSlots.push(this.executionSlots.shift()!);
+        }
+        await this.executeNonExclusiveSlots(nonExclusiveSlots);
+      }
+    }
+    this.isProcessing = false;
+  }
+
+  private async executeExclusiveSlot(slot: IExecutionSlot<any>) {
+    try {
+      if (slot.timeout) {
+        const result = await Promise.race([
+          slot.funcToExecute(),
+          plugins.smartdelay.delayFor(slot.timeout).then(() => {
+            throw new Error('Timeout reached');
+          }),
+        ]);
+        slot.executionDeferred.resolve(result);
+      } else {
+        const result = await slot.funcToExecute();
+        slot.executionDeferred.resolve(result);
+      }
+    } catch (error) {
+      slot.executionDeferred.reject(error);
+    }
+  }
+
+  private async executeNonExclusiveSlots(slots: IExecutionSlot<any>[]) {
+    const promises = slots.map(async (slot) => {
+      try {
+        if (slot.timeout) {
+          const result = await Promise.race([
+            slot.funcToExecute(),
+            plugins.smartdelay.delayFor(slot.timeout).then(() => {
+              throw new Error('Timeout reached');
+            }),
+          ]);
+          slot.executionDeferred.resolve(result);
+        } else {
+          const result = await slot.funcToExecute();
+          slot.executionDeferred.resolve(result);
+        }
+      } catch (error) {
+        slot.executionDeferred.reject(error);
+      }
+    });
+
+    await Promise.all(promises);
+  }
+}

ts/lik.fastmap.ts

@@ -0,0 +1,97 @@
+/* ============
+The FastMap has the goal of creating the fastes to use map possible in JS
+
+============ */
+
+import * as plugins from './lik.plugins.js';
+
+/**
+ * fast map allows for very quick lookups of objects with a unique key
+ */
+export class FastMap<T> {
+  private mapObject: { [key: string]: T } = {};
+
+  public isUniqueKey(keyArg: string): boolean {
+    return this.mapObject[keyArg] ? false : true;
+  }
+
+  public addToMap(
+    keyArg: string,
+    objectArg: T,
+    optionsArg?: {
+      force: boolean;
+    }
+  ): boolean {
+    if (this.isUniqueKey(keyArg) || (optionsArg && optionsArg.force)) {
+      this.mapObject[keyArg] = objectArg;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public getByKey(keyArg: string) {
+    return this.mapObject[keyArg];
+  }
+
+  public removeFromMap(keyArg: string): T {
+    const removedItem = this.getByKey(keyArg);
+    delete this.mapObject[keyArg];
+    return removedItem;
+  }
+
+  public getKeys() {
+    const keys: string[] = [];
+    for (const keyArg in this.mapObject) {
+      if (this.mapObject[keyArg]) {
+        keys.push(keyArg);
+      }
+    }
+    return keys;
+  }
+
+  public clean() {
+    this.mapObject = {};
+  }
+
+  /**
+   * returns a new Fastmap that includes all values from this and all from the fastmap in the argument
+   */
+  public concat(fastMapArg: FastMap<T>) {
+    const concatedFastmap = new FastMap<T>();
+    for (const key of this.getKeys()) {
+      concatedFastmap.addToMap(key, this.getByKey(key));
+    }
+
+    for (const key of fastMapArg.getKeys()) {
+      concatedFastmap.addToMap(key, fastMapArg.getByKey(key), {
+        force: true,
+      });
+    }
+
+    return concatedFastmap;
+  }
+
+  /**
+   * tries to merge another Fastmap
+   * Note: uniqueKeyCollisions will cause overwrite
+   * @param fastMapArg
+   */
+  public addAllFromOther(fastMapArg: FastMap<T>) {
+    for (const key of fastMapArg.getKeys()) {
+      this.addToMap(key, fastMapArg.getByKey(key), {
+        force: true,
+      });
+    }
+  }
+
+  public async find(findFunctionArg: (mapItemArg: T) => Promise<boolean>) {
+    for (const key of this.getKeys()) {
+      const item = this.getByKey(key);
+      const findFunctionResult = await findFunctionArg(item);
+      if (findFunctionResult) {
+        return item;
+      }
+    }
+  }
+}

ts/lik.interestmap.interest.ts

@@ -0,0 +1,93 @@
+import * as plugins from './lik.plugins.js';
+
+import { InterestMap, type IInterestComparisonFunc } from './lik.interestmap.js';
+
+export interface IInterestOptions<DTInterestFullfillment> {
+  markLostAfterDefault: number;
+  defaultFullfillment?: DTInterestFullfillment;
+}
+
+export class Interest<DTInterestId, DTInterestFullfillment> {
+  public options: IInterestOptions<DTInterestFullfillment>;
+
+  private interestMapRef: InterestMap<DTInterestId, DTInterestFullfillment>;
+  public originalInterest: DTInterestId;
+  public comparisonFunc: IInterestComparisonFunc<DTInterestId>;
+  public destructionTimer = new plugins.smarttime.Timer(10000);
+  public isFullfilled = false;
+
+  /**
+   * a generic store to store objects in that are needed for fullfillment;
+   */
+  public fullfillmentStore: any[] = [];
+
+  /**
+   * quick access to a string that makes the interest comparable for checking for similar interests
+   */
+  public get comparisonString() {
+    return this.comparisonFunc(this.originalInterest);
+  }
+
+  private interestDeferred: plugins.smartpromise.Deferred<DTInterestFullfillment> =
+    new plugins.smartpromise.Deferred();
+  public interestFullfilled = this.interestDeferred.promise;
+
+  /**
+   * fullfill the interest
+   */
+  public fullfillInterest(objectArg: DTInterestFullfillment) {
+    this.isFullfilled = true;
+    this.fullfillmentStore = [];
+    this.interestDeferred.resolve(objectArg);
+  }
+
+  /**
+   *
+   */
+  constructor(
+    interestMapArg: InterestMap<DTInterestId, DTInterestFullfillment>,
+    interestArg: DTInterestId,
+    comparisonFuncArg: IInterestComparisonFunc<DTInterestId>,
+    optionsArg?: IInterestOptions<DTInterestFullfillment>
+  ) {
+    this.interestMapRef = interestMapArg;
+    this.originalInterest = interestArg;
+    this.comparisonFunc = comparisonFuncArg;
+    this.options = optionsArg;
+
+    this.destructionTimer.completed.then(() => {
+      this.destroy();
+    });
+    if (this.options?.markLostAfterDefault) {
+      plugins.smartdelay.delayFor(this.options.markLostAfterDefault).then(this.markLost);
+    }
+  }
+
+  // ===============================
+  // LIFECYCLE MANAGEMENT
+  // ===============================
+
+  /**
+   * self destructs the interest
+   */
+  public destroy() {
+    this.interestMapRef.removeInterest(this);
+    if (!this.isFullfilled && this.options.defaultFullfillment) {
+      this.fullfillInterest(this.options.defaultFullfillment);
+    }
+  }
+
+  /**
+   * notifies the interest that the interest in it has been lost
+   */
+  public markLost() {
+    this.destructionTimer.start();
+  }
+
+  /**
+   * notifies the interest that the interest in it has been restored
+   */
+  public renew() {
+    this.destructionTimer.reset();
+  }
+}

ts/lik.interestmap.ts

@@ -0,0 +1,134 @@
+/* ===========
+The InterestMap is an mechanism that collects interests into something
+An interest is expressed by an object, string or number.
+A comparison func can be specified to make interests comparable
+
+For every unique interestId an interest is created.
+Subssequent interests will be mapped to the same interest
+which is then is only fullfilled once.
+=========== */
+
+import * as plugins from './lik.plugins.js';
+import { ObjectMap } from './lik.objectmap.js';
+import { Interest } from './lik.interestmap.interest.js';
+
+export type IInterestComparisonFunc<T> = (objectArg: T) => string;
+
+export interface IInterestMapOptions {
+  markLostAfterDefault?: number;
+}
+
+export class InterestMap<DTInterestId, DTInterestFullfillment> {
+  public options: IInterestMapOptions;
+
+  /**
+   * stores interests that are currently fullfilled by the cache
+   */
+  private interestObjectMap = new ObjectMap<Interest<DTInterestId, DTInterestFullfillment>>();
+
+  /**
+   * a function to compare interests
+   */
+  private comparisonFunc: IInterestComparisonFunc<DTInterestId>;
+
+  constructor(
+    comparisonFuncArg: IInterestComparisonFunc<DTInterestId>,
+    optionsArg: IInterestMapOptions = {}
+  ) {
+    this.comparisonFunc = comparisonFuncArg;
+    this.options = optionsArg;
+  }
+
+  /**
+   * adds an interest to the InterestMap
+   * @param interestId
+   */
+  public async addInterest(
+    interestId: DTInterestId,
+    defaultFullfillmentArg?: DTInterestFullfillment
+  ): Promise<Interest<DTInterestId, DTInterestFullfillment>> {
+    const comparisonString = this.comparisonFunc(interestId);
+    let returnInterest: Interest<DTInterestId, DTInterestFullfillment>;
+    const newInterest = new Interest<DTInterestId, DTInterestFullfillment>(
+      this,
+      interestId,
+      this.comparisonFunc,
+      {
+        markLostAfterDefault: this.options.markLostAfterDefault,
+        defaultFullfillment: defaultFullfillmentArg,
+      }
+    );
+    let interestExists = false;
+    await this.interestObjectMap.forEach((interestArg) => {
+      if (!interestExists && interestArg.comparisonString === newInterest.comparisonString) {
+        console.log('info', `interest already exists for ${newInterest.comparisonString}`);
+        interestExists = true;
+        returnInterest = interestArg;
+        returnInterest.renew();
+      }
+    });
+    if (!returnInterest) {
+      returnInterest = newInterest;
+      this.interestObjectMap.add(returnInterest);
+    }
+    this.interestObservable.push(returnInterest);
+    return returnInterest;
+  }
+
+  public interestObservable = new plugins.smartrx.ObservableIntake<Interest<DTInterestId, any>>();
+
+  /**
+   * removes an interest from the interest map
+   */
+  public removeInterest(interestArg: Interest<DTInterestId, DTInterestFullfillment>) {
+    const interestToRemove = this.interestObjectMap.findOneAndRemoveSync((interestArg2) => {
+      return interestArg.comparisonString === interestArg2.comparisonString;
+    });
+  }
+
+  /**
+   * check interest
+   */
+  public checkInterest(objectArg: DTInterestId): boolean {
+    const comparisonString = this.comparisonFunc(objectArg);
+    return this.checkInterestByString(comparisonString);
+  }
+
+  /**
+   * checks an interest
+   * @param comparisonStringArg
+   */
+  public checkInterestByString(comparisonStringArg: string): boolean {
+    const foundInterest = this.interestObjectMap.findSync((interest) => {
+      return interest.comparisonString === comparisonStringArg;
+    });
+    if (foundInterest) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * inform lost interest
+   * @param interestId
+   */
+  public informLostInterest(interestId: DTInterestId) {
+    const wantedInterest = this.findInterest(interestId);
+    if (wantedInterest) {
+      wantedInterest.markLost();
+    }
+  }
+
+  /**
+   * finds an interest
+   * @param interestId
+   */
+  public findInterest(interestId: DTInterestId): Interest<DTInterestId, DTInterestFullfillment> {
+    const comparableString = this.comparisonFunc(interestId);
+    const interest = this.interestObjectMap.findSync((interestArg) => {
+      return interestArg.comparisonString === comparableString;
+    });
+    return interest; // if an interest is found, the interest is returned, otherwise interest is null
+  }
+}

ts/lik.limitedarray.ts

@@ -0,0 +1,42 @@
+import * as plugins from './lik.plugins.js';
+
+export class LimitedArray<T> {
+  array: T[] = [];
+  arrayLimit: number;
+  constructor(limitArg: number) {
+    this.arrayLimit = limitArg;
+  }
+
+  addOne(objectArg: T) {
+    this.array.unshift(objectArg);
+    if (this.array.length > this.arrayLimit) {
+      this.array.length = this.arrayLimit;
+    }
+  }
+
+  addMany(objectArrayArg: T[]) {
+    for (let objectArg of objectArrayArg) {
+      this.addOne(objectArg);
+    }
+  }
+
+  setLimit(limitArg: number) {
+    this.arrayLimit = limitArg;
+    if (this.array.length > this.arrayLimit) {
+      this.array.length = this.arrayLimit;
+    }
+  }
+
+  getAverage(): number {
+    if (typeof this.array[0] === 'number') {
+      let sum = 0;
+      for (let localNumber of this.array) {
+        let localNumberAny: any = localNumber;
+        sum = sum + localNumberAny;
+      }
+      return sum / this.array.length;
+    } else {
+      return null;
+    }
+  }
+}

ts/lik.looptracker.ts

@@ -0,0 +1,23 @@
+import * as plugins from './lik.plugins.js';
+
+import { ObjectMap } from './lik.objectmap.js';
+
+export class LoopTracker<T> {
+  referenceObjectMap = new ObjectMap<any>();
+  constructor() {
+    // nothing here
+  }
+
+  /**
+   * checks and tracks an object
+   * @param objectArg
+   */
+  checkAndTrack(objectArg: T): boolean {
+    if (!this.referenceObjectMap.checkForObject(objectArg)) {
+      this.referenceObjectMap.add(objectArg);
+      return true;
+    } else {
+      return false;
+    }
+  }
+}

ts/lik.objectmap.ts

@@ -0,0 +1,246 @@
+import * as plugins from './lik.plugins.js';
+import { FastMap } from './lik.fastmap.js';
+
+export const uni = (prefix: string = 'uni') => {
+  return `${prefix}xxxxxxxxxxx`.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+};
+
+export interface IObjectmapForEachFunction<T> {
+  (itemArg: T): void;
+}
+
+export interface IObjectmapFindFunctionSync<T> {
+  (itemArg: T): boolean;
+}
+
+export interface IObjectmapFindFunction<T> {
+  (itemArg: T): Promise<boolean>;
+}
+
+export interface IObjectMapEventData<T> {
+  operation: 'add' | 'remove';
+  payload: T;
+}
+
+/**
+ * allows keeping track of objects
+ */
+export class ObjectMap<T> {
+  private fastMap = new FastMap<T>();
+
+  // events
+  public eventSubject = new plugins.smartrx.rxjs.Subject<IObjectMapEventData<T>>();
+
+  /**
+   * returns a new instance
+   */
+  constructor() {
+    // nothing here
+  }
+
+  /**
+   * adds an object mapped to a string
+   * the string must be unique
+   */
+  addMappedUnique(uniqueKeyArg: string, objectArg: T) {
+    this.fastMap.addToMap(uniqueKeyArg, objectArg);
+  }
+
+  /**
+   * fastest way to get an object from the map
+   * @param uniqueKey
+   */
+  public getMappedUnique(uniqueKeyArg: string) {
+    return this.fastMap.getByKey(uniqueKeyArg);
+  }
+
+  /**
+   * remove key
+   * @param functionArg
+   */
+  public removeMappedUnique(uniqueKey: string) {
+    const object = this.getMappedUnique(uniqueKey);
+  }
+
+  /**
+   * add object to Objectmap
+   * returns false if the object is already in the map
+   * returns true if the object was added successfully
+   */
+  public add(objectArg: T): string {
+    // lets search for an existing unique key
+    for (const keyArg of this.fastMap.getKeys()) {
+      const object = this.fastMap.getByKey(keyArg);
+      if (object === objectArg) {
+        return keyArg;
+      }
+    }
+
+    // otherwise lets create it
+    const uniqueKey = uni('key');
+    this.addMappedUnique(uniqueKey, objectArg);
+    this.eventSubject.next({
+      operation: 'add',
+      payload: objectArg,
+    });
+    return uniqueKey;
+  }
+
+  /**
+   * like .add but adds an whole array of objects
+   */
+  public addArray(objectArrayArg: T[]) {
+    for (const item of objectArrayArg) {
+      this.add(item);
+    }
+  }
+
+  /**
+   * check if object is in Objectmap
+   */
+  public checkForObject(objectArg: T): boolean {
+    return !!this.getKeyForObject(objectArg);
+  }
+
+  /**
+   * get key for object
+   * @param findFunction
+   */
+  public getKeyForObject(objectArg: T) {
+    let foundKey: string = null;
+    for (const keyArg of this.fastMap.getKeys()) {
+      if (!foundKey && this.fastMap.getByKey(keyArg) === objectArg) {
+        foundKey = keyArg;
+      } else {
+        continue;
+      }
+    }
+    return foundKey;
+  }
+
+  /**
+   * find object
+   */
+  public async find(findFunction: IObjectmapFindFunction<T>): Promise<T> {
+    return this.fastMap.find(findFunction);
+  }
+
+  public findSync(findFunction: IObjectmapFindFunctionSync<T>): T {
+    for (const keyArg of this.fastMap.getKeys()) {
+      if (findFunction(this.fastMap.getByKey(keyArg))) {
+        return this.getMappedUnique(keyArg);
+      }
+    }
+  }
+
+  /**
+   * finds a specific element and then removes it
+   */
+  public async findOneAndRemove(findFunction: IObjectmapFindFunction<T>): Promise<T> {
+    const foundElement = await this.find(findFunction);
+    if (foundElement) {
+      this.remove(foundElement);
+    }
+    return foundElement;
+  }
+  public findOneAndRemoveSync(findFunction: IObjectmapFindFunctionSync<T>): T {
+    const foundElement = this.findSync(findFunction);
+    if (foundElement) {
+      this.remove(foundElement);
+    }
+    return foundElement;
+  }
+
+  /**
+   * run function for each item in Objectmap
+   */
+  public async forEach(functionArg: IObjectmapForEachFunction<T>) {
+    for (const keyArg of this.fastMap.getKeys()) {
+      await functionArg(this.fastMap.getByKey(keyArg));
+    }
+  }
+
+  /**
+   * gets an object in the Observablemap and removes it, so it can't be retrieved again
+   */
+  public getOneAndRemove(): T {
+    const keys = this.fastMap.getKeys();
+    if (keys.length === 0) {
+      return null;
+    } else {
+      const keyToUse = keys[0];
+      const removedItem = this.fastMap.removeFromMap(keyToUse);
+      this.eventSubject.next({
+        operation: 'remove',
+        payload: removedItem,
+      });
+      return removedItem;
+    }
+  }
+
+  /**
+   * returns a cloned array of all the objects currently in the Objectmap
+   */
+  public getArray(): T[] {
+    const returnArray: any[] = [];
+    for (const keyArg of this.fastMap.getKeys()) {
+      returnArray.push(this.fastMap.getByKey(keyArg));
+    }
+    return returnArray;
+  }
+
+  /**
+   * check if Objectmap ist empty
+   */
+  public isEmpty(): boolean {
+    return this.fastMap.getKeys().length === 0;
+  }
+
+  /**
+   * remove object from Objectmap
+   */
+  public remove(objectArg: T): T {
+    if (this.checkForObject(objectArg)) {
+      const keyArg = this.getKeyForObject(objectArg);
+      const removedObject = this.fastMap.removeFromMap(keyArg);
+      this.eventSubject.next({
+        operation: 'remove',
+        payload: removedObject,
+      });
+      return removedObject;
+    }
+    return null;
+  }
+
+  /**
+   * wipe Objectmap
+   */
+  public wipe() {
+    for (const keyArg of this.fastMap.getKeys()) {
+      this.fastMap.removeFromMap(keyArg);
+    }
+  }
+
+  /**
+   * returns a new Objectmap that includes
+   */
+  public concat(objectMapArg: ObjectMap<T>) {
+    const concattedObjectMap = new ObjectMap<T>();
+    concattedObjectMap.fastMap.addAllFromOther(this.fastMap);
+    concattedObjectMap.fastMap.addAllFromOther(objectMapArg.fastMap);
+    return concattedObjectMap;
+  }
+
+  /**
+   * tries to merge another Objectmap
+   * Note: uniqueKeyCollisions will cause overwrite
+   * @param objectMapArg
+   */
+  public addAllFromOther(objectMapArg: ObjectMap<T>) {
+    this.fastMap.addAllFromOther(objectMapArg.fastMap);
+  }
+}

ts/lik.plugins.ts

@@ -1,3 +1,17 @@
-import "typings-global";
-export import q = require("q");
-export import minimatch = require("minimatch");
+// ==============
+// @pushrocks
+// ==============
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartmatch from '@push.rocks/smartmatch';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smarttime from '@push.rocks/smarttime';
+
+export { smartdelay, smartmatch, smartpromise, smartrx, smarttime };
+
+// ==============
+// third party
+// ==============
+import symbolTree from 'symbol-tree';
+
+export { symbolTree };

ts/lik.stringmap.ts

@@ -1,99 +1,119 @@
-import * as plugins from "./lik.plugins";
+import * as plugins from './lik.plugins.js';
 
 /**
- * allows you to easily keep track of a bunch of strings;
+ * allows you to easily keep track of a bunch of strings
  */
 
-export interface triggerFunction {
-    ():boolean;
-}
+export type TTriggerFunction = (stringArray?: string[]) => boolean;
 
 export class Stringmap {
-    private _stringArray:string[] = [];
-    private _triggerUntilTrueFunctionArray:triggerFunction[] = [];
-    constructor(){
+  private _stringArray: string[] = [];
+  private _triggerUntilTrueFunctionArray: TTriggerFunction[] = [];
+  constructor() {}
+  /**
+   * add a string to the Stringmap
+   */
+  addString(stringArg: string) {
+    this._stringArray.push(stringArg);
+    this.notifyTrigger();
+  }
 
-    };
-    /**
-     * add a string to the Stringmap
-     */
-    addString(stringArg:string){
-        this._stringArray.push(stringArg);
-        this.notifyTrigger();
-    };
-
-    /**
-     * removes a string from Stringmap
-     */
-    removeString(stringArg:string){
-        for (let keyArg in this._stringArray){
-            if(this._stringArray[keyArg] == stringArg){
-                this._stringArray.splice(parseInt(keyArg),1);
-            };
-        };
-        this.notifyTrigger();
+  /**
+   * like addString, but accepts an array of strings
+   */
+  addStringArray(stringArrayArg: string[]) {
+    for (const stringItem of stringArrayArg) {
+      this.addString(stringItem);
     }
+  }
 
-    /**
-     * wipes the Stringmap
-     */
-    wipe(){
-        this._stringArray = [];
-        this.notifyTrigger();
+  /**
+   * removes a string from Stringmap
+   */
+  removeString(stringArg: string) {
+    for (const keyArg in this._stringArray) {
+      if (this._stringArray[keyArg] === stringArg) {
+        this._stringArray.splice(parseInt(keyArg), 1);
+      }
     }
+    this.notifyTrigger();
+  }
 
-    /**
-     * check if string is in Stringmap
-     */
-    checkString(stringArg:string):boolean {
-        return this._stringArray.indexOf(stringArg) != -1;
+  /**
+   * wipes the Stringmap
+   */
+  wipe() {
+    this._stringArray = [];
+    this.notifyTrigger();
+  }
+
+  /**
+   * check if string is in Stringmap
+   */
+  public checkString(stringArg: string): boolean {
+    return this._stringArray.indexOf(stringArg) !== -1;
+  }
+
+  /**
+   * checks stringPresence with minimatch
+   */
+  public checkMinimatch(miniMatchStringArg: string): boolean {
+    const smartMatchInstance = new plugins.smartmatch.SmartMatch(miniMatchStringArg);
+    let foundMatch: boolean = false;
+    for (const stringItem of this._stringArray) {
+      if (smartMatchInstance.match(stringItem)) {
+        foundMatch = true;
+      }
     }
+    return foundMatch;
+  }
 
-    /**
-     * checks stringPresence with minimatch
-     */
-    checkMinimatch(miniMatchStringArg:string):boolean {
-        let foundMatch:boolean = false;
-        for(let stringItem of this._stringArray){
-            if(plugins.minimatch(stringItem,miniMatchStringArg)){
-                foundMatch = true;
-            };
-        };
-        return foundMatch;
-    };
+  /**
+   * checks if the Stringmap is empty
+   */
+  public checkIsEmpty() {
+    return this._stringArray.length === 0;
+  }
 
-    /**
-     * checks if the Stringmap is empty
-     */
-    checkIsEmpty(){
-        return (this._stringArray.length == 0);
+  /**
+   * gets a cloned copy of the current string Array
+   */
+  public getStringArray() {
+    const returnArray: string[] = [];
+    for (const stringItem of this._stringArray) {
+      returnArray.push(stringItem);
     }
+    return returnArray;
+  }
 
-    // trigger registering
+  // trigger registering
 
-    /**
-     * notifies triggers
-     */
-    private notifyTrigger(){
-        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
-            return !functionArg();
-        });
-        this._triggerUntilTrueFunctionArray = filteredArray;
-    };
+  /**
+   * register a new trigger
+   */
+  public registerUntilTrue(functionArg: TTriggerFunction, callbackArg?: () => any) {
+    const trueDeferred = plugins.smartpromise.defer();
+    this._triggerUntilTrueFunctionArray.push(() => {
+      const result = functionArg(this.getStringArray());
+      if (result === true) {
+        if (callbackArg) {
+          callbackArg();
+        }
+        trueDeferred.resolve();
+      }
+      return result;
+    });
+    this.notifyTrigger();
+    return trueDeferred.promise;
+  }
 
-    /**
-     * register a new trigger
-     */
-    registerUntilTrue(functionArg:triggerFunction,doFunctionArg){
-        this._triggerUntilTrueFunctionArray.push(
-            () => {
-                let result = functionArg();
-                if(result == true){
-                    doFunctionArg();
-                }
-                return result;
-            }
-        );
-        this.notifyTrigger();
-    }
-}
+  /**
+   * notifies triggers
+   */
+  private notifyTrigger() {
+    const filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
+      return !functionArg();
+    });
+    this._triggerUntilTrueFunctionArray = filteredArray;
+  }
+}

ts/lik.timedaggregator.ts

@@ -0,0 +1,41 @@
+import * as plugins from './lik.plugins.js';
+
+export interface ITimedAggregatorOptions<T> {
+  aggregationIntervalInMillis: number;
+  functionForAggregation: (input: T[]) => void;
+}
+
+export class TimedAggregtor<T> {
+  public options: ITimedAggregatorOptions<T>;
+  private storageArray: T[] = [];
+
+  constructor(optionsArg: ITimedAggregatorOptions<T>) {
+    this.options = optionsArg;
+  }
+
+  private aggregationTimer: plugins.smarttime.Timer;
+  private checkAggregationStatus() {
+    const addAggregationTimer = () => {
+      this.aggregationTimer = new plugins.smarttime.Timer(this.options.aggregationIntervalInMillis);
+      this.aggregationTimer.completed.then(() => {
+        const aggregateForProcessing = this.storageArray;
+        if (aggregateForProcessing.length === 0) {
+          this.aggregationTimer = null;
+          return;
+        }
+        this.storageArray = [];
+        addAggregationTimer();
+        this.options.functionForAggregation(aggregateForProcessing);
+      });
+      this.aggregationTimer.start();
+    };
+    if (!this.aggregationTimer) {
+      addAggregationTimer();
+    }
+  }
+
+  public add(aggregationArg: T) {
+    this.storageArray.push(aggregationArg);
+    this.checkAggregationStatus();
+  }
+}

ts/lik.tree.ts

@@ -0,0 +1,141 @@
+import * as plugins from './lik.plugins.js';
+
+export class Tree<T> {
+  symbolTree: any;
+  constructor() {
+    this.symbolTree = new plugins.symbolTree();
+  }
+
+  // =======================================
+  // Functions that map to the functionality of symbol-tree
+  // =======================================
+
+  /**
+   *
+   * @param objectArg
+   */
+  initialize(objectArg: T): T {
+    return this.symbolTree.initialize(objectArg);
+  }
+
+  hasChildren(objectArg: T): boolean {
+    return this.symbolTree.hasChildren(objectArg);
+  }
+
+  firstChild(objectArg: T): T {
+    return this.symbolTree.firstChild(objectArg);
+  }
+
+  lastChild(objectArg: T): T {
+    return this.symbolTree.lastChild(objectArg);
+  }
+
+  previousSibling(objectArg: T): T {
+    return this.symbolTree.previousSibling(objectArg);
+  }
+
+  nextSibling(objectArg: T): T {
+    return this.symbolTree.nextSibling(objectArg);
+  }
+
+  parent(objectArg: T): T {
+    return this.symbolTree.parent(objectArg);
+  }
+
+  lastInclusiveDescendant(objectArg: T): T {
+    return this.symbolTree.lastInclusiveDescendant(objectArg);
+  }
+
+  preceding(objectArg: T, optionsArg?: any): T {
+    return this.symbolTree.preceding(objectArg, optionsArg);
+  }
+
+  following(object: T, optionsArg: any) {
+    return this.symbolTree.following(object, optionsArg);
+  }
+
+  childrenToArray(parentArg: T, optionsArg: any): T[] {
+    return this.symbolTree.childrenToArray(parentArg, optionsArg);
+  }
+
+  ancestorsToArray(objectArg: T, optionsArg: any): T[] {
+    return this.symbolTree.ancestorsToArray(objectArg, optionsArg);
+  }
+
+  treeToArray(rootArg: T, optionsArg: any): T[] {
+    return this.symbolTree.treeToArray(rootArg, optionsArg);
+  }
+
+  childrenIterator(parentArg: T, optionsArg: any): T {
+    return this.symbolTree.childrenIterator(parentArg, optionsArg);
+  }
+
+  previousSiblingsIterator(objectArg: T): T {
+    return this.symbolTree.previousSiblingsIterator(objectArg);
+  }
+
+  nextSiblingsIterator(objectArg: T) {
+    return this.symbolTree.nextSiblingsIterator();
+  }
+
+  ancestorsIterator(objectArg: T) {
+    this.symbolTree.ancestorsIterator();
+  }
+
+  treeIterator(rootArg: T, optionsArg: any): Iterable<T> {
+    return this.symbolTree.treeIterator(rootArg);
+  }
+
+  index(childArg: T): number {
+    return this.symbolTree.index(childArg);
+  }
+
+  childrenCount(parentArg: T): number {
+    return this.symbolTree.childrenCount(parentArg);
+  }
+
+  compareTreePosition(leftArg: T, rightArg: T): number {
+    return this.compareTreePosition(leftArg, rightArg);
+  }
+
+  remove(removeObjectArg: T): T {
+    return this.symbolTree.remove(removeObjectArg);
+  }
+
+  insertBefore(referenceObjectArg: T, newObjectArg: T): T {
+    return this.symbolTree.insertBefore(referenceObjectArg, newObjectArg);
+  }
+
+  insertAfter(referenceObject: T, newObjectArg: T) {
+    return this.symbolTree.insertAfter(referenceObject, newObjectArg);
+  }
+
+  prependChild(referenceObjectArg: T, newObjectArg: T): T {
+    return this.symbolTree.prependChild(referenceObjectArg, newObjectArg);
+  }
+
+  appendChild(referenceObjectArg: T, newObjectArg: T) {
+    return this.symbolTree.appendChild(referenceObjectArg, newObjectArg);
+  }
+
+  // ===========================================
+  // Functionionality that extends symbol-tree
+  // ===========================================
+
+  /**
+   * returns a branch of the tree as JSON
+   * can be user
+   */
+  toJsonWithHierachy(rootElement: T) {
+    const treeIterable = this.treeIterator(rootElement, {});
+    for (const treeItem of treeIterable) {
+      console.log(treeItem);
+    }
+  }
+
+  /**
+   * builds a tree from a JSON with hierachy
+   * @param rootElement
+   */
+  fromJsonWithHierachy(rootElement: T) {}
+}

tsconfig.json

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