1.0.16

.gitignore

@@ -1,4 +1,5 @@
 node_modules/
-docs/
+pages/
+public/
 coverage/
 .nogit/

README.md

@@ -2,6 +2,7 @@
 light little helpers for node
 
 ## Status
+[![build status](https://gitlab.com/pushrocks/lik/badges/master/build.svg)](https://gitlab.com/pushrocks/lik/commits/master)
 
 ## Usage
 We recommend the use of TypeScript for good intellisense.

dist/index.d.ts

@@ -1 +1,2 @@
-export * from "./lik.stringmap";
+export * from './lik.stringmap';
+export * from './lik.objectmap';

dist/index.js

@@ -4,4 +4,5 @@ function __export(m) {
 }
 // import modules
 __export(require("./lik.stringmap"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWlCO0FBRWpCLGlCQUFjLGlCQUFpQixDQUFDLEVBQUEifQ==
+__export(require("./lik.objectmap"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWlCO0FBRWpCLHFDQUErQjtBQUMvQixxQ0FBK0IifQ==

dist/lik.objectmap.d.ts

@@ -0,0 +1,40 @@
+export interface IObjectmapForEachFunction<T> {
+    (itemArg: T): void;
+}
+export interface IObjectmapFindFunction<T> {
+    (itemArg: T): boolean;
+}
+/**
+ * allows keeping track of objects
+ */
+export declare class Objectmap<T> {
+    private objectArray;
+    /**
+     * returns a new instance
+     */
+    constructor();
+    /**
+     * add object to Objectmap
+     */
+    add(objectArg: T): void;
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg: T): void;
+    /**
+     * check if object is in Objectmap
+     */
+    checkForObject(objectArg: T): boolean;
+    /**
+     * find object
+     */
+    find(findFunction: IObjectmapFindFunction<T>): T;
+    /**
+     * run function for each item in Objectmap
+     */
+    forEach(functionArg: IObjectmapForEachFunction<T>): void;
+    /**
+     * wipe Objectmap
+     */
+    wipe(): void;
+}

dist/lik.objectmap.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * allows keeping track of objects
+ */
+class Objectmap {
+    /**
+     * returns a new instance
+     */
+    constructor() {
+        this.objectArray = [];
+    }
+    /**
+     * add object to Objectmap
+     */
+    add(objectArg) {
+        this.objectArray.push(objectArg);
+    }
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg) {
+        let replacmentArray = [];
+        for (let item of this.objectArray) {
+            if (item !== objectArg) {
+                replacmentArray.push(item);
+            }
+        }
+        this.objectArray = replacmentArray;
+    }
+    /**
+     * check if object is in Objectmap
+     */
+    checkForObject(objectArg) {
+        return this.objectArray.indexOf(objectArg) !== -1;
+    }
+    /**
+     * find object
+     */
+    find(findFunction) {
+        let resultArray = this.objectArray.filter(findFunction);
+        if (resultArray.length > 0) {
+            return resultArray[0];
+        }
+        else {
+            return undefined;
+        }
+    }
+    /**
+     * run function for each item in Objectmap
+     */
+    forEach(functionArg) {
+        return this.objectArray.forEach(functionArg);
+    }
+    /**
+     * wipe Objectmap
+     */
+    wipe() {
+        this.objectArray = [];
+    }
+}
+exports.Objectmap = Objectmap;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLm9iamVjdG1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2xpay5vYmplY3RtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQVVBOztHQUVHO0FBQ0g7SUFHSTs7T0FFRztJQUNIO1FBTFEsZ0JBQVcsR0FBUSxFQUFFLENBQUE7SUFPN0IsQ0FBQztJQUVEOztPQUVHO0lBQ0gsR0FBRyxDQUFDLFNBQVk7UUFDWixJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUNwQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxNQUFNLENBQUMsU0FBWTtRQUNmLElBQUksZUFBZSxHQUFHLEVBQUUsQ0FBQTtRQUN4QixHQUFHLENBQUMsQ0FBQyxJQUFJLElBQUksSUFBSSxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztZQUNoQyxFQUFFLENBQUMsQ0FBQyxJQUFJLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQztnQkFDckIsZUFBZSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtZQUM5QixDQUFDO1FBQ0wsQ0FBQztRQUNELElBQUksQ0FBQyxXQUFXLEdBQUcsZUFBZSxDQUFBO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNILGNBQWMsQ0FBQyxTQUFZO1FBQ3ZCLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtJQUNyRCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLENBQUMsWUFBdUM7UUFDeEMsSUFBSSxXQUFXLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUE7UUFDdkQsRUFBRSxDQUFDLENBQUMsV0FBVyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3pCLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFDekIsQ0FBQztRQUFDLElBQUksQ0FBQyxDQUFDO1lBQ0osTUFBTSxDQUFDLFNBQVMsQ0FBQTtRQUNwQixDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsT0FBTyxDQUFDLFdBQXlDO1FBQzdDLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQTtJQUNoRCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJO1FBQ0EsSUFBSSxDQUFDLFdBQVcsR0FBRyxFQUFFLENBQUE7SUFDekIsQ0FBQztDQUNKO0FBOURELDhCQThEQyJ9

dist/lik.plugins.d.ts

@@ -1,2 +1,4 @@
-import "typings-global";
-export import q = require("q");
+import 'typings-global';
+export import q = require('q');
+export import lodash = require('lodash');
+export import minimatch = require('minimatch');

dist/lik.plugins.js

@@ -1,4 +1,6 @@
 "use strict";
 require("typings-global");
 exports.q = require("q");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsUUFBTyxnQkFBZ0IsQ0FBQyxDQUFBO0FBQ1YsU0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDIn0=
+exports.lodash = require("lodash");
+exports.minimatch = require("minimatch");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLHlCQUE4QjtBQUM5QixtQ0FBd0M7QUFDeEMseUNBQThDIn0=

dist/lik.stringmap.d.ts

@@ -1,8 +1,12 @@
 /**
- * allows you to easily keep track of a bunch of strings;
+ * allows you to easily keep track of a bunch of strings
  */
+export interface ITriggerFunction {
+    (): boolean;
+}
 export declare class Stringmap {
     private _stringArray;
+    private _triggerUntilTrueFunctionArray;
     constructor();
     /**
      * add a string to the Stringmap
@@ -12,8 +16,32 @@ export declare class Stringmap {
      * removes a string from Stringmap
      */
     removeString(stringArg: string): void;
+    /**
+     * wipes the Stringmap
+     */
+    wipe(): void;
     /**
      * check if string is in Stringmap
      */
     checkString(stringArg: string): boolean;
+    /**
+     * checks stringPresence with minimatch
+     */
+    checkMinimatch(miniMatchStringArg: string): boolean;
+    /**
+     * checks if the Stringmap is empty
+     */
+    checkIsEmpty(): boolean;
+    /**
+     * gets a cloned copy of the current string Array
+     */
+    getStringArray(): string[];
+    /**
+     * register a new trigger
+     */
+    registerUntilTrue(functionArg: ITriggerFunction, doFunctionArg: any): void;
+    /**
+     * notifies triggers
+     */
+    private notifyTrigger();
 }

dist/lik.stringmap.js

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lik",
-  "version": "1.0.2",
+  "version": "1.0.16",
   "description": "light little helpers for node",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -18,12 +18,17 @@
   },
   "homepage": "https://gitlab.com/pushrocks/lik#README",
   "devDependencies": {
-    "npmts-g": "^5.2.6",
-    "should": "^10.0.0",
-    "typings-test": "^1.0.1"
+    "@types/should": "^8.1.30",
+    "npmts-g": "^5.2.8",
+    "should": "^11.1.0",
+    "typings-test": "^1.0.3"
   },
   "dependencies": {
-    "@types/q": "^0.0.27",
+    "@types/lodash": "^4.14.35",
+    "@types/minimatch": "2.x.x",
+    "@types/q": "0.x.x",
+    "lodash": "^4.16.1",
+    "minimatch": "^3.0.3",
     "q": "^1.4.1"
   }
 }

test/test.d.ts

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

test/test.js

@@ -1,32 +1,83 @@
 "use strict";
 require("typings-test");
 const lik = require("../dist/index");
-require("should");
-describe("lik", function () {
-    describe("Stringmap", function () {
+const should = require("should");
+describe('lik', function () {
+    describe('Stringmap', function () {
         let testStringmap;
-        let testString1 = "testString1";
-        let testString2 = "testString2";
-        let testString3 = "testString3";
-        it("should create an instance of Stringmap", function () {
+        let testString1 = 'testString1';
+        let testString2 = 'testString2';
+        let testString3 = 'testString3';
+        it('should create an instance of Stringmap', function () {
             testStringmap = new lik.Stringmap();
-            testStringmap.should.be.instanceof(lik.Stringmap);
+            should(testStringmap).be.instanceof(lik.Stringmap);
         });
-        it("should return false for an string not in Stringmap", function () {
-            testStringmap.checkString(testString1).should.be.false();
+        it('should return false for an string not in Stringmap', function () {
+            should(testStringmap.checkString(testString1)).be.false();
         });
-        it("should add an string to Stringmap", function () {
+        it('should add an string to Stringmap', function () {
             testStringmap.addString(testString1);
             testStringmap.addString(testString2);
             testStringmap.addString(testString3);
-            testStringmap.checkString(testString1).should.be.true();
-            testStringmap.checkString(testString2).should.be.true();
-            testStringmap.checkString(testString3).should.be.true();
+            should(testStringmap.checkString(testString1)).be.true();
+            should(testStringmap.checkString(testString2)).be.true();
+            should(testStringmap.checkString(testString3)).be.true();
+            should(testStringmap.checkMinimatch('*String1')).be.true();
+            should(testStringmap.checkMinimatch('*String2')).be.true();
+            should(testStringmap.checkMinimatch('*String4')).be.false();
         });
-        it("should remove a string from Stringmap", function () {
+        it('should remove a string from Stringmap', function () {
             testStringmap.removeString(testString2);
-            testStringmap.checkString(testString2).should.be.false();
+            should(testStringmap.checkString(testString2)).be.false();
+        });
+        it('should return a copy of stringArray', function () {
+            let clonedArray = testStringmap.getStringArray();
+            should(clonedArray[0] === 'testString1').be.true();
+            should(clonedArray[0] === testString1).be.true();
+        });
+        it('should register a function to trigger when empty', function () {
+            testStringmap.registerUntilTrue(() => { return testStringmap.checkIsEmpty(); }, () => { console.log('Stringmap now is empty'); });
+        });
+        it('should remove wipe and then notify', function () {
+            testStringmap.wipe();
+        });
+    });
+    describe('Objectmap', function () {
+        let testObjectmap;
+        let testObject1 = {
+            propOne: 'hello',
+            propTwo: 'hello2'
+        };
+        let testObject2 = {
+            propOne: 'hello',
+            propTwo: 'hello2'
+        };
+        it('should correctly instantiate an Objectmap', function () {
+            testObjectmap = new lik.Objectmap();
+            should(testObjectmap).be.instanceof(lik.Objectmap);
+        });
+        it('should correctly add an object to Objectmap', function () {
+            testObjectmap.add(testObject1);
+            should(testObjectmap.checkForObject(testObject1)).be.true;
+            should(testObjectmap.checkForObject(testObject2)).be.false;
+        });
+        it('should correctly remove an object to Objectmap', function () {
+            testObjectmap.add(testObject2);
+            testObjectmap.remove(testObject1);
+            should(testObjectmap.checkForObject(testObject1)).be.false;
+            should(testObjectmap.checkForObject(testObject2)).be.true;
+        });
+        it('should correctly run a function forEach map object', function () {
+            testObjectmap.forEach(itemArg => {
+                should(itemArg).have.ownProperty('propOne');
+            });
+        });
+        it('should correctly find an object', function () {
+            let myObject = { propOne: 'helloThere', propTwo: 'helloAnyway' };
+            testObjectmap.add(myObject);
+            let referenceObject = testObjectmap.find((itemArg) => { return (itemArg.propOne === 'helloThere'); });
+            should(myObject === referenceObject).be.true();
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLFFBQU8sY0FBYyxDQUFDLENBQUE7QUFDdEIsTUFBTyxHQUFHLFdBQVcsZUFBZSxDQUFDLENBQUM7QUFDdEMsUUFBTyxRQUFRLENBQUMsQ0FBQTtBQUVoQixRQUFRLENBQUMsS0FBSyxFQUFDO0lBQ1gsUUFBUSxDQUFDLFdBQVcsRUFBQztRQUNqQixJQUFJLGFBQTJCLENBQUM7UUFDaEMsSUFBSSxXQUFXLEdBQUcsYUFBYSxDQUFDO1FBQ2hDLElBQUksV0FBVyxHQUFHLGFBQWEsQ0FBQztRQUNoQyxJQUFJLFdBQVcsR0FBRyxhQUFhLENBQUM7UUFDaEMsRUFBRSxDQUFDLHdDQUF3QyxFQUFDO1lBQ3hDLGFBQWEsR0FBRyxJQUFJLEdBQUcsQ0FBQyxTQUFTLEVBQUUsQ0FBQztZQUNwQyxhQUFhLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ3RELENBQUMsQ0FBQyxDQUFDO1FBQ0gsRUFBRSxDQUFDLG9EQUFvRCxFQUFDO1lBQ3BELGFBQWEsQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUM3RCxDQUFDLENBQUMsQ0FBQztRQUNILEVBQUUsQ0FBQyxtQ0FBbUMsRUFBQztZQUNuQyxhQUFhLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxDQUFDO1lBQ3JDLGFBQWEsQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUFDLENBQUM7WUFDckMsYUFBYSxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsQ0FBQztZQUNyQyxhQUFhLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxFQUFFLENBQUMsSUFBSSxFQUFFLENBQUM7WUFDeEQsYUFBYSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ3hELGFBQWEsQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUM1RCxDQUFDLENBQUMsQ0FBQztRQUNILEVBQUUsQ0FBQyx1Q0FBdUMsRUFBQztZQUN2QyxhQUFhLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1lBQ3hDLGFBQWEsQ0FBQyxXQUFXLENBQUMsV0FBVyxDQUFDLENBQUMsTUFBTSxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUM3RCxDQUFDLENBQUMsQ0FBQztJQUNQLENBQUMsQ0FBQyxDQUFBO0FBQ04sQ0FBQyxDQUFDLENBQUMifQ==
+//# sourceMappingURL=data:application/json;base64,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

test/test.ts

@@ -1,31 +1,89 @@
-import "typings-test";
-import lik = require("../dist/index");
-import "should";
+import 'typings-test'
+import lik = require('../dist/index')
+import * as should from 'should'
 
-describe("lik",function(){
-    describe("Stringmap",function(){
-        let testStringmap:lik.Stringmap;
-        let testString1 = "testString1";
-        let testString2 = "testString2";
-        let testString3 = "testString3";
-        it("should create an instance of Stringmap",function(){
-            testStringmap = new lik.Stringmap();
-            testStringmap.should.be.instanceof(lik.Stringmap);
-        });
-        it("should return false for an string not in Stringmap",function(){
-            testStringmap.checkString(testString1).should.be.false();
-        });
-        it("should add an string to Stringmap",function(){
-            testStringmap.addString(testString1);
-            testStringmap.addString(testString2);
-            testStringmap.addString(testString3);
-            testStringmap.checkString(testString1).should.be.true();
-            testStringmap.checkString(testString2).should.be.true();
-            testStringmap.checkString(testString3).should.be.true();
-        });
-        it("should remove a string from Stringmap",function(){
-            testStringmap.removeString(testString2);
-            testStringmap.checkString(testString2).should.be.false();
-        });
+describe('lik',function(){
+    describe('Stringmap',function(){
+        let testStringmap: lik.Stringmap
+        let testString1 = 'testString1'
+        let testString2 = 'testString2'
+        let testString3 = 'testString3'
+        it('should create an instance of Stringmap',function(){
+            testStringmap = new lik.Stringmap()
+            should(testStringmap).be.instanceof(lik.Stringmap)
+        })
+        it('should return false for an string not in Stringmap',function(){
+            should(testStringmap.checkString(testString1)).be.false()
+        })
+        it('should add an string to Stringmap',function(){
+            testStringmap.addString(testString1)
+            testStringmap.addString(testString2)
+            testStringmap.addString(testString3)
+            should(testStringmap.checkString(testString1)).be.true()
+            should(testStringmap.checkString(testString2)).be.true()
+            should(testStringmap.checkString(testString3)).be.true()
+            should(testStringmap.checkMinimatch('*String1')).be.true()
+            should(testStringmap.checkMinimatch('*String2')).be.true()
+            should(testStringmap.checkMinimatch('*String4')).be.false()
+        })
+        it('should remove a string from Stringmap',function(){
+            testStringmap.removeString(testString2)
+            should(testStringmap.checkString(testString2)).be.false()
+        })
+        it('should return a copy of stringArray',function(){
+            let clonedArray = testStringmap.getStringArray()
+            should(clonedArray[0] === 'testString1').be.true()
+            should(clonedArray[0] === testString1).be.true()
+        })
+        it('should register a function to trigger when empty',function(){
+            testStringmap.registerUntilTrue(
+                () => { return testStringmap.checkIsEmpty() },
+                () => { console.log('Stringmap now is empty') }
+            )
+        })
+        it('should remove wipe and then notify',function(){
+            testStringmap.wipe()
+        })
     })
-});
+    describe('Objectmap',function(){
+        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'
+        }
+        it('should correctly instantiate an Objectmap',function(){
+            testObjectmap = new lik.Objectmap<ITestObject>()
+            should(testObjectmap).be.instanceof(lik.Objectmap)
+        })
+        it('should correctly add an object to Objectmap',function(){
+            testObjectmap.add(testObject1)
+            should(testObjectmap.checkForObject(testObject1)).be.true
+            should(testObjectmap.checkForObject(testObject2)).be.false
+        })
+        it('should correctly remove an object to Objectmap',function(){
+            testObjectmap.add(testObject2)
+            testObjectmap.remove(testObject1)
+            should(testObjectmap.checkForObject(testObject1)).be.false
+            should(testObjectmap.checkForObject(testObject2)).be.true
+        })
+        it('should correctly run a function forEach map object',function(){
+            testObjectmap.forEach(itemArg => {
+                should(itemArg).have.ownProperty('propOne')
+            })
+        })
+        it('should correctly find an object',function(){
+            let myObject = {propOne: 'helloThere', propTwo: 'helloAnyway'}
+            testObjectmap.add(myObject)
+            let referenceObject = testObjectmap.find((itemArg) => { return (itemArg.propOne === 'helloThere') })
+            should(myObject === referenceObject).be.true()
+        })
+    })
+})

ts/index.ts

@@ -1,5 +1,6 @@
-import * as plugins from "./lik.plugins";
+import * as plugins from './lik.plugins'
 
 // import modules
 
-export * from "./lik.stringmap";
+export * from './lik.stringmap'
+export * from './lik.objectmap'

ts/lik.objectmap.ts

@@ -0,0 +1,76 @@
+import * as plugins from './lik.plugins'
+
+export interface IObjectmapForEachFunction<T> {
+    (itemArg: T): void
+}
+
+export interface IObjectmapFindFunction<T> {
+    (itemArg: T): boolean
+}
+
+/**
+ * allows keeping track of objects
+ */
+export class Objectmap<T> {
+    private objectArray: T[] = []
+
+    /**
+     * returns a new instance
+     */
+    constructor() {
+
+    }
+
+    /**
+     * add object to Objectmap
+     */
+    add(objectArg: T) {
+        this.objectArray.push(objectArg)
+    }
+
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg: T) {
+        let replacmentArray = []
+        for (let item of this.objectArray) {
+            if (item !== objectArg) {
+                replacmentArray.push(item)
+            }
+        }
+        this.objectArray = replacmentArray
+    }
+
+    /**
+     * check if object is in Objectmap
+     */
+    checkForObject(objectArg: T) {
+        return this.objectArray.indexOf(objectArg) !== -1
+    }
+
+    /**
+     * find object
+     */
+    find(findFunction: IObjectmapFindFunction<T>) {
+        let resultArray = this.objectArray.filter(findFunction)
+        if (resultArray.length > 0) {
+            return resultArray[0]
+        } else {
+            return undefined
+        }
+    }
+
+    /**
+     * run function for each item in Objectmap
+     */
+    forEach(functionArg: IObjectmapForEachFunction<T>) {
+        return this.objectArray.forEach(functionArg)
+    }
+
+    /**
+     * wipe Objectmap
+     */
+    wipe() {
+        this.objectArray = []
+    }
+}

ts/lik.plugins.ts

@@ -1,2 +1,4 @@
-import "typings-global";
-export import q = require("q"); 
+import 'typings-global'
+export import q = require('q')
+export import lodash = require('lodash')
+export import minimatch = require('minimatch')

ts/lik.stringmap.ts

@@ -1,35 +1,105 @@
-import * as plugins from "./lik.plugins";
+import * as plugins from './lik.plugins'
 
 /**
- * allows you to easily keep track of a bunch of strings;
+ * allows you to easily keep track of a bunch of strings
  */
-export class Stringmap {
-    private _stringArray:string[] = [];
-    constructor(){
 
-    };
+export interface ITriggerFunction {
+    (): boolean
+}
+
+export class Stringmap {
+    private _stringArray: string[] = []
+    private _triggerUntilTrueFunctionArray: ITriggerFunction[] = []
+    constructor() {}
     /**
      * add a string to the Stringmap
      */
-    addString(stringArg:string){
-        this._stringArray.push(stringArg);
-    };
+    addString(stringArg: string) {
+        this._stringArray.push(stringArg)
+        this.notifyTrigger()
+    }
 
     /**
      * removes a string from Stringmap
      */
-    removeString(stringArg:string){
-        for (let keyArg in this._stringArray){
-            if(this._stringArray[keyArg] == stringArg){
-                this._stringArray.splice(parseInt(keyArg),1);
-            };
+    removeString(stringArg: string) {
+        for (let keyArg in this._stringArray) {
+            if (this._stringArray[keyArg] === stringArg) {
+                this._stringArray.splice(parseInt(keyArg),1)
+            }
         }
+        this.notifyTrigger()
+    }
+
+    /**
+     * wipes the Stringmap
+     */
+    wipe() {
+        this._stringArray = []
+        this.notifyTrigger()
     }
 
     /**
      * check if string is in Stringmap
      */
-    checkString(stringArg:string):boolean{
-        return this._stringArray.indexOf(stringArg) != -1;
+    checkString(stringArg: string): boolean {
+        return this._stringArray.indexOf(stringArg) !== -1
     }
+
+    /**
+     * checks stringPresence with minimatch
+     */
+    checkMinimatch(miniMatchStringArg: string): boolean {
+        let foundMatch: boolean = false
+        for (let stringItem of this._stringArray){
+            if (plugins.minimatch(stringItem,miniMatchStringArg)) {
+                foundMatch = true
+            }
+        }
+        return foundMatch
+    }
+
+    /**
+     * checks if the Stringmap is empty
+     */
+    checkIsEmpty() {
+        return (this._stringArray.length === 0)
+    }
+
+    /**
+     * gets a cloned copy of the current string Array
+     */
+    getStringArray() {
+        return plugins.lodash.cloneDeep(this._stringArray)
+    }
+
+    // trigger registering
+
+    /**
+     * register a new trigger
+     */
+    registerUntilTrue(functionArg: ITriggerFunction,doFunctionArg) {
+        this._triggerUntilTrueFunctionArray.push(
+            () => {
+                let result = functionArg()
+                if (result === true) {
+                    doFunctionArg()
+                }
+                return result
+            }
+        )
+        this.notifyTrigger()
+    }
+
+    /**
+     * notifies triggers
+     */
+    private notifyTrigger() {
+        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
+            return !functionArg()
+        })
+        this._triggerUntilTrueFunctionArray = filteredArray
+    }
+
 }

tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": "tslint-config-standard"
+}