@igo2/common 16.3.0 → 17.0.0-next.10

package/esm2022/entity/shared/state.mjs

@@ -0,0 +1,194 @@
+import { ReplaySubject } from 'rxjs';
+import { getEntityId } from './entity.utils';
+/**
+ * This class is used to track a store's entities state
+ */
+export class EntityStateManager {
+    options;
+    /**
+     * State index
+     */
+    index = new Map();
+    /**
+     * Change emitter
+     */
+    change$ = new ReplaySubject(1);
+    /**
+     * Method to get an entity's id
+     */
+    getKey;
+    constructor(options = {}) {
+        this.options = options;
+        this.getKey = options.getKey ? options.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 = Array.from(this.options?.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/entity/src/shared/state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ReplaySubject } from 'rxjs';\n\nimport { EntityKey, EntityState } from './entity.interfaces';\nimport { getEntityId } from './entity.utils';\n\ninterface EntityStateManagerOptions<E extends object> {\n  getKey?: (entity: object) => EntityKey;\n  index?: Map<EntityKey, E>;\n}\n\n/**\n * This class is used to track a store's entities state\n */\nexport class EntityStateManager<\n  E extends object,\n  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  constructor(private options: EntityStateManagerOptions<E> = {}) {\n    this.getKey = options.getKey ? options.getKey : getEntityId;\n\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(\n        (acc: { [key: string]: boolean }, key: string) => {\n          acc[key] = currentState[key] || false;\n          return acc;\n        },\n        {}\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(\n          (changeKey: string) => {\n            return (\n              state[changeKey] !== undefined &&\n              state[changeKey] !== reverseChanges[changeKey]\n            );\n          }\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(\n      (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\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 = Array.from(this.options?.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"]}

package/esm2022/entity/shared/store.mjs

@@ -0,0 +1,322 @@
+import { BehaviorSubject } from 'rxjs';
+import { getEntityId, getEntityProperty } from './entity.utils';
+import { EntityStateManager } from './state';
+import { EntityView } from './view';
+/**
+ * An entity store class holds any number of entities
+ * as well as their state. It can be observed, filtered and sorted and
+ * provides methods to insert, update or delete entities.
+ */
+export class EntityStore {
+    /**
+     * Observable of the raw entities
+     */
+    entities$ = new BehaviorSubject([]);
+    /**
+     * Number of entities
+     */
+    count$ = new BehaviorSubject(0);
+    get count() {
+        return this.count$.value;
+    }
+    /**
+     * Whether the store is empty
+     */
+    empty$ = new BehaviorSubject(true);
+    get empty() {
+        return this.empty$.value;
+    }
+    /**
+     * Entity store state
+     */
+    state;
+    /**
+     * View of all the entities
+     */
+    view;
+    /**
+     * View of all the entities and their state
+     */
+    stateView;
+    /**
+     * Method to get an entity's id
+     */
+    getKey;
+    /**
+     * Method to get an entity's named property
+     */
+    getProperty;
+    /**
+     * Store index
+     */
+    get index() {
+        return this._index;
+    }
+    _index;
+    /**
+     * Store index
+     */
+    get pristine() {
+        return this._pristine;
+    }
+    _pristine = true;
+    /**
+     * Strategies
+     */
+    strategies = [];
+    constructor(entities, options = {}) {
+        this.getKey = options.getKey ? options.getKey : getEntityId;
+        this.getProperty = options.getProperty
+            ? options.getProperty
+            : getEntityProperty;
+        this.state = this.createStateManager();
+        this.view = this.createDataView();
+        this.stateView = this.createStateView();
+        this.view.lift();
+        this.stateView.lift();
+        if (entities.length > 0) {
+            this.load(entities);
+        }
+        else {
+            this._index = this.generateIndex(entities);
+        }
+    }
+    /**
+     * Get an entity from the store by key
+     * @param key Key
+     * @returns Entity
+     */
+    get(key) {
+        return this.index.get(key);
+    }
+    /**
+     * Get all entities in the store
+     * @returns Array of entities
+     */
+    all() {
+        return this.entities$.value;
+    }
+    /**
+     * Set this store's entities
+     * @param entities Entities
+     */
+    load(entities, pristine = true) {
+        this._index = this.generateIndex(entities);
+        this._pristine = pristine;
+        this.next();
+    }
+    /**
+     * Clear the store's entities but keep the state and views intact.
+     * Views won't return any data but future data will be subject to the
+     * current views filter and sort
+     */
+    softClear() {
+        if (this.index && this.index.size > 0) {
+            this.index.clear();
+            this._pristine = true;
+            this.next();
+        }
+        else if (this.index) {
+            this.updateCount();
+        }
+    }
+    /**
+     * Clear the store's entities, state and views
+     */
+    clear() {
+        this.stateView.clear();
+        this.view.clear();
+        this.state.clear();
+        this.softClear();
+    }
+    destroy() {
+        this.stateView.destroy();
+        this.view.destroy();
+        this.clear();
+    }
+    /**
+     * Insert an entity into the store
+     * @param entity Entity
+     */
+    insert(entity) {
+        this.insertMany([entity]);
+    }
+    /**
+     * Insert many entities into the store
+     * @param entities Entities
+     */
+    insertMany(entities) {
+        entities.forEach((entity) => this.index.set(this.getKey(entity), entity));
+        this._pristine = false;
+        this.next();
+    }
+    /**
+     * Update or insert an entity into the store
+     * @param entity Entity
+     */
+    update(entity) {
+        this.updateMany([entity]);
+    }
+    /**
+     * Update or insert many entities into the store
+     * @param entities Entities
+     */
+    updateMany(entities) {
+        entities.forEach((entity) => this.index.set(this.getKey(entity), entity));
+        this._pristine = false;
+        this.next();
+    }
+    /**
+     * Add a strategy to this store
+     * @param strategy Entity store strategy
+     * @returns Entity store
+     */
+    addStrategy(strategy, activate = false) {
+        const existingStrategy = this.strategies.find((_strategy) => {
+            return strategy.constructor === _strategy.constructor;
+        });
+        if (existingStrategy !== undefined) {
+            throw new Error('A strategy of this type already exists on that EntityStore.');
+        }
+        this.strategies.push(strategy);
+        strategy.bindStore(this);
+        if (activate === true) {
+            strategy.activate();
+        }
+        return this;
+    }
+    /**
+     * Remove a strategy from this store
+     * @param strategy Entity store strategy
+     * @returns Entity store
+     */
+    removeStrategy(strategy) {
+        const index = this.strategies.indexOf(strategy);
+        if (index >= 0) {
+            this.strategies.splice(index, 1);
+            strategy.unbindStore(this);
+        }
+        return this;
+    }
+    /**
+     * Return strategies of a given type
+     * @param type Entity store strategy class
+     * @returns Strategies
+     */
+    getStrategyOfType(type) {
+        return this.strategies.find((strategy) => {
+            return strategy instanceof type;
+        });
+    }
+    /**
+     * Activate strategies of a given type
+     * @param type Entity store strategy class
+     */
+    activateStrategyOfType(type) {
+        const strategy = this.getStrategyOfType(type);
+        if (strategy !== undefined) {
+            strategy.activate();
+        }
+    }
+    /**
+     * Deactivate strategies of a given type
+     * @param type Entity store strategy class
+     */
+    deactivateStrategyOfType(type) {
+        const strategy = this.getStrategyOfType(type);
+        if (strategy !== undefined) {
+            strategy.deactivate();
+        }
+    }
+    /**
+     * Delete an entity from the store
+     * @param entity Entity
+     */
+    delete(entity) {
+        this.deleteMany([entity]);
+    }
+    /**
+     * Delete many entities from the store
+     * @param entities Entities
+     */
+    deleteMany(entities) {
+        entities.forEach((entity) => this.index.delete(this.getKey(entity)));
+        this._pristine = false;
+        this.next();
+    }
+    /**
+     * Generate a complete index of all the entities
+     * @param entities Entities
+     * @returns Index
+     */
+    generateIndex(entities) {
+        const entries = entities.map((entity) => [this.getKey(entity), entity]);
+        return new Map(entries);
+    }
+    /**
+     * Push the index's entities into the entities$ observable
+     */
+    next() {
+        this.entities$.next(Array.from(this.index.values()));
+        this.updateCount();
+    }
+    /**
+     * Update the store's count and empty
+     */
+    updateCount() {
+        const count = this.index.size;
+        const empty = count === 0;
+        this.count$.next(count);
+        this.empty$.next(empty);
+    }
+    /**
+     * Create the entity state manager
+     * @returns EntityStateManager
+     */
+    createStateManager() {
+        return new EntityStateManager({
+            getKey: this.getKey,
+            index: this.index
+        });
+    }
+    /**
+     * Create the data view
+     * @returns EntityView<E>
+     */
+    createDataView() {
+        return new EntityView(this.entities$);
+    }
+    /**
+     * Create the state view
+     * @returns EntityView<EntityRecord<E>>
+     */
+    createStateView() {
+        return new EntityView(this.view.all$())
+            .join({
+            source: this.state.change$,
+            reduce: (entity) => {
+                const key = this.getKey(entity);
+                const state = this.state.get(entity);
+                const currentRecord = this.stateView.get(key);
+                if (currentRecord !== undefined &&
+                    currentRecord.entity === entity &&
+                    this.statesAreTheSame(currentRecord.state, state)) {
+                    return currentRecord;
+                }
+                const revision = currentRecord ? currentRecord.revision + 1 : 1;
+                const ref = `${key}-${revision}`;
+                return { entity, state, revision, ref };
+            }
+        })
+            .createIndex((record) => this.getKey(record.entity));
+    }
+    statesAreTheSame(currentState, newState) {
+        if (currentState === newState) {
+            return true;
+        }
+        const currentStateIsEmpty = Object.keys(currentState).length === 0;
+        const newStateIsEmpty = Object.keys(newState).length === 0;
+        return currentStateIsEmpty && newStateIsEmpty;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../../packages/common/entity/src/shared/store.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject } from 'rxjs';\n\nimport { EntityKey, EntityRecord, EntityState } from './entity.interfaces';\nimport { getEntityId, getEntityProperty } from './entity.utils';\nimport { EntityStateManager } from './state';\nimport type { EntityStoreStrategy } from './strategies/strategy';\nimport { EntityView } from './view';\n\nexport interface EntityStoreOptions {\n  getKey?: (entity: object) => EntityKey;\n  getProperty?: (entity: object, property: string) => any;\n}\n\n/**\n * An entity store class holds any number of entities\n * as well as their state. It can be observed, filtered and sorted and\n * provides methods to insert, update or delete entities.\n */\nexport class EntityStore<\n  E extends object = object,\n  S extends EntityState = EntityState\n> {\n  /**\n   * Observable of the raw entities\n   */\n  readonly entities$ = new BehaviorSubject<E[]>([]);\n\n  /**\n   * Number of entities\n   */\n  readonly count$ = new BehaviorSubject<number>(0);\n  get count(): number {\n    return this.count$.value;\n  }\n\n  /**\n   * Whether the store is empty\n   */\n  readonly empty$ = new BehaviorSubject<boolean>(true);\n  get empty(): boolean {\n    return this.empty$.value;\n  }\n\n  /**\n   * Entity store state\n   */\n  readonly state: EntityStateManager<E, S>;\n\n  /**\n   * View of all the entities\n   */\n  readonly view: EntityView<E>;\n\n  /**\n   * View of all the entities and their state\n   */\n  readonly stateView: EntityView<E, EntityRecord<E, S>>;\n\n  /**\n   * Method to get an entity's id\n   */\n  readonly getKey: (E) => EntityKey;\n\n  /**\n   * Method to get an entity's named property\n   */\n  readonly getProperty: (E, prop: string) => any;\n\n  /**\n   * Store index\n   */\n  get index(): Map<EntityKey, E> {\n    return this._index;\n  }\n  private _index: Map<EntityKey, E>;\n\n  /**\n   * Store index\n   */\n  get pristine(): boolean {\n    return this._pristine;\n  }\n  private _pristine: boolean = true;\n\n  /**\n   * Strategies\n   */\n  private strategies: EntityStoreStrategy[] = [];\n\n  constructor(entities: E[], options: EntityStoreOptions = {}) {\n    this.getKey = options.getKey ? options.getKey : getEntityId;\n    this.getProperty = options.getProperty\n      ? options.getProperty\n      : getEntityProperty;\n\n    this.state = this.createStateManager();\n    this.view = this.createDataView();\n    this.stateView = this.createStateView();\n\n    this.view.lift();\n    this.stateView.lift();\n\n    if (entities.length > 0) {\n      this.load(entities);\n    } else {\n      this._index = this.generateIndex(entities);\n    }\n  }\n\n  /**\n   * Get an entity from the store by key\n   * @param key Key\n   * @returns Entity\n   */\n  get(key: EntityKey): E {\n    return this.index.get(key);\n  }\n\n  /**\n   * Get all entities in the store\n   * @returns Array of entities\n   */\n  all(): E[] {\n    return this.entities$.value;\n  }\n\n  /**\n   * Set this store's entities\n   * @param entities Entities\n   */\n  load(entities: E[], pristine: boolean = true) {\n    this._index = this.generateIndex(entities);\n    this._pristine = pristine;\n    this.next();\n  }\n\n  /**\n   * Clear the store's entities but keep the state and views intact.\n   * Views won't return any data but future data will be subject to the\n   * current views filter and sort\n   */\n  softClear() {\n    if (this.index && this.index.size > 0) {\n      this.index.clear();\n      this._pristine = true;\n      this.next();\n    } else if (this.index) {\n      this.updateCount();\n    }\n  }\n\n  /**\n   * Clear the store's entities, state and views\n   */\n  clear() {\n    this.stateView.clear();\n    this.view.clear();\n    this.state.clear();\n    this.softClear();\n  }\n\n  destroy() {\n    this.stateView.destroy();\n    this.view.destroy();\n    this.clear();\n  }\n\n  /**\n   * Insert an entity into the store\n   * @param entity Entity\n   */\n  insert(entity: E) {\n    this.insertMany([entity]);\n  }\n\n  /**\n   * Insert many entities into the store\n   * @param entities Entities\n   */\n  insertMany(entities: E[]) {\n    entities.forEach((entity: E) =>\n      this.index.set(this.getKey(entity), entity)\n    );\n    this._pristine = false;\n    this.next();\n  }\n\n  /**\n   * Update or insert an entity into the store\n   * @param entity Entity\n   */\n  update(entity: E) {\n    this.updateMany([entity]);\n  }\n\n  /**\n   * Update or insert many entities into the store\n   * @param entities Entities\n   */\n  updateMany(entities: E[]) {\n    entities.forEach((entity: E) =>\n      this.index.set(this.getKey(entity), entity)\n    );\n    this._pristine = false;\n    this.next();\n  }\n\n  /**\n   * Add a strategy to this store\n   * @param strategy Entity store strategy\n   * @returns Entity store\n   */\n  addStrategy(\n    strategy: EntityStoreStrategy,\n    activate: boolean = false\n  ): EntityStore {\n    const existingStrategy = this.strategies.find(\n      (_strategy: EntityStoreStrategy) => {\n        return strategy.constructor === _strategy.constructor;\n      }\n    );\n    if (existingStrategy !== undefined) {\n      throw new Error(\n        'A strategy of this type already exists on that EntityStore.'\n      );\n    }\n\n    this.strategies.push(strategy);\n    strategy.bindStore(this);\n\n    if (activate === true) {\n      strategy.activate();\n    }\n\n    return this;\n  }\n\n  /**\n   * Remove a strategy from this store\n   * @param strategy Entity store strategy\n   * @returns Entity store\n   */\n  removeStrategy(strategy: EntityStoreStrategy): EntityStore {\n    const index = this.strategies.indexOf(strategy);\n    if (index >= 0) {\n      this.strategies.splice(index, 1);\n      strategy.unbindStore(this);\n    }\n    return this;\n  }\n\n  /**\n   * Return strategies of a given type\n   * @param type Entity store strategy class\n   * @returns Strategies\n   */\n  getStrategyOfType(type: typeof EntityStoreStrategy): EntityStoreStrategy {\n    return this.strategies.find((strategy: EntityStoreStrategy) => {\n      return strategy instanceof type;\n    });\n  }\n\n  /**\n   * Activate strategies of a given type\n   * @param type Entity store strategy class\n   */\n  activateStrategyOfType(type: typeof EntityStoreStrategy) {\n    const strategy = this.getStrategyOfType(type);\n    if (strategy !== undefined) {\n      strategy.activate();\n    }\n  }\n\n  /**\n   * Deactivate strategies of a given type\n   * @param type Entity store strategy class\n   */\n  deactivateStrategyOfType(type: typeof EntityStoreStrategy) {\n    const strategy = this.getStrategyOfType(type);\n    if (strategy !== undefined) {\n      strategy.deactivate();\n    }\n  }\n\n  /**\n   * Delete an entity from the store\n   * @param entity Entity\n   */\n  delete(entity: E) {\n    this.deleteMany([entity]);\n  }\n\n  /**\n   * Delete many entities from the store\n   * @param entities Entities\n   */\n  deleteMany(entities: E[]) {\n    entities.forEach((entity: E) => this.index.delete(this.getKey(entity)));\n    this._pristine = false;\n    this.next();\n  }\n\n  /**\n   * Generate a complete index of all the entities\n   * @param entities Entities\n   * @returns Index\n   */\n  private generateIndex(entities: E[]): Map<EntityKey, E> {\n    const entries = entities.map((entity: E) => [this.getKey(entity), entity]);\n    return new Map(entries as [EntityKey, E][]);\n  }\n\n  /**\n   * Push the index's entities into the entities$ observable\n   */\n  private next() {\n    this.entities$.next(Array.from(this.index.values()));\n    this.updateCount();\n  }\n\n  /**\n   * Update the store's count and empty\n   */\n  private updateCount() {\n    const count = this.index.size;\n    const empty = count === 0;\n    this.count$.next(count);\n    this.empty$.next(empty);\n  }\n\n  /**\n   * Create the entity state manager\n   * @returns EntityStateManager\n   */\n  private createStateManager() {\n    return new EntityStateManager<E, S>({\n      getKey: this.getKey,\n      index: this.index\n    });\n  }\n\n  /**\n   * Create the data view\n   * @returns EntityView<E>\n   */\n  private createDataView() {\n    return new EntityView<E>(this.entities$);\n  }\n\n  /**\n   * Create the state view\n   * @returns EntityView<EntityRecord<E>>\n   */\n  private createStateView() {\n    return new EntityView<E, EntityRecord<E, S>>(this.view.all$())\n      .join({\n        source: this.state.change$,\n        reduce: (entity: E): EntityRecord<E, S> => {\n          const key = this.getKey(entity);\n          const state = this.state.get(entity);\n          const currentRecord = this.stateView.get(key);\n\n          if (\n            currentRecord !== undefined &&\n            currentRecord.entity === entity &&\n            this.statesAreTheSame(currentRecord.state, state)\n          ) {\n            return currentRecord;\n          }\n\n          const revision = currentRecord ? currentRecord.revision + 1 : 1;\n          const ref = `${key}-${revision}`;\n          return { entity, state, revision, ref };\n        }\n      })\n      .createIndex((record: EntityRecord<E, S>) => this.getKey(record.entity));\n  }\n\n  private statesAreTheSame(currentState: S, newState: S): boolean {\n    if (currentState === newState) {\n      return true;\n    }\n\n    const currentStateIsEmpty = Object.keys(currentState).length === 0;\n    const newStateIsEmpty = Object.keys(newState).length === 0;\n    return currentStateIsEmpty && newStateIsEmpty;\n  }\n}\n"]}

package/esm2022/entity/shared/strategies/filter-custom-function.mjs

@@ -0,0 +1,80 @@
+import { EntityStoreStrategy } from './strategy';
+/**
+ * When active, this strategy filters a store's stateView to return
+ * selected entities only.
+ */
+export class EntityStoreFilterCustomFuncStrategy extends EntityStoreStrategy {
+    options;
+    constructor(options) {
+        super(options);
+        this.options = options;
+    }
+    /**
+     * Store / filter ids map
+     */
+    filters = new Map();
+    /**
+     * Bind this strategy to a store and start filtering it
+     * @param store Entity store
+     */
+    bindStore(store) {
+        super.bindStore(store);
+        if (this.active === true) {
+            this.filterStore(store);
+        }
+    }
+    /**
+     * Unbind this strategy from a store and stop filtering it
+     * @param store Entity store
+     */
+    unbindStore(store) {
+        super.unbindStore(store);
+        if (this.active === true) {
+            this.unfilterStore(store);
+        }
+    }
+    /**
+     * Start filtering all stores
+     * @internal
+     */
+    doActivate() {
+        this.filterAll();
+    }
+    /**
+     * Stop filtering all stores
+     * @internal
+     */
+    doDeactivate() {
+        this.unfilterAll();
+    }
+    /**
+     * Filter all stores
+     */
+    filterAll() {
+        this.stores.forEach((store) => this.filterStore(store));
+    }
+    /**
+     * Unfilter all stores
+     */
+    unfilterAll() {
+        this.stores.forEach((store) => this.unfilterStore(store));
+    }
+    /**
+     * Filter a store and add it to the filters map
+     */
+    filterStore(store) {
+        this.filters.set(store, store.stateView.addFilter(this.options.filterClauseFunc));
+    }
+    /**
+     * Unfilter a store and delete it from the filters map
+     */
+    unfilterStore(store) {
+        const filterId = this.filters.get(store);
+        if (filterId === undefined) {
+            return;
+        }
+        store.stateView.removeFilter(filterId);
+        this.filters.delete(store);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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