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

package/operators/remove-item.d.ts

@@ -1,7 +1,7 @@
-import { StateOperator } from '@ngxs/store';
-import { Predicate } from './internals';
-import { RepairType } from './utils';
-/**
- * @param selector - index or predicate to remove an item from an array by
- */
-export declare function removeItem<T>(selector: number | Predicate<T>): StateOperator<RepairType<T>[]>;
+import { StateOperator } from '@ngxs/store';
+import { Predicate } from './internals';
+import { RepairType } from './utils';
+/**
+ * @param selector - index or predicate to remove an item from an array by
+ */
+export declare function removeItem<T>(selector: number | Predicate<T>): StateOperator<RepairType<T>[]>;

package/operators/update-item.d.ts

@@ -1,10 +1,10 @@
-import { StateOperator } from '@ngxs/store';
-import { RepairType } from './utils';
-import { Predicate } from './internals';
-/**
- * @param selector - Index of item in the array or a predicate function
- * that can be provided in `Array.prototype.findIndex`
- * @param operatorOrValue - New value under the `selector` index or a
- * function that can be applied to an existing value
- */
-export declare function updateItem<T>(selector: number | Predicate<T>, operatorOrValue: T | StateOperator<T>): StateOperator<RepairType<T>[]>;
+import { StateOperator } from '@ngxs/store';
+import { RepairType } from './utils';
+import { Predicate } from './internals';
+/**
+ * @param selector - Index of item in the array or a predicate function
+ * that can be provided in `Array.prototype.findIndex`
+ * @param operatorOrValue - New value under the `selector` index or a
+ * function that can be applied to an existing value
+ */
+export declare function updateItem<T>(selector: number | Predicate<T>, operatorOrValue: T | StateOperator<T>): StateOperator<RepairType<T>[]>;

package/operators/utils.d.ts

@@ -1,9 +1,9 @@
-import { StateOperator } from '@ngxs/store';
-import { Predicate } from './internals';
-export declare function isStateOperator<T>(value: T | StateOperator<T>): value is StateOperator<T>;
-export declare function isUndefined(value: any): value is undefined;
-export declare function isPredicate<T>(value: Predicate<T> | boolean | number): value is Predicate<T>;
-export declare function isNumber(value: any): value is number;
-export declare function invalidIndex(index: number): boolean;
-export declare function isNil<T>(value: T | null | undefined): value is null | undefined;
-export declare type RepairType<T> = T extends true ? boolean : (T extends false ? boolean : T);
+import { StateOperator } from '@ngxs/store';
+import { Predicate } from './internals';
+export declare function isStateOperator<T>(value: T | StateOperator<T>): value is StateOperator<T>;
+export declare function isUndefined(value: any): value is undefined;
+export declare function isPredicate<T>(value: Predicate<T> | boolean | number): value is Predicate<T>;
+export declare function isNumber(value: any): value is number;
+export declare function invalidIndex(index: number): boolean;
+export declare function isNil<T>(value: T | null | undefined): value is null | undefined;
+export declare type RepairType<T> = T extends true ? boolean : (T extends false ? boolean : T);

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "../../node_modules/ng-packagr/package.schema.json",
   "name": "@ngxs/store",
-  "version": "3.7.2-dev.master-bfe989b",
+  "version": "3.7.2",
   "license": "MIT",
   "sideEffects": true,
   "peerDependencies": {
@@ -63,4 +63,4 @@
     "type": "opencollective",
     "url": "https://opencollective.com/ngxs"
   }
-}
+}

package/src/actions/actions.d.ts

@@ -1,15 +1,15 @@
-import { PlainObject } from '@ngxs/store/internals';
-/**
- * Init action
- */
-export declare class InitState {
-    static readonly type: string;
-}
-/**
- * Update action
- */
-export declare class UpdateState {
-    addedStates?: PlainObject | undefined;
-    static readonly type: string;
-    constructor(addedStates?: PlainObject | undefined);
-}
+import { PlainObject } from '@ngxs/store/internals';
+/**
+ * Init action
+ */
+export declare class InitState {
+    static readonly type: string;
+}
+/**
+ * Update action
+ */
+export declare class UpdateState {
+    addedStates?: PlainObject | undefined;
+    static readonly type: string;
+    constructor(addedStates?: PlainObject | undefined);
+}

package/src/actions/symbols.d.ts

@@ -1,21 +1,21 @@
-export interface ActionDef<T = any, U = any> {
-    type: string;
-    new (...args: T[]): U;
-}
-export declare type ActionType = ActionDef | {
-    type: string;
-};
-/**
- * Actions that can be provided in a action decorator.
- */
-export interface ActionOptions {
-    /**
-     * Cancel the previous uncompleted observable(s).
-     */
-    cancelUncompleted?: boolean;
-}
-export interface ActionHandlerMetaData {
-    fn: string | symbol;
-    options: ActionOptions;
-    type: string;
-}
+export interface ActionDef<T = any, U = any> {
+    type: string;
+    new (...args: T[]): U;
+}
+export declare type ActionType = ActionDef | {
+    type: string;
+};
+/**
+ * Actions that can be provided in a action decorator.
+ */
+export interface ActionOptions {
+    /**
+     * Cancel the previous uncompleted observable(s).
+     */
+    cancelUncompleted?: boolean;
+}
+export interface ActionHandlerMetaData {
+    fn: string | symbol;
+    options: ActionOptions;
+    type: string;
+}

package/src/actions-stream.d.ts

@@ -1,49 +1,49 @@
-import { Subject, Observable } from 'rxjs';
-import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
-/**
- * Status of a dispatched action
- */
-export declare const enum ActionStatus {
-    Dispatched = "DISPATCHED",
-    Successful = "SUCCESSFUL",
-    Canceled = "CANCELED",
-    Errored = "ERRORED"
-}
-export interface ActionContext<T = any> {
-    status: ActionStatus;
-    action: T;
-    error?: Error;
-}
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-export declare class OrderedSubject<T> extends Subject<T> {
-    private _itemQueue;
-    private _busyPushingNext;
-    next(value?: T): void;
-}
-/**
- * Internal Action stream that is emitted anytime an action is dispatched.
- */
-export declare class InternalActions extends OrderedSubject<ActionContext> {
-}
-/**
- * Action stream that is emitted anytime an action is dispatched.
- *
- * You can listen to this in services to react without stores.
- */
-export declare class Actions extends Observable<ActionContext> {
-    constructor(internalActions$: InternalActions, internalExecutionStrategy: InternalNgxsExecutionStrategy);
-}
+import { Subject, Observable } from 'rxjs';
+import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+/**
+ * Status of a dispatched action
+ */
+export declare const enum ActionStatus {
+    Dispatched = "DISPATCHED",
+    Successful = "SUCCESSFUL",
+    Canceled = "CANCELED",
+    Errored = "ERRORED"
+}
+export interface ActionContext<T = any> {
+    status: ActionStatus;
+    action: T;
+    error?: Error;
+}
+/**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new Subject<string>();
+     subject.subscribe(value => {
+       if (value === 'start') subject.next('end');
+     });
+     subject.subscribe(value => { });
+     subject.next('start');
+ * ```
+ * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
+ */
+export declare class OrderedSubject<T> extends Subject<T> {
+    private _itemQueue;
+    private _busyPushingNext;
+    next(value?: T): void;
+}
+/**
+ * Internal Action stream that is emitted anytime an action is dispatched.
+ */
+export declare class InternalActions extends OrderedSubject<ActionContext> {
+}
+/**
+ * Action stream that is emitted anytime an action is dispatched.
+ *
+ * You can listen to this in services to react without stores.
+ */
+export declare class Actions extends Observable<any> {
+    constructor(internalActions$: InternalActions, internalExecutionStrategy: InternalNgxsExecutionStrategy);
+}

package/src/configs/messages.config.d.ts

@@ -1,11 +1,30 @@
-export declare function throwStateNameError(name: string): never;
-export declare function throwStateNamePropertyError(): never;
-export declare function throwStateUniqueError(current: string, newName: string, oldName: string): never;
-export declare function throwStateDecoratorError(name: string): never;
-export declare function throwActionDecoratorError(): never;
-export declare function throwSelectorDecoratorError(): never;
-export declare function getZoneWarningMessage(): string;
-export declare function getUndecoratedStateInIvyWarningMessage(name: string): string;
-export declare function throwSelectFactoryNotConnectedError(): never;
-export declare function throwPatchingArrayError(): never;
-export declare function throwPatchingPrimitiveError(): never;
+export declare enum VALIDATION_CODE {
+    STATE_NAME = "STATE_NAME",
+    STATE_UNIQUE = "STATE_UNIQUE",
+    STATE_NAME_PROPERTY = "STATE_NAME_PROPERTY",
+    STATE_DECORATOR = "STATE_DECORATOR",
+    INCORRECT_PRODUCTION = "INCORRECT_PRODUCTION",
+    INCORRECT_DEVELOPMENT = "INCORRECT_DEVELOPMENT",
+    SELECT_FACTORY_NOT_CONNECTED = "SELECT_FACTORY_NOT_CONNECTED",
+    ACTION_DECORATOR = "ACTION_DECORATOR",
+    SELECTOR_DECORATOR = "SELECTOR_DECORATOR",
+    ZONE_WARNING = "ZONE_WARNING",
+    PATCHING_ARRAY = "PATCHING_ARRAY",
+    PATCHING_PRIMITIVE = "PATCHING_PRIMITIVE",
+    UNDECORATED_STATE_IN_IVY = "UNDECORATED_STATE_IN_IVY"
+}
+export declare const CONFIG_MESSAGES: {
+    [VALIDATION_CODE.STATE_NAME]: (name: string) => string;
+    [VALIDATION_CODE.STATE_NAME_PROPERTY]: () => string;
+    [VALIDATION_CODE.STATE_UNIQUE]: (current: string, newName: string, oldName: string) => string;
+    [VALIDATION_CODE.STATE_DECORATOR]: () => string;
+    [VALIDATION_CODE.INCORRECT_PRODUCTION]: () => string;
+    [VALIDATION_CODE.INCORRECT_DEVELOPMENT]: () => string;
+    [VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED]: () => string;
+    [VALIDATION_CODE.ACTION_DECORATOR]: () => string;
+    [VALIDATION_CODE.SELECTOR_DECORATOR]: () => string;
+    [VALIDATION_CODE.ZONE_WARNING]: () => string;
+    [VALIDATION_CODE.PATCHING_ARRAY]: () => string;
+    [VALIDATION_CODE.PATCHING_PRIMITIVE]: () => string;
+    [VALIDATION_CODE.UNDECORATED_STATE_IN_IVY]: (name: string) => string;
+};

package/src/decorators/action.d.ts

@@ -1,5 +1,5 @@
-import { ActionType, ActionOptions } from '../actions/symbols';
-/**
- * Decorates a method with a action information.
- */
-export declare function Action(actions: ActionType | ActionType[], options?: ActionOptions): MethodDecorator;
+import { ActionType, ActionOptions } from '../actions/symbols';
+/**
+ * Decorates a method with a action information.
+ */
+export declare function Action(actions: ActionType | ActionType[], options?: ActionOptions): MethodDecorator;

package/src/decorators/select/select-factory.d.ts

@@ -1,13 +1,14 @@
-import { OnDestroy } from '@angular/core';
-import { Store } from '../../store';
-import { NgxsConfig } from '../../symbols';
-/**
- * Allows the select decorator to get access to the DI store, this is used internally
- * in `@Select` decorator.
- */
-export declare class SelectFactory implements OnDestroy {
-    static store: Store | null;
-    static config: NgxsConfig | null;
-    constructor(store: Store, config: NgxsConfig);
-    ngOnDestroy(): void;
-}
+import { OnDestroy } from '@angular/core';
+import { Store } from '../../store';
+import { NgxsConfig } from '../../symbols';
+/**
+ * Allows the select decorator to get access to the DI store.
+ * @internal only use in @Select decorator
+ * @ignore
+ */
+export declare class SelectFactory implements OnDestroy {
+    static store: Store | null;
+    static config: NgxsConfig | null;
+    constructor(store: Store, config: NgxsConfig);
+    ngOnDestroy(): void;
+}

package/src/decorators/select/select.d.ts

@@ -1,4 +1,4 @@
-/**
- * Decorator for selecting a slice of state from the store.
- */
-export declare function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator;
+/**
+ * Decorator for selecting a slice of state from the store.
+ */
+export declare function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator;

package/src/decorators/select/symbols.d.ts

@@ -1,14 +1,10 @@
-import { Type } from '@angular/core';
-import { Observable } from 'rxjs';
-import { Store } from '../../store';
-import { NgxsConfig } from '../../symbols';
-import { StateToken } from '../../state-token/state-token';
-import { ExtractTokenType } from '../../state-token/symbols';
-export declare function createSelectObservable<T = any>(selector: any, store: Store | null): Observable<T>;
-export declare function createSelectorFn(config: NgxsConfig | null, name: string, rawSelector?: any, paths?: string[]): SelectorFn;
-/**
- * @example If `foo$` => make it just `foo`
- */
-export declare function removeDollarAtTheEnd(name: string): string;
-export declare type SelectorFn = ((state: any, ...states: any[]) => any) | string | Type<any> | StateToken<any>;
-export declare type PropertyType<T> = T extends StateToken<any> ? Observable<ExtractTokenType<T>> : T extends (...args: any[]) => any ? Observable<ReturnType<T>> : any;
+import { Observable } from 'rxjs';
+import { StateToken } from '../../state-token/state-token';
+import { ExtractTokenType } from '../../state-token/symbols';
+export declare function createSelectObservable<T = any>(selector: any): Observable<T>;
+export declare function createSelectorFn(name: string, rawSelector?: any, paths?: string[]): any;
+/**
+ * @example If `foo$` => make it just `foo`
+ */
+export declare function removeDollarAtTheEnd(name: string): string;
+export declare type PropertyType<T> = T extends StateToken<any> ? Observable<ExtractTokenType<T>> : T extends (...args: any[]) => any ? Observable<ReturnType<T>> : any;

package/src/decorators/selector/selector.d.ts

@@ -1,5 +1,5 @@
-import { SelectorType } from './symbols';
-/**
- * Decorator for memoizing a state selector.
- */
-export declare function Selector<T>(selectors?: T[]): SelectorType<T>;
+import { SelectorType } from './symbols';
+/**
+ * Decorator for memoizing a state selector.
+ */
+export declare function Selector<T>(selectors?: T[]): SelectorType<T>;

package/src/decorators/selector/symbols.d.ts

@@ -1,4 +1,4 @@
-import { StateToken } from '../../state-token/state-token';
-import { ExtractTokenType } from '../../state-token/symbols';
-export declare type SelectorSpec<T, U> = [T] extends [never] ? ((...states: any[]) => any) : (T extends StateToken<any> ? (state: ExtractTokenType<T>) => U : (...states: any[]) => any);
-export declare type SelectorType<T> = <U>(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>) => TypedPropertyDescriptor<SelectorSpec<T, U>> | void;
+import { StateToken } from '../../state-token/state-token';
+import { ExtractTokenType } from '../../state-token/symbols';
+export declare type SelectorSpec<T, U> = [T] extends [never] ? ((...states: any[]) => any) : (T extends StateToken<any> ? (state: ExtractTokenType<T>) => U : (...states: any[]) => any);
+export declare type SelectorType<T> = <U>(target: any, key: string | symbol, descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>) => TypedPropertyDescriptor<SelectorSpec<T, U>> | void;

package/src/decorators/selector-options.d.ts

@@ -1,5 +1,5 @@
-import { SharedSelectorOptions } from '../internal/internals';
-/**
- * Decorator for setting selector options at a method or class level.
- */
-export declare function SelectorOptions(options: SharedSelectorOptions): ClassDecorator & MethodDecorator;
+import { SharedSelectorOptions } from '../internal/internals';
+/**
+ * Decorator for setting selector options at a method or class level.
+ */
+export declare function SelectorOptions(options: SharedSelectorOptions): ClassDecorator & MethodDecorator;

package/src/decorators/state.d.ts

@@ -1,6 +1,6 @@
-import { StateClass } from '@ngxs/store/internals';
-import { StoreOptions } from '../symbols';
-/**
- * Decorates a class with ngxs state information.
- */
-export declare function State<T>(options: StoreOptions<T>): (target: StateClass<any>) => void;
+import { StateClass } from '@ngxs/store/internals';
+import { StoreOptions } from '../symbols';
+/**
+ * Decorates a class with ngxs state information.
+ */
+export declare function State<T>(options: StoreOptions<T>): (target: StateClass<any>) => void;

package/src/execution/dispatch-outside-zone-ngxs-execution-strategy.d.ts

@@ -1,11 +1,12 @@
-import { NgZone } from '@angular/core';
-import { NgxsExecutionStrategy } from './symbols';
-export declare class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    private _ngZone;
-    private _platformId;
-    constructor(_ngZone: NgZone, _platformId: string);
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-    private runInsideAngular;
-    private runOutsideAngular;
-}
+import { NgZone } from '@angular/core';
+import { NgxsExecutionStrategy } from './symbols';
+export declare class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {
+    private _ngZone;
+    private _platformId;
+    constructor(_ngZone: NgZone, _platformId: string);
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+    private runInsideAngular;
+    private runOutsideAngular;
+    private verifyZoneIsNotNooped;
+}

package/src/execution/internal-ngxs-execution-strategy.d.ts

@@ -1,7 +1,7 @@
-import { NgxsExecutionStrategy } from './symbols';
-export declare class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    private _executionStrategy;
-    constructor(_executionStrategy: NgxsExecutionStrategy);
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-}
+import { NgxsExecutionStrategy } from './symbols';
+export declare class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {
+    private _executionStrategy;
+    constructor(_executionStrategy: NgxsExecutionStrategy);
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+}

package/src/execution/noop-ngxs-execution-strategy.d.ts

@@ -1,5 +1,5 @@
-import { NgxsExecutionStrategy } from './symbols';
-export declare class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-}
+import { NgxsExecutionStrategy } from './symbols';
+export declare class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+}

package/src/execution/symbols.d.ts

@@ -1,6 +1,6 @@
-import { InjectionToken } from '@angular/core';
-export declare const NGXS_EXECUTION_STRATEGY: InjectionToken<NgxsExecutionStrategy>;
-export interface NgxsExecutionStrategy {
-    enter<T>(func: () => T): T;
-    leave<T>(func: () => T): T;
-}
+import { InjectionToken } from '@angular/core';
+export declare const NGXS_EXECUTION_STRATEGY: InjectionToken<NgxsExecutionStrategy>;
+export interface NgxsExecutionStrategy {
+    enter<T>(func: () => T): T;
+    leave<T>(func: () => T): T;
+}

package/src/host-environment/host-environment.d.ts

@@ -0,0 +1,6 @@
+import { Callback } from '../internal/internals';
+export declare class HostEnvironment {
+    isDevMode: Callback<boolean>;
+    isTestMode: Callback<boolean>;
+    constructor(isDevMode: Callback<boolean>, isTestMode: Callback<boolean>);
+}

package/src/internal/config-validator.d.ts

@@ -0,0 +1,10 @@
+import { NgxsConfig } from '../symbols';
+import { HostEnvironment } from '../host-environment/host-environment';
+export declare class ConfigValidator {
+    private _host;
+    private _config;
+    constructor(_host: HostEnvironment, _config: NgxsConfig);
+    private readonly isIncorrectProduction;
+    private readonly isIncorrectDevelopment;
+    verifyDevMode(): void;
+}

package/src/internal/dispatcher.d.ts

@@ -1,32 +1,32 @@
-import { Injector } from '@angular/core';
-import { Observable, Subject } from 'rxjs';
-import { ActionContext, InternalActions } from '../actions-stream';
-import { StateStream } from './state-stream';
-import { PluginManager } from '../plugin-manager';
-import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';
-/**
- * Internal Action result stream that is emitted when an action is completed.
- * This is used as a method of returning the action result to the dispatcher
- * for the observable returned by the dispatch(...) call.
- * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
- */
-export declare class InternalDispatchedActionResults extends Subject<ActionContext> {
-}
-export declare class InternalDispatcher {
-    private _injector;
-    private _actions;
-    private _actionResults;
-    private _pluginManager;
-    private _stateStream;
-    private _ngxsExecutionStrategy;
-    private _errorHandler;
-    constructor(_injector: Injector, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _pluginManager: PluginManager, _stateStream: StateStream, _ngxsExecutionStrategy: InternalNgxsExecutionStrategy);
-    /**
-     * Dispatches event(s).
-     */
-    dispatch(actionOrActions: any | any[]): Observable<any>;
-    private dispatchByEvents;
-    private dispatchSingle;
-    private getActionResultStream;
-    private createDispatchObservable;
-}
+import { Injector } from '@angular/core';
+import { Observable, Subject } from 'rxjs';
+import { ActionContext, InternalActions } from '../actions-stream';
+import { StateStream } from './state-stream';
+import { PluginManager } from '../plugin-manager';
+import { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';
+/**
+ * Internal Action result stream that is emitted when an action is completed.
+ * This is used as a method of returning the action result to the dispatcher
+ * for the observable returned by the dispatch(...) call.
+ * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
+ */
+export declare class InternalDispatchedActionResults extends Subject<ActionContext> {
+}
+export declare class InternalDispatcher {
+    private _injector;
+    private _actions;
+    private _actionResults;
+    private _pluginManager;
+    private _stateStream;
+    private _ngxsExecutionStrategy;
+    private _errorHandler;
+    constructor(_injector: Injector, _actions: InternalActions, _actionResults: InternalDispatchedActionResults, _pluginManager: PluginManager, _stateStream: StateStream, _ngxsExecutionStrategy: InternalNgxsExecutionStrategy);
+    /**
+     * Dispatches event(s).
+     */
+    dispatch(actionOrActions: any | any[]): Observable<any>;
+    private dispatchByEvents;
+    private dispatchSingle;
+    private getActionResultStream;
+    private createDispatchObservable;
+}