@igo2/common 1.14.2 → 1.14.3

package/esm2020/lib/entity/shared/state.mjs

@@ -1,191 +1,191 @@
-import { ReplaySubject } from 'rxjs';
-import { getEntityId } from './entity.utils';
-/**
- * This class is used to track a store's entities state
- */
-export class EntityStateManager {
-    constructor(options = {}) {
-        /**
-         * State index
-         */
-        this.index = new Map();
-        /**
-         * Change emitter
-         */
-        this.change$ = new ReplaySubject(1);
-        this.store = options.store ? options.store : undefined;
-        this.getKey = options.getKey
-            ? options.getKey
-            : (this.store ? this.store.getKey : getEntityId);
-        this.next();
-    }
-    /**
-     * Clear state
-     */
-    clear() {
-        if (this.index.size > 0) {
-            this.index.clear();
-            this.next();
-        }
-    }
-    /**
-     * Get an entity's state
-     * @param entity Entity
-     * @returns State
-     */
-    get(entity) {
-        return (this.index.get(this.getKey(entity)) || {});
-    }
-    /**
-     * Set an entity's state
-     * @param entity Entity
-     * @param state State
-     */
-    set(entity, state) {
-        this.setMany([entity], state);
-    }
-    /**
-     * Set many entitie's state
-     * @param entitie Entities
-     * @param state State
-     */
-    setMany(entities, state) {
-        entities.forEach((entity) => {
-            this.index.set(this.getKey(entity), Object.assign({}, state));
-        });
-        this.next();
-    }
-    /**
-     * Set state of all entities that already have a state. This is not
-     * the same as setting the state of all the store's entities.
-     * @param state State
-     */
-    setAll(state) {
-        Array.from(this.index.keys()).forEach((key) => {
-            this.index.set(key, Object.assign({}, state));
-        });
-        this.next();
-    }
-    /**
-     * Update an entity's state
-     * @param entity Entity
-     * @param changes State changes
-     */
-    update(entity, changes, exclusive = false) {
-        this.updateMany([entity], changes, exclusive);
-    }
-    /**
-     * Update many entitie's state
-     * @param entitie Entities
-     * @param changes State changes
-     */
-    updateMany(entities, changes, exclusive = false) {
-        if (exclusive === true) {
-            return this.updateManyExclusive(entities, changes);
-        }
-        entities.forEach((entity) => {
-            const state = Object.assign({}, this.get(entity), changes);
-            this.index.set(this.getKey(entity), state);
-        });
-        this.next();
-    }
-    /**
-     * Reversee an entity's state
-     * @param entity Entity
-     * @param keys State keys to reverse
-     */
-    reverse(entity, keys) {
-        this.reverseMany([entity], keys);
-    }
-    /**
-     * Reverse many entitie's state
-     * @param entitie Entities
-     * @param keys State keys to reverse
-     */
-    reverseMany(entities, keys) {
-        entities.forEach((entity) => {
-            const currentState = this.get(entity);
-            const changes = keys.reduce((acc, key) => {
-                acc[key] = currentState[key] || false;
-                return acc;
-            }, {});
-            const reversedChanges = this.reverseChanges(changes);
-            const state = Object.assign({}, currentState, reversedChanges);
-            this.index.set(this.getKey(entity), state);
-        });
-        this.next();
-    }
-    /**
-     * Update state of all entities that already have a state. This is not
-     * the same as updating the state of all the store's entities.
-     * @param changes State
-     */
-    updateAll(changes) {
-        const allKeys = this.getAllKeys();
-        Array.from(allKeys).forEach((key) => {
-            const state = Object.assign({}, this.index.get(key), changes);
-            this.index.set(key, state);
-        });
-        this.next();
-    }
-    /**
-     * When some state changes are flagged as 'exclusive', reverse
-     * the state of all other entities. Changes are reversable when
-     * they are boolean.
-     * @param entitie Entities
-     * @param changes State changes
-     */
-    updateManyExclusive(entities, changes) {
-        const reverseChanges = this.reverseChanges(changes);
-        const keys = entities.map((entity) => this.getKey(entity));
-        const allKeys = new Set(keys.concat(Array.from(this.getAllKeys())));
-        allKeys.forEach((key) => {
-            const state = this.index.get(key) || {};
-            if (keys.indexOf(key) >= 0) {
-                this.index.set(key, Object.assign({}, state, changes));
-            }
-            else {
-                // Update only if the reverse changes would modify
-                // a key already present in the current state
-                const shouldUpdate = Object.keys(reverseChanges).some((changeKey) => {
-                    return state[changeKey] !== undefined &&
-                        state[changeKey] !== reverseChanges[changeKey];
-                });
-                if (shouldUpdate === true) {
-                    this.index.set(key, Object.assign({}, state, reverseChanges));
-                }
-            }
-        });
-        this.next();
-    }
-    /**
-     * Compute a 'reversed' version of some state changes.
-     * Changes are reversable when they are boolean.
-     * @param changes State changes
-     * @returns Reversed state changes
-     */
-    reverseChanges(changes) {
-        return Object.entries(changes).reduce((reverseChanges, bunch) => {
-            const [changeKey, value] = bunch;
-            if (typeof value === typeof true) {
-                reverseChanges[changeKey] = !value;
-            }
-            return reverseChanges;
-        }, {});
-    }
-    /**
-     * Return all the keys in that state and in the store it's bound to, if any.
-     * @returns Set of keys
-     */
-    getAllKeys() {
-        const storeKeys = this.store ? Array.from(this.store.index.keys()) : [];
-        return new Set(Array.from(this.index.keys()).concat(storeKeys));
-    }
-    /**
-     * Emit 'change' event
-     */
-    next() {
-        this.change$.next();
-    }
-}
+import { ReplaySubject } from 'rxjs';
+import { getEntityId } from './entity.utils';
+/**
+ * This class is used to track a store's entities state
+ */
+export class EntityStateManager {
+    constructor(options = {}) {
+        /**
+         * State index
+         */
+        this.index = new Map();
+        /**
+         * Change emitter
+         */
+        this.change$ = new ReplaySubject(1);
+        this.store = options.store ? options.store : undefined;
+        this.getKey = options.getKey
+            ? options.getKey
+            : (this.store ? this.store.getKey : getEntityId);
+        this.next();
+    }
+    /**
+     * Clear state
+     */
+    clear() {
+        if (this.index.size > 0) {
+            this.index.clear();
+            this.next();
+        }
+    }
+    /**
+     * Get an entity's state
+     * @param entity Entity
+     * @returns State
+     */
+    get(entity) {
+        return (this.index.get(this.getKey(entity)) || {});
+    }
+    /**
+     * Set an entity's state
+     * @param entity Entity
+     * @param state State
+     */
+    set(entity, state) {
+        this.setMany([entity], state);
+    }
+    /**
+     * Set many entitie's state
+     * @param entitie Entities
+     * @param state State
+     */
+    setMany(entities, state) {
+        entities.forEach((entity) => {
+            this.index.set(this.getKey(entity), Object.assign({}, state));
+        });
+        this.next();
+    }
+    /**
+     * Set state of all entities that already have a state. This is not
+     * the same as setting the state of all the store's entities.
+     * @param state State
+     */
+    setAll(state) {
+        Array.from(this.index.keys()).forEach((key) => {
+            this.index.set(key, Object.assign({}, state));
+        });
+        this.next();
+    }
+    /**
+     * Update an entity's state
+     * @param entity Entity
+     * @param changes State changes
+     */
+    update(entity, changes, exclusive = false) {
+        this.updateMany([entity], changes, exclusive);
+    }
+    /**
+     * Update many entitie's state
+     * @param entitie Entities
+     * @param changes State changes
+     */
+    updateMany(entities, changes, exclusive = false) {
+        if (exclusive === true) {
+            return this.updateManyExclusive(entities, changes);
+        }
+        entities.forEach((entity) => {
+            const state = Object.assign({}, this.get(entity), changes);
+            this.index.set(this.getKey(entity), state);
+        });
+        this.next();
+    }
+    /**
+     * Reversee an entity's state
+     * @param entity Entity
+     * @param keys State keys to reverse
+     */
+    reverse(entity, keys) {
+        this.reverseMany([entity], keys);
+    }
+    /**
+     * Reverse many entitie's state
+     * @param entitie Entities
+     * @param keys State keys to reverse
+     */
+    reverseMany(entities, keys) {
+        entities.forEach((entity) => {
+            const currentState = this.get(entity);
+            const changes = keys.reduce((acc, key) => {
+                acc[key] = currentState[key] || false;
+                return acc;
+            }, {});
+            const reversedChanges = this.reverseChanges(changes);
+            const state = Object.assign({}, currentState, reversedChanges);
+            this.index.set(this.getKey(entity), state);
+        });
+        this.next();
+    }
+    /**
+     * Update state of all entities that already have a state. This is not
+     * the same as updating the state of all the store's entities.
+     * @param changes State
+     */
+    updateAll(changes) {
+        const allKeys = this.getAllKeys();
+        Array.from(allKeys).forEach((key) => {
+            const state = Object.assign({}, this.index.get(key), changes);
+            this.index.set(key, state);
+        });
+        this.next();
+    }
+    /**
+     * When some state changes are flagged as 'exclusive', reverse
+     * the state of all other entities. Changes are reversable when
+     * they are boolean.
+     * @param entitie Entities
+     * @param changes State changes
+     */
+    updateManyExclusive(entities, changes) {
+        const reverseChanges = this.reverseChanges(changes);
+        const keys = entities.map((entity) => this.getKey(entity));
+        const allKeys = new Set(keys.concat(Array.from(this.getAllKeys())));
+        allKeys.forEach((key) => {
+            const state = this.index.get(key) || {};
+            if (keys.indexOf(key) >= 0) {
+                this.index.set(key, Object.assign({}, state, changes));
+            }
+            else {
+                // Update only if the reverse changes would modify
+                // a key already present in the current state
+                const shouldUpdate = Object.keys(reverseChanges).some((changeKey) => {
+                    return state[changeKey] !== undefined &&
+                        state[changeKey] !== reverseChanges[changeKey];
+                });
+                if (shouldUpdate === true) {
+                    this.index.set(key, Object.assign({}, state, reverseChanges));
+                }
+            }
+        });
+        this.next();
+    }
+    /**
+     * Compute a 'reversed' version of some state changes.
+     * Changes are reversable when they are boolean.
+     * @param changes State changes
+     * @returns Reversed state changes
+     */
+    reverseChanges(changes) {
+        return Object.entries(changes).reduce((reverseChanges, bunch) => {
+            const [changeKey, value] = bunch;
+            if (typeof value === typeof true) {
+                reverseChanges[changeKey] = !value;
+            }
+            return reverseChanges;
+        }, {});
+    }
+    /**
+     * Return all the keys in that state and in the store it's bound to, if any.
+     * @returns Set of keys
+     */
+    getAllKeys() {
+        const storeKeys = this.store ? Array.from(this.store.index.keys()) : [];
+        return new Set(Array.from(this.index.keys()).concat(storeKeys));
+    }
+    /**
+     * Emit 'change' event
+     */
+    next() {
+        this.change$.next();
+    }
+}
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.js","sourceRoot":"","sources":["../../../../../../packages/common/src/lib/entity/shared/state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReplaySubject } from 'rxjs';\n\nimport { EntityKey, EntityState, EntityStateManagerOptions } from './entity.interfaces';\nimport { getEntityId } from './entity.utils';\nimport { EntityStore } from './store';\n\n/**\n * This class is used to track a store's entities state\n */\nexport class EntityStateManager<E extends object, S extends EntityState = EntityState> {\n\n  /**\n   * State index\n   */\n  readonly index = new Map<EntityKey, S>();\n\n  /**\n   * Change emitter\n   */\n  readonly change$ = new ReplaySubject<void>(1);\n\n  /**\n   * Method to get an entity's id\n   */\n  readonly getKey: (E) => EntityKey;\n\n  private store: EntityStore<object> | undefined;\n\n  constructor(options: EntityStateManagerOptions = {}) {\n    this.store = options.store ? options.store : undefined;\n    this.getKey = options.getKey\n      ? options.getKey\n      : (this.store ? this.store.getKey : getEntityId);\n    this.next();\n  }\n\n  /**\n   * Clear state\n   */\n  clear() {\n    if (this.index.size > 0) {\n      this.index.clear();\n      this.next();\n    }\n  }\n\n  /**\n   * Get an entity's state\n   * @param entity Entity\n   * @returns State\n   */\n  get(entity: E): S {\n    return (this.index.get(this.getKey(entity)) || {}) as S;\n  }\n\n  /**\n   * Set an entity's state\n   * @param entity Entity\n   * @param state State\n   */\n  set(entity: E, state: S) {\n    this.setMany([entity], state);\n  }\n\n  /**\n   * Set many entitie's state\n   * @param entitie Entities\n   * @param state State\n   */\n  setMany(entities: E[], state: S) {\n    entities.forEach((entity: E) => {\n      this.index.set(this.getKey(entity), Object.assign({}, state));\n    });\n    this.next();\n  }\n\n  /**\n   * Set state of all entities that already have a state. This is not\n   * the same as setting the state of all the store's entities.\n   * @param state State\n   */\n  setAll(state: S) {\n    Array.from(this.index.keys()).forEach((key: EntityKey) => {\n      this.index.set(key, Object.assign({}, state));\n    });\n    this.next();\n  }\n\n  /**\n   * Update an entity's state\n   * @param entity Entity\n   * @param changes State changes\n   */\n  update(entity: E, changes: Partial<S>, exclusive = false) {\n    this.updateMany([entity], changes, exclusive);\n  }\n\n  /**\n   * Update many entitie's state\n   * @param entitie Entities\n   * @param changes State changes\n   */\n  updateMany(entities: E[], changes: Partial<S>, exclusive = false) {\n    if (exclusive === true) {\n      return this.updateManyExclusive(entities, changes);\n    }\n\n    entities.forEach((entity: E) => {\n      const state = Object.assign({}, this.get(entity), changes);\n      this.index.set(this.getKey(entity), state);\n    });\n    this.next();\n  }\n\n  /**\n   * Reversee an entity's state\n   * @param entity Entity\n   * @param keys State keys to reverse\n   */\n  reverse(entity: E, keys: string[]) {\n    this.reverseMany([entity], keys);\n  }\n\n  /**\n   * Reverse many entitie's state\n   * @param entitie Entities\n   * @param keys State keys to reverse\n   */\n  reverseMany(entities: E[], keys: string[]) {\n    entities.forEach((entity: E) => {\n      const currentState = this.get(entity);\n      const changes = keys.reduce((acc: {[key: string]: boolean}, key: string) => {\n        acc[key] = currentState[key] || false;\n        return acc;\n      }, {}) as Partial<S>;\n      const reversedChanges = this.reverseChanges(changes);\n      const state = Object.assign({}, currentState, reversedChanges);\n      this.index.set(this.getKey(entity), state);\n    });\n    this.next();\n  }\n\n  /**\n   * Update state of all entities that already have a state. This is not\n   * the same as updating the state of all the store's entities.\n   * @param changes State\n   */\n  updateAll(changes: Partial<S>) {\n    const allKeys = this.getAllKeys();\n    Array.from(allKeys).forEach((key: EntityKey) => {\n      const state = Object.assign({}, this.index.get(key), changes);\n      this.index.set(key, state);\n    });\n    this.next();\n  }\n\n  /**\n   * When some state changes are flagged as 'exclusive', reverse\n   * the state of all other entities. Changes are reversable when\n   * they are boolean.\n   * @param entitie Entities\n   * @param changes State changes\n   */\n  private updateManyExclusive(entities: E[], changes: Partial<S>) {\n    const reverseChanges = this.reverseChanges(changes);\n\n    const keys = entities.map((entity: E) => this.getKey(entity));\n    const allKeys = new Set(keys.concat(Array.from(this.getAllKeys())));\n    allKeys.forEach((key: EntityKey) => {\n      const state = this.index.get(key) || {} as S;\n\n      if (keys.indexOf(key) >= 0) {\n        this.index.set(key, Object.assign({}, state, changes));\n      } else {\n        // Update only if the reverse changes would modify\n        // a key already present in the current state\n        const shouldUpdate = Object.keys(reverseChanges).some((changeKey: string) => {\n          return state[changeKey] !== undefined &&\n            state[changeKey] !== reverseChanges[changeKey];\n        });\n        if (shouldUpdate === true) {\n          this.index.set(key, Object.assign({}, state, reverseChanges));\n        }\n      }\n    });\n\n    this.next();\n  }\n\n  /**\n   * Compute a 'reversed' version of some state changes.\n   * Changes are reversable when they are boolean.\n   * @param changes State changes\n   * @returns Reversed state changes\n   */\n  private reverseChanges(changes: Partial<S>): Partial<S> {\n    return Object.entries(changes).reduce((reverseChanges: Partial<S>, bunch: [string, any]) => {\n      const [changeKey, value] = bunch;\n      if (typeof value === typeof true) {\n        (reverseChanges as object)[changeKey] = !value;\n      }\n      return reverseChanges;\n    }, {});\n  }\n\n  /**\n   * Return all the keys in that state and in the store it's bound to, if any.\n   * @returns Set of keys\n   */\n  private getAllKeys(): Set<EntityKey> {\n    const storeKeys = this.store ? Array.from(this.store.index.keys()) : [];\n    return new Set(Array.from(this.index.keys()).concat(storeKeys));\n  }\n\n  /**\n   * Emit 'change' event\n   */\n  private next() {\n    this.change$.next();\n  }\n\n}\n"]}