@fireflysemantics/slice 16.2.14 → 16.2.16

package/README.md

@@ -1,19 +1,29 @@
-[![Build Status](https://travis-ci.org/fireflysemantics/slice.svg?branch=master)](https://travis-ci.org/fireflysemantics/slice)
-
 ![Slice](slicelogo.png)
 
 # @fireflysemantics/slice
 
-Lightweight Javascript Reactive State Management for Web Applications.
+Lightweight Javascript Reactive State Management for Angular Applications.
 
 If you like the [@fireflysemantics/slice API](https://fireflysemantics.github.io/slice/doc/) please star our [Github Repository](https://github.com/fireflysemantics/slice).
 
 # Install
 
-Install Slice with peer dependencies:
+
+Install Slice with the `nanoid` peer dependency:
+
+- `v17.0.x` for Angular 17
+- `v16.2.x` for Angular 16
+- `v15.2.x` for Angular 15
+
+So for example for an Angular 15 project run.
+
+```
+npm i @fireflysemantics/slice@15.2.x nanoid
+```
+For Angular 17 run.
 
 ```
-npm i @fireflysemantics/slice tslib rxjs nanoid
+npm i @fireflysemantics/slice@lastest nanoid
 ```
 
 # Firefly Semantics Slice Development Center Media and Documentation

package/esm2020/lib/OStore.mjs

@@ -0,0 +1,145 @@
+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);
+            });
+        }
+    }
+    /**
+     * 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) {
+        //===========================================
+        // Delete the entry
+        //===========================================
+        this.entries.delete(key);
+        const subject = this.subjects.get(key);
+        if (subject) {
+            subject.next(undefined);
+        }
+    }
+    /**
+     * Clear all entries.
+     *
+     * Note that
+     * this will call delete for on all
+     * keys defined which also also
+     * unsubscribes and deletes
+     * all the sbujects.
+     */
+    clear() {
+        for (let key of this.entries.keys()) {
+            this.delete(key);
+        }
+    }
+    /**
+     * Observe changes to the values.
+     *
+     * @param key
+     * @return An {@link Observable} of the value
+     */
+    observe(key) {
+        return this.subjects.get(key)
+            ? this.subjects.get(key).asObservable()
+            : undefined;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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":"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","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 = <E>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   * 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  private post(key: ObsValueReset, 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    //===========================================\n    // Delete the entry\n    //===========================================\n    this.entries.delete(key);\n    const subject = this.subjects.get(key);\n    if (subject) {\n      subject.next(undefined);\n    }\n  }\n\n  /**\n   * Clear all entries.  \n   * \n   * Note that \n   * this will call delete for on all\n   * keys defined which also also \n   * unsubscribes and deletes \n   * all the sbujects.\n   */\n  public clear() {\n    for (let key of this.entries.keys()) {\n        this.delete(key);\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): Observable<any> | undefined {\n    return this.subjects.get(key)\n      ? this.subjects.get(key)!.asObservable()\n      : undefined;\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);\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}\n"]}