4.0.0

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/lik",
-  "version": "3.0.15",
+  "version": "4.0.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -385,6 +385,17 @@
         "luxon": "^1.16.0"
       }
     },
+    "@pushrocks/smartunique": {
+      "version": "3.0.1",
+      "resolved": "https://verdaccio.lossless.one/@pushrocks%2fsmartunique/-/smartunique-3.0.1.tgz",
+      "integrity": "sha512-xBu9ZB4C0BA0S/pbFFZn2ItPfnodPKpzrYIq1yN5XDs6OaookwcDF/iBwfS9+EYMSPENC9wAsOxg2RGMm4Qicw==",
+      "requires": {
+        "@types/shortid": "^0.0.29",
+        "@types/uuid": "^3.0.0",
+        "shortid": "^2.2.8",
+        "uuid": "^3.1.0"
+      }
+    },
     "@pushrocks/tapbundle": {
       "version": "3.2.0",
       "resolved": "https://verdaccio.lossless.one/@pushrocks%2ftapbundle/-/tapbundle-3.2.0.tgz",
@@ -540,6 +551,11 @@
       "resolved": "https://verdaccio.lossless.one/@types%2fnode/-/node-13.7.0.tgz",
       "integrity": "sha512-GnZbirvmqZUzMgkFn70c74OQpTTUcCzlhQliTzYjQMqg+hVKcDnxdL19Ne3UdYzdMA/+W3eb646FWn/ZaT1NfQ=="
     },
+    "@types/shortid": {
+      "version": "0.0.29",
+      "resolved": "https://verdaccio.lossless.one/@types%2fshortid/-/shortid-0.0.29.tgz",
+      "integrity": "sha1-gJPuBBam4r8qpjOBCRFLP7/6Dps="
+    },
     "@types/through2": {
       "version": "2.0.34",
       "resolved": "https://verdaccio.lossless.one/@types%2fthrough2/-/through2-2.0.34.tgz",
@@ -549,6 +565,11 @@
         "@types/node": "*"
       }
     },
+    "@types/uuid": {
+      "version": "3.4.7",
+      "resolved": "https://verdaccio.lossless.one/@types%2fuuid/-/uuid-3.4.7.tgz",
+      "integrity": "sha512-C2j2FWgQkF1ru12SjZJyMaTPxs/f6n90+5G5qNakBxKXjTBc/YTSelHh4Pz1HUDwxFXD9WvpQhOGCDC+/Y4mIQ=="
+    },
     "@types/vinyl": {
       "version": "2.0.3",
       "resolved": "https://verdaccio.lossless.one/@types%2fvinyl/-/vinyl-2.0.3.tgz",
@@ -1259,6 +1280,11 @@
       "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
       "dev": true
     },
+    "nanoid": {
+      "version": "2.1.11",
+      "resolved": "https://verdaccio.lossless.one/nanoid/-/nanoid-2.1.11.tgz",
+      "integrity": "sha512-s/snB+WGm6uwi0WjsZdaVcuf3KJXlfGl2LcxgwkEwJF0D/BWzVWAZW/XY4bFaiR7s0Jk3FPvlnepg1H1b1UwlA=="
+    },
     "nice-try": {
       "version": "1.0.5",
       "resolved": "https://verdaccio.lossless.one/nice-try/-/nice-try-1.0.5.tgz",
@@ -1542,6 +1568,14 @@
       "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=",
       "dev": true
     },
+    "shortid": {
+      "version": "2.2.15",
+      "resolved": "https://verdaccio.lossless.one/shortid/-/shortid-2.2.15.tgz",
+      "integrity": "sha512-5EaCy2mx2Jgc/Fdn9uuDuNIIfWBpzY4XIlhoqtXF6qsf+/+SGZ+FxDdX/ZsMZiWupIWNqAEmiNY4RC+LSmCeOw==",
+      "requires": {
+        "nanoid": "^2.1.0"
+      }
+    },
     "signal-exit": {
       "version": "3.0.2",
       "resolved": "https://verdaccio.lossless.one/signal-exit/-/signal-exit-3.0.2.tgz",
@@ -1755,6 +1789,11 @@
       "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=",
       "dev": true
     },
+    "uuid": {
+      "version": "3.4.0",
+      "resolved": "https://verdaccio.lossless.one/uuid/-/uuid-3.4.0.tgz",
+      "integrity": "sha512-HjSDRw6gZE5JMggctHBcjVak08+KEVhSIiDzFnT9S9aegmp85S/bReBVTb4QTFaRNptJ9kuYaNhnbNEOkbKb/A=="
+    },
     "vinyl": {
       "version": "2.2.0",
       "resolved": "https://verdaccio.lossless.one/vinyl/-/vinyl-2.2.0.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushrocks/lik",
-  "version": "3.0.15",
+  "version": "4.0.0",
   "private": false,
   "description": "light little helpers for node",
   "main": "dist/index.js",
@@ -33,6 +33,7 @@
     "@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",
     "minimatch": "^3.0.4",
     "symbol-tree": "^3.2.4"

test/test.objectmap.ts

@@ -11,7 +11,7 @@ interface ITestObject {
   propOne: string;
   propTwo: string;
 }
-let testObjectmap: lik.Objectmap<ITestObject>;
+let testObjectmap: lik.ObjectMap<ITestObject>;
 let testObject1: ITestObject = {
   propOne: 'hello',
   propTwo: 'hello2'
@@ -22,8 +22,8 @@ let testObject2: ITestObject = {
 };
 
 tap.test('new lik.Objectmap() -> should correctly instantiate an Objectmap', async () => {
-  testObjectmap = new lik.Objectmap<ITestObject>();
+  testObjectmap = new lik.ObjectMap<ITestObject>();
-  expect(testObjectmap).be.instanceof(lik.Objectmap);
+  expect(testObjectmap).be.instanceof(lik.ObjectMap);
 });
 
 tap.test('lik.Objectmap.add() -> should correctly add an object to Objectmap', async () => {

ts/index.ts

@@ -1,7 +1,4 @@
-import * as plugins from './lik.plugins';
+export * from './lik.fastmap';
-
-// import modules
-
 export * from './lik.interestmap';
 export * from './lik.limitedarray';
 export * from './lik.looptracker';

ts/lik.fastmap.ts

@@ -1,11 +1,82 @@
 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() {}
+  public isUniqueKey(keyArg: string): boolean {
+    return this.mapObject[keyArg] ? false : true;
+  }
 
-  public addToMap(identifier: string, objectArg: T) {
+  public addToMap(
-    this.mapObject[identifier] = objectArg;
+    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): 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 Objectmap that includes
+   */
+  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 Objectmap
+   * Note: uniqueKeyCollisions will cause overwrite
+   * @param objectMapArg
+   */
+  public addAllFromOther(fastMapArg: FastMap<T>) {
+    for (const key of fastMapArg.getKeys()) {
+      this.addToMap(key, fastMapArg.getByKey(key), {
+        force: true
+      });
+    }
   }
 }

ts/lik.interestmap.ts

@@ -1,5 +1,5 @@
 import * as plugins from './lik.plugins';
-import { Objectmap } from './lik.objectmap';
+import { ObjectMap } from './lik.objectmap';
 
 import { Observable } from 'rxjs';
 
@@ -11,7 +11,7 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
   /**
    * stores interests that are currently fullfilled by the cache
    */
-  private interestObjectMap = new Objectmap<Interest<DTInterestId, DTInterestFullfillment>>();
+  private interestObjectMap = new ObjectMap<Interest<DTInterestId, DTInterestFullfillment>>();
 
   /**
    * a function to compare interests
@@ -106,8 +106,8 @@ export class InterestMap<DTInterestId, DTInterestFullfillment> {
    */
   public findInterest(objectArg: DTInterestId): Interest<DTInterestId, DTInterestFullfillment> {
     const comparableString = this.comparisonFunc(objectArg);
-    const interest = this.interestObjectMap.find(interest => {
+    const interest = this.interestObjectMap.find(interestArg => {
-      return interest.comparisonString === comparableString;
+      return interestArg.comparisonString === comparableString;
     });
     return interest; // if an interest is found, the interest is returned, otherwise interest is null
   }

ts/lik.looptracker.ts

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

ts/lik.objectmap.ts

@@ -12,9 +12,8 @@ export interface IObjectmapFindFunction<T> {
 /**
  * allows keeping track of objects
  */
-export class Objectmap<T> {
+export class ObjectMap<T> {
   private fastMap = new FastMap<T>();
-  private objectArray: T[] = [];
 
   // events
   public eventSubject = new plugins.smartrx.rxjs.Subject<any>();
@@ -30,45 +29,51 @@ export class Objectmap<T> {
    * adds an object mapped to a string
    * the string must be unique
    */
-  addMappedUnique(uniqueKey: string, objectArg: T) {
+  addMappedUnique(uniqueKeyArg: string, objectArg: T) {
-    this.add(objectArg);
+    this.fastMap.addToMap(uniqueKeyArg, objectArg);
-    this.fastMap.addToMap(uniqueKey, objectArg);
   }
 
   /**
    * fastest way to get an object from the map
    * @param uniqueKey
    */
-  public getMappedUnique(uniqueKey: string) {}
+  public getMappedUnique(uniqueKeyArg: string) {
+    return this.fastMap.getByKey(uniqueKeyArg);
+  }
 
   /**
    * remove key
    * @param functionArg
    */
-  public removeMappedUnique() {}
+  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): boolean {
+  public add(objectArg: T): string {
-    if (this.checkForObject(objectArg)) {
+    // lets search for an existing unique key
-      // the object is already in the objectmap
+    for (const keyArg of this.fastMap.getKeys()) {
-      return false;
+      const object = this.fastMap.getByKey(keyArg);
-    } else {
+      if (object === objectArg) {
-      // the object is not yet in the objectmap
+        return keyArg;
-      this.objectArray.push(objectArg);
+      }
-      this.eventSubject.next('add');
-      return true;
     }
+
+    // otherwise lets create it
+    const uniqueKey = plugins.smartunique.shortId();
+    this.addMappedUnique(uniqueKey, objectArg);
+    return uniqueKey;
   }
 
   /**
    * like .add but adds an whole array of objects
    */
   public addArray(objectArrayArg: T[]) {
-    for (let item of objectArrayArg) {
+    for (const item of objectArrayArg) {
       this.add(item);
     }
   }
@@ -76,19 +81,34 @@ export class Objectmap<T> {
   /**
    * check if object is in Objectmap
    */
-  public checkForObject(objectArg: T) {
+  public checkForObject(objectArg: T): boolean {
-    return this.objectArray.indexOf(objectArg) !== -1;
+    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 find(findFunction: IObjectmapFindFunction<T>) {
+  public find(findFunction: IObjectmapFindFunction<T>): T {
-    const resultArray = this.objectArray.filter(findFunction);
+    for (const keyArg of this.fastMap.getKeys()) {
-    if (resultArray.length > 0) {
+      if (findFunction(this.fastMap.getByKey(keyArg))) {
-      return resultArray[0];
+        return this.getMappedUnique(keyArg);
-    } else {
+      }
-      return null;
     }
   }
 
@@ -107,8 +127,8 @@ export class Objectmap<T> {
    * run function for each item in Objectmap
    */
   public async forEach(functionArg: IObjectmapForEachFunction<T>) {
-    for (let object of this.objectArray) {
+    for (const keyArg of this.fastMap.getKeys()) {
-      await functionArg(object);
+      await functionArg(this.fastMap.getByKey(keyArg));
     }
   }
 
@@ -116,9 +136,15 @@ export class Objectmap<T> {
    * gets an object in the Observablemap and removes it, so it can't be retrieved again
    */
   public getOneAndRemove(): T {
-    const removedItem = this.objectArray.shift();
+    const keys = this.fastMap.getKeys();
-    this.eventSubject.next('remove');
+    if (keys.length === 0) {
-    return removedItem;
+      return null;
+    } else {
+      const keyToUse = keys[0];
+      const removedItem = this.fastMap.removeFromMap(keyToUse);
+      this.eventSubject.next('remove');
+      return removedItem;
+    }
   }
 
   /**
@@ -126,8 +152,8 @@ export class Objectmap<T> {
    */
   public getArray(): T[] {
     const returnArray: any[] = [];
-    for (const objectItem of this.objectArray) {
+    for (const keyArg of this.fastMap.getKeys()) {
-      returnArray.push(objectItem);
+      returnArray.push(this.fastMap.getByKey(keyArg));
     }
     return returnArray;
   }
@@ -136,32 +162,47 @@ export class Objectmap<T> {
    * check if Objectmap ist empty
    */
   public isEmpty(): boolean {
-    if (this.objectArray.length === 0) {
+    return this.fastMap.getKeys().length === 0;
-      return true;
-    } else {
-      return false;
-    }
   }
 
   /**
    * remove object from Objectmap
    */
-  public remove(objectArg: T) {
+  public remove(objectArg: T): T {
-    let replacementArray = [];
+    if (this.checkForObject(objectArg)) {
-    for (let item of this.objectArray) {
+      const keyArg = this.getKeyForObject(objectArg);
-      if (item !== objectArg) {
+      const removedObject = this.fastMap.removeFromMap(keyArg);
-        replacementArray.push(item);
+      this.eventSubject.next('remove');
-      }
+      return removedObject;
     }
-    this.objectArray = replacementArray;
+    return null;
-    this.eventSubject.next('remove');
   }
 
   /**
    * wipe Objectmap
    */
   public wipe() {
-    this.objectArray = [];
+    for (const keyArg of this.fastMap.getKeys()) {
-    this.eventSubject.next('wiped');
+      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

@@ -13,8 +13,9 @@ 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 };
+export { smartdelay, smartpromise, smartrx, smarttime, smartunique };
 
 // ==============
 // third party