@ngxs/store 3.7.3 → 3.7.4-dev.master-327646e

package/src/ivy/ivy-enabled-in-dev-mode.d.ts

@@ -1,14 +1,6 @@
-import { ReplaySubject } from 'rxjs';
-export declare const ivyEnabledInDevMode$: ReplaySubject<boolean>;
-/**
- * Ivy exposes helper functions to the global `window.ng` object.
- * Those functions are `getComponent, getContext,
- * getListeners, getViewComponent, getHostElement, getInjector,
- * getRootComponents, getDirectives, getDebugNode`
- * Previously, old view engine exposed `window.ng.coreTokens` and
- * `window.ng.probe` if an application was in development/production.
- * Ivy doesn't expose these functions in production. Developers will be able
- * to see warnings in both JIT/AOT modes, but only if an application
- * is in development.
- */
-export declare function setIvyEnabledInDevMode(): void;
+/**
+ * All provided or injected tokens must have `@Injectable` decorator
+ * (previously, injected tokens without `@Injectable` were allowed
+ * if another decorator was used, e.g. pipes).
+ */
+export declare function ensureStateClassIsInjectable(target: any): void;

package/src/module.d.ts

@@ -1,23 +1,23 @@
-import { ModuleWithProviders } from '@angular/core';
-import { StateClass } from '@ngxs/store/internals';
-import { NgxsModuleOptions } from './symbols';
-import { NgxsRootModule } from './modules/ngxs-root.module';
-import { NgxsFeatureModule } from './modules/ngxs-feature.module';
-/**
- * Ngxs Module
- */
-export declare class NgxsModule {
-    private static readonly ROOT_OPTIONS;
-    /**
-     * Root module factory
-     */
-    static forRoot(states?: StateClass[], options?: NgxsModuleOptions): ModuleWithProviders<NgxsRootModule>;
-    /**
-     * Feature module factory
-     */
-    static forFeature(states?: StateClass[]): ModuleWithProviders<NgxsFeatureModule>;
-    private static ngxsTokenProviders;
-    private static ngxsConfigFactory;
-    private static appBootstrapListenerFactory;
-    private static getInitialState;
-}
+import { ModuleWithProviders } from '@angular/core';
+import { StateClass } from '@ngxs/store/internals';
+import { NgxsModuleOptions } from './symbols';
+import { NgxsRootModule } from './modules/ngxs-root.module';
+import { NgxsFeatureModule } from './modules/ngxs-feature.module';
+/**
+ * Ngxs Module
+ */
+export declare class NgxsModule {
+    private static readonly ROOT_OPTIONS;
+    /**
+     * Root module factory
+     */
+    static forRoot(states?: StateClass[], options?: NgxsModuleOptions): ModuleWithProviders<NgxsRootModule>;
+    /**
+     * Feature module factory
+     */
+    static forFeature(states?: StateClass[]): ModuleWithProviders<NgxsFeatureModule>;
+    private static ngxsTokenProviders;
+    private static ngxsConfigFactory;
+    private static appBootstrapListenerFactory;
+    private static getInitialState;
+}

package/src/modules/ngxs-feature.module.d.ts

@@ -1,13 +1,13 @@
-import { Store } from '../store';
-import { InternalStateOperations } from '../internal/state-operations';
-import { StateFactory } from '../internal/state-factory';
-import { LifecycleStateManager } from '../internal/lifecycle-state-manager';
-import { StateClassInternal } from '../internal/internals';
-/**
- * Feature module
- * @ignore
- */
-export declare class NgxsFeatureModule {
-    constructor(_store: Store, internalStateOperations: InternalStateOperations, factory: StateFactory, states: StateClassInternal<any, any>[][] | undefined, lifecycleStateManager: LifecycleStateManager);
-    private static flattenStates;
-}
+import { Store } from '../store';
+import { InternalStateOperations } from '../internal/state-operations';
+import { StateFactory } from '../internal/state-factory';
+import { LifecycleStateManager } from '../internal/lifecycle-state-manager';
+import { StateClassInternal } from '../internal/internals';
+/**
+ * Feature module
+ * @ignore
+ */
+export declare class NgxsFeatureModule {
+    constructor(_store: Store, internalStateOperations: InternalStateOperations, factory: StateFactory, states: StateClassInternal<any, any>[][] | undefined, lifecycleStateManager: LifecycleStateManager);
+    private static flattenStates;
+}

package/src/modules/ngxs-root.module.d.ts

@@ -1,13 +1,13 @@
-import { StateFactory } from '../internal/state-factory';
-import { InternalStateOperations } from '../internal/state-operations';
-import { Store } from '../store';
-import { SelectFactory } from '../decorators/select/select-factory';
-import { StateClassInternal } from '../internal/internals';
-import { LifecycleStateManager } from '../internal/lifecycle-state-manager';
-/**
- * Root module
- * @ignore
- */
-export declare class NgxsRootModule {
-    constructor(factory: StateFactory, internalStateOperations: InternalStateOperations, _store: Store, _select: SelectFactory, states: StateClassInternal<any, any>[] | undefined, lifecycleStateManager: LifecycleStateManager);
-}
+import { Injector } from '@angular/core';
+import { StateFactory } from '../internal/state-factory';
+import { InternalStateOperations } from '../internal/state-operations';
+import { Store } from '../store';
+import { StateClassInternal } from '../internal/internals';
+import { LifecycleStateManager } from '../internal/lifecycle-state-manager';
+/**
+ * Root module
+ * @ignore
+ */
+export declare class NgxsRootModule {
+    constructor(factory: StateFactory, internalStateOperations: InternalStateOperations, _store: Store, injector: Injector, states: StateClassInternal<any, any>[] | undefined, lifecycleStateManager: LifecycleStateManager);
+}

package/src/operators/leave-ngxs.d.ts

@@ -1,7 +1,7 @@
-import { MonoTypeOperatorFunction } from 'rxjs';
-import { NgxsExecutionStrategy } from '../execution/symbols';
-/**
- * Returns operator that will run
- * `subscribe` outside of the ngxs execution context
- */
-export declare function leaveNgxs<T>(ngxsExecutionStrategy: NgxsExecutionStrategy): MonoTypeOperatorFunction<T>;
+import { MonoTypeOperatorFunction } from 'rxjs';
+import { NgxsExecutionStrategy } from '../execution/symbols';
+/**
+ * Returns operator that will run
+ * `subscribe` outside of the ngxs execution context
+ */
+export declare function leaveNgxs<T>(ngxsExecutionStrategy: NgxsExecutionStrategy): MonoTypeOperatorFunction<T>;

package/src/operators/of-action.d.ts

@@ -1,43 +1,56 @@
-import { OperatorFunction } from 'rxjs';
-import { ActionType } from '../actions/symbols';
-import { ActionContext } from '../actions-stream';
-export interface ActionCompletion<T = any, E = Error> {
-    action: T;
-    result: {
-        successful: boolean;
-        canceled: boolean;
-        error?: E;
-    };
-}
-export declare function ofAction<T = any>(allowedType: ActionType): OperatorFunction<ActionContext, T>;
-export declare function ofAction<T = any>(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, T>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been dispatched
- */
-export declare function ofActionDispatched(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, any>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been successfully completed
- */
-export declare function ofActionSuccessful(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, any>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been canceled
- */
-export declare function ofActionCanceled(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, any>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been completed
- */
-export declare function ofActionCompleted(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, ActionCompletion>;
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just thrown an error
- */
-export declare function ofActionErrored(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, any>;
+import { OperatorFunction } from 'rxjs';
+import { ActionType } from '../actions/symbols';
+import { ActionContext } from '../actions-stream';
+declare type TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>;
+/**
+ * Given a POJO, returns the POJO type, given a class constructor object, returns the type of the class.
+ *
+ * This utility type exists due to the complexity of ActionType being either an ActionDef class or the plain
+ * `{ type: string }` type (or similar compatible POJO types).
+ */
+declare type Constructed<T> = T extends new (...args: any[]) => infer U ? U : T;
+export interface ActionCompletion<T = any, E = Error> {
+    action: T;
+    result: {
+        successful: boolean;
+        canceled: boolean;
+        error?: E;
+    };
+}
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will grab actions that have just been dispatched as well as actions that have completed
+ */
+export declare function ofAction<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been dispatched
+ */
+export declare function ofActionDispatched<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been successfully completed
+ */
+export declare function ofActionSuccessful<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been canceled
+ */
+export declare function ofActionCanceled<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been completed
+ */
+export declare function ofActionCompleted<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, ActionCompletion<Constructed<T[TupleKeys<T>]>>>;
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just thrown an error
+ */
+export declare function ofActionErrored<T extends ActionType[]>(...allowedTypes: T): OperatorFunction<ActionContext<Constructed<T[TupleKeys<T>]>>, Constructed<T[TupleKeys<T>]>>;
+export {};

package/src/plugin-manager.d.ts

@@ -1,10 +1,10 @@
-import { NgxsPlugin, NgxsPluginFn } from './symbols';
-export declare class PluginManager {
-    private _parentManager;
-    private _pluginHandlers;
-    plugins: NgxsPluginFn[];
-    constructor(_parentManager: PluginManager, _pluginHandlers: NgxsPlugin[]);
-    private readonly rootPlugins;
-    private registerHandlers;
-    private getPluginHandlers;
-}
+import { NgxsPlugin, NgxsPluginFn } from './symbols';
+export declare class PluginManager {
+    private _parentManager;
+    private _pluginHandlers;
+    plugins: NgxsPluginFn[];
+    constructor(_parentManager: PluginManager, _pluginHandlers: NgxsPlugin[]);
+    private readonly rootPlugins;
+    private registerHandlers;
+    private getPluginHandlers;
+}

package/src/plugin_api.d.ts

@@ -1,5 +1,5 @@
-export { NgxsModule } from './module';
-export { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn, NgxsNextPluginFn } from './symbols';
-export { StateStream } from './internal/state-stream';
-export { getActionTypeFromInstance, setValue, getValue } from './utils/utils';
-export { InitState, UpdateState } from './actions/actions';
+export { NgxsModule } from './module';
+export { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn, NgxsNextPluginFn } from './symbols';
+export { StateStream } from './internal/state-stream';
+export { getActionTypeFromInstance, setValue, getValue } from './utils/utils';
+export { InitState, UpdateState } from './actions/actions';

package/src/public_api.d.ts

@@ -1,17 +1,17 @@
-export { NgxsModule } from './module';
-export { Action } from './decorators/action';
-export { Store } from './store';
-export { State } from './decorators/state';
-export { Select } from './decorators/select/select';
-export { SelectorOptions } from './decorators/selector-options';
-export { Actions } from './actions-stream';
-export { getSelectorMetadata, getStoreMetadata, ensureStoreMetadata, ensureSelectorMetadata } from './public_to_deprecate';
-export { ofAction, ofActionDispatched, ofActionSuccessful, ofActionCanceled, ofActionErrored, ofActionCompleted, ActionCompletion } from './operators/of-action';
-export { StateContext, StateOperator, NgxsOnInit, NgxsAfterBootstrap, NgxsOnChanges, NgxsModuleOptions, NgxsSimpleChange } from './symbols';
-export { Selector } from './decorators/selector/selector';
-export { getActionTypeFromInstance, actionMatcher } from './utils/utils';
-export { createSelector } from './utils/selector-utils';
-export { NgxsExecutionStrategy } from './execution/symbols';
-export { ActionType, ActionOptions } from './actions/symbols';
-export { NoopNgxsExecutionStrategy } from './execution/noop-ngxs-execution-strategy';
-export { StateToken } from './state-token/state-token';
+export { NgxsModule } from './module';
+export { Action } from './decorators/action';
+export { Store } from './store';
+export { State } from './decorators/state';
+export { Select } from './decorators/select/select';
+export { SelectorOptions } from './decorators/selector-options';
+export { Actions, ActionContext, ActionStatus } from './actions-stream';
+export { getSelectorMetadata, getStoreMetadata, ensureStoreMetadata, ensureSelectorMetadata } from './public_to_deprecate';
+export { ofAction, ofActionDispatched, ofActionSuccessful, ofActionCanceled, ofActionErrored, ofActionCompleted, ActionCompletion } from './operators/of-action';
+export { StateContext, StateOperator, NgxsOnInit, NgxsAfterBootstrap, NgxsOnChanges, NgxsModuleOptions, NgxsSimpleChange } from './symbols';
+export { Selector } from './decorators/selector/selector';
+export { getActionTypeFromInstance, actionMatcher } from './utils/utils';
+export { createSelector } from './utils/selector-utils';
+export { NgxsExecutionStrategy } from './execution/symbols';
+export { ActionType, ActionOptions } from './actions/symbols';
+export { NoopNgxsExecutionStrategy } from './execution/noop-ngxs-execution-strategy';
+export { StateToken } from './state-token/state-token';

package/src/public_to_deprecate.d.ts

@@ -1,21 +1,21 @@
-import { StateClassInternal, SharedSelectorOptions } from './internal/internals';
-import { PlainObjectOf } from '../internals/src/symbols';
-import { ActionHandlerMetaData } from './actions/symbols';
-interface MetaDataModel {
-    name: string | null;
-    actions: PlainObjectOf<ActionHandlerMetaData[]>;
-    defaults: any;
-    path: string | null;
-    children?: StateClassInternal[];
-}
-interface SelectorMetaDataModel {
-    originalFn: Function | null;
-    containerClass: any;
-    selectorName: string | null;
-    getSelectorOptions: () => SharedSelectorOptions;
-}
-export declare function ensureStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel;
-export declare function getStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel;
-export declare function ensureSelectorMetadata(target: Function): SelectorMetaDataModel;
-export declare function getSelectorMetadata(target: any): SelectorMetaDataModel;
-export {};
+import { StateClassInternal, SharedSelectorOptions } from './internal/internals';
+import { PlainObjectOf } from '../internals/src/symbols';
+import { ActionHandlerMetaData } from './actions/symbols';
+interface MetaDataModel {
+    name: string | null;
+    actions: PlainObjectOf<ActionHandlerMetaData[]>;
+    defaults: any;
+    path: string | null;
+    children?: StateClassInternal[];
+}
+interface SelectorMetaDataModel {
+    originalFn: Function | null;
+    containerClass: any;
+    selectorName: string | null;
+    getSelectorOptions: () => SharedSelectorOptions;
+}
+export declare function ensureStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel;
+export declare function getStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel;
+export declare function ensureSelectorMetadata(target: Function): SelectorMetaDataModel;
+export declare function getSelectorMetadata(target: any): SelectorMetaDataModel;
+export {};

package/src/state-token/state-token.d.ts

@@ -1,7 +1,7 @@
-import { TokenName } from './symbols';
-export declare class StateToken<T = void> {
-    private readonly name;
-    constructor(name: TokenName<T>);
-    getName(): string;
-    toString(): string;
-}
+import { TokenName } from './symbols';
+export declare class StateToken<T = void> {
+    private readonly name;
+    constructor(name: TokenName<T>);
+    getName(): string;
+    toString(): string;
+}

package/src/state-token/symbols.d.ts

@@ -1,5 +1,5 @@
-import { StateToken } from './state-token';
-declare type RequireGeneric<T, U> = T extends void ? 'You must provide a type parameter' : U;
-export declare type TokenName<T> = string & RequireGeneric<T, string>;
-export declare type ExtractTokenType<P> = P extends StateToken<infer T> ? T : never;
-export {};
+import { StateToken } from './state-token';
+declare type RequireGeneric<T, U> = T extends void ? 'You must provide a type parameter' : U;
+export declare type TokenName<T> = string & RequireGeneric<T, string>;
+export declare type ExtractTokenType<P> = P extends StateToken<infer T> ? T : never;
+export {};

package/src/store.d.ts

@@ -1,53 +1,59 @@
-import { Type } from '@angular/core';
-import { Observable, Subscription } from 'rxjs';
-import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
-import { InternalStateOperations } from './internal/state-operations';
-import { StateStream } from './internal/state-stream';
-import { NgxsConfig } from './symbols';
-import { StateToken } from './state-token/state-token';
-import { StateFactory } from './internal/state-factory';
-export declare class Store {
-    private _stateStream;
-    private _internalStateOperations;
-    private _config;
-    private _internalExecutionStrategy;
-    private _stateFactory;
-    constructor(_stateStream: StateStream, _internalStateOperations: InternalStateOperations, _config: NgxsConfig, _internalExecutionStrategy: InternalNgxsExecutionStrategy, _stateFactory: StateFactory, initialStateValue: any);
-    /**
-     * Dispatches event(s).
-     */
-    dispatch(actionOrActions: any | any[]): Observable<any>;
-    /**
-     * Selects a slice of data from the store.
-     */
-    select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;
-    select<T = any>(selector: string | Type<any>): Observable<T>;
-    select<T>(selector: StateToken<T>): Observable<T>;
-    /**
-     * Select one slice of data from the store.
-     */
-    selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;
-    selectOnce<T = any>(selector: string | Type<any>): Observable<T>;
-    selectOnce<T>(selector: StateToken<T>): Observable<T>;
-    /**
-     * Select a snapshot from the state.
-     */
-    selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;
-    selectSnapshot<T = any>(selector: string | Type<any>): T;
-    selectSnapshot<T>(selector: StateToken<T>): T;
-    /**
-     * Allow the user to subscribe to the root of the state
-     */
-    subscribe(fn?: (value: any) => void): Subscription;
-    /**
-     * Return the raw value of the state.
-     */
-    snapshot(): any;
-    /**
-     * Reset the state to a specific point in time. This method is useful
-     * for plugin's who need to modify the state directly or unit testing.
-     */
-    reset(state: any): any;
-    private getStoreBoundSelectorFn;
-    private initStateStream;
-}
+import { Type } from '@angular/core';
+import { Observable, Subscription } from 'rxjs';
+import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+import { InternalStateOperations } from './internal/state-operations';
+import { StateStream } from './internal/state-stream';
+import { NgxsConfig } from './symbols';
+import { StateToken } from './state-token/state-token';
+import { StateFactory } from './internal/state-factory';
+export declare class Store {
+    private _stateStream;
+    private _internalStateOperations;
+    private _config;
+    private _internalExecutionStrategy;
+    private _stateFactory;
+    /**
+     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+     */
+    private _selectableStateStream;
+    constructor(_stateStream: StateStream, _internalStateOperations: InternalStateOperations, _config: NgxsConfig, _internalExecutionStrategy: InternalNgxsExecutionStrategy, _stateFactory: StateFactory, initialStateValue: any);
+    /**
+     * Dispatches event(s).
+     */
+    dispatch(actionOrActions: any | any[]): Observable<any>;
+    /**
+     * Selects a slice of data from the store.
+     */
+    select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;
+    select<T = any>(selector: string | Type<any>): Observable<T>;
+    select<T>(selector: StateToken<T>): Observable<T>;
+    /**
+     * Select one slice of data from the store.
+     */
+    selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;
+    selectOnce<T = any>(selector: string | Type<any>): Observable<T>;
+    selectOnce<T>(selector: StateToken<T>): Observable<T>;
+    /**
+     * Select a snapshot from the state.
+     */
+    selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;
+    selectSnapshot<T = any>(selector: string | Type<any>): T;
+    selectSnapshot<T>(selector: StateToken<T>): T;
+    /**
+     * Allow the user to subscribe to the root of the state
+     */
+    subscribe(fn?: (value: any) => void): Subscription;
+    /**
+     * Return the raw value of the state.
+     */
+    snapshot(): any;
+    /**
+     * Reset the state to a specific point in time. This method is useful
+     * for plugin's who need to modify the state directly or unit testing.
+     */
+    reset(state: any): any;
+    private getStoreBoundSelectorFn;
+    private initStateStream;
+}