@igo2/common 1.15.3 → 16.0.0-rc.0

package/esm2022/lib/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/src/lib/entity/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/lib/entity/shared/store-strategy.mjs

@@ -0,0 +1,73 @@
+import { EntityStore } from './store';
+export class EntityStoreWithStrategy extends EntityStore {
+    /**
+     * Strategies
+     */
+    strategies = [];
+    constructor(entities, options = {}) {
+        super(entities, options);
+    }
+    /**
+     * 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();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/entity/shared/store.mjs

@@ -0,0 +1,256 @@
+import { BehaviorSubject } from 'rxjs';
+import { EntityStateManager } from './state';
+import { EntityView } from './view';
+import { getEntityId, getEntityProperty } from './entity.utils';
+/**
+ * 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;
+    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();
+    }
+    /**
+     * 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/src/lib/entity/shared/store.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject } from 'rxjs';\r\n\r\nimport { EntityStateManager } from './state';\r\nimport { EntityView } from './view';\r\nimport { EntityKey, EntityState, EntityRecord } from './entity.interfaces';\r\nimport { getEntityId, getEntityProperty } from './entity.utils';\r\n\r\nexport interface EntityStoreOptions {\r\n  getKey?: (entity: object) => EntityKey;\r\n  getProperty?: (entity: object, property: string) => any;\r\n}\r\n\r\n/**\r\n * An entity store class holds any number of entities\r\n * as well as their state. It can be observed, filtered and sorted and\r\n * provides methods to insert, update or delete entities.\r\n */\r\nexport class EntityStore<\r\n  E extends object = object,\r\n  S extends EntityState = EntityState\r\n> {\r\n  /**\r\n   * Observable of the raw entities\r\n   */\r\n  readonly entities$ = new BehaviorSubject<E[]>([]);\r\n\r\n  /**\r\n   * Number of entities\r\n   */\r\n  readonly count$ = new BehaviorSubject<number>(0);\r\n  get count(): number {\r\n    return this.count$.value;\r\n  }\r\n\r\n  /**\r\n   * Whether the store is empty\r\n   */\r\n  readonly empty$ = new BehaviorSubject<boolean>(true);\r\n  get empty(): boolean {\r\n    return this.empty$.value;\r\n  }\r\n\r\n  /**\r\n   * Entity store state\r\n   */\r\n  readonly state: EntityStateManager<E, S>;\r\n\r\n  /**\r\n   * View of all the entities\r\n   */\r\n  readonly view: EntityView<E>;\r\n\r\n  /**\r\n   * View of all the entities and their state\r\n   */\r\n  readonly stateView: EntityView<E, EntityRecord<E, S>>;\r\n\r\n  /**\r\n   * Method to get an entity's id\r\n   */\r\n  readonly getKey: (E) => EntityKey;\r\n\r\n  /**\r\n   * Method to get an entity's named property\r\n   */\r\n  readonly getProperty: (E, prop: string) => any;\r\n\r\n  /**\r\n   * Store index\r\n   */\r\n  get index(): Map<EntityKey, E> {\r\n    return this._index;\r\n  }\r\n  private _index: Map<EntityKey, E>;\r\n\r\n  /**\r\n   * Store index\r\n   */\r\n  get pristine(): boolean {\r\n    return this._pristine;\r\n  }\r\n  private _pristine: boolean = true;\r\n\r\n  constructor(entities: E[], options: EntityStoreOptions = {}) {\r\n    this.getKey = options.getKey ? options.getKey : getEntityId;\r\n    this.getProperty = options.getProperty\r\n      ? options.getProperty\r\n      : getEntityProperty;\r\n\r\n    this.state = this.createStateManager();\r\n    this.view = this.createDataView();\r\n    this.stateView = this.createStateView();\r\n\r\n    this.view.lift();\r\n    this.stateView.lift();\r\n\r\n    if (entities.length > 0) {\r\n      this.load(entities);\r\n    } else {\r\n      this._index = this.generateIndex(entities);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get an entity from the store by key\r\n   * @param key Key\r\n   * @returns Entity\r\n   */\r\n  get(key: EntityKey): E {\r\n    return this.index.get(key);\r\n  }\r\n\r\n  /**\r\n   * Get all entities in the store\r\n   * @returns Array of entities\r\n   */\r\n  all(): E[] {\r\n    return this.entities$.value;\r\n  }\r\n\r\n  /**\r\n   * Set this store's entities\r\n   * @param entities Entities\r\n   */\r\n  load(entities: E[], pristine: boolean = true) {\r\n    this._index = this.generateIndex(entities);\r\n    this._pristine = pristine;\r\n    this.next();\r\n  }\r\n\r\n  /**\r\n   * Clear the store's entities but keep the state and views intact.\r\n   * Views won't return any data but future data will be subject to the\r\n   * current views filter and sort\r\n   */\r\n  softClear() {\r\n    if (this.index && this.index.size > 0) {\r\n      this.index.clear();\r\n      this._pristine = true;\r\n      this.next();\r\n    } else if (this.index) {\r\n      this.updateCount();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clear the store's entities, state and views\r\n   */\r\n  clear() {\r\n    this.stateView.clear();\r\n    this.view.clear();\r\n    this.state.clear();\r\n    this.softClear();\r\n  }\r\n\r\n  destroy() {\r\n    this.stateView.destroy();\r\n    this.view.destroy();\r\n    this.clear();\r\n  }\r\n\r\n  /**\r\n   * Insert an entity into the store\r\n   * @param entity Entity\r\n   */\r\n  insert(entity: E) {\r\n    this.insertMany([entity]);\r\n  }\r\n\r\n  /**\r\n   * Insert many entities into the store\r\n   * @param entities Entities\r\n   */\r\n  insertMany(entities: E[]) {\r\n    entities.forEach((entity: E) =>\r\n      this.index.set(this.getKey(entity), entity)\r\n    );\r\n    this._pristine = false;\r\n    this.next();\r\n  }\r\n\r\n  /**\r\n   * Update or insert an entity into the store\r\n   * @param entity Entity\r\n   */\r\n  update(entity: E) {\r\n    this.updateMany([entity]);\r\n  }\r\n\r\n  /**\r\n   * Update or insert many entities into the store\r\n   * @param entities Entities\r\n   */\r\n  updateMany(entities: E[]) {\r\n    entities.forEach((entity: E) =>\r\n      this.index.set(this.getKey(entity), entity)\r\n    );\r\n    this._pristine = false;\r\n    this.next();\r\n  }\r\n\r\n  /**\r\n   * Delete an entity from the store\r\n   * @param entity Entity\r\n   */\r\n  delete(entity: E) {\r\n    this.deleteMany([entity]);\r\n  }\r\n\r\n  /**\r\n   * Delete many entities from the store\r\n   * @param entities Entities\r\n   */\r\n  deleteMany(entities: E[]) {\r\n    entities.forEach((entity: E) => this.index.delete(this.getKey(entity)));\r\n    this._pristine = false;\r\n    this.next();\r\n  }\r\n\r\n  /**\r\n   * Generate a complete index of all the entities\r\n   * @param entities Entities\r\n   * @returns Index\r\n   */\r\n  private generateIndex(entities: E[]): Map<EntityKey, E> {\r\n    const entries = entities.map((entity: E) => [this.getKey(entity), entity]);\r\n    return new Map(entries as [EntityKey, E][]);\r\n  }\r\n\r\n  /**\r\n   * Push the index's entities into the entities$ observable\r\n   */\r\n  private next() {\r\n    this.entities$.next(Array.from(this.index.values()));\r\n    this.updateCount();\r\n  }\r\n\r\n  /**\r\n   * Update the store's count and empty\r\n   */\r\n  private updateCount() {\r\n    const count = this.index.size;\r\n    const empty = count === 0;\r\n    this.count$.next(count);\r\n    this.empty$.next(empty);\r\n  }\r\n\r\n  /**\r\n   * Create the entity state manager\r\n   * @returns EntityStateManager\r\n   */\r\n  private createStateManager() {\r\n    return new EntityStateManager<E, S>({\r\n      getKey: this.getKey,\r\n      index: this.index\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Create the data view\r\n   * @returns EntityView<E>\r\n   */\r\n  private createDataView() {\r\n    return new EntityView<E>(this.entities$);\r\n  }\r\n\r\n  /**\r\n   * Create the state view\r\n   * @returns EntityView<EntityRecord<E>>\r\n   */\r\n  private createStateView() {\r\n    return new EntityView<E, EntityRecord<E, S>>(this.view.all$())\r\n      .join({\r\n        source: this.state.change$,\r\n        reduce: (entity: E): EntityRecord<E, S> => {\r\n          const key = this.getKey(entity);\r\n          const state = this.state.get(entity);\r\n          const currentRecord = this.stateView.get(key);\r\n\r\n          if (\r\n            currentRecord !== undefined &&\r\n            currentRecord.entity === entity &&\r\n            this.statesAreTheSame(currentRecord.state, state)\r\n          ) {\r\n            return currentRecord;\r\n          }\r\n\r\n          const revision = currentRecord ? currentRecord.revision + 1 : 1;\r\n          const ref = `${key}-${revision}`;\r\n          return { entity, state, revision, ref };\r\n        }\r\n      })\r\n      .createIndex((record: EntityRecord<E, S>) => this.getKey(record.entity));\r\n  }\r\n\r\n  private statesAreTheSame(currentState: S, newState: S): boolean {\r\n    if (currentState === newState) {\r\n      return true;\r\n    }\r\n\r\n    const currentStateIsEmpty = Object.keys(currentState).length === 0;\r\n    const newStateIsEmpty = Object.keys(newState).length === 0;\r\n    return currentStateIsEmpty && newStateIsEmpty;\r\n  }\r\n}\r\n"]}