@igo2/common 1.15.3 → 16.0.0-rc.0

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

@@ -1,176 +1,147 @@
-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 } from './entity.interfaces';
+export interface EntityStoreOptions {
+    getKey?: (entity: object) => EntityKey;
+    getProperty?: (entity: object, property: string) => any;
+}
+/**
+ * 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;
+    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;
+    /**
+     * 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;
+}

package/lib/entity/shared/strategies/filter-selection.d.ts

@@ -1,48 +1,48 @@
-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 EntityStoreFilterSelectionStrategy extends EntityStoreStrategy {
-    /**
-     * 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 { EntityStore } from '../store';
+import { EntityStoreStrategy } from './strategy';
+/**
+ * When active, this strategy filters a store's stateView to return
+ * selected entities only.
+ */
+export declare class EntityStoreFilterSelectionStrategy extends EntityStoreStrategy {
+    /**
+     * 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;
+}

package/lib/entity/shared/strategies/index.d.ts

@@ -1,3 +1,3 @@
-export * from './strategy';
-export * from './filter-custom-function';
-export * from './filter-selection';
+export * from './strategy';
+export * from './filter-custom-function';
+export * from './filter-selection';

package/lib/entity/shared/strategies/strategy.d.ts

@@ -1,56 +1,56 @@
-import { BehaviorSubject } from 'rxjs';
-import { EntityStoreStrategyOptions } from '../entity.interfaces';
-import { EntityStore } from '../store';
-/**
- * Entity store strategies. They can do pretty much anything during a store's
- * lifetime. For example, they may act as triggers when something happens.
- * Sharing a strategy is a good idea when multiple strategies would have
- * on cancelling effect on each other.
- *
- * At creation, strategy is inactive and needs to be manually activated.
- */
-export declare class EntityStoreStrategy {
-    protected options: EntityStoreStrategyOptions;
-    /**
-     * Feature store
-     * @internal
-     */
-    protected stores: EntityStore[];
-    /**
-     * Whether this strategy is active
-     * @internal
-     */
-    get active(): boolean;
-    readonly active$: BehaviorSubject<boolean>;
-    constructor(options?: EntityStoreStrategyOptions);
-    /**
-     * Activate the strategy. If it's already active, it'll be deactivated
-     * and activated again.
-     */
-    activate(): void;
-    /**
-     * Activate the strategy. If it's already active, it'll be deactivated
-     * and activated again.
-     */
-    deactivate(): void;
-    /**
-     * Bind this strategy to a store
-     * @param store Feature store
-     */
-    bindStore(store: EntityStore): void;
-    /**
-     * Unbind this strategy from store
-     * @param store Feature store
-     */
-    unbindStore(store: EntityStore): void;
-    /**
-     * Do the stataegy activation
-     * @internal
-     */
-    protected doActivate(): void;
-    /**
-     * Do the strategy deactivation
-     * @internal
-     */
-    protected doDeactivate(): void;
-}
+import { BehaviorSubject } from 'rxjs';
+import { EntityStoreStrategyOptions } from '../entity.interfaces';
+import { EntityStore } from '../store';
+/**
+ * Entity store strategies. They can do pretty much anything during a store's
+ * lifetime. For example, they may act as triggers when something happens.
+ * Sharing a strategy is a good idea when multiple strategies would have
+ * on cancelling effect on each other.
+ *
+ * At creation, strategy is inactive and needs to be manually activated.
+ */
+export declare class EntityStoreStrategy {
+    protected options: EntityStoreStrategyOptions;
+    /**
+     * Feature store
+     * @internal
+     */
+    protected stores: EntityStore[];
+    /**
+     * Whether this strategy is active
+     * @internal
+     */
+    get active(): boolean;
+    readonly active$: BehaviorSubject<boolean>;
+    constructor(options?: EntityStoreStrategyOptions);
+    /**
+     * Activate the strategy. If it's already active, it'll be deactivated
+     * and activated again.
+     */
+    activate(): void;
+    /**
+     * Activate the strategy. If it's already active, it'll be deactivated
+     * and activated again.
+     */
+    deactivate(): void;
+    /**
+     * Bind this strategy to a store
+     * @param store Feature store
+     */
+    bindStore(store: EntityStore): void;
+    /**
+     * Unbind this strategy from store
+     * @param store Feature store
+     */
+    unbindStore(store: EntityStore): void;
+    /**
+     * Do the stataegy activation
+     * @internal
+     */
+    protected doActivate(): void;
+    /**
+     * Do the strategy deactivation
+     * @internal
+     */
+    protected doDeactivate(): void;
+}