3.0.19

implement JSON methods for tree

See merge request pushrocks/lik!1

.gitignore

@@ -1,5 +1,22 @@
-node_modules/
-pages/
-public/
+.nogit/
+
+# artifacts
 coverage/
-.nogit/
+public/
+pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom

.gitlab-ci.yml

@@ -1,16 +1,16 @@
-# gitzone standard
-image: hosttoday/ht-docker-node:npmci
+# gitzone ci_default
+image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
 
 cache:
   paths:
-  - .npmci_cache/
-  key: "$CI_BUILD_STAGE"
+    - .npmci_cache/
+  key: '$CI_BUILD_STAGE'
 
 stages:
-- security
-- test
-- release
-- metadata
+  - security
+  - test
+  - release
+  - metadata
 
 # ====================
 # security stage
@@ -18,108 +18,103 @@ stages:
 mirror:
   stage: security
   script:
-  - npmci git mirror
+    - npmci git mirror
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv
 
 snyk:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:snyk
   stage: security
   script:
-    - npmci command npm install -g snyk
+    - npmci npm prepare
     - npmci command npm install --ignore-scripts
     - npmci command snyk test
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv
 
 # ====================
 # test stage
 # ====================
-testLEGACY:
-  stage: test
-  script:
-  - npmci node install legacy
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-  allow_failure: true
 
-testLTS:
+testStable:
   stage: test
   script:
-  - npmci node install lts
-  - npmci npm install
-  - npmci npm test
+    - npmci npm prepare
+    - npmci node install stable
+    - npmci npm install
+    - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
-  - notpriv
-    
-testSTABLE:
+    - lossless
+    - docker
+    - priv
+
+testBuild:
   stage: test
   script:
-  - npmci node install stable
-  - npmci npm install
-  - npmci npm test
+    - npmci npm prepare
+    - npmci node install stable
+    - npmci npm install
+    - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv
 
 release:
   stage: release
   script:
-  - npmci node install stable
-  - npmci npm publish
+    - npmci node install stable
+    - npmci npm publish
   only:
-  - tags
+    - tags
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - 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]
+    - npmci command npm install -g tslint typescript
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
-  - docker
-  - priv
+    - lossless
+    - docker
+    - priv
 
 trigger:
   stage: metadata
   script:
-  - npmci trigger
+    - npmci trigger
   only:
-  - tags
+    - tags
   tags:
-  - docker
-  - notpriv
+    - lossless
+    - docker
+    - notpriv
 
 pages:
-  image: hosttoday/ht-docker-node:npmci
   stage: metadata
   script:
-    - npmci command npm install -g npmpage
-    - npmci command npmpage
+    - npmci node install lts
+    - npmci command npm install -g @gitzone/tsdoc
+    - npmci npm prepare
+    - npmci npm install
+    - npmci command tsdoc
   tags:
+    - lossless
     - docker
     - notpriv
   only:
@@ -127,15 +122,5 @@ pages:
   artifacts:
     expire_in: 1 week
     paths:
-    - public
-  allow_failure: true
-
-windowsCompatibility:
-  image: stefanscherer/node-windows:10-build-tools
-  stage: metadata
-  script:
-  - npm install & npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - windows
+      - public
   allow_failure: true

.vscode/launch.json

@@ -0,0 +1,29 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "current file",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "${relativeFile}"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    },
+    {
+      "name": "test.ts",
+      "type": "node",
+      "request": "launch",
+      "args": [
+        "test/test.ts"
+      ],
+      "runtimeArgs": ["-r", "@gitzone/tsrun"],
+      "cwd": "${workspaceRoot}",
+      "protocol": "inspector",
+      "internalConsoleOptions": "openOnSessionStart"
+    }
+  ]
+}

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

README.md

@@ -1,47 +0,0 @@
-# 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)
-[![Known Vulnerabilities](https://snyk.io/test/npm/lik/badge.svg)](https://snyk.io/test/npm/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

@@ -1,14 +1,17 @@
 {
   "npmci": {
-    "npmGlobalTools": [
-      "npmts"
-    ],
+    "npmGlobalTools": [],
     "npmAccessLevel": "public"
   },
-  "npmts": {
-    "coverageTreshold": 40,
-    "testConfig": {
-      "parallel": false
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "lik",
+      "shortDescription": "light little helpers for node",
+      "npmPackagename": "@pushrocks/lik",
+      "license": "MIT"
     }
-  } 
+  }
 }

package.json

@@ -1,13 +1,13 @@
 {
   "name": "@pushrocks/lik",
-  "version": "2.0.6",
+  "version": "3.0.19",
   "private": false,
   "description": "light little helpers for node",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "scripts": {
-    "test": "tsrun test/test.ts",
-    "build": "(npmts)"
+    "test": "(tstest test/)",
+    "build": "(tsbuild)"
   },
   "repository": {
     "type": "git",
@@ -20,16 +20,33 @@
   },
   "homepage": "https://gitlab.com/pushrocks/lik#README",
   "devDependencies": {
-    "@gitzone/tsrun": "^1.1.9",
-    "@pushrocks/tapbundle": "^3.0.1",
-    "@types/node": "^10.5.2"
+    "@gitzone/tsbuild": "^2.1.17",
+    "@gitzone/tsrun": "^1.2.8",
+    "@gitzone/tstest": "^1.0.28",
+    "@pushrocks/tapbundle": "^3.2.0",
+    "@types/node": "^13.7.0",
+    "tslint": "^6.0.0",
+    "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartpromise": "^2.0.5",
-    "@types/lodash": "^4.14.112",
+    "@pushrocks/smartdelay": "^2.0.6",
+    "@pushrocks/smartpromise": "^3.0.6",
+    "@pushrocks/smartrx": "^2.0.5",
+    "@pushrocks/smarttime": "^3.0.12",
+    "@pushrocks/smartunique": "^3.0.1",
     "@types/minimatch": "^3.0.3",
-    "lodash": "^4.17.10",
     "minimatch": "^3.0.4",
-    "symbol-tree": "^3.2.2"
-  }
+    "symbol-tree": "^3.2.4"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_web/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }

readme.md

@@ -0,0 +1,48 @@
+# @pushrocks/lik
+light little helpers for node
+
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/lik)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/lik)
+* [github.com (source mirror)](https://github.com/pushrocks/lik)
+* [docs (typedoc)](https://pushrocks.gitlab.io/lik/)
+
+## Status for master
+[![pipeline status](https://gitlab.com/pushrocks/lik/badges/master/pipeline.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/@pushrocks/lik.svg)](https://www.npmjs.com/package/@pushrocks/lik)
+[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/lik/badge.svg)](https://snyk.io/test/npm/@pushrocks/lik)
+[![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/)
+
+## 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.
+
+> MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy)
+
+[![repo-footer](https://lossless.gitlab.io/publicrelations/repofooter.svg)](https://maintainedby.lossless.com)

test/test.interestmap.ts

@@ -0,0 +1,25 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+import * as lik from '../ts/index';
+
+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);
+});
+
+tap.start();

test/test.looptracker.ts

@@ -1,7 +1,7 @@
 // import test framework
 import { expect, tap } from '@pushrocks/tapbundle';
 import * as events from 'events';
-import * as smartq from 'smartq';
+import * as smartpromise from '@pushrocks/smartpromise';
 
 // import the module
 import * as lik from '../ts/index';

test/test.objectmap.ts

@@ -1,7 +1,7 @@
 // import test framework
 import { expect, tap } from '@pushrocks/tapbundle';
 import * as events from 'events';
-import * as smartq from 'smartq';
+import * as smartpromise from '@pushrocks/smartpromise';
 
 // import the module
 import * as lik from '../ts/index';

test/test.stringmap.ts

@@ -1,7 +1,7 @@
 // import test framework
 import { expect, tap } from '@pushrocks/tapbundle';
 import * as events from 'events';
-import * as smartq from 'smartq';
+import * as smartpromise from '@pushrocks/smartpromise';
 
 // import the module
 import * as lik from '../ts/index';

test/test.timedaggregator.ts

@@ -0,0 +1,25 @@
+// import test framework
+import { expect, tap } from '@pushrocks/tapbundle';
+import * as events from 'events';
+import * as smartpromise from '@pushrocks/smartpromise';
+
+// import the module
+import * as lik from '../ts/index';
+
+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);
+});
+
+tap.start();

test/test.tree.ts

@@ -1,14 +1,20 @@
 import { tap, expect } from '@pushrocks/tapbundle';
 import * as lik from '../ts/index';
 
-let testTree = new lik.Tree<TestClass>();
-
 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();
@@ -21,4 +27,14 @@ tap.test('should insert an object', async () => {
   expect(resultArray).to.contain(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);
+});
+
 tap.start();

ts/index.ts

@@ -1,9 +1,8 @@
-import * as plugins from './lik.plugins';
-
-// import modules
-
+export * from './lik.fastmap';
+export * from './lik.interestmap';
+export * from './lik.limitedarray';
 export * from './lik.looptracker';
 export * from './lik.objectmap';
 export * from './lik.stringmap';
-export * from './lik.limitedarray';
+export * from './lik.timedaggregator';
 export * from './lik.tree';

ts/lik.fastmap.ts

@@ -0,0 +1,45 @@
+import * as plugins from './lik.plugins';
+
+/**
+ * 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): boolean {
+    if (this.isUniqueKey(keyArg)) {
+      this.mapObject[keyArg] = objectArg;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  public getByKey(keyArg: string) {
+    return this.mapObject[keyArg];
+  }
+
+  public removeFromMap(keyArg): 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 = {};
+  }
+}

ts/lik.interestmap.interest.ts

@@ -0,0 +1,78 @@
+import * as plugins from './lik.plugins';
+
+import { InterestMap, IInterestComparisonFunc } from './lik.interestmap';
+
+export class Interest<DTInterestId, 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>
+  ) {
+    this.originalInterest = interestArg;
+    this.comparisonFunc = comparisonFuncArg;
+    this.interestMapRef = interestMapArg;
+    this.destructionTimer.completed.then(() => {
+      this.destroy();
+    });
+  }
+
+  // ===============================
+  // LIFECYCLE MANAGEMENT
+  // ===============================
+
+  /**
+   * self destructs the interest
+   */
+  public destroy() {
+    this.interestMapRef.removeInterest(this);
+  }
+
+  /**
+   * 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,114 @@
+import * as plugins from './lik.plugins';
+import { Objectmap } from './lik.objectmap';
+
+import { Observable } from 'rxjs';
+
+import { Interest } from './lik.interestmap.interest';
+
+export type IInterestComparisonFunc<T> = (objectArg: T) => string;
+
+export class InterestMap<DTInterestId, DTInterestFullfillment> {
+  /**
+   * 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>) {
+    this.comparisonFunc = comparisonFuncArg;
+  }
+
+  /**
+   * adds an interest to the InterestMap
+   * @param objectArg
+   */
+  public async addInterest(
+    objectArg: DTInterestId
+  ): Promise<Interest<DTInterestId, DTInterestFullfillment>> {
+    const comparisonString = this.comparisonFunc(objectArg);
+    let returnInterest: Interest<DTInterestId, DTInterestFullfillment>;
+    const newInterest = new Interest<DTInterestId, DTInterestFullfillment>(
+      this,
+      objectArg,
+      this.comparisonFunc
+    );
+    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;
+  }
+
+  // tslint:disable-next-line:member-ordering
+  public interestObservable = new plugins.smartrx.ObservableIntake<Interest<DTInterestId, any>>();
+
+  /**
+   * removes an interest from the interest map
+   * @param objectArg removes an interest from the InterestMap
+   */
+  public removeInterest(interestArg: Interest<DTInterestId, DTInterestFullfillment>) {
+    const interestToRemove = this.interestObjectMap.findOneAndRemove(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.find(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 objectArg
+   */
+  public findInterest(objectArg: DTInterestId): Interest<DTInterestId, DTInterestFullfillment> {
+    const comparableString = this.comparisonFunc(objectArg);
+    const interest = this.interestObjectMap.find(interestArg => {
+      return interestArg.comparisonString === comparableString;
+    });
+    return interest; // if an interest is found, the interest is returned, otherwise interest is null
+  }
+}

ts/lik.looptracker.ts

@@ -12,7 +12,12 @@ export class LoopTracker<T> {
    * checks and tracks an object
    * @param objectArg
    */
-  checkAndTrack(objectArg: T) {
-    return this.referenceObjectMap.add(objectArg);
+  checkAndTrack(objectArg: T): boolean {
+    if (!this.referenceObjectMap.checkForObject(objectArg)) {
+      this.referenceObjectMap.add(objectArg);
+      return true;
+    } else {
+      return false;
+    }
   }
 }

ts/lik.objectmap.ts

@@ -1,4 +1,5 @@
 import * as plugins from './lik.plugins';
+import { FastMap } from './lik.fastmap';
 
 export interface IObjectmapForEachFunction<T> {
   (itemArg: T): void;
@@ -12,7 +13,10 @@ export interface IObjectmapFindFunction<T> {
  * allows keeping track of objects
  */
 export class Objectmap<T> {
-  private objectArray: T[] = [];
+  private fastMap = new FastMap<T>();
+
+  // events
+  public eventSubject = new plugins.smartrx.rxjs.Subject<any>();
 
   /**
    * returns a new instance
@@ -21,27 +25,55 @@ export class Objectmap<T> {
     // 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
    */
-  add(objectArg: T): boolean {
-    if (this.checkForObject(objectArg)) {
-      // the object is already in the objectmap
-      return false;
-    } else {
-      // the object is not yet in the objectmap
-      this.objectArray.push(objectArg);
-      return true;
+  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 = plugins.smartunique.shortId();
+    this.addMappedUnique(uniqueKey, objectArg);
+    return uniqueKey;
   }
 
   /**
    * like .add but adds an whole array of objects
    */
-  addArray(objectArrayArg: T[]) {
-    for (let item of objectArrayArg) {
+  public addArray(objectArrayArg: T[]) {
+    for (const item of objectArrayArg) {
       this.add(item);
     }
   }
@@ -49,27 +81,42 @@ export class Objectmap<T> {
   /**
    * check if object is in Objectmap
    */
-  checkForObject(objectArg: T) {
-    return this.objectArray.indexOf(objectArg) !== -1;
+  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
    */
-  find(findFunction: IObjectmapFindFunction<T>) {
-    let resultArray = this.objectArray.filter(findFunction);
-    if (resultArray.length > 0) {
-      return resultArray[0];
-    } else {
-      return null;
+  public find(findFunction: IObjectmapFindFunction<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
    */
-  findOneAndRemove(findFunction: IObjectmapFindFunction<T>): T {
-    let foundElement = this.find(findFunction);
+  public findOneAndRemove(findFunction: IObjectmapFindFunction<T>): T {
+    const foundElement = this.find(findFunction);
     if (foundElement) {
       this.remove(foundElement);
     }
@@ -79,54 +126,64 @@ export class Objectmap<T> {
   /**
    * run function for each item in Objectmap
    */
-  async forEach(functionArg: IObjectmapForEachFunction<T>) {
-    for (let object of this.objectArray) {
-      await functionArg(object);
+  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
    */
-  getOneAndRemove(): T {
-    return this.objectArray.shift();
+  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('remove');
+      return removedItem;
+    }
   }
 
   /**
    * returns a cloned array of all the objects currently in the Objectmap
    */
-  getArray() {
-    return plugins.lodash.cloneDeep(this.objectArray);
+  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
    */
-  isEmpty(): boolean {
-    if (this.objectArray.length === 0) {
-      return true;
-    } else {
-      return false;
-    }
+  public isEmpty(): boolean {
+    return this.fastMap.getKeys().length === 0;
   }
 
   /**
    * remove object from Objectmap
    */
-  remove(objectArg: T) {
-    let replacementArray = [];
-    for (let item of this.objectArray) {
-      if (item !== objectArg) {
-        replacementArray.push(item);
-      }
+  public remove(objectArg: T): T {
+    if (this.checkForObject(objectArg)) {
+      const keyArg = this.getKeyForObject(objectArg);
+      const removedObject = this.fastMap.removeFromMap(keyArg);
+      this.eventSubject.next('remove');
+      return removedObject;
     }
-    this.objectArray = replacementArray;
+    return null;
   }
 
   /**
    * wipe Objectmap
    */
-  wipe() {
-    this.objectArray = [];
+  public wipe() {
+    for (const keyArg of this.fastMap.getKeys()) {
+      this.fastMap.removeFromMap(keyArg);
+    }
   }
 }

ts/lik.plugins.ts

@@ -1,7 +1,26 @@
+// ==============
+// native
+// ==============
+
 import * as events from 'events';
-import * as lodash from 'lodash';
-import * as minimatch from 'minimatch';
+
+export { events };
+
+// ==============
+// @pushrocks
+// ==============
+import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartpromise from '@pushrocks/smartpromise';
+import * as smartrx from '@pushrocks/smartrx';
+import * as smarttime from '@pushrocks/smarttime';
+import * as smartunique from '@pushrocks/smartunique';
+
+export { smartdelay, smartpromise, smartrx, smarttime, smartunique };
+
+// ==============
+// third party
+// ==============
+import minimatch from 'minimatch';
 const symbolTree = require('symbol-tree');
 
-export { events, lodash, minimatch, smartpromise, symbolTree };
+export { minimatch, symbolTree };

ts/lik.stringmap.ts

@@ -24,7 +24,7 @@ export class Stringmap {
    * like addString, but accepts an array of strings
    */
   addStringArray(stringArrayArg: string[]) {
-    for (let stringItem of stringArrayArg) {
+    for (const stringItem of stringArrayArg) {
       this.addString(stringItem);
     }
   }
@@ -33,7 +33,7 @@ export class Stringmap {
    * removes a string from Stringmap
    */
   removeString(stringArg: string) {
-    for (let keyArg in this._stringArray) {
+    for (const keyArg in this._stringArray) {
       if (this._stringArray[keyArg] === stringArg) {
         this._stringArray.splice(parseInt(keyArg), 1);
       }
@@ -52,16 +52,16 @@ export class Stringmap {
   /**
    * check if string is in Stringmap
    */
-  checkString(stringArg: string): boolean {
+  public checkString(stringArg: string): boolean {
     return this._stringArray.indexOf(stringArg) !== -1;
   }
 
   /**
    * checks stringPresence with minimatch
    */
-  checkMinimatch(miniMatchStringArg: string): boolean {
+  public checkMinimatch(miniMatchStringArg: string): boolean {
     let foundMatch: boolean = false;
-    for (let stringItem of this._stringArray) {
+    for (const stringItem of this._stringArray) {
       if (plugins.minimatch(stringItem, miniMatchStringArg)) {
         foundMatch = true;
       }
@@ -72,15 +72,19 @@ export class Stringmap {
   /**
    * checks if the Stringmap is empty
    */
-  checkIsEmpty() {
+  public checkIsEmpty() {
     return this._stringArray.length === 0;
   }
 
   /**
    * gets a cloned copy of the current string Array
    */
-  getStringArray() {
-    return plugins.lodash.cloneDeep(this._stringArray);
+  public getStringArray() {
+    const returnArray: string[] = [];
+    for (const stringItem of this._stringArray) {
+      returnArray.push(stringItem);
+    }
+    return returnArray;
   }
 
   // trigger registering
@@ -88,9 +92,9 @@ export class Stringmap {
   /**
    * register a new trigger
    */
-  registerUntilTrue(functionArg: ITriggerFunction, doFunctionArg) {
+  public registerUntilTrue(functionArg: ITriggerFunction, doFunctionArg) {
     this._triggerUntilTrueFunctionArray.push(() => {
-      let result = functionArg();
+      const result = functionArg();
       if (result === true) {
         doFunctionArg();
       }
@@ -103,7 +107,7 @@ export class Stringmap {
    * notifies triggers
    */
   private notifyTrigger() {
-    let filteredArray = this._triggerUntilTrueFunctionArray.filter(functionArg => {
+    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';
+
+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

@@ -6,6 +6,10 @@ export class Tree<T> {
     this.symbolTree = new plugins.symbolTree();
   }
 
+  // =======================================
+  // Functions that map to the functionality of symbol-tree
+  // =======================================
+
   /**
    *
    * @param objectArg
@@ -78,7 +82,7 @@ export class Tree<T> {
     this.symbolTree.ancestorsIterator();
   }
 
-  treeIterator(rootArg: T, optionsArg): T {
+  treeIterator(rootArg: T, optionsArg): Iterable<T> {
     return this.symbolTree.treeIterator(rootArg);
   }
 
@@ -113,4 +117,25 @@ export class Tree<T> {
   appendChild(referenceObjectArg, newObjectArg) {
     return this.symbolTree.appendChild(referenceObjectArg, newObjectArg);
   }
+
+  // ===========================================
+  // Functionionality that extends symbol-tree
+  // ===========================================
+
+  /**
+   * returns a branch of the tree as JSON
+   * can be user
+   */
+  toJsonWithHierachy(rootElement) {
+    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) {}
 }

tslint.json

@@ -1,3 +1,17 @@
 {
-    "extends": "tslint-config-standard"
+  "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"
 }