@fireflysemantics/slice 14.0.7

package/esm2015/lib/utilities.js

@@ -0,0 +1,213 @@
+import { ESTORE_CONFIG_DEFAULT } from "./AbstractStore";
+import { fromEvent, of } from 'rxjs';
+import { switchMap, pairwise, debounceTime, distinctUntilChanged, map } 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 Object.assign({}, 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;
+}
+//# 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 } 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: E, 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}"]}

package/esm2015/public-api.js

@@ -0,0 +1,10 @@
+/*
+ * Public API Surface of slice
+ */
+export * from './lib/models/';
+export * from './lib/AbstractStore';
+export * from './lib/EStore';
+export * from './lib/OStore';
+export * from './lib/Slice';
+export * from './lib/utilities';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3NsaWNlL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsY0FBYyxlQUFlLENBQUE7QUFDN0IsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGNBQWMsQ0FBQTtBQUM1QixjQUFjLGFBQWEsQ0FBQTtBQUMzQixjQUFjLGlCQUFpQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBzbGljZVxuICovXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMvJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvQWJzdHJhY3RTdG9yZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL0VTdG9yZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL09TdG9yZSdcbmV4cG9ydCAqIGZyb20gJy4vbGliL1NsaWNlJ1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdXRpbGl0aWVzJ1xuIl19