@fireflysemantics/slice 15.0.18 → 15.0.24

package/esm2020/lib/Slice.mjs

@@ -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" /* ActionTypes.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" /* ActionTypes.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" /* ActionTypes.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" /* ActionTypes.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" /* ActionTypes.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" /* ActionTypes.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" /* ActionTypes.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" /* ActionTypes.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" /* ActionTypes.PUT */, entries: u };
+            this.notifyAll([...Array.from(this.entries.values())], delta);
+        }
+    }
+    /**
+     * Resets the slice to empty.
+     */
+    reset() {
+        let delta = {
+            type: "Reset" /* ActionTypes.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 override 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/esm2020/lib/utilities.mjs

@@ -0,0 +1,226 @@
+import { ESTORE_CONFIG_DEFAULT } from "./AbstractStore";
+import { fromEvent, of } from 'rxjs';
+import { switchMap, pairwise, debounceTime, distinctUntilChanged, map, filter } from 'rxjs/operators';
+import { nanoid } from "nanoid";
+/**
+ * Returns all the entities are distinct by the
+ * `property` value argument.
+ *
+ * Note that the implementation uses a `Map<string, E>` to
+ * index the entities by key.  Therefore the more recent occurences
+ * matching a key instance will overwrite the previous ones.
+ *
+ * @param property The name of the property to check for distinct values by.
+ * @param entities The entities in the array.
+ *
+ * @example
+ ```
+  let todos: Todo[] = [
+    { id: 1, title: "Lets do it!" },
+    { id: 1, title: "Lets do it again!" },
+    { id: 2, title: "All done!" }
+  ];
+
+  let todos2: Todo[] = [
+    { id: 1, title: "Lets do it!" },
+    { id: 2, title: "All done!" }
+  ];
+
+  expect(distinct(todos, "id").length).toEqual(2);
+  expect(distinct(todos2, "id").length).toEqual(2);
+
+ ```
+ */
+export function distinct(entities, property) {
+    const entitiesByProperty = new Map(entities.map(e => [e[property], e]));
+    return Array.from(entitiesByProperty.values());
+}
+/**
+ * Returns true if all the entities are distinct by the
+ * `property` value argument.
+ *
+ * @param property The name of the property to check for distinct values by.
+ * @param entities The entities in the array.
+ *
+ * @example
+ *
+ ```
+  let todos: Todo[] = [
+    { id: 1, title: "Lets do it!" },
+    { id: 1, title: "Lets do it again!" },
+    { id: 2, title: "All done!" }
+  ];
+
+  let todos2: Todo[] = [
+    { id: 1, title: "Lets do it!" },
+    { id: 2, title: "All done!" }
+  ];
+
+  expect(unique(todos, "id")).toBeFalsy();
+  expect(unique(todos2, "id")).toBeTruthy();
+ ```
+ */
+export function unique(entities, property) {
+    return entities.length == distinct(entities, property).length ? true : false;
+}
+/**
+ * Create a global ID
+ * @return The global id.
+ *
+ * @example
+ * let e.guid = GUID();
+ */
+export function GUID() {
+    return nanoid();
+}
+/**
+ * Set the global identfication property on the instance.
+ *
+ * @param e Entity we want to set the global identifier on.
+ * @param gid The name of the `gid` property.  If not specified it defaults to `ESTORE_CONFIG_DEFAULT.guidKey`.
+ */
+export function attachGUID(e, gid) {
+    const guidKey = gid ? gid : ESTORE_CONFIG_DEFAULT.guidKey;
+    let id = nanoid();
+    e[guidKey] = id;
+    return id;
+}
+/**
+ * Set the global identfication property on the instance.
+ *
+ * @param e[] Entity array we want to set the global identifiers on.
+ * @param gid The name of the `gid` property.  If not specified it defaults to `gid`.
+ */
+export function attachGUIDs(e, gid) {
+    e.forEach(e => {
+        attachGUID(e, gid);
+    });
+}
+/**
+ * Create a shallow copy of the argument.
+ * @param o The object to copy
+ */
+export function shallowCopy(o) {
+    return { ...o };
+}
+/**
+ * Create a deep copy of the argument.
+ * @param o The object to copy
+ */
+export function deepCopy(o) {
+    return JSON.parse(JSON.stringify(o));
+}
+/**
+ * Gets the current active value from the `active`
+ * Map.
+ *
+ * This is used for the scenario where we are managing
+ * a single active instance.  For example
+ * when selecting a book from a collection of books.
+ *
+ * The selected `Book` instance becomes the active value.
+ *
+ * @example
+ * const book:Book = getActiveValue(bookStore.active);
+ * @param m
+ */
+export function getActiveValue(m) {
+    if (m.size) {
+        return m.entries().next().value[1];
+    }
+    return null;
+}
+/**
+ * The method can be used to exclude keys from an instance
+ * of type `E`.
+ *
+ * We can use this to exclude values when searching an object.
+ *
+ * @param entity An instance of type E
+ * @param exclude The keys to exclude
+ *
+ * @example
+ * todo = { id: '1', description: 'Do it!' }
+ * let keys = excludeKeys<Todo>(todo, ['id]);
+ * // keys = ['description']
+ */
+export function excludeKeys(entity, exclude) {
+    const keys = Object.keys(entity);
+    return keys.filter((key) => {
+        return exclude.indexOf(key) < 0;
+    });
+}
+/**
+ *
+ * @param entities The entity to search
+ * @param exclude Keys to exclude from each entity
+ *
+ * @return E[] Array of entities with properties containing the search term.
+ */
+export function search(query = '', entities, exclude = []) {
+    const { isArray } = Array;
+    query = query.toLowerCase();
+    return entities.filter(function (e) {
+        //Do the keys calculation on each instance e:E
+        //because an instance can have optional parameters,
+        //and thus we have to check each instance, not just
+        //the first one in the array.
+        const keys = excludeKeys(e, exclude);
+        return keys.some((key) => {
+            const value = e[key];
+            if (!value) {
+                return false;
+            }
+            if (isArray(value)) {
+                return value.some(v => {
+                    return String(v).toLowerCase().includes(query);
+                });
+            }
+            else {
+                return String(value).toLowerCase().includes(query);
+            }
+        });
+    });
+}
+/**
+ * @param scrollable The element being scrolled
+ * @param debounceMS The number of milliseconds to debounce scroll events
+ * @param sp The function returning the scroll position coordinates.
+ * @return A boolean valued observable indicating whether the element is scrolling up or down
+ */
+export function scrollingUp(scrollable, debounceMS, sp) {
+    return fromEvent(scrollable, 'scroll').pipe(debounceTime(debounceMS), distinctUntilChanged(), map(v => sp()), pairwise(), switchMap(p => {
+        const y1 = p[0][1];
+        const y2 = p[1][1];
+        return y1 - y2 > 0 ? of(false) : of(true);
+    }));
+}
+/**
+ * Filters the entities properties to the set contained in the
+ * `keys` array.
+ *
+ * @param keys The array of keys that the entity be limited to
+ * @param entity The entity to map
+ * @return An entity instance that has only the keys provided in the keys array
+ */
+export function mapEntity(keys, entity) {
+    const result = {};
+    keys.forEach(k => {
+        result[k] = entity[k];
+    });
+    return result;
+}
+/**
+ * Returns an `Observable<E>` instance that
+ * filters for arguments where the property
+ * value matches the provided value.
+ *
+ * @param value The value targeted
+ * @param propertyName The name of the property to contain the value
+ * @param obs The Slice Object Store Observable
+ * @returns Observable<E>
+ */
+export function onFilteredEvent(value, propertyName, obs) {
+    return obs.pipe(filter((e) => !!(e && e[propertyName] === value)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../../../projects/slice/src/lib/utilities.ts"],"names":[],"mappings":"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","sourcesContent":["import { ESTORE_CONFIG_DEFAULT } from \"./AbstractStore\";\nimport { Observable, fromEvent, of } from 'rxjs'\nimport { switchMap, pairwise, debounceTime, distinctUntilChanged, map, filter } from 'rxjs/operators'\nimport { nanoid} from \"nanoid\"\nimport { scrollPosition } from \"./models/scrollPosition\";\n\n/**\n * Returns all the entities are distinct by the \n * `property` value argument.  \n * \n * Note that the implementation uses a `Map<string, E>` to\n * index the entities by key.  Therefore the more recent occurences \n * matching a key instance will overwrite the previous ones.\n * \n * @param property The name of the property to check for distinct values by.\n * @param entities The entities in the array.\n * \n * @example\n ```\n  let todos: Todo[] = [\n    { id: 1, title: \"Lets do it!\" },\n    { id: 1, title: \"Lets do it again!\" },\n    { id: 2, title: \"All done!\" }\n  ];\n\n  let todos2: Todo[] = [\n    { id: 1, title: \"Lets do it!\" },\n    { id: 2, title: \"All done!\" }\n  ];\n\n  expect(distinct(todos, \"id\").length).toEqual(2);\n  expect(distinct(todos2, \"id\").length).toEqual(2);\n\n ```\n */\nexport function distinct<E, K extends keyof E>(entities: E[], property: K): E[] {\n  const entitiesByProperty = new Map(entities.map(e => [e[property], e] as [E[K], E]));\n  return Array.from(entitiesByProperty.values());\n}\n\n/**\n * Returns true if all the entities are distinct by the \n * `property` value argument.\n * \n * @param property The name of the property to check for distinct values by.\n * @param entities The entities in the array.\n * \n * @example\n * \n ```\n  let todos: Todo[] = [\n    { id: 1, title: \"Lets do it!\" },\n    { id: 1, title: \"Lets do it again!\" },\n    { id: 2, title: \"All done!\" }\n  ];\n\n  let todos2: Todo[] = [\n    { id: 1, title: \"Lets do it!\" },\n    { id: 2, title: \"All done!\" }\n  ];\n\n  expect(unique(todos, \"id\")).toBeFalsy();\n  expect(unique(todos2, \"id\")).toBeTruthy();\n ```\n */\nexport function unique<E>(entities: E[], property: keyof E):boolean {\n  return entities.length == distinct(entities, property).length ? true : false;\n}\n\n/**\n * Create a global ID\n * @return The global id.\n * \n * @example\n * let e.guid = GUID();\n */\nexport function GUID() {\n  return nanoid();\n}\n\n/**\n * Set the global identfication property on the instance.\n * \n * @param e Entity we want to set the global identifier on.\n * @param gid The name of the `gid` property.  If not specified it defaults to `ESTORE_CONFIG_DEFAULT.guidKey`.\n */\nexport function attachGUID<E>(e: E, gid?: string): string {\n  const guidKey = gid ? gid : ESTORE_CONFIG_DEFAULT.guidKey\n  let id: string = nanoid();\n  (<any>e)[guidKey] = id\n  return id\n}\n\n/**\n * Set the global identfication property on the instance.\n * \n * @param e[] Entity array we want to set the global identifiers on.\n * @param gid The name of the `gid` property.  If not specified it defaults to `gid`.\n */\nexport function attachGUIDs<E>(e: E[], gid?: string) {\n  e.forEach(e => {\n    attachGUID(e, gid);\n  });\n}\n\n/**\n * Create a shallow copy of the argument.\n * @param o The object to copy\n */\nexport function shallowCopy<E>(o: E) {\n  return { ...o };\n}\n\n/**\n * Create a deep copy of the argument.\n * @param o The object to copy\n */\nexport function deepCopy<E>(o: E) {\n  return JSON.parse(JSON.stringify(o));\n}\n\n/**\n * Gets the current active value from the `active`\n * Map.  \n * \n * This is used for the scenario where we are managing\n * a single active instance.  For example \n * when selecting a book from a collection of books.  \n * \n * The selected `Book` instance becomes the active value.\n * \n * @example\n * const book:Book = getActiveValue(bookStore.active);\n * @param m \n */\nexport function getActiveValue<E>(m: Map<any, E>) {\n  if (m.size) {\n    return m.entries().next().value[1];\n  }\n  return null;\n}\n\n/**\n * The method can be used to exclude keys from an instance\n * of type `E`.  \n * \n * We can use this to exclude values when searching an object.\n * \n * @param entity An instance of type E\n * @param exclude The keys to exclude\n * \n * @example\n * todo = { id: '1', description: 'Do it!' }\n * let keys = excludeKeys<Todo>(todo, ['id]);\n * // keys = ['description']\n */\nexport function excludeKeys<E>(entity: any, exclude: string[]) {\n  const keys: string[] = Object.keys(entity);\n  return keys.filter((key) => {\n    return exclude.indexOf(key) < 0;\n  });\n}\n\n/**\n * \n * @param entities The entity to search\n * @param exclude Keys to exclude from each entity\n * \n * @return E[] Array of entities with properties containing the search term.\n */\nexport function search<E>(query: string = '', entities: E[], exclude: string[] = []): E[] {\n  const { isArray } = Array\n\n  query = query.toLowerCase();\n\n\n  return entities.filter(function (e: E) {\n    //Do the keys calculation on each instance e:E\n    //because an instance can have optional parameters,\n    //and thus we have to check each instance, not just\n    //the first one in the array.\n    const keys = excludeKeys(e, exclude)\n    return keys.some( (key) => {\n      const value = (e as any)[key];\n      if (!value) {\n        return false;\n      }\n      if (isArray(value)) {\n        return value.some(v => {\n          return String(v).toLowerCase().includes(query);\n        });\n      }\n      else {\n        return String(value).toLowerCase().includes(query);\n      }\n    })\n  });\n}\n\n/**\n * @param scrollable The element being scrolled\n * @param debounceMS The number of milliseconds to debounce scroll events\n * @param sp The function returning the scroll position coordinates.\n * @return A boolean valued observable indicating whether the element is scrolling up or down\n */\nexport function scrollingUp(\n  scrollable: any, \n  debounceMS: number, \n  sp: scrollPosition): Observable<boolean> {\n  return fromEvent(scrollable, 'scroll').pipe(\n    debounceTime(debounceMS), \n    distinctUntilChanged(), \n    map(v => sp()), \n    pairwise(), \n    switchMap(p => {\n    const y1 = p[0][1]\n    const y2 = p[1][1]\n    return y1 - y2 > 0 ? of(false) : of(true)\n  }))\n}\n\n/**\n * Filters the entities properties to the set contained in the \n * `keys` array.\n *  \n * @param keys The array of keys that the entity be limited to\n * @param entity The entity to map\n * @return An entity instance that has only the keys provided in the keys array \n */\nexport function mapEntity(keys:string[], entity:any) {\n  const result:any = {}\n  keys.forEach(k=>{\n    result[k] = entity[k]\n  })\n  return result\n}\n\n/**\n * Returns an `Observable<E>` instance that \n * filters for arguments where the property \n * value matches the provided value.\n * \n * @param value The value targeted\n * @param propertyName The name of the property to contain the value\n * @param obs The Slice Object Store Observable\n * @returns Observable<E>\n */\n export function onFilteredEvent<E>(\n  value: any,\n  propertyName: string,\n  obs: Observable<E>\n): Observable<E> {\n  return obs.pipe(filter((e:any) => !!(e && e[propertyName] === value)));\n}"]}

package/{esm2015/public-api.js → esm2020/public-api.mjs}

@@ -7,4 +7,4 @@ export * from './lib/EStore';
 export * from './lib/OStore';
 export * from './lib/Slice';
 export * from './lib/utilities';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NsaWNlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxlQUFlLENBQUE7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzbGljZVxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMvJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvQWJzdHJhY3RTdG9yZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL0VTdG9yZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL09TdG9yZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL1NsaWNlJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdXRpbGl0aWVzJ1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NsaWNlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxlQUFlLENBQUE7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzbGljZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscy8nXG5leHBvcnQgKiBmcm9tICcuL2xpYi9BYnN0cmFjdFN0b3JlJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvRVN0b3JlJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvT1N0b3JlJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvU2xpY2UnXG5leHBvcnQgKiBmcm9tICcuL2xpYi91dGlsaXRpZXMnXG4iXX0=