@ngxs/store 3.7.2-dev.master-bfe989b → 3.7.2

package/src/internal/internals.d.ts

@@ -1,166 +1,167 @@
-import { PlainObjectOf, StateClass } from '@ngxs/store/internals';
-import { Observable } from 'rxjs';
-import { META_KEY, META_OPTIONS_KEY, NgxsConfig, NgxsSimpleChange, StoreOptions } from '../symbols';
-import { ActionHandlerMetaData } from '../actions/symbols';
-export interface StateClassInternal<T = any, U = any> extends StateClass<T> {
-    [META_KEY]?: MetaDataModel;
-    [META_OPTIONS_KEY]?: StoreOptions<U>;
-}
-export declare type StateKeyGraph = PlainObjectOf<string[]>;
-export declare type StatesByName = PlainObjectOf<StateClassInternal>;
-export interface StateOperations<T> {
-    getState(): T;
-    setState(val: T): T;
-    dispatch(actionOrActions: any | any[]): Observable<void>;
-}
-export interface MetaDataModel {
-    name: string | null;
-    actions: PlainObjectOf<ActionHandlerMetaData[]>;
-    defaults: any;
-    path: string | null;
-    makeRootSelector: SelectorFactory | null;
-    children?: StateClassInternal[];
-}
-export interface RuntimeSelectorContext {
-    getStateGetter(key: any): (state: any) => any;
-    getSelectorOptions(localOptions?: SharedSelectorOptions): SharedSelectorOptions;
-}
-export declare type SelectFromRootState = (rootState: any) => any;
-export declare type SelectorFactory = (runtimeContext: RuntimeSelectorContext) => SelectFromRootState;
-export interface SharedSelectorOptions {
-    injectContainerState?: boolean;
-    suppressErrors?: boolean;
-}
-export interface SelectorMetaDataModel {
-    makeRootSelector: SelectorFactory | null;
-    originalFn: Function | null;
-    containerClass: any;
-    selectorName: string | null;
-    getSelectorOptions: () => SharedSelectorOptions;
-}
-export interface MappedStore {
-    name: string;
-    isInitialised: boolean;
-    actions: PlainObjectOf<ActionHandlerMetaData[]>;
-    defaults: any;
-    instance: any;
-    path: string;
-}
-export interface StatesAndDefaults {
-    defaults: any;
-    states: MappedStore[];
-}
-export interface RootStateDiff<T> {
-    currentAppState: T;
-    newAppState: T;
-}
-/**
- * Ensures metadata is attached to the class and returns it.
- *
- * @ignore
- */
-export declare function ensureStoreMetadata(target: StateClassInternal): MetaDataModel;
-/**
- * Get the metadata attached to the state class if it exists.
- *
- * @ignore
- */
-export declare function getStoreMetadata(target: StateClassInternal): MetaDataModel;
-/**
- * Ensures metadata is attached to the selector and returns it.
- *
- * @ignore
- */
-export declare function ensureSelectorMetadata(target: Function): SelectorMetaDataModel;
-/**
- * Get the metadata attached to the selector if it exists.
- *
- * @ignore
- */
-export declare function getSelectorMetadata(target: any): SelectorMetaDataModel;
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- */
-export declare function propGetter(paths: string[], config: NgxsConfig): (x: any) => any;
-/**
- * Given an array of states, it will return a object graph. Example:
- *    const states = [
- *      Cart,
- *      CartSaved,
- *      CartSavedItems
- *    ]
- *
- * would return:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * @ignore
- */
-export declare function buildGraph(stateClasses: StateClassInternal[]): StateKeyGraph;
-/**
- * Given a states array, returns object graph
- * returning the name and state metadata. Example:
- *
- *  const graph = {
- *    cart: { metadata }
- *  };
- *
- * @ignore
- */
-export declare function nameToState(states: StateClassInternal[]): PlainObjectOf<StateClassInternal>;
-/**
- * Given a object relationship graph will return the full path
- * for the child items. Example:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * would return:
- *
- *  const r = {
- *    cart: 'cart',
- *    saved: 'cart.saved',
- *    items: 'cart.saved.items'
- *  };
- *
- * @ignore
- */
-export declare function findFullParentPath(obj: StateKeyGraph, newObj?: PlainObjectOf<string>): PlainObjectOf<string>;
-/**
- * Given a object graph, it will return the items topologically sorted Example:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
- *
- * would return:
- *
- *  const results = [
- *    'items',
- *    'saved',
- *    'cart'
- *  ];
- *
- * @ignore
- */
-export declare function topologicalSort(graph: StateKeyGraph): string[];
-/**
- * Returns if the parameter is a object or not.
- *
- * @ignore
- */
-export declare function isObject(obj: any): boolean;
-export declare function getStateDiffChanges<T>(mappedStore: MappedStore, diff: RootStateDiff<T>): NgxsSimpleChange;
+import { PlainObjectOf, StateClass } from '@ngxs/store/internals';
+import { Observable } from 'rxjs';
+import { META_KEY, META_OPTIONS_KEY, NgxsConfig, NgxsSimpleChange, StoreOptions } from '../symbols';
+import { ActionHandlerMetaData } from '../actions/symbols';
+export interface StateClassInternal<T = any, U = any> extends StateClass<T> {
+    [META_KEY]?: MetaDataModel;
+    [META_OPTIONS_KEY]?: StoreOptions<U>;
+}
+export declare type StateKeyGraph = PlainObjectOf<string[]>;
+export declare type StatesByName = PlainObjectOf<StateClassInternal>;
+export interface StateOperations<T> {
+    getState(): T;
+    setState(val: T): T;
+    dispatch(actionOrActions: any | any[]): Observable<void>;
+}
+export interface MetaDataModel {
+    name: string | null;
+    actions: PlainObjectOf<ActionHandlerMetaData[]>;
+    defaults: any;
+    path: string | null;
+    makeRootSelector: SelectorFactory | null;
+    children?: StateClassInternal[];
+}
+export interface RuntimeSelectorContext {
+    getStateGetter(key: any): (state: any) => any;
+    getSelectorOptions(localOptions?: SharedSelectorOptions): SharedSelectorOptions;
+}
+export declare type SelectFromRootState = (rootState: any) => any;
+export declare type SelectorFactory = (runtimeContext: RuntimeSelectorContext) => SelectFromRootState;
+export interface SharedSelectorOptions {
+    injectContainerState?: boolean;
+    suppressErrors?: boolean;
+}
+export interface SelectorMetaDataModel {
+    makeRootSelector: SelectorFactory | null;
+    originalFn: Function | null;
+    containerClass: any;
+    selectorName: string | null;
+    getSelectorOptions: () => SharedSelectorOptions;
+}
+export interface MappedStore {
+    name: string;
+    isInitialised: boolean;
+    actions: PlainObjectOf<ActionHandlerMetaData[]>;
+    defaults: any;
+    instance: any;
+    path: string;
+}
+export interface StatesAndDefaults {
+    defaults: any;
+    states: MappedStore[];
+}
+export declare type Callback<T = any, V = any> = (...args: V[]) => T;
+export interface RootStateDiff<T> {
+    currentAppState: T;
+    newAppState: T;
+}
+/**
+ * Ensures metadata is attached to the class and returns it.
+ *
+ * @ignore
+ */
+export declare function ensureStoreMetadata(target: StateClassInternal): MetaDataModel;
+/**
+ * Get the metadata attached to the state class if it exists.
+ *
+ * @ignore
+ */
+export declare function getStoreMetadata(target: StateClassInternal): MetaDataModel;
+/**
+ * Ensures metadata is attached to the selector and returns it.
+ *
+ * @ignore
+ */
+export declare function ensureSelectorMetadata(target: Function): SelectorMetaDataModel;
+/**
+ * Get the metadata attached to the selector if it exists.
+ *
+ * @ignore
+ */
+export declare function getSelectorMetadata(target: any): SelectorMetaDataModel;
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * @ignore
+ */
+export declare function propGetter(paths: string[], config: NgxsConfig): (x: any) => any;
+/**
+ * Given an array of states, it will return a object graph. Example:
+ *    const states = [
+ *      Cart,
+ *      CartSaved,
+ *      CartSavedItems
+ *    ]
+ *
+ * would return:
+ *
+ *  const graph = {
+ *    cart: ['saved'],
+ *    saved: ['items'],
+ *    items: []
+ *  };
+ *
+ * @ignore
+ */
+export declare function buildGraph(stateClasses: StateClassInternal[]): StateKeyGraph;
+/**
+ * Given a states array, returns object graph
+ * returning the name and state metadata. Example:
+ *
+ *  const graph = {
+ *    cart: { metadata }
+ *  };
+ *
+ * @ignore
+ */
+export declare function nameToState(states: StateClassInternal[]): PlainObjectOf<StateClassInternal>;
+/**
+ * Given a object relationship graph will return the full path
+ * for the child items. Example:
+ *
+ *  const graph = {
+ *    cart: ['saved'],
+ *    saved: ['items'],
+ *    items: []
+ *  };
+ *
+ * would return:
+ *
+ *  const r = {
+ *    cart: 'cart',
+ *    saved: 'cart.saved',
+ *    items: 'cart.saved.items'
+ *  };
+ *
+ * @ignore
+ */
+export declare function findFullParentPath(obj: StateKeyGraph, newObj?: PlainObjectOf<string>): PlainObjectOf<string>;
+/**
+ * Given a object graph, it will return the items topologically sorted Example:
+ *
+ *  const graph = {
+ *    cart: ['saved'],
+ *    saved: ['items'],
+ *    items: []
+ *  };
+ *
+ * would return:
+ *
+ *  const results = [
+ *    'items',
+ *    'saved',
+ *    'cart'
+ *  ];
+ *
+ * @ignore
+ */
+export declare function topologicalSort(graph: StateKeyGraph): string[];
+/**
+ * Returns if the parameter is a object or not.
+ *
+ * @ignore
+ */
+export declare function isObject(obj: any): boolean;
+export declare function getStateDiffChanges<T>(mappedStore: MappedStore, diff: RootStateDiff<T>): NgxsSimpleChange;

package/src/internal/lifecycle-state-manager.d.ts

@@ -1,20 +1,20 @@
-import { NgxsBootstrapper } from '@ngxs/store/internals';
-import { StateContextFactory } from './state-context-factory';
-import { InternalStateOperations } from './state-operations';
-import { MappedStore, StatesAndDefaults } from './internals';
-export declare class LifecycleStateManager {
-    private internalStateOperations;
-    private stateContextFactory;
-    private bootstrapper;
-    constructor(internalStateOperations: InternalStateOperations, stateContextFactory: StateContextFactory, bootstrapper: NgxsBootstrapper);
-    ngxsBootstrap<T>(action: T, results: StatesAndDefaults | undefined): void;
-    /**
-     * Invoke the init function on the states.
-     */
-    invokeInit(mappedStores: MappedStore[]): void;
-    /**
-     * Invoke the bootstrap function on the states.
-     */
-    invokeBootstrap(mappedStores: MappedStore[]): void;
-    private getStateContext;
-}
+import { NgxsBootstrapper } from '@ngxs/store/internals';
+import { StateContextFactory } from './state-context-factory';
+import { InternalStateOperations } from './state-operations';
+import { MappedStore, StatesAndDefaults } from './internals';
+export declare class LifecycleStateManager {
+    private internalStateOperations;
+    private stateContextFactory;
+    private bootstrapper;
+    constructor(internalStateOperations: InternalStateOperations, stateContextFactory: StateContextFactory, bootstrapper: NgxsBootstrapper);
+    ngxsBootstrap<T>(action: T, results: StatesAndDefaults | undefined): void;
+    /**
+     * Invoke the init function on the states.
+     */
+    invokeInit(mappedStores: MappedStore[]): void;
+    /**
+     * Invoke the bootstrap function on the states.
+     */
+    invokeBootstrap(mappedStores: MappedStore[]): void;
+    private getStateContext;
+}

package/src/internal/state-context-factory.d.ts

@@ -1,15 +1,15 @@
-import { StateContext } from '../symbols';
-import { MappedStore } from '../internal/internals';
-import { InternalStateOperations } from '../internal/state-operations';
-/**
- * State Context factory class
- * @ignore
- */
-export declare class StateContextFactory {
-    private _internalStateOperations;
-    constructor(_internalStateOperations: InternalStateOperations);
-    /**
-     * Create the state context
-     */
-    createStateContext<T>(mappedStore: MappedStore): StateContext<T>;
-}
+import { StateContext } from '../symbols';
+import { MappedStore } from '../internal/internals';
+import { InternalStateOperations } from '../internal/state-operations';
+/**
+ * State Context factory class
+ * @ignore
+ */
+export declare class StateContextFactory {
+    private _internalStateOperations;
+    constructor(_internalStateOperations: InternalStateOperations);
+    /**
+     * Create the state context
+     */
+    createStateContext<T>(mappedStore: MappedStore): StateContext<T>;
+}

package/src/internal/state-factory.d.ts

@@ -1,57 +1,58 @@
-import { Injector, OnDestroy } from '@angular/core';
-import { Observable } from 'rxjs';
-import { NgxsConfig } from '../symbols';
-import { MappedStore, StateClassInternal, StatesAndDefaults, StatesByName, RuntimeSelectorContext } from './internals';
-import { ActionContext, InternalActions } from '../actions-stream';
-import { InternalDispatchedActionResults } from '../internal/dispatcher';
-import { StateContextFactory } from '../internal/state-context-factory';
-/**
- * State factory class
- * @ignore
- */
-export declare class StateFactory implements OnDestroy {
-    private _injector;
-    private _config;
-    private _parentFactory;
-    private _actions;
-    private _actionResults;
-    private _stateContextFactory;
-    private _initialState;
-    private _actionsSubscription;
-    constructor(_injector: Injector, _config: NgxsConfig, _parentFactory: StateFactory, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _stateContextFactory: StateContextFactory, _initialState: any);
-    private _states;
-    readonly states: MappedStore[];
-    private _statesByName;
-    readonly statesByName: StatesByName;
-    private _statePaths;
-    private readonly statePaths;
-    getRuntimeSelectorContext: () => RuntimeSelectorContext;
-    private static cloneDefaults;
-    ngOnDestroy(): void;
-    /**
-     * Add a new state to the global defs.
-     */
-    add(stateClasses: StateClassInternal[]): MappedStore[];
-    /**
-     * Add a set of states to the store and return the defaults
-     */
-    addAndReturnDefaults(stateClasses: StateClassInternal[]): StatesAndDefaults;
-    /**
-     * Bind the actions to the handlers
-     */
-    connectActionHandlers(): void;
-    /**
-     * Invoke actions on the states.
-     */
-    invokeActions(dispatched$: Observable<ActionContext>, action: any): Observable<{}[]>;
-    private addToStatesMap;
-    private addRuntimeInfoToMeta;
-    /**
-     * @description
-     * the method checks if the state has already been added to the tree
-     * and completed the life cycle
-     * @param name
-     * @param path
-     */
-    private hasBeenMountedAndBootstrapped;
-}
+import { Injector, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { NgxsConfig } from '../symbols';
+import { MappedStore, StateClassInternal, StatesAndDefaults, StatesByName, RuntimeSelectorContext } from './internals';
+import { InternalActions } from '../actions-stream';
+import { InternalDispatchedActionResults } from '../internal/dispatcher';
+import { StateContextFactory } from '../internal/state-context-factory';
+/**
+ * State factory class
+ * @ignore
+ */
+export declare class StateFactory implements OnDestroy {
+    private _injector;
+    private _config;
+    private _parentFactory;
+    private _actions;
+    private _actionResults;
+    private _stateContextFactory;
+    private _initialState;
+    private _actionsSubscription;
+    constructor(_injector: Injector, _config: NgxsConfig, _parentFactory: StateFactory, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _stateContextFactory: StateContextFactory, _initialState: any);
+    private _states;
+    readonly states: MappedStore[];
+    private _statesByName;
+    readonly statesByName: StatesByName;
+    private _statePaths;
+    private readonly statePaths;
+    getRuntimeSelectorContext: () => RuntimeSelectorContext;
+    private static cloneDefaults;
+    private static checkStatesAreValid;
+    ngOnDestroy(): void;
+    /**
+     * Add a new state to the global defs.
+     */
+    add(stateClasses: StateClassInternal[]): MappedStore[];
+    /**
+     * Add a set of states to the store and return the defaults
+     */
+    addAndReturnDefaults(stateClasses: StateClassInternal[]): StatesAndDefaults;
+    /**
+     * Bind the actions to the handlers
+     */
+    connectActionHandlers(): void;
+    /**
+     * Invoke actions on the states.
+     */
+    invokeActions(actions$: InternalActions, action: any): Observable<{}[]>;
+    private addToStatesMap;
+    private addRuntimeInfoToMeta;
+    /**
+     * @description
+     * the method checks if the state has already been added to the tree
+     * and completed the life cycle
+     * @param name
+     * @param path
+     */
+    private hasBeenMountedAndBootstrapped;
+}

package/src/internal/state-operations.d.ts

@@ -1,19 +1,21 @@
-import { StateOperations, StatesAndDefaults } from '../internal/internals';
-import { InternalDispatcher } from '../internal/dispatcher';
-import { StateStream } from './state-stream';
-import { NgxsConfig } from '../symbols';
-/**
- * State Context factory class
- * @ignore
- */
-export declare class InternalStateOperations {
-    private _stateStream;
-    private _dispatcher;
-    private _config;
-    constructor(_stateStream: StateStream, _dispatcher: InternalDispatcher, _config: NgxsConfig);
-    /**
-     * Returns the root state operators.
-     */
-    getRootStateOperations(): StateOperations<any>;
-    setStateToTheCurrentWithNew(results: StatesAndDefaults): void;
-}
+import { StateOperations, StatesAndDefaults } from '../internal/internals';
+import { InternalDispatcher } from '../internal/dispatcher';
+import { StateStream } from './state-stream';
+import { NgxsConfig } from '../symbols';
+import { ConfigValidator } from '../internal/config-validator';
+/**
+ * State Context factory class
+ * @ignore
+ */
+export declare class InternalStateOperations {
+    private _stateStream;
+    private _dispatcher;
+    private _config;
+    constructor(_stateStream: StateStream, _dispatcher: InternalDispatcher, _config: NgxsConfig, configValidator: ConfigValidator);
+    /**
+     * Returns the root state operators.
+     */
+    getRootStateOperations(): StateOperations<any>;
+    private ensureStateAndActionsAreImmutable;
+    setStateToTheCurrentWithNew(results: StatesAndDefaults): void;
+}

package/src/internal/state-operators.d.ts

@@ -1,2 +1,2 @@
-import { StateOperator } from '../symbols';
-export declare function simplePatch<T>(val: Partial<T>): StateOperator<T>;
+import { StateOperator } from '../symbols';
+export declare function simplePatch<T>(val: Partial<T>): StateOperator<T>;

package/src/internal/state-stream.d.ts

@@ -1,9 +1,9 @@
-import { BehaviorSubject } from 'rxjs';
-import { PlainObject } from '@ngxs/store/internals';
-/**
- * BehaviorSubject of the entire state.
- * @ignore
- */
-export declare class StateStream extends BehaviorSubject<PlainObject> {
-    constructor();
-}
+import { BehaviorSubject } from 'rxjs';
+import { PlainObject } from '@ngxs/store/internals';
+/**
+ * BehaviorSubject of the entire state.
+ * @ignore
+ */
+export declare class StateStream extends BehaviorSubject<PlainObject> {
+    constructor();
+}

package/src/ivy/ensure-state-class-is-injectable.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 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/ivy/ivy-enabled-in-dev-mode.d.ts

@@ -1,6 +1,14 @@
-/**
- * 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;
+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;