@fireflysemantics/slice 14.0.7

package/esm2015/lib/OStore.js

@@ -0,0 +1,133 @@
+import { ReplaySubject } from 'rxjs';
+export class OStore {
+    constructor(start) {
+        /**
+         * Map of Key Value pair entries
+         * containing values store in this store.
+         */
+        this.entries = new Map();
+        /**
+         * Map of replay subject id to `ReplaySubject` instance.
+         */
+        this.subjects = new Map();
+        if (start) {
+            this.S = start;
+            const keys = Object.keys(start);
+            keys.forEach((k) => {
+                const ovr = start[k];
+                this.post(ovr, ovr.value);
+                ovr.obs = this.observe(ovr);
+            });
+        }
+    }
+    /**
+     * Reset the state of the OStore to the
+     * values or reset provided in the constructor
+     * {@link OStoreStart} instance.
+     */
+    reset() {
+        if (this.S) {
+            const keys = Object.keys(this.S);
+            keys.forEach((k) => {
+                const ovr = this.S[k];
+                this.put(ovr, ovr.reset ? ovr.reset : ovr.value);
+            });
+        }
+    }
+    /**
+     * Clear all entries
+     */
+    clear() {
+        this.entries.clear();
+    }
+    /**
+     * Set create a key value pair entry and creates a
+     * corresponding replay subject instance that will
+     * be used to broadcast updates.
+     *
+     * @param key The key identifying the value
+     * @param value The value
+     */
+    post(key, value) {
+        this.entries.set(key, value);
+        this.subjects.set(key, new ReplaySubject(1));
+        //Emit immediately so that Observers can receive 
+        //the value straight away.
+        const subject = this.subjects.get(key);
+        if (subject) {
+            subject.next(value);
+        }
+    }
+    /**
+     * Update a value and notify subscribers.
+     *
+     * @param key
+     * @param value
+     */
+    put(key, value) {
+        this.entries.set(key, value);
+        const subject = this.subjects.get(key);
+        if (subject) {
+            subject.next(value);
+        }
+    }
+    /**
+     * Deletes both the value entry and the corresponding {@link ReplaySubject}.
+     * Will unsubscribe the {@link ReplaySubject} prior to deleting it,
+     * severing communication with corresponding {@link Observable}s.
+     *
+     * @param key
+     */
+    delete(key) {
+        this.entries.delete(key);
+        this.subjects.delete(key);
+        const subject = this.subjects.get(key);
+        if (subject) {
+            subject.unsubscribe();
+        }
+    }
+    /**
+     * Observe changes to the values.
+     *
+     * @param key
+     * @return An {@link Observable} of the value
+     */
+    observe(key) {
+        return this.subjects.get(key).asObservable();
+    }
+    /**
+      * Check whether a value exists.
+      *
+      * @param key
+      * @return True if the entry exists ( Is not null or undefined ) and false otherwise.
+      */
+    exists(key) {
+        return this.entries.get(key) != null;
+    }
+    /**
+     * Retrieve a snapshot of the
+     * value.
+     *
+     * @param key
+     * @return A snapshot of the value corresponding to the key.
+     */
+    snapshot(key) {
+        return this.entries.get(key);
+    }
+    /**
+     * Indicates whether the store is empty.
+     * @return true if the store is empty, false otherwise.
+     */
+    isEmpty() {
+        return Array.from(this.entries.values()).length == 0;
+    }
+    /**
+     * Returns the number of key value pairs contained.
+     *
+     * @return the number of entries in the store.
+     */
+    count() {
+        return Array.from(this.entries.values()).length;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OStore.js","sourceRoot":"","sources":["../../../../projects/slice/src/lib/OStore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAc,MAAM,MAAM,CAAA;AA2BhD,MAAM,OAAO,MAAM;IAOf,YAAY,KAAkB;QAmC9B;;;WAGG;QACI,YAAO,GAAkB,IAAI,GAAG,EAAE,CAAA;QAEzC;;WAEG;QACK,aAAQ,GAAiC,IAAI,GAAG,EAAE,CAAA;QA3CtD,IAAI,KAAK,EAAE;YACP,IAAI,CAAC,CAAC,GAAQ,KAAK,CAAC;YACpB,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAC/B,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;gBACf,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,CAAkB,CAAA;gBACrC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAA;gBACzB,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;YAC/B,CAAC,CAAC,CAAA;SACL;IACL,CAAC;IAED;;;;OAIG;IACI,KAAK;QACR,IAAI,IAAI,CAAC,CAAC,EAAE;YACR,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;YAChC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;gBACf,MAAM,GAAG,GAAkB,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;gBACpC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;YACpD,CAAC,CAAC,CAAA;SACL;IACL,CAAC;IAED;;OAEG;IACI,KAAK;QACR,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAA;IACxB,CAAC;IAcD;;;;;;;OAOG;IACI,IAAI,CAAC,GAAQ,EAAE,KAAU;QAC5B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QAC5B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC,CAAA;QAC5C,iDAAiD;QACjD,0BAA0B;QAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACtC,IAAI,OAAO,EAAE;YACT,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;SACtB;IACL,CAAC;IACD;;;;;OAKG;IACI,GAAG,CAAC,GAAQ,EAAE,KAAU;QAC3B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACtC,IAAI,OAAO,EAAE;YACT,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;SACtB;IACL,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,GAAQ;QAClB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACxB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,CAAA;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;QACtC,IAAI,OAAO,EAAE;YACT,OAAO,CAAC,WAAW,EAAE,CAAA;SACxB;IACL,CAAC;IAED;;;;;OAKG;IACI,OAAO,CAAC,GAAQ;QACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC,YAAY,EAAE,CAAA;IACjD,CAAC;IAED;;;;;QAKI;IACG,MAAM,CAAC,GAAQ;QAClB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,CAAA;IACxC,CAAC;IAED;;;;;;OAMG;IACI,QAAQ,CAAC,GAAQ;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IAChC,CAAC;IAED;;;OAGG;IACI,OAAO;QACV,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,CAAA;IACxD,CAAC;IAED;;;;OAIG;IACI,KAAK;QACR,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAA;IACnD,CAAC;CACJ","sourcesContent":["import { ReplaySubject, Observable } from 'rxjs'\n\n/**\n * Initialize hte store with this.\n */\nexport interface ValueReset {\n    value: any\n    reset?: any\n}\n\n/**\n * OStore Key Value Reset\n */\nexport interface ObsValueReset {\n    value: any\n    reset?: any\n    obs: Observable<any>\n}\n\nexport interface KeyObsValueReset {\n    [key: string]: ObsValueReset\n}\n\nexport interface OStoreStart {\n    [key: string]: ValueReset\n}\n\nexport class OStore<E extends KeyObsValueReset> {\n    /**\n     * Start keys and values\n     * passed in via constructor.\n     */\n    public S!: E\n\n    constructor(start: OStoreStart) {\n        if (start) {\n            this.S = <any>start;\n            const keys = Object.keys(start)\n            keys.forEach((k) => {\n                const ovr = start[k] as ObsValueReset\n                this.post(ovr, ovr.value)\n                ovr.obs = this.observe(ovr)\n            })\n        }\n    }\n\n    /**\n     * Reset the state of the OStore to the\n     * values or reset provided in the constructor\n     * {@link OStoreStart} instance.\n     */\n    public reset() {\n        if (this.S) {\n            const keys = Object.keys(this.S)\n            keys.forEach((k) => {\n                const ovr: ObsValueReset = this.S[k]\n                this.put(ovr, ovr.reset ? ovr.reset : ovr.value)\n            })\n        }\n    }\n\n    /**\n     * Clear all entries\n     */\n    public clear() {\n        this.entries.clear()\n    }\n\n\n    /**\n     * Map of Key Value pair entries\n     * containing values store in this store.\n     */\n    public entries: Map<any, any> = new Map()\n\n    /**\n     * Map of replay subject id to `ReplaySubject` instance.\n     */\n    private subjects: Map<any, ReplaySubject<any>> = new Map()\n\n    /**\n     * Set create a key value pair entry and creates a \n     * corresponding replay subject instance that will\n     * be used to broadcast updates.\n     * \n     * @param key The key identifying the value\n     * @param value The value\n     */\n    public post(key: any, value: any) {\n        this.entries.set(key, value)\n        this.subjects.set(key, new ReplaySubject(1))\n        //Emit immediately so that Observers can receive \n        //the value straight away.\n        const subject = this.subjects.get(key)\n        if (subject) {\n            subject.next(value)\n        }\n    }\n    /**\n     * Update a value and notify subscribers.\n     * \n     * @param key \n     * @param value \n     */\n    public put(key: any, value: any) {\n        this.entries.set(key, value)\n        const subject = this.subjects.get(key)\n        if (subject) {\n            subject.next(value)\n        }\n    }\n\n    /**\n     * Deletes both the value entry and the corresponding {@link ReplaySubject}.\n     * Will unsubscribe the {@link ReplaySubject} prior to deleting it,\n     * severing communication with corresponding {@link Observable}s.\n     *  \n     * @param key \n     */\n    public delete(key: any) {\n        this.entries.delete(key)\n        this.subjects.delete(key)\n        const subject = this.subjects.get(key)\n        if (subject) {\n            subject.unsubscribe()\n        }\n    }\n\n    /**\n     * Observe changes to the values.\n     * \n     * @param key \n     * @return An {@link Observable} of the value\n     */\n    public observe(key: any) {\n        return this.subjects.get(key)!.asObservable()\n    }\n\n    /**\n      * Check whether a value exists.\n      * \n      * @param key \n      * @return True if the entry exists ( Is not null or undefined ) and false otherwise.\n      */\n    public exists(key: any): boolean {\n        return this.entries.get(key) != null\n    }\n\n    /**\n     * Retrieve a snapshot of the \n     * value.\n     *  \n     * @param key \n     * @return A snapshot of the value corresponding to the key.\n     */\n    public snapshot(key: any): any {\n        return this.entries.get(key)\n    }\n\n    /**\n     * Indicates whether the store is empty.\n     * @return true if the store is empty, false otherwise.\n     */\n    public isEmpty() {\n        return Array.from(this.entries.values()).length == 0\n    }\n\n    /**\n     * Returns the number of key value pairs contained.\n     * \n     * @return the number of entries in the store.\n     */\n    public count() {\n        return Array.from(this.entries.values()).length\n    }\n}"]}

package/esm2015/lib/Slice.js

@@ -0,0 +1,222 @@
+import { AbstractStore } from "./AbstractStore";
+const { isArray } = Array;
+export class Slice extends AbstractStore {
+    /**
+     * perform initial notification to all observers,
+     * such that operations like {@link combineLatest}{}
+     * will execute at least once.
+     *
+     * @param label The slice label
+     * @param predicate The slice predicate
+     * @param eStore The EStore instance containing the elements considered for slicing
+     *
+     * @example
+       <pre>
+       //Empty slice
+       new Slice<Todo>(Todo.COMPLETE, todo=>!todo.complete);
+  
+       //Initialized slice
+       let todos = [new Todo(false, "You complete me!"),
+                    new Todo(true, "You completed me!")];
+       new Slice<Todo>(Todo.COMPLETE, todo=>!todo.complete, todos);
+       </pre>
+     */
+    constructor(label, predicate, eStore) {
+        super();
+        this.label = label;
+        this.predicate = predicate;
+        this.eStore = eStore;
+        /* The slice element entries */
+        this.entries = new Map();
+        const entities = eStore.allSnapshot();
+        this.config = eStore.config;
+        let passed = this.test(predicate, entities);
+        const delta = { type: "Initialize" /* INTIALIZE */, entries: passed };
+        this.post(passed);
+        this.notifyDelta.next(delta);
+    }
+    /**
+     * Add the element if it satisfies the predicate
+     * and notify subscribers that an element was added.
+     *
+     * @param e The element to be considered for slicing
+     */
+    post(e) {
+        if (isArray(e)) {
+            this.postA(e);
+        }
+        else {
+            if (this.predicate(e)) {
+                const id = e[this.config.guidKey];
+                this.entries.set(id, e);
+                const delta = { type: "Post" /* POST */, entries: [e] };
+                this.notifyAll([...Array.from(this.entries.values())], delta);
+            }
+        }
+    }
+    /**
+     * Add the elements if they satisfy the predicate
+     * and notify subscribers that elements were added.
+     *
+     * @param e The element to be considered for slicing
+     */
+    postN(...e) {
+        this.postA(e);
+    }
+    /**
+     * Add the elements if they satisfy the predicate
+     * and notify subscribers that elements were added.
+     *
+     * @param e The element to be considered for slicing
+     */
+    postA(e) {
+        const d = [];
+        e.forEach(e => {
+            if (this.predicate(e)) {
+                const id = e[this.config.guidKey];
+                this.entries.set(id, e);
+                d.push(e);
+            }
+        });
+        const delta = { type: "Post" /* POST */, entries: d };
+        this.notifyAll([...Array.from(this.entries.values())], delta);
+    }
+    /**
+     * Delete an element from the slice.
+     *
+     * @param e The element to be deleted if it satisfies the predicate
+     */
+    delete(e) {
+        if (isArray(e)) {
+            this.deleteA(e);
+        }
+        else {
+            if (this.predicate(e)) {
+                const id = e[this.config.guidKey];
+                this.entries.delete(id);
+                const delta = { type: "Delete" /* DELETE */, entries: [e] };
+                this.notifyAll(Array.from(this.entries.values()), delta);
+            }
+        }
+    }
+    /**
+     * @param e The elements to be deleted if it satisfies the predicate
+     */
+    deleteN(...e) {
+        this.deleteA(e);
+    }
+    /**
+     * @param e The elements to be deleted if they satisfy the predicate
+     */
+    deleteA(e) {
+        const d = [];
+        e.forEach(e => {
+            if (this.predicate(e)) {
+                const id = e[this.config.guidKey];
+                d.push(this.entries.get(id));
+                this.entries.delete(id);
+            }
+        });
+        const delta = { type: "Delete" /* DELETE */, entries: d };
+        this.notifyAll([...Array.from(this.entries.values())], delta);
+    }
+    /**
+     * Update the slice when an Entity instance mutates.
+     *
+     * @param e The element to be added or deleted depending on predicate reevaluation
+     */
+    put(e) {
+        if (isArray(e)) {
+            this.putA(e);
+        }
+        else {
+            const id = e[this.config.guidKey];
+            if (this.entries.get(id)) {
+                if (!this.predicate(e)) {
+                    //Note that this is a ActionTypes.DELETE because we are removing the
+                    //entity from the slice.
+                    const delta = { type: "Delete" /* DELETE */, entries: [e] };
+                    this.entries.delete(id);
+                    this.notifyAll([...Array.from(this.entries.values())], delta);
+                }
+            }
+            else if (this.predicate(e)) {
+                this.entries.set(id, e);
+                const delta = { type: "Put" /* PUT */, entries: [e] };
+                this.notifyAll([...Array.from(this.entries.values())], delta);
+            }
+        }
+    }
+    /**
+     * Update the slice with mutated Entity instances.
+     *
+     * @param e The elements to be deleted if it satisfies the predicate
+     */
+    putN(...e) {
+        this.putA(e);
+    }
+    /**
+     * @param e The elements to be put
+     */
+    putA(e) {
+        const d = []; //instances to delete
+        const u = []; //instances to update
+        e.forEach(e => {
+            const id = e[this.config.guidKey];
+            if (this.entries.get(id)) {
+                if (!this.predicate(e)) {
+                    d.push(this.entries.get(id));
+                }
+            }
+            else if (this.predicate(e)) {
+                u.push(e);
+            }
+        });
+        if (d.length > 0) {
+            d.forEach(e => {
+                this.entries.delete(e[this.config.guidKey]);
+            });
+            const delta = { type: "Delete" /* DELETE */, entries: d };
+            this.notifyAll([...Array.from(this.entries.values())], delta);
+        }
+        if (u.length > 0) {
+            u.forEach(e => {
+                this.entries.set(e[this.config.guidKey], e);
+            });
+            const delta = { type: "Put" /* PUT */, entries: u };
+            this.notifyAll([...Array.from(this.entries.values())], delta);
+        }
+    }
+    /**
+     * Resets the slice to empty.
+     */
+    reset() {
+        let delta = {
+            type: "Reset" /* RESET */,
+            entries: [...Array.from(this.entries.values())]
+        };
+        this.notifyAll([], delta);
+        this.entries = new Map();
+    }
+    /**
+     * Utility method that applies the predicate to an array
+     * of entities and return the ones that pass the test.
+     *
+     * Used to create an initial set of values
+     * that should be part of the `Slice`.
+     *
+     * @param p
+     * @param e
+     * @return The the array of entities that pass the predicate test.
+     */
+    test(p, e) {
+        let v = [];
+        e.forEach((e) => {
+            if (p(e)) {
+                v.push(e);
+            }
+        });
+        return v;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Slice.js","sourceRoot":"","sources":["../../../../projects/slice/src/lib/Slice.ts"],"names":[],"mappings":"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","sourcesContent":["import { Delta, ActionTypes, Predicate } from \"./models\"\nimport { AbstractStore } from \"./AbstractStore\"\nimport { EStore } from \"./EStore\";\n\nconst { isArray } = Array\n\nexport class Slice<E> extends AbstractStore<E> {\n\n\n    /* The slice element entries */\n    public entries: Map<string, E> = new Map();\n\n    /**\n     * perform initial notification to all observers,\n     * such that operations like {@link combineLatest}{}\n     * will execute at least once.\n     * \n     * @param label The slice label\n     * @param predicate The slice predicate\n     * @param eStore The EStore instance containing the elements considered for slicing\n     * \n     * @example \n       <pre>\n       //Empty slice\n       new Slice<Todo>(Todo.COMPLETE, todo=>!todo.complete);\n  \n       //Initialized slice\n       let todos = [new Todo(false, \"You complete me!\"), \n                    new Todo(true, \"You completed me!\")];\n       new Slice<Todo>(Todo.COMPLETE, todo=>!todo.complete, todos);\n       </pre>\n     */\n    constructor(\n        public label: string,\n        public predicate: Predicate<E>,\n        public eStore: EStore<E>) {\n        super();\n        const entities: E[] = eStore.allSnapshot()\n        this.config = eStore.config\n        let passed: E[] = this.test(predicate, entities);\n        const delta: Delta<E> = { type: ActionTypes.INTIALIZE, entries: passed };\n        this.post(passed);\n        this.notifyDelta.next(delta)\n    }\n\n    /**\n     * Add the element if it satisfies the predicate\n     * and notify subscribers that an element was added.\n     *\n     * @param e The element to be considered for slicing\n     */\n    post(e: E | E[]) {\n        if (isArray(e)) {\n            this.postA(e)\n        }\n        else {\n            if (this.predicate(e)) {\n                const id = (<any>e)[this.config.guidKey];\n                this.entries.set(id, e);\n                const delta: Delta<E> = { type: ActionTypes.POST, entries: [e] };\n                this.notifyAll([...Array.from(this.entries.values())], delta);\n            }\n        }\n    }\n\n    /**\n     * Add the elements if they satisfy the predicate\n     * and notify subscribers that elements were added.\n     *\n     * @param e The element to be considered for slicing\n     */\n    postN(...e: E[]) {\n        this.postA(e);\n    }\n\n    /**\n     * Add the elements if they satisfy the predicate\n     * and notify subscribers that elements were added.\n     *\n     * @param e The element to be considered for slicing\n     */\n    postA(e: E[]) {\n        const d: E[] = [];\n        e.forEach(e => {\n            if (this.predicate(e)) {\n                const id = (<any>e)[this.config.guidKey];\n                this.entries.set(id, e);\n                d.push(e);\n            }\n        });\n        const delta: Delta<E> = { type: ActionTypes.POST, entries: d };\n        this.notifyAll([...Array.from(this.entries.values())], delta);\n    }\n\n    /**\n     * Delete an element from the slice.\n     *\n     * @param e The element to be deleted if it satisfies the predicate\n     */\n    delete(e: E | E[]) {\n        if (isArray(e)) {\n            this.deleteA(e)\n        }\n        else {\n            if (this.predicate(e)) {\n                const id = (<any>e)[this.config.guidKey]\n                this.entries.delete(id)\n                const delta: Delta<E> = { type: ActionTypes.DELETE, entries: [e] }\n                this.notifyAll(Array.from(this.entries.values()), delta)\n            }\n        }\n    }\n\n    /**\n     * @param e The elements to be deleted if it satisfies the predicate\n     */\n    deleteN(...e: E[]) {\n        this.deleteA(e);\n    }\n\n    /**\n     * @param e The elements to be deleted if they satisfy the predicate\n     */\n    deleteA(e: E[]) {\n        const d: E[] = []\n        e.forEach(e => {\n            if (this.predicate(e)) {\n                const id = (<any>e)[this.config.guidKey]\n                d.push(this.entries.get(id)!)\n                this.entries.delete(id)\n            }\n        });\n        const delta: Delta<E> = { type: ActionTypes.DELETE, entries: d };\n        this.notifyAll([...Array.from(this.entries.values())], delta);\n    }\n\n    /**\n     * Update the slice when an Entity instance mutates.\n     *\n     * @param e The element to be added or deleted depending on predicate reevaluation\n     */\n    put(e: E | E[]) {\n        if (isArray(e)) {\n            this.putA(e)\n        }\n        else {\n            const id = (<any>e)[this.config.guidKey];\n            if (this.entries.get(id)) {\n                if (!this.predicate(e)) {\n                    //Note that this is a ActionTypes.DELETE because we are removing the\n                    //entity from the slice.\n                    const delta: Delta<E> = { type: ActionTypes.DELETE, entries: [e] };\n                    this.entries.delete(id);\n                    this.notifyAll([...Array.from(this.entries.values())], delta);\n                }\n            } else if (this.predicate(e)) {\n                this.entries.set(id, e);\n                const delta: Delta<E> = { type: ActionTypes.PUT, entries: [e] };\n                this.notifyAll([...Array.from(this.entries.values())], delta);\n            }    \n        }\n    }\n\n    /**\n     * Update the slice with mutated Entity instances.\n     *\n     * @param e The elements to be deleted if it satisfies the predicate\n     */\n    putN(...e: E[]) {\n        this.putA(e);\n    }\n\n    /**\n     * @param e The elements to be put\n     */\n    putA(e: E[]) {\n        const d: E[] = []; //instances to delete\n        const u: E[] = []; //instances to update\n        e.forEach(e => {\n            const id = (<any>e)[this.config.guidKey];\n            if (this.entries.get(id)) {\n                if (!this.predicate(e)) {\n                    d.push(this.entries.get(id)!);\n                }\n            } else if (this.predicate(e)) {\n                u.push(e);\n            }\n        });\n        if (d.length > 0) {\n            d.forEach(e => {\n                this.entries.delete((<any>e)[this.config.guidKey])\n            });\n            const delta: Delta<E> = { type: ActionTypes.DELETE, entries: d };\n            this.notifyAll([...Array.from(this.entries.values())], delta);\n        }\n        if (u.length > 0) {\n            u.forEach(e => {\n                this.entries.set((<any>e)[this.config.guidKey], e);\n            });\n            const delta: Delta<E> = { type: ActionTypes.PUT, entries: u };\n            this.notifyAll([...Array.from(this.entries.values())], delta);\n        }\n    }\n\n    /**\n     * Resets the slice to empty.\n     */\n    reset() {\n        let delta: Delta<E> = {\n            type: ActionTypes.RESET,\n            entries: [...Array.from(this.entries.values())]\n        };\n        this.notifyAll([], delta);\n        this.entries = new Map();\n    }\n\n    /**\n     * Utility method that applies the predicate to an array\n     * of entities and return the ones that pass the test.\n     *\n     * Used to create an initial set of values\n     * that should be part of the `Slice`.\n     *\n     * @param p\n     * @param e\n     * @return The the array of entities that pass the predicate test.\n     */\n    public test(p: Predicate<E>, e: E[]): E[] {\n        let v: E[] = [];\n        e.forEach((e: E) => {\n            if (p(e)) {\n                v.push(e);\n            }\n        });\n        return v;\n    }\n}\n"]}

package/esm2015/lib/models/ActionTypes.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQWN0aW9uVHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbGljZS9zcmMvbGliL21vZGVscy9BY3Rpb25UeXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgYWN0aW9uIHR5cGVzIGZvciB0aGUgc3RvcmUuXG4gKi9cbmV4cG9ydCBjb25zdCBlbnVtIEFjdGlvblR5cGVzIHtcbiAgICBQT1NUID0gXCJQb3N0XCIsXG4gICAgUFVUID0gXCJQdXRcIixcbiAgICBERUxFVEUgPSBcIkRlbGV0ZVwiLFxuICAgIElOVElBTElaRSA9IFwiSW5pdGlhbGl6ZVwiLFxuICAgIFJFU0VUID0gXCJSZXNldFwiXG4gIH1cbiAgIl19

package/esm2015/lib/models/Delta.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRGVsdGEuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbGljZS9zcmMvbGliL21vZGVscy9EZWx0YS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWN0aW9uVHlwZXMgfSBmcm9tIFwiLi9BY3Rpb25UeXBlc1wiO1xuXG4vKipcbiAqIERlbHRhIHVwZGF0ZSBpbnRlcmZhY2UgbW9kZWxzXG4gKiB0aGUgdHlwZSBvZiB0aGUgdXBkYXRlIGFuZCB0aGUgZW50aXRpZXNcbiAqIGFzc29jaWF0ZWQgd2l0aCB0aGUgdXBkYXRlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIERlbHRhPEU+IHtcbiAgICB0eXBlOiBBY3Rpb25UeXBlcztcbiAgICBlbnRyaWVzOiBFW107XG4gIH1cbiAgIl19

package/esm2015/lib/models/Predicate.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUHJlZGljYXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvc2xpY2Uvc3JjL2xpYi9tb2RlbHMvUHJlZGljYXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEZ1bmN0aW9uIHR5cGUgZm9yIHByZWRpY2F0ZSBvcGVyYXRpb25zXG4gKi9cbmV4cG9ydCB0eXBlIFByZWRpY2F0ZTxFPiA9IChlOiBFKSA9PiBib29sZWFuO1xuIl19

package/esm2015/lib/models/StoreConfig.js

@@ -0,0 +1,3 @@
+;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU3RvcmVDb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbGljZS9zcmMvbGliL21vZGVscy9TdG9yZUNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFPQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGUgY29uZmlndXJhdGlvbiBpbnRlcmZhY2UgZm9yIHRoZSBlbnRpdHkgc3RvcmVcbiAqIGRlZmluZXMgdGhlIHN0cmluZ3MgZm9yIHRoZSBJRCBLZXkgYW5kIEdsb2JhbCBJRCBrZXkuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU3RvcmVDb25maWcge1xuICAgIGlkS2V5OiBzdHJpbmc7XG4gICAgZ3VpZEtleTogc3RyaW5nO1xufTtcbiAgIl19

package/esm2015/lib/models/index.js

@@ -0,0 +1,5 @@
+export * from './ActionTypes';
+export * from './Delta';
+export * from './Predicate';
+export * from './StoreConfig';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbGljZS9zcmMvbGliL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQTtBQUM3QixjQUFjLFNBQVMsQ0FBQTtBQUN2QixjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLGVBQWUsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vQWN0aW9uVHlwZXMnXG5leHBvcnQgKiBmcm9tICcuL0RlbHRhJ1xuZXhwb3J0ICogZnJvbSAnLi9QcmVkaWNhdGUnXG5leHBvcnQgKiBmcm9tICcuL1N0b3JlQ29uZmlnJyJdfQ==

package/esm2015/lib/models/scrollPosition.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nyb2xsUG9zaXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbGljZS9zcmMvbGliL21vZGVscy9zY3JvbGxQb3NpdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTY3JvbGwgcG9zaXRpb24gZnVuY3Rpb24gdHlwZSB1c2VkIHRvIGF1dG8gaGlkZVxuICogdGhlIG1hdGVyaWFsIHRvb2xiYXIgaW4gY29uanVjdGlvbiB3aXRoIEFuZ3VsYXIgQ0RLLlxuICovXG5leHBvcnQgdHlwZSBzY3JvbGxQb3NpdGlvbiA9ICgpPT5bbnVtYmVyLCBudW1iZXJdIl19