@igo2/common 1.15.4 → 16.0.0-rc.1

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

@@ -0,0 +1,330 @@
+import { BehaviorSubject, combineLatest } from 'rxjs';
+import { debounceTime, map, skip } from 'rxjs/operators';
+import { ObjectUtils, uuid } from '@igo2/utils';
+/**
+ * An entity view streams entities from an observable source. These entities
+ * can be filtered or sorted without affecting the source. A view can also
+ * combine data from multiple sources, joined together.
+ */
+export class EntityView {
+    source$;
+    /**
+     * Observable stream of values
+     */
+    values$ = new BehaviorSubject([]);
+    /**
+     * Subscription to the source (and joined sources) values
+     */
+    values$$;
+    /**
+     * Whether this view has been lifted
+     */
+    lifted = false;
+    /**
+     * Join clauses
+     */
+    joins = [];
+    /**
+     * Observable of a filter clause
+     */
+    filter$ = new BehaviorSubject(undefined);
+    /**
+     * Observable of filter clauses
+     */
+    filters$ = new BehaviorSubject([]);
+    /**
+     * Filters index
+     */
+    filterIndex = new Map();
+    /**
+     * Observable of a sort clause
+     */
+    sort$ = new BehaviorSubject(undefined);
+    /**
+     * Method for indexing
+     */
+    get getKey() {
+        return this.getKey$.value;
+    }
+    getKey$ = new BehaviorSubject(undefined);
+    /**
+     * 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;
+    }
+    /**
+     * Store index
+     */
+    get index() {
+        return this._index;
+    }
+    _index;
+    constructor(source$) {
+        this.source$ = source$;
+    }
+    /**
+     * Get a value from the view by key
+     * @param key Key
+     * @returns Value
+     */
+    get(key) {
+        if (this._index === undefined) {
+            throw new Error('This view has no index, therefore, this method is unavailable.');
+        }
+        return this.index.get(key);
+    }
+    /**
+     * Get all the values
+     * @returns Array of values
+     */
+    all() {
+        return this.values$.value;
+    }
+    /**
+     * Observe all the values
+     * @returns Observable of values
+     */
+    all$() {
+        return this.values$;
+    }
+    /**
+     * Get the first value that respects a criteria
+     * @returns A value
+     */
+    firstBy(clause) {
+        return this.values$.value.find(clause);
+    }
+    /**
+     * Observe the first value that respects a criteria
+     * @returns Observable of a value
+     */
+    firstBy$(clause) {
+        return this.values$.pipe(map((values) => values.find(clause)));
+    }
+    /**
+     * Get all the values that respect a criteria
+     * @returns Array of values
+     */
+    manyBy(clause) {
+        return this.values$.value.filter(clause);
+    }
+    /**
+     * Observe all the values that respect a criteria
+     * @returns Observable of values
+     */
+    manyBy$(clause) {
+        return this.values$.pipe(map((values) => values.filter(clause)));
+    }
+    /**
+     * Clear the filter and sort and unsubscribe from the source
+     */
+    clear() {
+        this.filter(undefined);
+        this.sort(undefined);
+    }
+    destroy() {
+        if (this.values$$ !== undefined) {
+            this.values$$.unsubscribe();
+        }
+        this.clear();
+    }
+    /**
+     * Create an index
+     * @param getKey Method to get a value's id
+     * @returns The view
+     */
+    createIndex(getKey) {
+        this._index = new Map();
+        this.getKey$.next(getKey);
+        return this;
+    }
+    /**
+     * Join another source to the stream (chainable)
+     * @param clause Join clause
+     * @returns The view
+     */
+    join(clause) {
+        if (this.lifted === true) {
+            throw new Error('This view has already been lifted, therefore, no join is allowed.');
+        }
+        this.joins.push(clause);
+        return this;
+    }
+    /**
+     * Filter values (chainable)
+     * @param clause Filter clause
+     * @returns The view
+     */
+    filter(clause) {
+        this.filter$.next(clause);
+        return this;
+    }
+    /**
+     * @param clause Filter clause
+     * @returns The filter id
+     */
+    addFilter(clause) {
+        const id = uuid();
+        this.filterIndex.set(id, clause);
+        this.filters$.next(Array.from(this.filterIndex.values()));
+        return id;
+    }
+    /**
+     * Remove a filter by id
+     * @param clause Filter clause
+     */
+    removeFilter(id) {
+        this.filterIndex.delete(id);
+        this.filters$.next(Array.from(this.filterIndex.values()));
+    }
+    /**
+     * Sort values (chainable)
+     * @param clauseSort clause
+     * @returns The view
+     */
+    sort(clause) {
+        this.sort$.next(clause);
+        return this;
+    }
+    /**
+     * Create the final observable
+     * @returns Observable
+     */
+    lift() {
+        this.lifted = true;
+        const source$ = this.joins.length > 0 ? this.liftJoinedSource() : this.liftSource();
+        const observables$ = [
+            source$,
+            this.filters$,
+            this.filter$,
+            this.sort$,
+            this.getKey$
+        ];
+        this.values$$ = combineLatest(observables$)
+            .pipe(skip(1), debounceTime(5))
+            .subscribe((bunch) => {
+            const [_values, filters, filter, sort, getKey] = bunch;
+            const values = this.processValues(_values, filters, filter, sort);
+            const generateIndex = getKey !== undefined;
+            this.setValues(values, generateIndex);
+        });
+    }
+    /**
+     * Create the source observable when no joins are defined
+     * @returns Observable
+     */
+    liftSource() {
+        return this.source$;
+    }
+    /**
+     * Create the source observable when joins are defined
+     * @returns Observable
+     */
+    liftJoinedSource() {
+        const sources$ = [
+            this.source$,
+            combineLatest(this.joins.map((join) => join.source))
+        ];
+        return combineLatest(sources$).pipe(map((bunch) => {
+            const [entities, joinData] = bunch;
+            return entities.reduce((values, entity) => {
+                const value = this.computeJoinedValue(entity, joinData);
+                if (value !== undefined) {
+                    values.push(value);
+                }
+                return values;
+            }, []);
+        }));
+    }
+    /**
+     * Apply joins to a source's entity and return the final value
+     * @returns Final value
+     */
+    computeJoinedValue(entity, joinData) {
+        let value = entity;
+        let joinIndex = 0;
+        while (value !== undefined && joinIndex < this.joins.length) {
+            value = this.joins[joinIndex].reduce(value, joinData[joinIndex]);
+            joinIndex += 1;
+        }
+        return value;
+    }
+    /**
+     * Filter and sort values before streaming them
+     * @param values Values
+     * @param filters Filter clauses
+     * @param filter Filter clause
+     * @param sort Sort clause
+     * @returns Filtered and sorted values
+     */
+    processValues(values, filters, filter, sort) {
+        values = values.slice(0);
+        values = this.filterValues(values, filters.concat([filter]));
+        values = this.sortValues(values, sort);
+        return values;
+    }
+    /**
+     * Filter values
+     * @param values Values
+     * @param filters Filter clauses
+     * @returns Filtered values
+     */
+    filterValues(values, clauses) {
+        if (clauses.length === 0) {
+            return values;
+        }
+        return values.filter((value) => {
+            return clauses
+                .filter((clause) => clause !== undefined)
+                .every((clause) => clause(value));
+        });
+    }
+    /**
+     * Sort values
+     * @param values Values
+     * @param sort Sort clause
+     * @returns Sorted values
+     */
+    sortValues(values, clause) {
+        if (clause === undefined) {
+            return values;
+        }
+        return values.sort((v1, v2) => {
+            return ObjectUtils.naturalCompare(clause.valueAccessor(v1), clause.valueAccessor(v2), clause.direction, clause.nullsFirst);
+        });
+    }
+    /**
+     * Set value and optionally generate an index
+     * @param values Values
+     * @param generateIndex boolean
+     */
+    setValues(values, generateIndex) {
+        if (generateIndex === true) {
+            this._index = this.generateIndex(values);
+        }
+        this.values$.next(values);
+        const count = values.length;
+        const empty = count === 0;
+        this.count$.next(count);
+        this.empty$.next(empty);
+    }
+    /**
+     * Generate a complete index of all the values
+     * @param entities Entities
+     * @returns Index
+     */
+    generateIndex(values) {
+        const entries = values.map((value) => [this.getKey(value), value]);
+        return new Map(entries);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"view.js","sourceRoot":"","sources":["../../../../../../packages/common/src/lib/entity/shared/view.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable, Subscription, combineLatest } from 'rxjs';\nimport { debounceTime, map, skip } from 'rxjs/operators';\n\nimport { ObjectUtils, uuid } from '@igo2/utils';\nimport {\n  EntityKey,\n  EntityFilterClause,\n  EntitySortClause,\n  EntityJoinClause\n} from './entity.interfaces';\n\n/**\n * An entity view streams entities from an observable source. These entities\n * can be filtered or sorted without affecting the source. A view can also\n * combine data from multiple sources, joined together.\n */\nexport class EntityView<E extends object, V extends object = E> {\n  /**\n   * Observable stream of values\n   */\n  readonly values$ = new BehaviorSubject<V[]>([]);\n\n  /**\n   * Subscription to the source (and joined sources) values\n   */\n  private values$$: Subscription;\n\n  /**\n   * Whether this view has been lifted\n   */\n  private lifted = false;\n\n  /**\n   * Join clauses\n   */\n  private joins: EntityJoinClause[] = [];\n\n  /**\n   * Observable of a filter clause\n   */\n  private filter$ = new BehaviorSubject(undefined);\n\n  /**\n   * Observable of filter clauses\n   */\n  private filters$: BehaviorSubject<EntityFilterClause[]> = new BehaviorSubject(\n    []\n  );\n\n  /**\n   * Filters index\n   */\n  private filterIndex: Map<string, EntityFilterClause> = new Map();\n\n  /**\n   * Observable of a sort clause\n   */\n  private sort$ = new BehaviorSubject(undefined);\n\n  /**\n   * Method for indexing\n   */\n  get getKey(): (V) => EntityKey {\n    return this.getKey$.value;\n  }\n  private getKey$: BehaviorSubject<(V) => EntityKey> = new BehaviorSubject(\n    undefined\n  );\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   * Store index\n   */\n  get index(): Map<EntityKey, V> {\n    return this._index;\n  }\n  private _index: Map<EntityKey, V>;\n\n  constructor(private source$: BehaviorSubject<E[]>) {}\n\n  /**\n   * Get a value from the view by key\n   * @param key Key\n   * @returns Value\n   */\n  get(key: EntityKey): V {\n    if (this._index === undefined) {\n      throw new Error(\n        'This view has no index, therefore, this method is unavailable.'\n      );\n    }\n    return this.index.get(key);\n  }\n\n  /**\n   * Get all the values\n   * @returns Array of values\n   */\n  all(): V[] {\n    return this.values$.value;\n  }\n\n  /**\n   * Observe all the values\n   * @returns Observable of values\n   */\n  all$(): BehaviorSubject<V[]> {\n    return this.values$;\n  }\n\n  /**\n   * Get the first value that respects a criteria\n   * @returns A value\n   */\n  firstBy(clause: EntityFilterClause<V>): V {\n    return this.values$.value.find(clause);\n  }\n\n  /**\n   * Observe the first value that respects a criteria\n   * @returns Observable of a value\n   */\n  firstBy$(clause: EntityFilterClause<V>): Observable<V> {\n    return this.values$.pipe(map((values: V[]) => values.find(clause)));\n  }\n\n  /**\n   * Get all the values that respect a criteria\n   * @returns Array of values\n   */\n  manyBy(clause: EntityFilterClause<V>): V[] {\n    return this.values$.value.filter(clause);\n  }\n\n  /**\n   * Observe all the values that respect a criteria\n   * @returns Observable of values\n   */\n  manyBy$(clause: EntityFilterClause<V>): Observable<V[]> {\n    return this.values$.pipe(map((values: V[]) => values.filter(clause)));\n  }\n\n  /**\n   * Clear the filter and sort and unsubscribe from the source\n   */\n  clear() {\n    this.filter(undefined);\n    this.sort(undefined);\n  }\n\n  destroy() {\n    if (this.values$$ !== undefined) {\n      this.values$$.unsubscribe();\n    }\n    this.clear();\n  }\n\n  /**\n   * Create an index\n   * @param getKey Method to get a value's id\n   * @returns The view\n   */\n  createIndex(getKey: (E) => EntityKey): EntityView<E, V> {\n    this._index = new Map();\n    this.getKey$.next(getKey);\n    return this;\n  }\n\n  /**\n   * Join another source to the stream (chainable)\n   * @param clause Join clause\n   * @returns The view\n   */\n  join(clause: EntityJoinClause): EntityView<E, V> {\n    if (this.lifted === true) {\n      throw new Error(\n        'This view has already been lifted, therefore, no join is allowed.'\n      );\n    }\n    this.joins.push(clause);\n    return this;\n  }\n\n  /**\n   * Filter values (chainable)\n   * @param clause Filter clause\n   * @returns The view\n   */\n  filter(clause: EntityFilterClause<V>): EntityView<E, V> {\n    this.filter$.next(clause);\n    return this;\n  }\n\n  /**\n   * @param clause Filter clause\n   * @returns The filter id\n   */\n  addFilter(clause: EntityFilterClause<V>): string {\n    const id = uuid();\n    this.filterIndex.set(id, clause);\n    this.filters$.next(Array.from(this.filterIndex.values()));\n    return id;\n  }\n\n  /**\n   * Remove a filter by id\n   * @param clause Filter clause\n   */\n  removeFilter(id: string) {\n    this.filterIndex.delete(id);\n    this.filters$.next(Array.from(this.filterIndex.values()));\n  }\n\n  /**\n   * Sort values (chainable)\n   * @param clauseSort clause\n   * @returns The view\n   */\n  sort(clause: EntitySortClause<V>): EntityView<E, V> {\n    this.sort$.next(clause);\n    return this;\n  }\n\n  /**\n   * Create the final observable\n   * @returns Observable\n   */\n  lift() {\n    this.lifted = true;\n    const source$ =\n      this.joins.length > 0 ? this.liftJoinedSource() : this.liftSource();\n    const observables$ = [\n      source$,\n      this.filters$,\n      this.filter$,\n      this.sort$,\n      this.getKey$\n    ];\n\n    this.values$$ = combineLatest(observables$)\n      .pipe(skip(1), debounceTime(5))\n      .subscribe((bunch: any[]) => {\n        const [_values, filters, filter, sort, getKey] = bunch;\n        const values = this.processValues(_values, filters, filter, sort);\n        const generateIndex = getKey !== undefined;\n        this.setValues(values, generateIndex);\n      });\n  }\n\n  /**\n   * Create the source observable when no joins are defined\n   * @returns Observable\n   */\n  private liftSource(): Observable<V[]> {\n    return this.source$ as any as Observable<V[]>;\n  }\n\n  /**\n   * Create the source observable when joins are defined\n   * @returns Observable\n   */\n  private liftJoinedSource(): Observable<V[]> {\n    const sources$ = [\n      this.source$,\n      combineLatest(this.joins.map((join: EntityJoinClause) => join.source))\n    ];\n\n    return combineLatest(sources$).pipe(\n      map((bunch: [E[], any[]]) => {\n        const [entities, joinData] = bunch;\n        return entities.reduce((values: V[], entity: E) => {\n          const value = this.computeJoinedValue(entity, joinData);\n          if (value !== undefined) {\n            values.push(value);\n          }\n          return values;\n        }, []);\n      })\n    );\n  }\n\n  /**\n   * Apply joins to a source's entity and return the final value\n   * @returns Final value\n   */\n  private computeJoinedValue(entity: E, joinData: any[]): V | undefined {\n    let value = entity as Partial<V>;\n    let joinIndex = 0;\n    while (value !== undefined && joinIndex < this.joins.length) {\n      value = this.joins[joinIndex].reduce(value, joinData[joinIndex]);\n      joinIndex += 1;\n    }\n    return value as V;\n  }\n\n  /**\n   * Filter and sort values before streaming them\n   * @param values Values\n   * @param filters Filter clauses\n   * @param filter Filter clause\n   * @param sort Sort clause\n   * @returns Filtered and sorted values\n   */\n  private processValues(\n    values: V[],\n    filters: EntityFilterClause[],\n    filter: EntityFilterClause,\n    sort: EntitySortClause\n  ): V[] {\n    values = values.slice(0);\n    values = this.filterValues(values, filters.concat([filter]));\n    values = this.sortValues(values, sort);\n    return values;\n  }\n\n  /**\n   * Filter values\n   * @param values Values\n   * @param filters Filter clauses\n   * @returns Filtered values\n   */\n  private filterValues(values: V[], clauses: EntityFilterClause[]): V[] {\n    if (clauses.length === 0) {\n      return values;\n    }\n\n    return values.filter((value: V) => {\n      return clauses\n        .filter((clause: EntityFilterClause) => clause !== undefined)\n        .every((clause: EntityFilterClause) => clause(value));\n    });\n  }\n\n  /**\n   * Sort values\n   * @param values Values\n   * @param sort Sort clause\n   * @returns Sorted values\n   */\n  private sortValues(values: V[], clause: EntitySortClause): V[] {\n    if (clause === undefined) {\n      return values;\n    }\n    return values.sort((v1: V, v2: V) => {\n      return ObjectUtils.naturalCompare(\n        clause.valueAccessor(v1),\n        clause.valueAccessor(v2),\n        clause.direction,\n        clause.nullsFirst\n      );\n    });\n  }\n\n  /**\n   * Set value and optionally generate an index\n   * @param values Values\n   * @param generateIndex boolean\n   */\n  private setValues(values: V[], generateIndex: boolean) {\n    if (generateIndex === true) {\n      this._index = this.generateIndex(values);\n    }\n\n    this.values$.next(values);\n\n    const count = values.length;\n    const empty = count === 0;\n    this.count$.next(count);\n    this.empty$.next(empty);\n  }\n\n  /**\n   * Generate a complete index of all the values\n   * @param entities Entities\n   * @returns Index\n   */\n  private generateIndex(values: V[]): Map<EntityKey, V> {\n    const entries = values.map((value: V) => [this.getKey(value), value]);\n    return new Map(entries as [EntityKey, V][]);\n  }\n}\n"]}

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

@@ -0,0 +1,135 @@
+import { skip } from 'rxjs/operators';
+import { ObjectUtils } from '@igo2/utils';
+/**
+ * This class is used to synchronize a component's changes
+ * detection with an EntityStore changes. For example, it is frequent
+ * to have a component subscribe to a store's selected entity and, at the same time,
+ * this component provides a way to select an entity with, let's say, a click.
+ *
+ * This class automatically handles those case and triggers the compoent's
+ * change detection when needed.
+ *
+ * Note: If the component observes the store's stateView, a workspace is
+ * probably not required because the stateView catches any changes to the
+ * entities and their state.
+ */
+export class EntityStoreWatcher {
+    /**
+     * Component change detector
+     */
+    cdRef;
+    /**
+     * Entity store
+     */
+    store;
+    /**
+     * Component inner state
+     */
+    innerStateIndex = new Map();
+    /**
+     * Subscription to the store's entities
+     */
+    entities$$;
+    /**
+     * Subscription to the store's state
+     */
+    state$$;
+    constructor(store, cdRef) {
+        this.setChangeDetector(cdRef);
+        this.setStore(store);
+    }
+    destroy() {
+        this.setChangeDetector(undefined);
+        this.setStore(undefined);
+    }
+    /**
+     * Bind this workspace to a store and start watching for changes
+     * @param store Entity store
+     */
+    setStore(store) {
+        if (store === undefined) {
+            this.teardownObservers();
+            this.innerStateIndex.clear();
+            this.store = undefined;
+            return;
+        }
+        this.setStore(undefined);
+        this.store = store;
+        this.setupObservers();
+        this.detectChanges();
+    }
+    /**
+     * Bind this workspace to a component's change detector
+     * @param cdRef Change detector
+     */
+    setChangeDetector(cdRef) {
+        this.cdRef = cdRef;
+    }
+    /**
+     * Set up observers on a store's entities and their state
+     * @param store Entity store
+     */
+    setupObservers() {
+        this.teardownObservers();
+        this.entities$$ = this.store.entities$.subscribe((entities) => this.onEntitiesChange(entities));
+        this.state$$ = this.store.state.change$
+            .pipe(skip(1))
+            .subscribe(() => this.onStateChange());
+    }
+    /**
+     * Teardown store observers
+     */
+    teardownObservers() {
+        if (this.entities$$ !== undefined) {
+            this.entities$$.unsubscribe();
+        }
+        if (this.state$$ !== undefined) {
+            this.state$$.unsubscribe();
+        }
+        this.entities$$ = undefined;
+        this.state$$ = undefined;
+    }
+    /**
+     * When the entities change, always trigger the changes detection
+     */
+    onEntitiesChange(entities) {
+        this.detectChanges();
+    }
+    /**
+     * When the entities state change, trigger the change detection
+     * only if the component has not handled these changes yet. For example,
+     * the component might have initiated thoses changes itself.
+     */
+    onStateChange() {
+        let changesDetected = false;
+        const storeIndex = this.store.state.index;
+        const innerIndex = this.innerStateIndex;
+        if (storeIndex.size !== innerIndex.size) {
+            changesDetected = this.detectChanges();
+        }
+        const storeKeys = Array.from(storeIndex.keys());
+        for (const key of storeKeys) {
+            const storeValue = storeIndex.get(key);
+            const innerValue = innerIndex.get(key);
+            if (changesDetected === false) {
+                if (innerValue === undefined) {
+                    changesDetected = this.detectChanges();
+                }
+                else if (!ObjectUtils.objectsAreEquivalent(storeValue, innerValue)) {
+                    changesDetected = this.detectChanges();
+                }
+            }
+            this.innerStateIndex.set(key, Object.assign({}, storeValue));
+        }
+    }
+    /**
+     * Trigger the change detection of the workspace is bound to a change detector
+     */
+    detectChanges() {
+        if (this.cdRef !== undefined) {
+            this.cdRef.detectChanges();
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"watcher.js","sourceRoot":"","sources":["../../../../../../packages/common/src/lib/entity/shared/watcher.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef } from '@angular/core';\n\nimport { Subscription } from 'rxjs';\nimport { skip } from 'rxjs/operators';\n\nimport { ObjectUtils } from '@igo2/utils';\nimport { EntityKey } from './entity.interfaces';\n\nimport { EntityStore } from './store';\n\n/**\n * This class is used to synchronize a component's changes\n * detection with an EntityStore changes. For example, it is frequent\n * to have a component subscribe to a store's selected entity and, at the same time,\n * this component provides a way to select an entity with, let's say, a click.\n *\n * This class automatically handles those case and triggers the compoent's\n * change detection when needed.\n *\n * Note: If the component observes the store's stateView, a workspace is\n * probably not required because the stateView catches any changes to the\n * entities and their state.\n */\nexport class EntityStoreWatcher<E extends object> {\n  /**\n   * Component change detector\n   */\n  private cdRef: ChangeDetectorRef;\n\n  /**\n   * Entity store\n   */\n  private store: EntityStore<E>;\n\n  /**\n   * Component inner state\n   */\n  private innerStateIndex = new Map<EntityKey, { [key: string]: any }>();\n\n  /**\n   * Subscription to the store's entities\n   */\n  private entities$$: Subscription;\n\n  /**\n   * Subscription to the store's state\n   */\n  private state$$: Subscription;\n\n  constructor(store?: EntityStore<E>, cdRef?: ChangeDetectorRef) {\n    this.setChangeDetector(cdRef);\n    this.setStore(store);\n  }\n\n  destroy() {\n    this.setChangeDetector(undefined);\n    this.setStore(undefined);\n  }\n\n  /**\n   * Bind this workspace to a store and start watching for changes\n   * @param store Entity store\n   */\n  setStore(store?: EntityStore<E>) {\n    if (store === undefined) {\n      this.teardownObservers();\n      this.innerStateIndex.clear();\n      this.store = undefined;\n      return;\n    }\n\n    this.setStore(undefined);\n    this.store = store;\n    this.setupObservers();\n    this.detectChanges();\n  }\n\n  /**\n   * Bind this workspace to a component's change detector\n   * @param cdRef Change detector\n   */\n  setChangeDetector(cdRef?: ChangeDetectorRef) {\n    this.cdRef = cdRef;\n  }\n\n  /**\n   * Set up observers on a store's entities and their state\n   * @param store Entity store\n   */\n  private setupObservers() {\n    this.teardownObservers();\n\n    this.entities$$ = this.store.entities$.subscribe((entities: E[]) =>\n      this.onEntitiesChange(entities)\n    );\n\n    this.state$$ = this.store.state.change$\n      .pipe(skip(1))\n      .subscribe(() => this.onStateChange());\n  }\n\n  /**\n   * Teardown store observers\n   */\n  private teardownObservers() {\n    if (this.entities$$ !== undefined) {\n      this.entities$$.unsubscribe();\n    }\n    if (this.state$$ !== undefined) {\n      this.state$$.unsubscribe();\n    }\n    this.entities$$ = undefined;\n    this.state$$ = undefined;\n  }\n\n  /**\n   * When the entities change, always trigger the changes detection\n   */\n  private onEntitiesChange(entities: E[]) {\n    this.detectChanges();\n  }\n\n  /**\n   * When the entities state change, trigger the change detection\n   * only if the component has not handled these changes yet. For example,\n   * the component might have initiated thoses changes itself.\n   */\n  private onStateChange() {\n    let changesDetected = false;\n    const storeIndex = this.store.state.index;\n    const innerIndex = this.innerStateIndex;\n\n    if (storeIndex.size !== innerIndex.size) {\n      changesDetected = this.detectChanges();\n    }\n\n    const storeKeys = Array.from(storeIndex.keys());\n    for (const key of storeKeys) {\n      const storeValue = storeIndex.get(key);\n      const innerValue = innerIndex.get(key);\n      if (changesDetected === false) {\n        if (innerValue === undefined) {\n          changesDetected = this.detectChanges();\n        } else if (!ObjectUtils.objectsAreEquivalent(storeValue, innerValue)) {\n          changesDetected = this.detectChanges();\n        }\n      }\n\n      this.innerStateIndex.set(key, Object.assign({}, storeValue));\n    }\n  }\n\n  /**\n   * Trigger the change detection of the workspace is bound to a change detector\n   */\n  private detectChanges() {\n    if (this.cdRef !== undefined) {\n      this.cdRef.detectChanges();\n    }\n    return true;\n  }\n}\n"]}