@igo2/common 1.15.3 → 16.0.0-rc.0

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';\r\nimport { debounceTime, map, skip } from 'rxjs/operators';\r\n\r\nimport { ObjectUtils, uuid } from '@igo2/utils';\r\nimport {\r\n  EntityKey,\r\n  EntityFilterClause,\r\n  EntitySortClause,\r\n  EntityJoinClause\r\n} from './entity.interfaces';\r\n\r\n/**\r\n * An entity view streams entities from an observable source. These entities\r\n * can be filtered or sorted without affecting the source. A view can also\r\n * combine data from multiple sources, joined together.\r\n */\r\nexport class EntityView<E extends object, V extends object = E> {\r\n  /**\r\n   * Observable stream of values\r\n   */\r\n  readonly values$ = new BehaviorSubject<V[]>([]);\r\n\r\n  /**\r\n   * Subscription to the source (and joined sources) values\r\n   */\r\n  private values$$: Subscription;\r\n\r\n  /**\r\n   * Whether this view has been lifted\r\n   */\r\n  private lifted = false;\r\n\r\n  /**\r\n   * Join clauses\r\n   */\r\n  private joins: EntityJoinClause[] = [];\r\n\r\n  /**\r\n   * Observable of a filter clause\r\n   */\r\n  private filter$ = new BehaviorSubject(undefined);\r\n\r\n  /**\r\n   * Observable of filter clauses\r\n   */\r\n  private filters$: BehaviorSubject<EntityFilterClause[]> = new BehaviorSubject(\r\n    []\r\n  );\r\n\r\n  /**\r\n   * Filters index\r\n   */\r\n  private filterIndex: Map<string, EntityFilterClause> = new Map();\r\n\r\n  /**\r\n   * Observable of a sort clause\r\n   */\r\n  private sort$ = new BehaviorSubject(undefined);\r\n\r\n  /**\r\n   * Method for indexing\r\n   */\r\n  get getKey(): (V) => EntityKey {\r\n    return this.getKey$.value;\r\n  }\r\n  private getKey$: BehaviorSubject<(V) => EntityKey> = new BehaviorSubject(\r\n    undefined\r\n  );\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   * Store index\r\n   */\r\n  get index(): Map<EntityKey, V> {\r\n    return this._index;\r\n  }\r\n  private _index: Map<EntityKey, V>;\r\n\r\n  constructor(private source$: BehaviorSubject<E[]>) {}\r\n\r\n  /**\r\n   * Get a value from the view by key\r\n   * @param key Key\r\n   * @returns Value\r\n   */\r\n  get(key: EntityKey): V {\r\n    if (this._index === undefined) {\r\n      throw new Error(\r\n        'This view has no index, therefore, this method is unavailable.'\r\n      );\r\n    }\r\n    return this.index.get(key);\r\n  }\r\n\r\n  /**\r\n   * Get all the values\r\n   * @returns Array of values\r\n   */\r\n  all(): V[] {\r\n    return this.values$.value;\r\n  }\r\n\r\n  /**\r\n   * Observe all the values\r\n   * @returns Observable of values\r\n   */\r\n  all$(): BehaviorSubject<V[]> {\r\n    return this.values$;\r\n  }\r\n\r\n  /**\r\n   * Get the first value that respects a criteria\r\n   * @returns A value\r\n   */\r\n  firstBy(clause: EntityFilterClause<V>): V {\r\n    return this.values$.value.find(clause);\r\n  }\r\n\r\n  /**\r\n   * Observe the first value that respects a criteria\r\n   * @returns Observable of a value\r\n   */\r\n  firstBy$(clause: EntityFilterClause<V>): Observable<V> {\r\n    return this.values$.pipe(map((values: V[]) => values.find(clause)));\r\n  }\r\n\r\n  /**\r\n   * Get all the values that respect a criteria\r\n   * @returns Array of values\r\n   */\r\n  manyBy(clause: EntityFilterClause<V>): V[] {\r\n    return this.values$.value.filter(clause);\r\n  }\r\n\r\n  /**\r\n   * Observe all the values that respect a criteria\r\n   * @returns Observable of values\r\n   */\r\n  manyBy$(clause: EntityFilterClause<V>): Observable<V[]> {\r\n    return this.values$.pipe(map((values: V[]) => values.filter(clause)));\r\n  }\r\n\r\n  /**\r\n   * Clear the filter and sort and unsubscribe from the source\r\n   */\r\n  clear() {\r\n    this.filter(undefined);\r\n    this.sort(undefined);\r\n  }\r\n\r\n  destroy() {\r\n    if (this.values$$ !== undefined) {\r\n      this.values$$.unsubscribe();\r\n    }\r\n    this.clear();\r\n  }\r\n\r\n  /**\r\n   * Create an index\r\n   * @param getKey Method to get a value's id\r\n   * @returns The view\r\n   */\r\n  createIndex(getKey: (E) => EntityKey): EntityView<E, V> {\r\n    this._index = new Map();\r\n    this.getKey$.next(getKey);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Join another source to the stream (chainable)\r\n   * @param clause Join clause\r\n   * @returns The view\r\n   */\r\n  join(clause: EntityJoinClause): EntityView<E, V> {\r\n    if (this.lifted === true) {\r\n      throw new Error(\r\n        'This view has already been lifted, therefore, no join is allowed.'\r\n      );\r\n    }\r\n    this.joins.push(clause);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Filter values (chainable)\r\n   * @param clause Filter clause\r\n   * @returns The view\r\n   */\r\n  filter(clause: EntityFilterClause<V>): EntityView<E, V> {\r\n    this.filter$.next(clause);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * @param clause Filter clause\r\n   * @returns The filter id\r\n   */\r\n  addFilter(clause: EntityFilterClause<V>): string {\r\n    const id = uuid();\r\n    this.filterIndex.set(id, clause);\r\n    this.filters$.next(Array.from(this.filterIndex.values()));\r\n    return id;\r\n  }\r\n\r\n  /**\r\n   * Remove a filter by id\r\n   * @param clause Filter clause\r\n   */\r\n  removeFilter(id: string) {\r\n    this.filterIndex.delete(id);\r\n    this.filters$.next(Array.from(this.filterIndex.values()));\r\n  }\r\n\r\n  /**\r\n   * Sort values (chainable)\r\n   * @param clauseSort clause\r\n   * @returns The view\r\n   */\r\n  sort(clause: EntitySortClause<V>): EntityView<E, V> {\r\n    this.sort$.next(clause);\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Create the final observable\r\n   * @returns Observable\r\n   */\r\n  lift() {\r\n    this.lifted = true;\r\n    const source$ =\r\n      this.joins.length > 0 ? this.liftJoinedSource() : this.liftSource();\r\n    const observables$ = [\r\n      source$,\r\n      this.filters$,\r\n      this.filter$,\r\n      this.sort$,\r\n      this.getKey$\r\n    ];\r\n\r\n    this.values$$ = combineLatest(observables$)\r\n      .pipe(skip(1), debounceTime(5))\r\n      .subscribe((bunch: any[]) => {\r\n        const [_values, filters, filter, sort, getKey] = bunch;\r\n        const values = this.processValues(_values, filters, filter, sort);\r\n        const generateIndex = getKey !== undefined;\r\n        this.setValues(values, generateIndex);\r\n      });\r\n  }\r\n\r\n  /**\r\n   * Create the source observable when no joins are defined\r\n   * @returns Observable\r\n   */\r\n  private liftSource(): Observable<V[]> {\r\n    return this.source$ as any as Observable<V[]>;\r\n  }\r\n\r\n  /**\r\n   * Create the source observable when joins are defined\r\n   * @returns Observable\r\n   */\r\n  private liftJoinedSource(): Observable<V[]> {\r\n    const sources$ = [\r\n      this.source$,\r\n      combineLatest(this.joins.map((join: EntityJoinClause) => join.source))\r\n    ];\r\n\r\n    return combineLatest(sources$).pipe(\r\n      map((bunch: [E[], any[]]) => {\r\n        const [entities, joinData] = bunch;\r\n        return entities.reduce((values: V[], entity: E) => {\r\n          const value = this.computeJoinedValue(entity, joinData);\r\n          if (value !== undefined) {\r\n            values.push(value);\r\n          }\r\n          return values;\r\n        }, []);\r\n      })\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Apply joins to a source's entity and return the final value\r\n   * @returns Final value\r\n   */\r\n  private computeJoinedValue(entity: E, joinData: any[]): V | undefined {\r\n    let value = entity as Partial<V>;\r\n    let joinIndex = 0;\r\n    while (value !== undefined && joinIndex < this.joins.length) {\r\n      value = this.joins[joinIndex].reduce(value, joinData[joinIndex]);\r\n      joinIndex += 1;\r\n    }\r\n    return value as V;\r\n  }\r\n\r\n  /**\r\n   * Filter and sort values before streaming them\r\n   * @param values Values\r\n   * @param filters Filter clauses\r\n   * @param filter Filter clause\r\n   * @param sort Sort clause\r\n   * @returns Filtered and sorted values\r\n   */\r\n  private processValues(\r\n    values: V[],\r\n    filters: EntityFilterClause[],\r\n    filter: EntityFilterClause,\r\n    sort: EntitySortClause\r\n  ): V[] {\r\n    values = values.slice(0);\r\n    values = this.filterValues(values, filters.concat([filter]));\r\n    values = this.sortValues(values, sort);\r\n    return values;\r\n  }\r\n\r\n  /**\r\n   * Filter values\r\n   * @param values Values\r\n   * @param filters Filter clauses\r\n   * @returns Filtered values\r\n   */\r\n  private filterValues(values: V[], clauses: EntityFilterClause[]): V[] {\r\n    if (clauses.length === 0) {\r\n      return values;\r\n    }\r\n\r\n    return values.filter((value: V) => {\r\n      return clauses\r\n        .filter((clause: EntityFilterClause) => clause !== undefined)\r\n        .every((clause: EntityFilterClause) => clause(value));\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Sort values\r\n   * @param values Values\r\n   * @param sort Sort clause\r\n   * @returns Sorted values\r\n   */\r\n  private sortValues(values: V[], clause: EntitySortClause): V[] {\r\n    if (clause === undefined) {\r\n      return values;\r\n    }\r\n    return values.sort((v1: V, v2: V) => {\r\n      return ObjectUtils.naturalCompare(\r\n        clause.valueAccessor(v1),\r\n        clause.valueAccessor(v2),\r\n        clause.direction,\r\n        clause.nullsFirst\r\n      );\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Set value and optionally generate an index\r\n   * @param values Values\r\n   * @param generateIndex boolean\r\n   */\r\n  private setValues(values: V[], generateIndex: boolean) {\r\n    if (generateIndex === true) {\r\n      this._index = this.generateIndex(values);\r\n    }\r\n\r\n    this.values$.next(values);\r\n\r\n    const count = values.length;\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   * Generate a complete index of all the values\r\n   * @param entities Entities\r\n   * @returns Index\r\n   */\r\n  private generateIndex(values: V[]): Map<EntityKey, V> {\r\n    const entries = values.map((value: V) => [this.getKey(value), value]);\r\n    return new Map(entries as [EntityKey, V][]);\r\n  }\r\n}\r\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';\r\n\r\nimport { Subscription } from 'rxjs';\r\nimport { skip } from 'rxjs/operators';\r\n\r\nimport { ObjectUtils } from '@igo2/utils';\r\nimport { EntityKey } from './entity.interfaces';\r\n\r\nimport { EntityStore } from './store';\r\n\r\n/**\r\n * This class is used to synchronize a component's changes\r\n * detection with an EntityStore changes. For example, it is frequent\r\n * to have a component subscribe to a store's selected entity and, at the same time,\r\n * this component provides a way to select an entity with, let's say, a click.\r\n *\r\n * This class automatically handles those case and triggers the compoent's\r\n * change detection when needed.\r\n *\r\n * Note: If the component observes the store's stateView, a workspace is\r\n * probably not required because the stateView catches any changes to the\r\n * entities and their state.\r\n */\r\nexport class EntityStoreWatcher<E extends object> {\r\n  /**\r\n   * Component change detector\r\n   */\r\n  private cdRef: ChangeDetectorRef;\r\n\r\n  /**\r\n   * Entity store\r\n   */\r\n  private store: EntityStore<E>;\r\n\r\n  /**\r\n   * Component inner state\r\n   */\r\n  private innerStateIndex = new Map<EntityKey, { [key: string]: any }>();\r\n\r\n  /**\r\n   * Subscription to the store's entities\r\n   */\r\n  private entities$$: Subscription;\r\n\r\n  /**\r\n   * Subscription to the store's state\r\n   */\r\n  private state$$: Subscription;\r\n\r\n  constructor(store?: EntityStore<E>, cdRef?: ChangeDetectorRef) {\r\n    this.setChangeDetector(cdRef);\r\n    this.setStore(store);\r\n  }\r\n\r\n  destroy() {\r\n    this.setChangeDetector(undefined);\r\n    this.setStore(undefined);\r\n  }\r\n\r\n  /**\r\n   * Bind this workspace to a store and start watching for changes\r\n   * @param store Entity store\r\n   */\r\n  setStore(store?: EntityStore<E>) {\r\n    if (store === undefined) {\r\n      this.teardownObservers();\r\n      this.innerStateIndex.clear();\r\n      this.store = undefined;\r\n      return;\r\n    }\r\n\r\n    this.setStore(undefined);\r\n    this.store = store;\r\n    this.setupObservers();\r\n    this.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * Bind this workspace to a component's change detector\r\n   * @param cdRef Change detector\r\n   */\r\n  setChangeDetector(cdRef?: ChangeDetectorRef) {\r\n    this.cdRef = cdRef;\r\n  }\r\n\r\n  /**\r\n   * Set up observers on a store's entities and their state\r\n   * @param store Entity store\r\n   */\r\n  private setupObservers() {\r\n    this.teardownObservers();\r\n\r\n    this.entities$$ = this.store.entities$.subscribe((entities: E[]) =>\r\n      this.onEntitiesChange(entities)\r\n    );\r\n\r\n    this.state$$ = this.store.state.change$\r\n      .pipe(skip(1))\r\n      .subscribe(() => this.onStateChange());\r\n  }\r\n\r\n  /**\r\n   * Teardown store observers\r\n   */\r\n  private teardownObservers() {\r\n    if (this.entities$$ !== undefined) {\r\n      this.entities$$.unsubscribe();\r\n    }\r\n    if (this.state$$ !== undefined) {\r\n      this.state$$.unsubscribe();\r\n    }\r\n    this.entities$$ = undefined;\r\n    this.state$$ = undefined;\r\n  }\r\n\r\n  /**\r\n   * When the entities change, always trigger the changes detection\r\n   */\r\n  private onEntitiesChange(entities: E[]) {\r\n    this.detectChanges();\r\n  }\r\n\r\n  /**\r\n   * When the entities state change, trigger the change detection\r\n   * only if the component has not handled these changes yet. For example,\r\n   * the component might have initiated thoses changes itself.\r\n   */\r\n  private onStateChange() {\r\n    let changesDetected = false;\r\n    const storeIndex = this.store.state.index;\r\n    const innerIndex = this.innerStateIndex;\r\n\r\n    if (storeIndex.size !== innerIndex.size) {\r\n      changesDetected = this.detectChanges();\r\n    }\r\n\r\n    const storeKeys = Array.from(storeIndex.keys());\r\n    for (const key of storeKeys) {\r\n      const storeValue = storeIndex.get(key);\r\n      const innerValue = innerIndex.get(key);\r\n      if (changesDetected === false) {\r\n        if (innerValue === undefined) {\r\n          changesDetected = this.detectChanges();\r\n        } else if (!ObjectUtils.objectsAreEquivalent(storeValue, innerValue)) {\r\n          changesDetected = this.detectChanges();\r\n        }\r\n      }\r\n\r\n      this.innerStateIndex.set(key, Object.assign({}, storeValue));\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Trigger the change detection of the workspace is bound to a change detector\r\n   */\r\n  private detectChanges() {\r\n    if (this.cdRef !== undefined) {\r\n      this.cdRef.detectChanges();\r\n    }\r\n    return true;\r\n  }\r\n}\r\n"]}