@igo2/common 1.14.2 → 1.14.3

package/lib/entity/shared/state.d.ts

@@ -1,103 +1,103 @@
-import { ReplaySubject } from 'rxjs';
-import { EntityKey, EntityState, EntityStateManagerOptions } from './entity.interfaces';
-/**
- * This class is used to track a store's entities state
- */
-export declare class EntityStateManager<E extends object, S extends EntityState = EntityState> {
-    /**
-     * State index
-     */
-    readonly index: Map<EntityKey, S>;
-    /**
-     * Change emitter
-     */
-    readonly change$: ReplaySubject<void>;
-    /**
-     * Method to get an entity's id
-     */
-    readonly getKey: (E: any) => EntityKey;
-    private store;
-    constructor(options?: EntityStateManagerOptions);
-    /**
-     * Clear state
-     */
-    clear(): void;
-    /**
-     * Get an entity's state
-     * @param entity Entity
-     * @returns State
-     */
-    get(entity: E): S;
-    /**
-     * Set an entity's state
-     * @param entity Entity
-     * @param state State
-     */
-    set(entity: E, state: S): void;
-    /**
-     * Set many entitie's state
-     * @param entitie Entities
-     * @param state State
-     */
-    setMany(entities: E[], state: S): void;
-    /**
-     * 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: S): void;
-    /**
-     * Update an entity's state
-     * @param entity Entity
-     * @param changes State changes
-     */
-    update(entity: E, changes: Partial<S>, exclusive?: boolean): void;
-    /**
-     * Update many entitie's state
-     * @param entitie Entities
-     * @param changes State changes
-     */
-    updateMany(entities: E[], changes: Partial<S>, exclusive?: boolean): void;
-    /**
-     * Reversee an entity's state
-     * @param entity Entity
-     * @param keys State keys to reverse
-     */
-    reverse(entity: E, keys: string[]): void;
-    /**
-     * Reverse many entitie's state
-     * @param entitie Entities
-     * @param keys State keys to reverse
-     */
-    reverseMany(entities: E[], keys: string[]): void;
-    /**
-     * 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: Partial<S>): void;
-    /**
-     * 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
-     */
-    private updateManyExclusive;
-    /**
-     * Compute a 'reversed' version of some state changes.
-     * Changes are reversable when they are boolean.
-     * @param changes State changes
-     * @returns Reversed state changes
-     */
-    private reverseChanges;
-    /**
-     * Return all the keys in that state and in the store it's bound to, if any.
-     * @returns Set of keys
-     */
-    private getAllKeys;
-    /**
-     * Emit 'change' event
-     */
-    private next;
-}
+import { ReplaySubject } from 'rxjs';
+import { EntityKey, EntityState, EntityStateManagerOptions } from './entity.interfaces';
+/**
+ * This class is used to track a store's entities state
+ */
+export declare class EntityStateManager<E extends object, S extends EntityState = EntityState> {
+    /**
+     * State index
+     */
+    readonly index: Map<EntityKey, S>;
+    /**
+     * Change emitter
+     */
+    readonly change$: ReplaySubject<void>;
+    /**
+     * Method to get an entity's id
+     */
+    readonly getKey: (E: any) => EntityKey;
+    private store;
+    constructor(options?: EntityStateManagerOptions);
+    /**
+     * Clear state
+     */
+    clear(): void;
+    /**
+     * Get an entity's state
+     * @param entity Entity
+     * @returns State
+     */
+    get(entity: E): S;
+    /**
+     * Set an entity's state
+     * @param entity Entity
+     * @param state State
+     */
+    set(entity: E, state: S): void;
+    /**
+     * Set many entitie's state
+     * @param entitie Entities
+     * @param state State
+     */
+    setMany(entities: E[], state: S): void;
+    /**
+     * 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: S): void;
+    /**
+     * Update an entity's state
+     * @param entity Entity
+     * @param changes State changes
+     */
+    update(entity: E, changes: Partial<S>, exclusive?: boolean): void;
+    /**
+     * Update many entitie's state
+     * @param entitie Entities
+     * @param changes State changes
+     */
+    updateMany(entities: E[], changes: Partial<S>, exclusive?: boolean): void;
+    /**
+     * Reversee an entity's state
+     * @param entity Entity
+     * @param keys State keys to reverse
+     */
+    reverse(entity: E, keys: string[]): void;
+    /**
+     * Reverse many entitie's state
+     * @param entitie Entities
+     * @param keys State keys to reverse
+     */
+    reverseMany(entities: E[], keys: string[]): void;
+    /**
+     * 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: Partial<S>): void;
+    /**
+     * 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
+     */
+    private updateManyExclusive;
+    /**
+     * Compute a 'reversed' version of some state changes.
+     * Changes are reversable when they are boolean.
+     * @param changes State changes
+     * @returns Reversed state changes
+     */
+    private reverseChanges;
+    /**
+     * Return all the keys in that state and in the store it's bound to, if any.
+     * @returns Set of keys
+     */
+    private getAllKeys;
+    /**
+     * Emit 'change' event
+     */
+    private next;
+}

package/lib/entity/shared/store.d.ts

@@ -1,176 +1,176 @@
-import { BehaviorSubject } from 'rxjs';
-import { EntityStateManager } from './state';
-import { EntityView } from './view';
-import { EntityKey, EntityState, EntityRecord, EntityStoreOptions } from './entity.interfaces';
-import { EntityStoreStrategy } from './strategies/strategy';
-/**
- * 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 declare class EntityStore<E extends object = object, S extends EntityState = EntityState> {
-    /**
-     * Observable of the raw entities
-     */
-    readonly entities$: BehaviorSubject<E[]>;
-    /**
-     * Number of entities
-     */
-    readonly count$: BehaviorSubject<number>;
-    get count(): number;
-    /**
-     * Whether the store is empty
-     */
-    readonly empty$: BehaviorSubject<boolean>;
-    get empty(): boolean;
-    /**
-     * Entity store state
-     */
-    readonly state: EntityStateManager<E, S>;
-    /**
-     * View of all the entities
-     */
-    readonly view: EntityView<E>;
-    /**
-     * View of all the entities and their state
-     */
-    readonly stateView: EntityView<E, EntityRecord<E, S>>;
-    /**
-     * Method to get an entity's id
-     */
-    readonly getKey: (E: any) => EntityKey;
-    /**
-     * Method to get an entity's named property
-     */
-    readonly getProperty: (E: any, prop: string) => any;
-    /**
-     * Store index
-     */
-    get index(): Map<EntityKey, E>;
-    private _index;
-    /**
-     * Store index
-     */
-    get pristine(): boolean;
-    private _pristine;
-    /**
-     * Strategies
-     */
-    private strategies;
-    constructor(entities: E[], options?: EntityStoreOptions);
-    /**
-     * Get an entity from the store by key
-     * @param key Key
-     * @returns Entity
-     */
-    get(key: EntityKey): E;
-    /**
-     * Get all entities in the store
-     * @returns Array of entities
-     */
-    all(): E[];
-    /**
-     * Set this store's entities
-     * @param entities Entities
-     */
-    load(entities: E[], pristine?: boolean): void;
-    /**
-     * 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(): void;
-    /**
-     * Clear the store's entities, state and views
-     */
-    clear(): void;
-    destroy(): void;
-    /**
-     * Insert an entity into the store
-     * @param entity Entity
-     */
-    insert(entity: E): void;
-    /**
-     * Insert many entities into the store
-     * @param entities Entities
-     */
-    insertMany(entities: E[]): void;
-    /**
-     * Update or insert an entity into the store
-     * @param entity Entity
-     */
-    update(entity: E): void;
-    /**
-     * Update or insert many entities into the store
-     * @param entities Entities
-     */
-    updateMany(entities: E[]): void;
-    /**
-     * Delete an entity from the store
-     * @param entity Entity
-     */
-    delete(entity: E): void;
-    /**
-     * Delete many entities from the store
-     * @param entities Entities
-     */
-    deleteMany(entities: E[]): void;
-    /**
-     * Add a strategy to this store
-     * @param strategy Entity store strategy
-     * @returns Entity store
-     */
-    addStrategy(strategy: EntityStoreStrategy, activate?: boolean): EntityStore;
-    /**
-     * Remove a strategy from this store
-     * @param strategy Entity store strategy
-     * @returns Entity store
-     */
-    removeStrategy(strategy: EntityStoreStrategy): EntityStore;
-    /**
-     * Return strategies of a given type
-     * @param type Entity store strategy class
-     * @returns Strategies
-     */
-    getStrategyOfType(type: typeof EntityStoreStrategy): EntityStoreStrategy;
-    /**
-     * Activate strategies of a given type
-     * @param type Entity store strategy class
-     */
-    activateStrategyOfType(type: typeof EntityStoreStrategy): void;
-    /**
-     * Deactivate strategies of a given type
-     * @param type Entity store strategy class
-     */
-    deactivateStrategyOfType(type: typeof EntityStoreStrategy): void;
-    /**
-     * Generate a complete index of all the entities
-     * @param entities Entities
-     * @returns Index
-     */
-    private generateIndex;
-    /**
-     * Push the index's entities into the entities$ observable
-     */
-    private next;
-    /**
-     * Update the store's count and empty
-     */
-    private updateCount;
-    /**
-     * Create the entity state manager
-     * @returns EntityStateManager
-     */
-    private createStateManager;
-    /**
-     * Create the data view
-     * @returns EntityView<E>
-     */
-    private createDataView;
-    /**
-     * Create the state view
-     * @returns EntityView<EntityRecord<E>>
-     */
-    private createStateView;
-    private statesAreTheSame;
-}
+import { BehaviorSubject } from 'rxjs';
+import { EntityStateManager } from './state';
+import { EntityView } from './view';
+import { EntityKey, EntityState, EntityRecord, EntityStoreOptions } from './entity.interfaces';
+import { EntityStoreStrategy } from './strategies/strategy';
+/**
+ * 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 declare class EntityStore<E extends object = object, S extends EntityState = EntityState> {
+    /**
+     * Observable of the raw entities
+     */
+    readonly entities$: BehaviorSubject<E[]>;
+    /**
+     * Number of entities
+     */
+    readonly count$: BehaviorSubject<number>;
+    get count(): number;
+    /**
+     * Whether the store is empty
+     */
+    readonly empty$: BehaviorSubject<boolean>;
+    get empty(): boolean;
+    /**
+     * Entity store state
+     */
+    readonly state: EntityStateManager<E, S>;
+    /**
+     * View of all the entities
+     */
+    readonly view: EntityView<E>;
+    /**
+     * View of all the entities and their state
+     */
+    readonly stateView: EntityView<E, EntityRecord<E, S>>;
+    /**
+     * Method to get an entity's id
+     */
+    readonly getKey: (E: any) => EntityKey;
+    /**
+     * Method to get an entity's named property
+     */
+    readonly getProperty: (E: any, prop: string) => any;
+    /**
+     * Store index
+     */
+    get index(): Map<EntityKey, E>;
+    private _index;
+    /**
+     * Store index
+     */
+    get pristine(): boolean;
+    private _pristine;
+    /**
+     * Strategies
+     */
+    private strategies;
+    constructor(entities: E[], options?: EntityStoreOptions);
+    /**
+     * Get an entity from the store by key
+     * @param key Key
+     * @returns Entity
+     */
+    get(key: EntityKey): E;
+    /**
+     * Get all entities in the store
+     * @returns Array of entities
+     */
+    all(): E[];
+    /**
+     * Set this store's entities
+     * @param entities Entities
+     */
+    load(entities: E[], pristine?: boolean): void;
+    /**
+     * 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(): void;
+    /**
+     * Clear the store's entities, state and views
+     */
+    clear(): void;
+    destroy(): void;
+    /**
+     * Insert an entity into the store
+     * @param entity Entity
+     */
+    insert(entity: E): void;
+    /**
+     * Insert many entities into the store
+     * @param entities Entities
+     */
+    insertMany(entities: E[]): void;
+    /**
+     * Update or insert an entity into the store
+     * @param entity Entity
+     */
+    update(entity: E): void;
+    /**
+     * Update or insert many entities into the store
+     * @param entities Entities
+     */
+    updateMany(entities: E[]): void;
+    /**
+     * Delete an entity from the store
+     * @param entity Entity
+     */
+    delete(entity: E): void;
+    /**
+     * Delete many entities from the store
+     * @param entities Entities
+     */
+    deleteMany(entities: E[]): void;
+    /**
+     * Add a strategy to this store
+     * @param strategy Entity store strategy
+     * @returns Entity store
+     */
+    addStrategy(strategy: EntityStoreStrategy, activate?: boolean): EntityStore;
+    /**
+     * Remove a strategy from this store
+     * @param strategy Entity store strategy
+     * @returns Entity store
+     */
+    removeStrategy(strategy: EntityStoreStrategy): EntityStore;
+    /**
+     * Return strategies of a given type
+     * @param type Entity store strategy class
+     * @returns Strategies
+     */
+    getStrategyOfType(type: typeof EntityStoreStrategy): EntityStoreStrategy;
+    /**
+     * Activate strategies of a given type
+     * @param type Entity store strategy class
+     */
+    activateStrategyOfType(type: typeof EntityStoreStrategy): void;
+    /**
+     * Deactivate strategies of a given type
+     * @param type Entity store strategy class
+     */
+    deactivateStrategyOfType(type: typeof EntityStoreStrategy): void;
+    /**
+     * Generate a complete index of all the entities
+     * @param entities Entities
+     * @returns Index
+     */
+    private generateIndex;
+    /**
+     * Push the index's entities into the entities$ observable
+     */
+    private next;
+    /**
+     * Update the store's count and empty
+     */
+    private updateCount;
+    /**
+     * Create the entity state manager
+     * @returns EntityStateManager
+     */
+    private createStateManager;
+    /**
+     * Create the data view
+     * @returns EntityView<E>
+     */
+    private createDataView;
+    /**
+     * Create the state view
+     * @returns EntityView<EntityRecord<E>>
+     */
+    private createStateView;
+    private statesAreTheSame;
+}

package/lib/entity/shared/strategies/filter-custom-function.d.ts

@@ -1,51 +1,51 @@
-import { EntityStoreStrategyFuncOptions } from '../entity.interfaces';
-import { EntityStore } from '../store';
-import { EntityStoreStrategy } from './strategy';
-/**
- * When active, this strategy filters a store's stateView to return
- * selected entities only.
- */
-export declare class EntityStoreFilterCustomFuncStrategy extends EntityStoreStrategy {
-    protected options: EntityStoreStrategyFuncOptions;
-    constructor(options: EntityStoreStrategyFuncOptions);
-    /**
-     * Store / filter ids map
-     */
-    private filters;
-    /**
-     * Bind this strategy to a store and start filtering it
-     * @param store Entity store
-     */
-    bindStore(store: EntityStore): void;
-    /**
-     * Unbind this strategy from a store and stop filtering it
-     * @param store Entity store
-     */
-    unbindStore(store: EntityStore): void;
-    /**
-     * Start filtering all stores
-     * @internal
-     */
-    protected doActivate(): void;
-    /**
-     * Stop filtering all stores
-     * @internal
-     */
-    protected doDeactivate(): void;
-    /**
-     * Filter all stores
-     */
-    private filterAll;
-    /**
-     * Unfilter all stores
-     */
-    private unfilterAll;
-    /**
-     * Filter a store and add it to the filters map
-     */
-    private filterStore;
-    /**
-     * Unfilter a store and delete it from the filters map
-     */
-    private unfilterStore;
-}
+import { EntityStoreStrategyFuncOptions } from '../entity.interfaces';
+import { EntityStore } from '../store';
+import { EntityStoreStrategy } from './strategy';
+/**
+ * When active, this strategy filters a store's stateView to return
+ * selected entities only.
+ */
+export declare class EntityStoreFilterCustomFuncStrategy extends EntityStoreStrategy {
+    protected options: EntityStoreStrategyFuncOptions;
+    constructor(options: EntityStoreStrategyFuncOptions);
+    /**
+     * Store / filter ids map
+     */
+    private filters;
+    /**
+     * Bind this strategy to a store and start filtering it
+     * @param store Entity store
+     */
+    bindStore(store: EntityStore): void;
+    /**
+     * Unbind this strategy from a store and stop filtering it
+     * @param store Entity store
+     */
+    unbindStore(store: EntityStore): void;
+    /**
+     * Start filtering all stores
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Stop filtering all stores
+     * @internal
+     */
+    protected doDeactivate(): void;
+    /**
+     * Filter all stores
+     */
+    private filterAll;
+    /**
+     * Unfilter all stores
+     */
+    private unfilterAll;
+    /**
+     * Filter a store and add it to the filters map
+     */
+    private filterStore;
+    /**
+     * Unfilter a store and delete it from the filters map
+     */
+    private unfilterStore;
+}