5.0.0

.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,6 +1,6 @@
 {
   "name": "@pushrocks/lik",
-  "version": "4.0.16",
+  "version": "5.0.0",
   "private": false,
   "description": "light little helpers for node",
   "main": "dist_ts/index.js",
@@ -20,22 +20,22 @@
   },
   "homepage": "https://gitlab.com/pushrocks/lik#README",
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.1.24",
+    "@gitzone/tsbuild": "^2.1.27",
-    "@gitzone/tsbundle": "^1.0.72",
+    "@gitzone/tsbundle": "^1.0.87",
-    "@gitzone/tsrun": "^1.2.12",
+    "@gitzone/tsrun": "^1.2.17",
-    "@gitzone/tstest": "^1.0.41",
+    "@gitzone/tstest": "^1.0.57",
-    "@pushrocks/tapbundle": "^3.2.9",
+    "@pushrocks/tapbundle": "^3.2.14",
-    "@types/node": "^14.0.22",
+    "@types/node": "^16.9.1",
-    "tslint": "^6.1.2",
+    "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartdelay": "^2.0.10",
+    "@pushrocks/smartdelay": "^2.0.13",
     "@pushrocks/smartmatch": "^1.0.7",
-    "@pushrocks/smartpromise": "^3.0.6",
+    "@pushrocks/smartpromise": "^3.1.6",
-    "@pushrocks/smartrx": "^2.0.17",
+    "@pushrocks/smartrx": "^2.0.19",
-    "@pushrocks/smarttime": "^3.0.24",
+    "@pushrocks/smarttime": "^3.0.38",
-    "@types/minimatch": "^3.0.3",
+    "@types/minimatch": "^3.0.5",
     "symbol-tree": "^3.2.4"
   },
   "files": [

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).to.be.instanceOf(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).to.equal('heyho3');
+});
+
+tap.start();

test/test.objectmap.both.ts

@@ -52,7 +52,7 @@ tap.test('Objectmap.forEach -> should correctly run a function forEach map objec
 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

test/test.objectmap.ts

@@ -1,78 +0,0 @@
-// 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';
-
-// 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).be.instanceof(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;
-  // tslint:disable-next-line:no-unused-expression
-  expect(testObjectmap.checkForObject(testObject2)).be.false;
-});
-
-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;
-  // tslint:disable-next-line:no-unused-expression
-  expect(testObjectmap.checkForObject(testObject2)).be.true;
-});
-
-tap.test('Objectmap.forEach -> should correctly run a function forEach map object', async () => {
-  testObjectmap.forEach((itemArg) => {
-    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) => {
-    return itemArg.propOne === 'helloThere';
-  });
-  // tslint:disable-next-line:no-unused-expression
-  expect(myObject === referenceObject).be.true;
-});
-
-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);
-});
-
-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;
-  expect(testObjectmap.getArray().length).equal(originalLength - 1);
-  expect(testObjectmap.getArray()).to.not.contain(oneObject);
-});
-
-tap.start();

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>();
@@ -68,9 +68,9 @@ 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()) {
@@ -79,4 +79,14 @@ export class FastMap<T> {
       });
     }
   }
+
+  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,12 +2,13 @@ import * as plugins from './lik.plugins';
 
 import { InterestMap, IInterestComparisonFunc } from './lik.interestmap';
 
-export interface IInterestOptions {
+export interface IInterestOptions<DTInterestFullfillment> {
   markLostAfterDefault: number;
+  defaultFullfillment?: DTInterestFullfillment;
 }
 
 export class Interest<DTInterestId, DTInterestFullfillment> {
-  public options: IInterestOptions;
+  public options: IInterestOptions<DTInterestFullfillment>;
 
   private interestMapRef: InterestMap<DTInterestId, DTInterestFullfillment>;
   public originalInterest: DTInterestId;
@@ -48,7 +49,7 @@ export class Interest<DTInterestId, DTInterestFullfillment> {
     interestMapArg: InterestMap<DTInterestId, DTInterestFullfillment>,
     interestArg: DTInterestId,
     comparisonFuncArg: IInterestComparisonFunc<DTInterestId>,
-    optionsArg?: IInterestOptions
+    optionsArg?: IInterestOptions<DTInterestFullfillment>
   ) {
     this.interestMapRef = interestMapArg;
     this.originalInterest = interestArg;
@@ -72,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

@@ -24,7 +24,10 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
    */
   private comparisonFunc: IInterestComparisonFunc<DTInterestId>;
 
-  constructor(comparisonFuncArg: IInterestComparisonFunc<DTInterestId>, optionsArg: IInterestMapOptions = {}) {
+  constructor(
+    comparisonFuncArg: IInterestComparisonFunc<DTInterestId>,
+    optionsArg: IInterestMapOptions = {}
+  ) {
     this.comparisonFunc = comparisonFuncArg;
     this.options = optionsArg;
   }
@@ -34,7 +37,8 @@ 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>;
@@ -43,7 +47,8 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
       objectArg,
       this.comparisonFunc,
       {
-        markLostAfterDefault: this.options.markLostAfterDefault
+        markLostAfterDefault: this.options.markLostAfterDefault,
+        defaultFullfillment: defaultFullfillmentArg,
       }
     );
     let interestExists = false;
@@ -71,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;
     });
   }
@@ -89,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) {
@@ -116,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

@@ -13,10 +13,19 @@ 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
  */
@@ -24,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
@@ -74,6 +83,10 @@ export class ObjectMap<T> {
     // otherwise lets create it
     const uniqueKey = uni('key');
     this.addMappedUnique(uniqueKey, objectArg);
+    this.eventSubject.next({
+      operation: 'add',
+      payload: objectArg
+    });
     return uniqueKey;
   }
 
@@ -112,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);
@@ -123,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);
     }
@@ -150,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;
     }
   }
@@ -180,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.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) {}
 }