1.0.27

.gitignore

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

.gitlab-ci.yml

@@ -3,6 +3,7 @@ image: hosttoday/ht-docker-node:npmts
 stages:
 - test
 - release
+- page
 
 testLEGACY:
   stage: test
@@ -33,4 +34,16 @@ release:
   only:
     - tags
   tags:
-    - docker
+    - docker
+
+pages:
+  image: hosttoday/ht-docker-node:npmpage
+  stage: page
+  script:
+    - npmci command npmpage --host gitlab
+  only:
+    - tags
+  artifacts:
+    expire_in: 1 week
+    paths:
+    - public

README.md

@@ -1,13 +1,44 @@
 # lik
 light little helpers for node
 
-## Status
+## Availabililty
+[![npm](https://push.rocks/assets/repo-button-npm.svg)](https://www.npmjs.com/package/lik)
+[![git](https://push.rocks/assets/repo-button-git.svg)](https://gitlab.com/pushrocks/lik)
+[![git](https://push.rocks/assets/repo-button-mirror.svg)](https://github.com/pushrocks/lik)
+[![docs](https://push.rocks/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/lik/gitbook)
+
+## Status for master
 [![build status](https://gitlab.com/pushrocks/lik/badges/master/build.svg)](https://gitlab.com/pushrocks/lik/commits/master)
+[![coverage report](https://gitlab.com/pushrocks/lik/badges/master/coverage.svg)](https://gitlab.com/pushrocks/lik/commits/master)
+[![Dependency Status](https://david-dm.org/pushrocks/lik.svg)](https://david-dm.org/pushrocks/lik)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/lik/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/lik/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/lik/badges/code.svg)](https://www.bithound.io/github/pushrocks/lik)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
 
 ## Usage
 We recommend the use of TypeScript for good intellisense.
 
 ```typescript
 // import any tool that you need from lik
-import {Stringmap} from "lik";
-```
+import { Stringmap, Objectmap, Observablemap } from "lik";
+```
+
+### class Stringmap
+Stringmap allows you to keep track of strings. It allows you to register triggers for certain events
+like when a certain string is removed or added to the map
+
+### class Objectmap
+Sometimes you need to keep track of objects, but implementing logic for removing, finding or updating is tedious.
+Objectmap takes care of keeping track of objects for you.
+
+### class Observablemap
+Event Emitters are nice. However often times you end up with registering multiple listeners for the exact same thing.
+Observables have a smaller footprint and a more manageable subscribe logic.
+Observablemap registers only one rxjs observable per event and then continues to reference
+the same observable that you can subscribe to.
+
+**For a detailed class overview, please take a look at the API docs**
+
+[![npm](https://push.rocks/assets/repo-header.svg)](https://push.rocks)

dist/index.d.ts

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

dist/index.js

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

dist/lik.objectmap.d.ts

@@ -1,13 +1,13 @@
-export interface IObjectmapForEachFunction {
-    (itemArg: any): void;
+export interface IObjectmapForEachFunction<T> {
+    (itemArg: T): void;
 }
-export interface IObjectmapFindFunction {
-    (itemArg: any): boolean;
+export interface IObjectmapFindFunction<T> {
+    (itemArg: T): boolean;
 }
 /**
  * allows keeping track of objects
  */
-export declare class Objectmap {
+export declare class Objectmap<T> {
     private objectArray;
     /**
      * returns a new instance
@@ -16,23 +16,43 @@ export declare class Objectmap {
     /**
      * add object to Objectmap
      */
-    add(objectArg: any): void;
+    add(objectArg: T): void;
     /**
-     * remove object from Objectmap
+     * like .add but adds an whole array of objects
      */
-    remove(objectArg: any): void;
+    addArray(objectArrayArg: T[]): void;
     /**
      * check if object is in Objectmap
      */
-    checkForObject(objectArg: any): number;
+    checkForObject(objectArg: T): boolean;
     /**
      * find object
      */
-    find(findFunction: IObjectmapFindFunction): any;
+    find(findFunction: IObjectmapFindFunction<T>): T;
+    /**
+     * finds a specific element and then removes it
+     */
+    findOneAndRemove(findFunction: any): T;
     /**
      * run function for each item in Objectmap
      */
-    forEach(functionArg: IObjectmapForEachFunction): void;
+    forEach(functionArg: IObjectmapForEachFunction<T>): void;
+    /**
+     * gets an object in the Observablemap and removes it, so it can't be retrieved again
+     */
+    getOneAndRemove(): T;
+    /**
+     * returns a cloned array of all the objects currently in the Objectmap
+     */
+    getArray(): T[];
+    /**
+     * check if Objectmap ist empty
+     */
+    isEmpty(): boolean;
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg: T): void;
     /**
      * wipe Objectmap
      */

dist/lik.objectmap.js

@@ -1,6 +1,5 @@
 "use strict";
-;
-;
+const plugins = require("./lik.plugins");
 /**
  * allows keeping track of objects
  */
@@ -11,35 +10,26 @@ class Objectmap {
     constructor() {
         this.objectArray = [];
     }
-    ;
     /**
      * add object to Objectmap
      */
     add(objectArg) {
         this.objectArray.push(objectArg);
     }
-    ;
     /**
-     * remove object from Objectmap
+     * like .add but adds an whole array of objects
      */
-    remove(objectArg) {
-        let replacmentArray = [];
-        for (let item of this.objectArray) {
-            if (item !== objectArg) {
-                replacmentArray.push(item);
-            }
+    addArray(objectArrayArg) {
+        for (let item of objectArrayArg) {
+            this.add(item);
         }
-        ;
-        this.objectArray = replacmentArray;
     }
-    ;
     /**
      * check if object is in Objectmap
      */
     checkForObject(objectArg) {
-        return this.objectArray.indexOf(objectArg !== -1);
+        return this.objectArray.indexOf(objectArg) !== -1;
     }
-    ;
     /**
      * find object
      */
@@ -49,9 +39,18 @@ class Objectmap {
             return resultArray[0];
         }
         else {
-            return undefined;
+            return null;
         }
-        ;
+    }
+    /**
+     * finds a specific element and then removes it
+     */
+    findOneAndRemove(findFunction) {
+        let foundElement = this.find(findFunction);
+        if (foundElement) {
+            this.remove(foundElement);
+        }
+        return foundElement;
     }
     /**
      * run function for each item in Objectmap
@@ -59,6 +58,41 @@ class Objectmap {
     forEach(functionArg) {
         return this.objectArray.forEach(functionArg);
     }
+    /**
+     * gets an object in the Observablemap and removes it, so it can't be retrieved again
+     */
+    getOneAndRemove() {
+        return this.objectArray.shift();
+    }
+    /**
+     * returns a cloned array of all the objects currently in the Objectmap
+     */
+    getArray() {
+        return plugins.lodash.cloneDeep(this.objectArray);
+    }
+    /**
+     * check if Objectmap ist empty
+     */
+    isEmpty() {
+        if (this.objectArray.length === 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg) {
+        let replacementArray = [];
+        for (let item of this.objectArray) {
+            if (item !== objectArg) {
+                replacementArray.push(item);
+            }
+        }
+        this.objectArray = replacementArray;
+    }
     /**
      * wipe Objectmap
      */
@@ -67,4 +101,4 @@ class Objectmap {
     }
 }
 exports.Objectmap = Objectmap;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLm9iamVjdG1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2xpay5vYmplY3RtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUtDLENBQUM7QUFJRCxDQUFDO0FBR0Y7O0dBRUc7QUFDSDtJQUdJOztPQUVHO0lBQ0g7UUFMUSxnQkFBVyxHQUFHLEVBQUUsQ0FBQztJQU96QixDQUFDOztJQUdEOztPQUVHO0lBQ0gsR0FBRyxDQUFDLFNBQVM7UUFDVCxJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNyQyxDQUFDOztJQUVEOztPQUVHO0lBQ0gsTUFBTSxDQUFDLFNBQVM7UUFDWixJQUFJLGVBQWUsR0FBRyxFQUFFLENBQUM7UUFDekIsR0FBRyxDQUFBLENBQUMsSUFBSSxJQUFJLElBQUksSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFBLENBQUM7WUFDOUIsRUFBRSxDQUFBLENBQUMsSUFBSSxLQUFLLFNBQVMsQ0FBQyxDQUFBLENBQUM7Z0JBQ25CLGVBQWUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDL0IsQ0FBQztRQUNMLENBQUM7UUFBQSxDQUFDO1FBQ0YsSUFBSSxDQUFDLFdBQVcsR0FBRyxlQUFlLENBQUM7SUFDdkMsQ0FBQzs7SUFFRDs7T0FFRztJQUNILGNBQWMsQ0FBQyxTQUFTO1FBQ3BCLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxTQUFTLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUNyRCxDQUFDOztJQUdEOztPQUVHO0lBQ0gsSUFBSSxDQUFDLFlBQW1DO1FBQ3BDLElBQUksV0FBVyxHQUFHLElBQUksQ0FBQyxXQUFXLENBQUMsTUFBTSxDQUFDLFlBQVksQ0FBQyxDQUFDO1FBQ3hELEVBQUUsQ0FBQyxDQUFDLFdBQVcsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUEsQ0FBQztZQUN4QixNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzFCLENBQUM7UUFBQyxJQUFJLENBQUMsQ0FBQztZQUNKLE1BQU0sQ0FBQyxTQUFTLENBQUM7UUFDckIsQ0FBQztRQUFBLENBQUM7SUFDTixDQUFDO0lBR0Q7O09BRUc7SUFDSCxPQUFPLENBQUMsV0FBcUM7UUFDekMsTUFBTSxDQUFDLElBQUksQ0FBQyxXQUFXLENBQUMsT0FBTyxDQUFDLFdBQVcsQ0FBQyxDQUFDO0lBQ2pELENBQUM7SUFFRDs7T0FFRztJQUNILElBQUk7UUFDQSxJQUFJLENBQUMsV0FBVyxHQUFHLEVBQUUsQ0FBQztJQUMxQixDQUFDO0FBQ0wsQ0FBQztBQWpFWSxpQkFBUyxZQWlFckIsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,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

dist/lik.observablemap.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import * as plugins from './lik.plugins';
+import { Objectmap } from './lik.objectmap';
+import { Observable } from 'rxjs/Rx';
+/**
+ * bundles an observable with an emitter
+ */
+export interface ObservableEmitterBundle {
+    observable: plugins.rx.Observable<any>;
+    emitter: plugins.events.EventEmitter;
+    event: string;
+}
+/**
+ * manages observables by making sure that only one observable is regsitered per event
+ */
+export declare class Observablemap {
+    ObservableEmitterBundleObjectmap: Objectmap<ObservableEmitterBundle>;
+    /**
+     * creates a new observable if not yet registered for the same event.
+     * In case event has been registered before the same observable is returned.
+     */
+    getObservableForEmitterEvent(emitterArg: plugins.events.EventEmitter, eventArg: string): Observable<any>;
+}

dist/lik.observablemap.js

@@ -0,0 +1,34 @@
+"use strict";
+const plugins = require("./lik.plugins");
+const lik_objectmap_1 = require("./lik.objectmap");
+/**
+ * manages observables by making sure that only one observable is regsitered per event
+ */
+class Observablemap {
+    constructor() {
+        this.ObservableEmitterBundleObjectmap = new lik_objectmap_1.Objectmap();
+    }
+    /**
+     * creates a new observable if not yet registered for the same event.
+     * In case event has been registered before the same observable is returned.
+     */
+    getObservableForEmitterEvent(emitterArg, eventArg) {
+        let existingBundle = this.ObservableEmitterBundleObjectmap.find((bundleArg) => {
+            return (bundleArg.emitter === emitterArg && bundleArg.event === eventArg);
+        });
+        if (existingBundle) {
+            return existingBundle.observable;
+        }
+        else {
+            let emitterObservable = plugins.rx.Observable.fromEvent(emitterArg, eventArg);
+            this.ObservableEmitterBundleObjectmap.add({
+                observable: emitterObservable,
+                emitter: emitterArg,
+                event: eventArg
+            });
+            return emitterObservable;
+        }
+    }
+}
+exports.Observablemap = Observablemap;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLm9ic2VydmFibGVtYXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsub2JzZXJ2YWJsZW1hcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEseUNBQXdDO0FBQ3hDLG1EQUEyQztBQWMzQzs7R0FFRztBQUNIO0lBQUE7UUFDSSxxQ0FBZ0MsR0FBRyxJQUFJLHlCQUFTLEVBQTJCLENBQUE7SUFzQi9FLENBQUM7SUFwQkc7OztPQUdHO0lBQ0gsNEJBQTRCLENBQUMsVUFBdUMsRUFBRSxRQUFnQjtRQUNsRixJQUFJLGNBQWMsR0FBRyxJQUFJLENBQUMsZ0NBQWdDLENBQUMsSUFBSSxDQUFDLENBQUMsU0FBUztZQUN0RSxNQUFNLENBQUEsQ0FBQyxTQUFTLENBQUMsT0FBTyxLQUFLLFVBQVUsSUFBSSxTQUFTLENBQUMsS0FBSyxLQUFLLFFBQVEsQ0FBQyxDQUFBO1FBQzVFLENBQUMsQ0FBQyxDQUFBO1FBQ0YsRUFBRSxDQUFDLENBQUMsY0FBYyxDQUFDLENBQUMsQ0FBQztZQUNqQixNQUFNLENBQUMsY0FBYyxDQUFDLFVBQVUsQ0FBQTtRQUNwQyxDQUFDO1FBQUMsSUFBSSxDQUFDLENBQUM7WUFDSixJQUFJLGlCQUFpQixHQUFHLE9BQU8sQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxVQUFVLEVBQUUsUUFBUSxDQUFDLENBQUE7WUFDN0UsSUFBSSxDQUFDLGdDQUFnQyxDQUFDLEdBQUcsQ0FBQztnQkFDdEMsVUFBVSxFQUFFLGlCQUFpQjtnQkFDN0IsT0FBTyxFQUFFLFVBQVU7Z0JBQ25CLEtBQUssRUFBRSxRQUFRO2FBQ2xCLENBQUMsQ0FBQTtZQUNGLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQTtRQUM1QixDQUFDO0lBQ0wsQ0FBQztDQUNKO0FBdkJELHNDQXVCQyJ9

dist/lik.plugins.d.ts

@@ -1,3 +1,6 @@
-import "typings-global";
-export import q = require("q");
-export import minimatch = require("minimatch");
+import 'typings-global';
+export import q = require('q');
+export import events = require('events');
+export import lodash = require('lodash');
+export import minimatch = require('minimatch');
+export import rx = require('rxjs/Rx');

dist/lik.plugins.js

@@ -1,5 +1,8 @@
 "use strict";
 require("typings-global");
 exports.q = require("q");
+exports.events = require("events");
+exports.lodash = require("lodash");
 exports.minimatch = require("minimatch");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsUUFBTyxnQkFBZ0IsQ0FBQyxDQUFBO0FBQ1YsU0FBQyxXQUFXLEdBQUcsQ0FBQyxDQUFDO0FBQ2pCLGlCQUFTLFdBQVcsV0FBVyxDQUFDLENBQUMifQ==
+exports.rx = require("rxjs/Rx");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLHlCQUE4QjtBQUM5QixtQ0FBd0M7QUFDeEMsbUNBQXdDO0FBQ3hDLHlDQUE4QztBQUM5QyxnQ0FBcUMifQ==

dist/lik.stringmap.d.ts

@@ -1,7 +1,7 @@
 /**
- * allows you to easily keep track of a bunch of strings;
+ * allows you to easily keep track of a bunch of strings
  */
-export interface triggerFunction {
+export interface ITriggerFunction {
     (): boolean;
 }
 export declare class Stringmap {
@@ -12,6 +12,10 @@ export declare class Stringmap {
      * add a string to the Stringmap
      */
     addString(stringArg: string): void;
+    /**
+     * like addString, but accepts an array of strings
+     */
+    addStringArray(stringArrayArg: string[]): void;
     /**
      * removes a string from Stringmap
      */
@@ -33,11 +37,15 @@ export declare class Stringmap {
      */
     checkIsEmpty(): boolean;
     /**
-     * notifies triggers
+     * gets a cloned copy of the current string Array
      */
-    private notifyTrigger();
+    getStringArray(): string[];
     /**
      * register a new trigger
      */
-    registerUntilTrue(functionArg: triggerFunction, doFunctionArg: any): void;
+    registerUntilTrue(functionArg: ITriggerFunction, doFunctionArg: any): void;
+    /**
+     * notifies triggers
+     */
+    private notifyTrigger();
 }

dist/lik.stringmap.js

@@ -5,7 +5,6 @@ class Stringmap {
         this._stringArray = [];
         this._triggerUntilTrueFunctionArray = [];
     }
-    ;
     /**
      * add a string to the Stringmap
      */
@@ -13,7 +12,14 @@ class Stringmap {
         this._stringArray.push(stringArg);
         this.notifyTrigger();
     }
-    ;
+    /**
+     * like addString, but accepts an array of strings
+     */
+    addStringArray(stringArrayArg) {
+        for (let stringItem of stringArrayArg) {
+            this.addString(stringItem);
+        }
+    }
     /**
      * removes a string from Stringmap
      */
@@ -22,9 +28,7 @@ class Stringmap {
             if (this._stringArray[keyArg] === stringArg) {
                 this._stringArray.splice(parseInt(keyArg), 1);
             }
-            ;
         }
-        ;
         this.notifyTrigger();
     }
     /**
@@ -38,7 +42,7 @@ class Stringmap {
      * check if string is in Stringmap
      */
     checkString(stringArg) {
-        return this._stringArray.indexOf(stringArg) != -1;
+        return this._stringArray.indexOf(stringArg) !== -1;
     }
     /**
      * checks stringPresence with minimatch
@@ -49,29 +53,22 @@ class Stringmap {
             if (plugins.minimatch(stringItem, miniMatchStringArg)) {
                 foundMatch = true;
             }
-            ;
         }
-        ;
         return foundMatch;
     }
-    ;
     /**
      * checks if the Stringmap is empty
      */
     checkIsEmpty() {
         return (this._stringArray.length === 0);
     }
-    // trigger registering
     /**
-     * notifies triggers
+     * gets a cloned copy of the current string Array
      */
-    notifyTrigger() {
-        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
-            return !functionArg();
-        });
-        this._triggerUntilTrueFunctionArray = filteredArray;
+    getStringArray() {
+        return plugins.lodash.cloneDeep(this._stringArray);
     }
-    ;
+    // trigger registering
     /**
      * register a new trigger
      */
@@ -85,6 +82,15 @@ class Stringmap {
         });
         this.notifyTrigger();
     }
+    /**
+     * notifies triggers
+     */
+    notifyTrigger() {
+        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
+            return !functionArg();
+        });
+        this._triggerUntilTrueFunctionArray = filteredArray;
+    }
 }
 exports.Stringmap = Stringmap;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "lik",
-  "version": "1.0.14",
+  "version": "1.0.27",
   "description": "light little helpers for node",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -18,14 +18,19 @@
   },
   "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/lodash": "^4.14.35",
     "@types/minimatch": "2.x.x",
     "@types/q": "0.x.x",
-    "minimatch": "^3.0.2",
-    "q": "^1.4.1"
+    "lodash": "^4.16.1",
+    "minimatch": "^3.0.3",
+    "q": "^1.4.1",
+    "rxjs": "^5.0.0-beta.12",
+    "typings-global": "^1.0.14"
   }
 }

test/test.d.ts

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

test/test.ts

@@ -1,84 +1,134 @@
-import "typings-test";
-import lik = require("../dist/index");
-import "should";
+import 'typings-test'
+import * as events from 'events'
+import * as rx from 'rxjs/Rx'
+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();
-            testStringmap.checkMinimatch("*String1").should.be.true();
-            testStringmap.checkMinimatch("*String2").should.be.true();
-            testStringmap.checkMinimatch("*String4").should.be.false();
-        });
-        it("should remove a string from Stringmap",function(){
-            testStringmap.removeString(testString2);
-            testStringmap.checkString(testString2).should.be.false();
-        });
-        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();
+import lik = require('../dist/index')
+describe('lik',function(){
+    describe('Stringmap',function(){
+        let testStringmap: lik.Stringmap
+        let testString1 = 'testString1'
+        let testString2 = 'testString2'
+        let testString3 = 'testString3'
+        let testString4 = 'testString4'
+        let testString5 = 'testString5'
+        let testString6 = 'testString6'
+        it('new lik.Objectmap() -> should create an instance of Stringmap',function(){
+            testStringmap = new lik.Stringmap()
+            should(testStringmap).be.instanceof(lik.Stringmap)
+        })
+        it('lik.Stringmap.checkString -> should return false for an string not in Stringmap',function(){
+            should(testStringmap.checkString(testString1)).be.false()
+        })
+        it('lik.Stringmap.addString -> 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('lik.Stringmap.addStringArray -> should add an array of strings',function(){
+            testStringmap.addStringArray([testString4,testString5,testString6])
+            should(testStringmap.checkMinimatch('*String4')).be.true()
+        })
+        it('lik.Stringmap.removeString -> should remove a string from Stringmap',function(){
+            testStringmap.removeString(testString2)
+            should(testStringmap.checkString(testString2)).be.false()
+        })
+        it('lik.Stringmap.getStringArray() -> should return a copy of stringArray',function(){
+            let clonedArray = testStringmap.getStringArray()
+            should(clonedArray[0] === 'testString1').be.true()
+            should(clonedArray[0] === testString1).be.true()
+        })
+        it('lik.Stringmap.checkIsEmpty() -> should register a function to trigger when empty',function(){
+            testStringmap.registerUntilTrue(
+                () => { return testStringmap.checkIsEmpty() },
+                () => { console.log('Stringmap now is empty') }
+            )
+        })
+        it('lik.Stringmap.empty() -> should remove wipe and then notify',function(){
+            testStringmap.wipe()
         })
-    });
-    describe("Objectmap",function(){
-        interface ITestObject {
-            propOne:string;
-            propTwo:string;
-        }
-        let testObjectmap:lik.Objectmap;
-        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();
-            testObjectmap.should.be.instanceof(lik.Objectmap);
-        });
-        it("should correctly add an object to Objectmap",function(){
-            testObjectmap.add(testObject1);
-            testObjectmap.checkForObject(testObject1).should.be.true;
-            testObjectmap.checkForObject(testObject2).should.be.false;
-        });
-        it("should correctly remove an object to Objectmap",function(){
-            testObjectmap.add(testObject2);
-            testObjectmap.remove(testObject1);
-            testObjectmap.checkForObject(testObject1).should.be.false;
-            testObjectmap.checkForObject(testObject2).should.be.true;
-        });
-        it("should correctly run a function forEach map object",function(){
-            testObjectmap.forEach(itemArg => {
-                itemArg.should.have.ownProperty("propOne");
-            })
-        });
-        it("should correctly find an object",function(){
-            let myObject = {item1: "hello",item2: "hello2"};
-            testObjectmap.add(myObject);
-            let referenceObject = testObjectmap.find((itemArg) => {return (itemArg.item1 === "hello")});
-            (myObject === referenceObject).should.be.true();
-        });
     })
-});
+    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('new lik.Objectmap() -> should correctly instantiate an Objectmap',function(){
+            testObjectmap = new lik.Objectmap<ITestObject>()
+            should(testObjectmap).be.instanceof(lik.Objectmap)
+        })
+        it('lik.Objectmap.add() -> should correctly add an object to Objectmap',function(){
+            testObjectmap.add(testObject1)
+            should(testObjectmap.checkForObject(testObject1)).be.true
+            should(testObjectmap.checkForObject(testObject2)).be.false
+        })
+        it('lik.Objectmap.remove() -> 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('Objectmap.forEach -> should correctly run a function forEach map object',function(){
+            testObjectmap.forEach(itemArg => {
+                should(itemArg).have.ownProperty('propOne')
+            })
+        })
+        it('lik.Objectmap.find() -> 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()
+        })
+        it('lik.Objectmap.getArray() -> should return a cloned array', function(){
+            let myObject = {propOne : 'test1', propTwo: 'wow, how awesome'}
+            testObjectmap.add(myObject)
+            let clonedArray = testObjectmap.getArray()
+            should(clonedArray[clonedArray.length - 1]).eql(myObject)
+        })
+        it('should get one object and then remove it', function() {
+            let originalLength = testObjectmap.getArray().length
+            let oneObject = testObjectmap.getOneAndRemove()
+            should(oneObject).not.be.null()
+            should(testObjectmap.getArray().length).equal(originalLength - 1)
+            should(testObjectmap.getArray()).not.containEql(oneObject)
+        })
+    })
+    describe('Observablemap',function(){
+        let testObservablemap: lik.Observablemap
+        let testObservable1: rx.Observable<any>
+        let testObservable2: rx.Observable<any>
+        let testObservable3: rx.Observable<any>
+        let testEmitter: events.EventEmitter
+        it('should create an instance',function(){
+            testObservablemap = new lik.Observablemap()
+            should(testObservablemap).be.instanceof(lik.Observablemap)
+        })
+        it('should accept a new emitter',function(done) {
+            testEmitter = new events.EventEmitter()
+            testObservable1 = testObservablemap.getObservableForEmitterEvent(testEmitter,'event1')
+            testObservable1.subscribe(x => {
+                done()
+            })
+            testObservable2 = testObservablemap.getObservableForEmitterEvent(testEmitter,'event1')
+            testObservable3 = testObservablemap.getObservableForEmitterEvent(testEmitter, 'event2')
+            should(testObservable1 === testObservable2).be.true()
+            should(testObservable1 === testObservable3).be.false()
+            testEmitter.emit('event1')
+        })
+    })
+})

ts/index.ts

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

ts/lik.objectmap.ts

@@ -1,81 +1,121 @@
-import * as plugins from "./lik.plugins";
+import * as plugins from './lik.plugins'
 
+export interface IObjectmapForEachFunction<T> {
+    (itemArg: T): void
+}
 
-export interface IObjectmapForEachFunction {
-    (itemArg:any):void
-};
-
-export interface IObjectmapFindFunction {
-    (itemArg:any):boolean
-};
-
+export interface IObjectmapFindFunction<T> {
+    (itemArg: T): boolean
+}
 
 /**
  * allows keeping track of objects
  */
-export class Objectmap {
-    private objectArray = [];
+export class Objectmap<T> {
+    private objectArray: T[] = []
 
     /**
      * returns a new instance
      */
-    constructor(){
-
-    };
+    constructor() {
 
+    }
 
     /**
      * add object to Objectmap
      */
-    add(objectArg){
-        this.objectArray.push(objectArg);
-    };
+    add(objectArg: T) {
+        this.objectArray.push(objectArg)
+    }
 
     /**
-     * remove object from Objectmap
+     * like .add but adds an whole array of objects
      */
-    remove(objectArg){
-        let replacmentArray = [];
-        for(let item of this.objectArray){
-            if(item !== objectArg){
-                replacmentArray.push(item);
-            }
-        };
-        this.objectArray = replacmentArray;
-    };
+    addArray(objectArrayArg: T[]) {
+        for (let item of objectArrayArg) {
+            this.add(item)
+        }
+    }
 
     /**
      * check if object is in Objectmap
      */
-    checkForObject(objectArg){
-        return this.objectArray.indexOf(objectArg !== -1)
-    };
-
+    checkForObject(objectArg: T) {
+        return this.objectArray.indexOf(objectArg) !== -1
+    }
 
     /**
      * find object
      */
-    find(findFunction:IObjectmapFindFunction){
-        let resultArray = this.objectArray.filter(findFunction);
-        if (resultArray.length > 0){
-            return resultArray[0];
+    find(findFunction: IObjectmapFindFunction<T>) {
+        let resultArray = this.objectArray.filter(findFunction)
+        if (resultArray.length > 0) {
+            return resultArray[0]
         } else {
-            return undefined;
-        };
+            return null
+        }
     }
 
+    /**
+     * finds a specific element and then removes it
+     */
+    findOneAndRemove(findFunction): T {
+        let foundElement = this.find(findFunction)
+        if (foundElement) {
+            this.remove(foundElement)
+        }
+        return foundElement
+    }
 
     /**
      * run function for each item in Objectmap
      */
-    forEach(functionArg:IObjectmapForEachFunction){
-        return this.objectArray.forEach(functionArg);
+    forEach(functionArg: IObjectmapForEachFunction<T>) {
+        return this.objectArray.forEach(functionArg)
+    }
+
+    /**
+     * gets an object in the Observablemap and removes it, so it can't be retrieved again
+     */
+    getOneAndRemove(): T {
+        return this.objectArray.shift()
+    }
+
+    /**
+     * returns a cloned array of all the objects currently in the Objectmap
+     */
+    getArray() {
+        return plugins.lodash.cloneDeep(this.objectArray)
+    }
+
+    /**
+     * check if Objectmap ist empty
+     */
+    isEmpty(): boolean {
+        if (this.objectArray.length === 0) {
+            return true
+        } else {
+            return false
+        }
+    }
+
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg: T) {
+        let replacementArray = []
+        for (let item of this.objectArray) {
+            if (item !== objectArg) {
+                replacementArray.push(item)
+            }
+        }
+        this.objectArray = replacementArray
     }
 
     /**
      * wipe Objectmap
      */
-    wipe(){
-        this.objectArray = [];
+    wipe() {
+        this.objectArray = []
     }
-}
+}

ts/lik.observablemap.ts

@@ -0,0 +1,42 @@
+import * as plugins from './lik.plugins'
+import { Objectmap } from './lik.objectmap'
+import { Stringmap } from './lik.stringmap'
+import { Observable } from 'rxjs/Rx'
+
+
+/**
+ * bundles an observable with an emitter
+ */
+export interface ObservableEmitterBundle {
+    observable: plugins.rx.Observable<any>
+    emitter: plugins.events.EventEmitter
+    event: string
+}
+
+/**
+ * manages observables by making sure that only one observable is regsitered per event
+ */
+export class Observablemap {
+    ObservableEmitterBundleObjectmap = new Objectmap<ObservableEmitterBundle>()
+
+    /**
+     * creates a new observable if not yet registered for the same event.
+     * In case event has been registered before the same observable is returned.
+     */
+    getObservableForEmitterEvent(emitterArg: plugins.events.EventEmitter, eventArg: string) {
+        let existingBundle = this.ObservableEmitterBundleObjectmap.find((bundleArg) => {
+            return(bundleArg.emitter === emitterArg && bundleArg.event === eventArg)
+        })
+        if (existingBundle) {
+            return existingBundle.observable
+        } else {
+            let emitterObservable = plugins.rx.Observable.fromEvent(emitterArg, eventArg)
+            this.ObservableEmitterBundleObjectmap.add({
+                observable: emitterObservable,
+                emitter: emitterArg,
+                event: eventArg
+            })
+            return emitterObservable
+        }
+    }
+}

ts/lik.plugins.ts

@@ -1,3 +1,6 @@
-import "typings-global";
-export import q = require("q");
-export import minimatch = require("minimatch");
+import 'typings-global'
+export import q = require('q')
+export import events = require('events')
+export import lodash = require('lodash')
+export import minimatch = require('minimatch')
+export import rx = require('rxjs/Rx')

ts/lik.stringmap.ts

@@ -1,99 +1,114 @@
-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 interface triggerFunction {
-    ():boolean;
+export interface ITriggerFunction {
+    (): boolean
 }
 
 export class Stringmap {
-    private _stringArray:string[] = [];
-    private _triggerUntilTrueFunctionArray:triggerFunction[] = [];
-    constructor(){
-
-    };
+    private _stringArray: string[] = []
+    private _triggerUntilTrueFunctionArray: ITriggerFunction[] = []
+    constructor() {}
     /**
      * add a string to the Stringmap
      */
-    addString(stringArg:string){
-        this._stringArray.push(stringArg);
-        this.notifyTrigger();
-    };
+    addString(stringArg: string) {
+        this._stringArray.push(stringArg)
+        this.notifyTrigger()
+    }
+
+    /**
+     * like addString, but accepts an array of strings
+     */
+    addStringArray(stringArrayArg: string[]) {
+        for (let stringItem of stringArrayArg){
+            this.addString(stringItem)
+        }
+    }
 
     /**
      * 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);
-            };
-        };
-        this.notifyTrigger();
+    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();
+    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;
-    };
+    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);
+    checkIsEmpty() {
+        return (this._stringArray.length === 0)
+    }
+
+    /**
+     * gets a cloned copy of the current string Array
+     */
+    getStringArray() {
+        return plugins.lodash.cloneDeep(this._stringArray)
     }
 
     // trigger registering
 
-    /**
-     * notifies triggers
-     */
-    private notifyTrigger(){
-        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
-            return !functionArg();
-        });
-        this._triggerUntilTrueFunctionArray = filteredArray;
-    };
-
     /**
      * register a new trigger
      */
-    registerUntilTrue(functionArg:triggerFunction,doFunctionArg){
+    registerUntilTrue(functionArg: ITriggerFunction,doFunctionArg) {
         this._triggerUntilTrueFunctionArray.push(
             () => {
-                let result = functionArg();
-                if(result === true){
-                    doFunctionArg();
+                let result = functionArg()
+                if (result === true) {
+                    doFunctionArg()
                 }
-                return result;
+                return result
             }
-        );
-        this.notifyTrigger();
+        )
+        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"
+}