5.0.1

.gitlab-ci.yml

@@ -19,23 +19,36 @@ mirror:
   stage: security
   script:
     - npmci git mirror
+  only:
+    - tags
   tags:
     - lossless
     - docker
     - notpriv
 
-audit:
+auditProductionDependencies:
+  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
+  stage: security
+  script:
+    - npmci npm prepare
+    - npmci command npm install --production --ignore-scripts
+    - npmci command npm config set registry https://registry.npmjs.org
+    - npmci command npm audit --audit-level=high --only=prod --production
+  tags:
+    - docker
+  allow_failure: true
+
+auditDevDependencies:
   image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
   stage: security
   script:
     - npmci npm prepare
     - npmci command npm install --ignore-scripts
     - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high
+    - npmci command npm audit --audit-level=high --only=dev
   tags:
-    - lossless
     - docker
-    - notpriv
+  allow_failure: true
 
 # ====================
 # test stage
@@ -50,9 +63,7 @@ testStable:
     - npmci npm test
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - priv
 
 testBuild:
   stage: test
@@ -63,9 +74,7 @@ testBuild:
     - npmci command npm run build
   coverage: /\d+.?\d+?\%\s*coverage/
   tags:
-    - lossless
     - docker
-    - notpriv
 
 release:
   stage: release
@@ -85,6 +94,8 @@ release:
 codequality:
   stage: metadata
   allow_failure: true
+  only:
+    - tags
   script:
     - npmci command npm install -g tslint typescript
     - npmci npm prepare

.vscode/settings.json

@@ -15,7 +15,7 @@
             "properties": {
               "projectType": {
                 "type": "string",
-                "enum": ["website", "element", "service", "npm"]
+                "enum": ["website", "element", "service", "npm", "wcc"]
               }
             }
           }

package.json

@@ -1,13 +1,13 @@
 {
   "name": "@pushrocks/lik",
-  "version": "4.0.10",
+  "version": "5.0.1",
   "private": false,
   "description": "light little helpers for node",
   "main": "dist_ts/index.js",
   "typings": "dist_ts/index.d.ts",
   "scripts": {
     "test": "(tstest test/)",
-    "build": "(tsbuild && tsbundle npm)"
+    "build": "(tsbuild --web && tsbundle npm)"
   },
   "repository": {
     "type": "git",
@@ -20,23 +20,22 @@
   },
   "homepage": "https://gitlab.com/pushrocks/lik#README",
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.24",
+    "@gitzone/tsbuild": "^2.1.29",
-    "@gitzone/tsbundle": "^1.0.69",
+    "@gitzone/tsbundle": "^1.0.89",
-    "@gitzone/tsrun": "^1.2.8",
+    "@gitzone/tsrun": "^1.2.18",
-    "@gitzone/tstest": "^1.0.28",
+    "@gitzone/tstest": "^1.0.60",
-    "@pushrocks/tapbundle": "^3.2.1",
+    "@pushrocks/tapbundle": "^4.0.0",
-    "@types/node": "^14.0.5",
+    "@types/node": "^17.0.10",
-    "tslint": "^6.1.2",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartdelay": "^2.0.9",
+    "@pushrocks/smartdelay": "^2.0.13",
     "@pushrocks/smartmatch": "^1.0.7",
-    "@pushrocks/smartpromise": "^3.0.6",
+    "@pushrocks/smartpromise": "^3.1.6",
-    "@pushrocks/smartrx": "^2.0.12",
+    "@pushrocks/smartrx": "^2.0.20",
-    "@pushrocks/smarttime": "^3.0.18",
+    "@pushrocks/smarttime": "^3.0.43",
-    "@pushrocks/smartunique": "^3.0.3",
+    "@types/minimatch": "^3.0.5",
-    "@types/minimatch": "^3.0.3",
     "symbol-tree": "^3.2.4"
   },
   "files": [
@@ -50,5 +49,8 @@
     "cli.js",
     "npmextra.json",
     "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
   ]
 }

readme.md

@@ -8,13 +8,20 @@ light little helpers for node
 * [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)
+Status Category | Status Badge
-[![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)
+GitLab Pipelines | [![pipeline status](https://gitlab.com/pushrocks/lik/badges/master/pipeline.svg)](https://lossless.cloud)
-[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+GitLab Pipline Test Coverage | [![coverage report](https://gitlab.com/pushrocks/lik/badges/master/coverage.svg)](https://lossless.cloud)
-[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+npm | [![npm downloads per month](https://badgen.net/npm/dy/@pushrocks/lik)](https://lossless.cloud)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
+Snyk | [![Known Vulnerabilities](https://badgen.net/snyk/pushrocks/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/@pushrocks/lik)](https://lossless.cloud)
+PackagePhobia (package size on registry) | [![PackagePhobia](https://badgen.net/packagephobia/publish/@pushrocks/lik)](https://lossless.cloud)
+BundlePhobia (total size when bundled) | [![BundlePhobia](https://badgen.net/bundlephobia/minzip/@pushrocks/lik)](https://lossless.cloud)
+Platform support | [![Supports Windows 10](https://badgen.net/badge/supports%20Windows%2010/yes/green?icon=windows)](https://lossless.cloud) [![Supports Mac OS X](https://badgen.net/badge/supports%20Mac%20OS%20X/yes/green?icon=apple)](https://lossless.cloud)
 
 ## Usage
 

test/test.fastmap.both.ts

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

test/test.interestmap.both.ts

@@ -4,7 +4,7 @@ import * as lik from '../ts/index';
 let testInterestmap: lik.InterestMap<number, number>;
 
 tap.test('should create an interestmap', async () => {
-  testInterestmap = new lik.InterestMap(numberArg => {
+  testInterestmap = new lik.InterestMap((numberArg) => {
     return numberArg.toString();
   });
 });

test/test.limitedarray.both.ts

@@ -6,12 +6,12 @@ let testLimitedArray: LimitedArray<string>;
 
 tap.test('should create a LimitedArray', async () => {
   testLimitedArray = new LimitedArray(6);
-  expect(testLimitedArray).to.be.instanceof(LimitedArray);
+  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).to.be.lessThan(7);
+  expect(testLimitedArray.array.length < 7).toBeTrue();
 });
 
 tap.start();

test/test.looptracker.both.ts

@@ -13,14 +13,14 @@ let myLoopTracker: lik.LoopTracker<any>;
 // tests
 tap.test('should create a valid looptracker instance', async () => {
   myLoopTracker = new lik.LoopTracker();
-  expect(myLoopTracker).to.be.instanceof(lik.LoopTracker);
+  expect(myLoopTracker).toBeInstanceOf(lik.LoopTracker);
 });
 
 tap.test('should add objects once and return true', async () => {
-  expect(myLoopTracker.checkAndTrack(object1)).to.be.true;
+  expect(myLoopTracker.checkAndTrack(object1)).toBeTrue();
-  expect(myLoopTracker.checkAndTrack(object1)).to.be.false;
+  expect(myLoopTracker.checkAndTrack(object1)).toBeFalse();
-  expect(myLoopTracker.checkAndTrack(object2)).to.be.true;
+  expect(myLoopTracker.checkAndTrack(object2)).toBeTrue();
-  expect(myLoopTracker.checkAndTrack(object2)).to.be.false;
+  expect(myLoopTracker.checkAndTrack(object2)).toBeFalse();
 });
 
 tap.start();

test/test.objectmap.both.ts

@@ -14,65 +14,65 @@ interface ITestObject {
 let testObjectmap: lik.ObjectMap<ITestObject>;
 let testObject1: ITestObject = {
   propOne: 'hello',
-  propTwo: 'hello2'
+  propTwo: 'hello2',
 };
 let testObject2: ITestObject = {
   propOne: 'hello',
-  propTwo: 'hello2'
+  propTwo: 'hello2',
 };
 
 tap.test('new lik.Objectmap() -> should correctly instantiate an Objectmap', async () => {
   testObjectmap = new lik.ObjectMap<ITestObject>();
-  expect(testObjectmap).be.instanceof(lik.ObjectMap);
+  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)).be.true;
+  expect(testObjectmap.checkForObject(testObject1)).toBeTrue();
   // tslint:disable-next-line:no-unused-expression
-  expect(testObjectmap.checkForObject(testObject2)).be.false;
+  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)).be.false;
+  expect(testObjectmap.checkForObject(testObject1)).toBeFalse();
   // tslint:disable-next-line:no-unused-expression
-  expect(testObjectmap.checkForObject(testObject2)).be.true;
+  expect(testObjectmap.checkForObject(testObject2)).toBeTrue();
 });
 
 tap.test('Objectmap.forEach -> should correctly run a function forEach map object', async () => {
-  testObjectmap.forEach(itemArg => {
+  testObjectmap.forEach((itemArg) => {
-    expect(itemArg).to.have.property('propOne');
+    // TODO expect(itemArg).to.have.property('propOne');
   });
 });
 
 tap.test('lik.Objectmap.find() -> should correctly find an object', async () => {
   let myObject = { propOne: 'helloThere', propTwo: 'helloAnyway' };
   testObjectmap.add(myObject);
-  let referenceObject = testObjectmap.find(itemArg => {
+  let referenceObject = await testObjectmap.find(async (itemArg) => {
     return itemArg.propOne === 'helloThere';
   });
   // tslint:disable-next-line:no-unused-expression
-  expect(myObject === referenceObject).be.true;
+  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]).to.eql(myObject);
+  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.be.null;
+  // TODO expect(oneObject).not.toBeNull();
-  expect(testObjectmap.getArray().length).equal(originalLength - 1);
+  expect(testObjectmap.getArray().length).toEqual(originalLength - 1);
-  expect(testObjectmap.getArray()).to.not.contain(oneObject);
+  // TODO expect(testObjectmap.getArray()).to.not.contain(oneObject);
 });
 
 tap.start();

test/test.stringmap.both.ts

@@ -18,14 +18,14 @@ let testString6 = 'testString6';
 // tests
 tap.test('new lik.Objectmap() -> should create an instance of Stringmap', async () => {
   testStringmap = new lik.Stringmap();
-  expect(testStringmap).be.instanceof(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)).be.false;
+    expect(testStringmap.checkString(testString1)).toBeFalse();
   }
 );
 
@@ -34,37 +34,37 @@ tap.test('lik.Stringmap.addString -> should add an string to Stringmap', async (
   testStringmap.addString(testString2);
   testStringmap.addString(testString3);
   // tslint:disable-next-line:no-unused-expression
-  expect(testStringmap.checkString(testString1)).be.true;
+  expect(testStringmap.checkString(testString1)).toBeTrue();
   // tslint:disable-next-line:no-unused-expression
-  expect(testStringmap.checkString(testString2)).be.true;
+  expect(testStringmap.checkString(testString2)).toBeTrue();
   // tslint:disable-next-line:no-unused-expression
-  expect(testStringmap.checkString(testString3)).be.true;
+  expect(testStringmap.checkString(testString3)).toBeTrue();
   // tslint:disable-next-line:no-unused-expression
-  expect(testStringmap.checkMinimatch('*String1')).be.true;
+  expect(testStringmap.checkMinimatch('*String1')).toBeTrue();
   // tslint:disable-next-line:no-unused-expression
-  expect(testStringmap.checkMinimatch('*String2')).be.true;
+  expect(testStringmap.checkMinimatch('*String2')).toBeTrue();
   // tslint:disable-next-line:no-unused-expression
-  expect(testStringmap.checkMinimatch('*String4')).be.false;
+  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')).be.true;
+  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)).be.false;
+  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').be.true;
+  expect(clonedArray[0] === 'testString1').toBeTrue();
   // tslint:disable-next-line:no-unused-expression
-  expect(clonedArray[0] === testString1).be.true;
+  expect(clonedArray[0] === testString1).toBeTrue();
 });
 
 tap.test(

test/test.timedaggregator.both.ts

@@ -8,12 +8,12 @@ import * as lik from '../ts/index';
 
 let testTimedAggregator: lik.TimedAggregtor<string>;
 
-tap.test('should create a timed aggregaotor', async tools => {
+tap.test('should create a timed aggregaotor', async (tools) => {
   testTimedAggregator = new lik.TimedAggregtor<string>({
     aggregationIntervalInMillis: 1000,
-    functionForAggregation: aggregation => {
+    functionForAggregation: (aggregation) => {
       console.log(aggregation);
-    }
+    },
   });
   testTimedAggregator.add('This');
   testTimedAggregator.add('is a whole sentence.');

test/test.tree.both.ts

@@ -18,13 +18,13 @@ let testInstance6 = new TestClass('sixth');
 
 tap.test('create a valid tree instance', async () => {
   testTree = new lik.Tree();
-  expect(testTree).to.be.instanceOf(lik.Tree);
+  expect(testTree).toBeInstanceOf(lik.Tree);
 });
 
 tap.test('should insert an object', async () => {
   testTree.initialize(testInstance);
   let resultArray = testTree.treeToArray(testInstance, {});
-  expect(resultArray).to.contain(testInstance);
+  // TODO expect(resultArray).toContain(testInstance);
 });
 
 tap.test('should add other objects in a hierachy', async () => {

test/test.ts

@@ -1 +0,0 @@
-import './test.objectmap';

ts/index.ts

@@ -1,5 +1,6 @@
 export * from './lik.fastmap';
 export * from './lik.interestmap';
+export * from './lik.interestmap.interest';
 export * from './lik.limitedarray';
 export * from './lik.looptracker';
 export * from './lik.objectmap';

ts/lik.fastmap.ts

@@ -29,7 +29,7 @@ export class FastMap<T> {
     return this.mapObject[keyArg];
   }
 
-  public removeFromMap(keyArg): T {
+  public removeFromMap(keyArg: string): T {
     const removedItem = this.getByKey(keyArg);
     delete this.mapObject[keyArg];
     return removedItem;
@@ -50,7 +50,7 @@ export class FastMap<T> {
   }
 
   /**
-   * returns a new Objectmap that includes
+   * 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>();
@@ -60,7 +60,7 @@ export class FastMap<T> {
 
     for (const key of fastMapArg.getKeys()) {
       concatedFastmap.addToMap(key, fastMapArg.getByKey(key), {
-        force: true
+        force: true,
       });
     }
 
@@ -68,15 +68,25 @@ export class FastMap<T> {
   }
 
   /**
-   * tries to merge another Objectmap
+   * tries to merge another Fastmap
    * Note: uniqueKeyCollisions will cause overwrite
-   * @param objectMapArg
+   * @param fastMapArg
    */
   public addAllFromOther(fastMapArg: FastMap<T>) {
     for (const key of fastMapArg.getKeys()) {
       this.addToMap(key, fastMapArg.getByKey(key), {
-        force: true
+        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

@@ -2,7 +2,14 @@ import * as plugins from './lik.plugins';
 
 import { InterestMap, IInterestComparisonFunc } from './lik.interestmap';
 
+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>;
@@ -41,14 +48,20 @@ export class Interest<DTInterestId, DTInterestFullfillment> {
   constructor(
     interestMapArg: InterestMap<DTInterestId, DTInterestFullfillment>,
     interestArg: DTInterestId,
-    comparisonFuncArg: IInterestComparisonFunc<DTInterestId>
+    comparisonFuncArg: IInterestComparisonFunc<DTInterestId>,
+    optionsArg?: IInterestOptions<DTInterestFullfillment>
   ) {
+    this.interestMapRef = interestMapArg;
     this.originalInterest = interestArg;
     this.comparisonFunc = comparisonFuncArg;
-    this.interestMapRef = interestMapArg;
+    this.options = optionsArg;
+
     this.destructionTimer.completed.then(() => {
       this.destroy();
     });
+    if (this.options?.markLostAfterDefault) {
+      plugins.smartdelay.delayFor(this.options.markLostAfterDefault).then(this.markLost);
+    }
   }
 
   // ===============================
@@ -60,6 +73,9 @@ export class Interest<DTInterestId, DTInterestFullfillment> {
    */
   public destroy() {
     this.interestMapRef.removeInterest(this);
+    if (!this.isFullfilled && this.options.defaultFullfillment) {
+      this.fullfillInterest(this.options.defaultFullfillment);
+    }
   }
 
   /**

ts/lik.interestmap.ts

@@ -7,7 +7,13 @@ import { Interest } from './lik.interestmap.interest';
 
 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
    */
@@ -18,8 +24,12 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
    */
   private comparisonFunc: IInterestComparisonFunc<DTInterestId>;
 
-  constructor(comparisonFuncArg: IInterestComparisonFunc<DTInterestId>) {
+  constructor(
+    comparisonFuncArg: IInterestComparisonFunc<DTInterestId>,
+    optionsArg: IInterestMapOptions = {}
+  ) {
     this.comparisonFunc = comparisonFuncArg;
+    this.options = optionsArg;
   }
 
   /**
@@ -27,17 +37,22 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
    * @param objectArg
    */
   public async addInterest(
-    objectArg: DTInterestId
+    objectArg: DTInterestId,
+    defaultFullfillmentArg?: DTInterestFullfillment
   ): Promise<Interest<DTInterestId, DTInterestFullfillment>> {
     const comparisonString = this.comparisonFunc(objectArg);
     let returnInterest: Interest<DTInterestId, DTInterestFullfillment>;
     const newInterest = new Interest<DTInterestId, DTInterestFullfillment>(
       this,
       objectArg,
-      this.comparisonFunc
+      this.comparisonFunc,
+      {
+        markLostAfterDefault: this.options.markLostAfterDefault,
+        defaultFullfillment: defaultFullfillmentArg,
+      }
     );
     let interestExists = false;
-    await this.interestObjectMap.forEach(interestArg => {
+    await this.interestObjectMap.forEach((interestArg) => {
       if (!interestExists && interestArg.comparisonString === newInterest.comparisonString) {
         console.log('info', `interest already exists for ${newInterest.comparisonString}`);
         interestExists = true;
@@ -61,7 +76,7 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
    * @param objectArg removes an interest from the InterestMap
    */
   public removeInterest(interestArg: Interest<DTInterestId, DTInterestFullfillment>) {
-    const interestToRemove = this.interestObjectMap.findOneAndRemove(interestArg2 => {
+    const interestToRemove = this.interestObjectMap.findOneAndRemoveSync((interestArg2) => {
       return interestArg.comparisonString === interestArg2.comparisonString;
     });
   }
@@ -79,7 +94,7 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
    * @param comparisonStringArg
    */
   public checkInterestByString(comparisonStringArg: string): boolean {
-    const foundInterest = this.interestObjectMap.find(interest => {
+    const foundInterest = this.interestObjectMap.findSync((interest) => {
       return interest.comparisonString === comparisonStringArg;
     });
     if (foundInterest) {
@@ -106,7 +121,7 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
    */
   public findInterest(objectArg: DTInterestId): Interest<DTInterestId, DTInterestFullfillment> {
     const comparableString = this.comparisonFunc(objectArg);
-    const interest = this.interestObjectMap.find(interestArg => {
+    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.objectmap.ts

@@ -1,14 +1,31 @@
 import * as plugins from './lik.plugins';
 import { FastMap } from './lik.fastmap';
 
+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 IObjectmapFindFunction<T> {
+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
  */
@@ -16,7 +33,7 @@ export class ObjectMap<T> {
   private fastMap = new FastMap<T>();
 
   // events
-  public eventSubject = new plugins.smartrx.rxjs.Subject<any>();
+  public eventSubject = new plugins.smartrx.rxjs.Subject<IObjectMapEventData<T>>();
 
   /**
    * returns a new instance
@@ -64,8 +81,12 @@ export class ObjectMap<T> {
     }
 
     // otherwise lets create it
-    const uniqueKey = plugins.smartunique.shortId();
+    const uniqueKey = uni('key');
     this.addMappedUnique(uniqueKey, objectArg);
+    this.eventSubject.next({
+      operation: 'add',
+      payload: objectArg
+    });
     return uniqueKey;
   }
 
@@ -104,7 +125,11 @@ export class ObjectMap<T> {
   /**
    * find object
    */
-  public find(findFunction: IObjectmapFindFunction<T>): T {
+  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);
@@ -115,8 +140,15 @@ export class ObjectMap<T> {
   /**
    * finds a specific element and then removes it
    */
-  public findOneAndRemove(findFunction: IObjectmapFindFunction<T>): T {
+   public async findOneAndRemove(findFunction: IObjectmapFindFunction<T>): Promise<T> {
-    const foundElement = this.find(findFunction);
+    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);
     }
@@ -142,7 +174,10 @@ export class ObjectMap<T> {
     } else {
       const keyToUse = keys[0];
       const removedItem = this.fastMap.removeFromMap(keyToUse);
-      this.eventSubject.next('remove');
+      this.eventSubject.next({
+        operation: 'remove',
+        payload: removedItem
+      });
       return removedItem;
     }
   }
@@ -172,7 +207,10 @@ export class ObjectMap<T> {
     if (this.checkForObject(objectArg)) {
       const keyArg = this.getKeyForObject(objectArg);
       const removedObject = this.fastMap.removeFromMap(keyArg);
-      this.eventSubject.next('remove');
+      this.eventSubject.next({
+        operation: 'remove',
+        payload: removedObject
+      });
       return removedObject;
     }
     return null;

ts/lik.plugins.ts

@@ -6,9 +6,8 @@ import * as smartmatch from '@pushrocks/smartmatch';
 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, smartmatch, smartpromise, smartrx, smarttime, smartunique };
+export { smartdelay, smartmatch, smartpromise, smartrx, smarttime };
 
 // ==============
 // third party

ts/lik.stringmap.ts

@@ -4,7 +4,7 @@ import * as plugins from './lik.plugins';
  * allows you to easily keep track of a bunch of strings
  */
 
-export type TTriggerFunction =  (stringArray?: string[]) => boolean;
+export type TTriggerFunction = (stringArray?: string[]) => boolean;
 
 export class Stringmap {
   private _stringArray: string[] = [];
@@ -111,7 +111,7 @@ export class Stringmap {
    * notifies triggers
    */
   private notifyTrigger() {
-    const filteredArray = this._triggerUntilTrueFunctionArray.filter(functionArg => {
+    const filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
       return !functionArg();
     });
     this._triggerUntilTrueFunctionArray = filteredArray;

ts/lik.tree.ts

@@ -62,15 +62,15 @@ export class Tree<T> {
     return this.symbolTree.ancestorsToArray(objectArg, optionsArg);
   }
 
-  treeToArray(rootArg, optionsArg: any): T[] {
+  treeToArray(rootArg: T, optionsArg: any): T[] {
     return this.symbolTree.treeToArray(rootArg, optionsArg);
   }
 
-  childrenIterator(parentArg: T, optionsArg): T {
+  childrenIterator(parentArg: T, optionsArg: any): T {
     return this.symbolTree.childrenIterator(parentArg, optionsArg);
   }
 
-  previousSiblingsIterator(objectArg): T {
+  previousSiblingsIterator(objectArg: T): T {
     return this.symbolTree.previousSiblingsIterator(objectArg);
   }
 
@@ -78,11 +78,11 @@ export class Tree<T> {
     return this.symbolTree.nextSiblingsIterator();
   }
 
-  ancestorsIterator(objectArg) {
+  ancestorsIterator(objectArg: T) {
     this.symbolTree.ancestorsIterator();
   }
 
-  treeIterator(rootArg: T, optionsArg): Iterable<T> {
+  treeIterator(rootArg: T, optionsArg: any): Iterable<T> {
     return this.symbolTree.treeIterator(rootArg);
   }
 
@@ -114,7 +114,7 @@ export class Tree<T> {
     return this.symbolTree.prependChild(referenceObjectArg, newObjectArg);
   }
 
-  appendChild(referenceObjectArg, newObjectArg) {
+  appendChild(referenceObjectArg: T, newObjectArg: T) {
     return this.symbolTree.appendChild(referenceObjectArg, newObjectArg);
   }
 
@@ -126,7 +126,7 @@ export class Tree<T> {
    * returns a branch of the tree as JSON
    * can be user
    */
-  toJsonWithHierachy(rootElement) {
+  toJsonWithHierachy(rootElement: T) {
     const treeIterable = this.treeIterator(rootElement, {});
     for (const treeItem of treeIterable) {
       console.log(treeItem);
@@ -137,5 +137,5 @@ export class Tree<T> {
    * builds a tree from a JSON with hierachy
    * @param rootElement
    */
-  fromJsonWithHierachy(rootElement) {}
+  fromJsonWithHierachy(rootElement: T) {}
 }