@ngxs/store 3.8.2 → 18.0.0-dev.master-f4c2c19

package/src/standalone-features/preboot.d.ts

@@ -0,0 +1,26 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * InjectionToken that registers preboot functions (called before the root initializer).
+ */
+export declare const NGXS_PREBOOT_FNS: InjectionToken<VoidFunction[]>;
+/**
+ * This function registers a preboot function which will be called before the root
+ * store initializer is run, but after all of the NGXS features are provided and
+ * available for injection. This is useful for registering action stream listeners
+ * before any action is dispatched.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(
+ *       [CountriesState],
+ *       withNgxsPreboot(() => {
+ *         const actions$ = inject(Actions);
+ *         actions$.subscribe(ctx => console.log(ctx));
+ *       })
+ *     )
+ *   ]
+ * });
+ * ```
+ */
+export declare function withNgxsPreboot(prebootFn: VoidFunction): import("@angular/core").EnvironmentProviders;

package/src/standalone-features/provide-states.d.ts

@@ -0,0 +1,18 @@
+import { EnvironmentProviders } from '@angular/core';
+import { ɵStateClass } from '@ngxs/store/internals';
+/**
+ * This version serves as a standalone alternative to `NgxsModule.forFeature`.
+ * It can be used in a similar manner to register feature states, but at the
+ * `Route` providers level:
+ *
+ * ```ts
+ * const routes: Routes = [
+ *   {
+ *     path: 'products',
+ *     loadComponent: async () => {...},
+ *     providers: [provideStates([ProductsState])]
+ *   }
+ * ];
+ * ```
+ */
+export declare function provideStates(states: ɵStateClass[], ...features: EnvironmentProviders[]): EnvironmentProviders;

package/src/standalone-features/provide-store.d.ts

@@ -0,0 +1,22 @@
+import { EnvironmentProviders } from '@angular/core';
+import { ɵStateClass } from '@ngxs/store/internals';
+import { NgxsModuleOptions } from '../symbols';
+/**
+ * This function provides global store providers and initializes the store.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideStore([CountriesState])]
+ * });
+ * ```
+ *
+ * The `provideStore` may be optionally called with a config before the list of features:
+ *
+ * ```ts
+ * provideStore([CountriesState], {
+ *   developmentMode: !environment.production
+ * });
+ * ```
+ */
+export declare function provideStore(states?: ɵStateClass[], ...features: EnvironmentProviders[]): EnvironmentProviders;
+export declare function provideStore(states?: ɵStateClass[], options?: NgxsModuleOptions, ...features: EnvironmentProviders[]): EnvironmentProviders;

package/src/standalone-features/root-providers.d.ts

@@ -0,0 +1,8 @@
+import { Provider } from '@angular/core';
+import { ɵStateClass } from '@ngxs/store/internals';
+import { NgxsModuleOptions } from '../symbols';
+/**
+ * This function provides the required providers when invoking `NgxsModule.forRoot`
+ * or `provideStore`. It is shared between the NgModule and standalone APIs.
+ */
+export declare function getRootProviders(states: ɵStateClass[], options: NgxsModuleOptions): Provider[];

package/src/store.d.ts

@@ -1,11 +1,11 @@
-import { Type } from '@angular/core';
+import { Signal } from '@angular/core';
 import { Observable, Subscription } from 'rxjs';
+import { ɵStateStream } from '@ngxs/store/internals';
 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';
+import { TypedSelector } from './selectors';
 import * as i0 from "@angular/core";
 export declare class Store {
     private _stateStream;
@@ -19,29 +19,27 @@ export declare class Store {
      * 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);
+    constructor(_stateStream: ɵStateStream, _internalStateOperations: InternalStateOperations, _config: NgxsConfig, _internalExecutionStrategy: InternalNgxsExecutionStrategy, _stateFactory: StateFactory, initialStateValue: any);
     /**
      * Dispatches event(s).
      */
-    dispatch(actionOrActions: any | any[]): Observable<any>;
+    dispatch(actionOrActions: any | any[]): Observable<void>;
     /**
      * 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<T>(selector: TypedSelector<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>;
+    selectOnce<T>(selector: TypedSelector<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;
+    selectSnapshot<T>(selector: TypedSelector<T>): T;
+    /**
+     * Select a signal from the state.
+     */
+    selectSignal<T>(selector: TypedSelector<T>): Signal<T>;
     /**
      * Allow the user to subscribe to the root of the state
      */
@@ -54,7 +52,7 @@ export declare class Store {
      * 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;
+    reset(state: any): void;
     private getStoreBoundSelectorFn;
     private initStateStream;
     static ɵfac: i0.ɵɵFactoryDeclaration<Store, [null, null, null, null, null, { optional: true; }]>;

package/src/symbols.d.ts

@@ -1,20 +1,13 @@
 import { InjectionToken, Type } from '@angular/core';
 import { Observable } from 'rxjs';
-import { PlainObject, StateClass } from '@ngxs/store/internals';
 import { StateOperator } from '@ngxs/store/operators';
+import { ɵSharedSelectorOptions, ɵStateClass } from '@ngxs/store/internals';
 import { NgxsExecutionStrategy } from './execution/symbols';
-import { SharedSelectorOptions } from './internal/internals';
-import { StateToken } from './state-token/state-token';
 import * as i0 from "@angular/core";
-export declare const ROOT_OPTIONS: InjectionToken<Partial<NgxsConfig>>;
-export declare const ROOT_STATE_TOKEN: InjectionToken<any>;
-export declare const FEATURE_STATE_TOKEN: InjectionToken<any>;
-export declare const NGXS_PLUGINS: InjectionToken<unknown>;
-export declare const META_KEY = "NGXS_META";
-export declare const META_OPTIONS_KEY = "NGXS_OPTIONS_META";
-export declare const SELECTOR_META_KEY = "NGXS_SELECTOR_META";
-export declare type NgxsLifeCycle = Partial<NgxsOnChanges> & Partial<NgxsOnInit> & Partial<NgxsAfterBootstrap>;
-export declare type NgxsPluginFn = (state: any, mutation: any, next: NgxsNextPluginFn) => any;
+export declare const ROOT_STATE_TOKEN: InjectionToken<ɵStateClass[]>;
+export declare const FEATURE_STATE_TOKEN: InjectionToken<ɵStateClass[][]>;
+export declare const NGXS_OPTIONS: InjectionToken<Partial<NgxsConfig>>;
+export type NgxsLifeCycle = Partial<NgxsOnChanges> & Partial<NgxsOnInit> & Partial<NgxsAfterBootstrap>;
 /**
  * The NGXS config settings.
  */
@@ -24,9 +17,9 @@ export declare class NgxsConfig {
      * - Object.freeze on the state and actions to guarantee immutability
      * (default: false)
      *
-     * Note: this property will be accounted only in development mode when using the Ivy compiler.
+     * Note: this property will be accounted only in development mode.
      * It makes sense to use it only during development to ensure there're no state mutations.
-     * When building for production, the Object.freeze will be tree-shaken away.
+     * When building for production, the `Object.freeze` will be tree-shaken away.
      */
     developmentMode: boolean;
     compatibility: {
@@ -42,25 +35,17 @@ export declare class NgxsConfig {
      * provided to override the default behaviour where the async operations are run
      * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.
      * These observable behaviours are from:
-     *   `@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
+     *   `store.selectSignal(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
      * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your
      * application doesn't rely on zone.js running change detection then you can switch to the
      * `NoopNgxsExecutionStrategy` that doesn't interact with zones.
      * (default: null)
      */
     executionStrategy: Type<NgxsExecutionStrategy>;
-    /**
-     * Defining the default state before module initialization
-     * This is convenient if we need to create a define our own set of states.
-     * @deprecated will be removed after v4
-     * (default: {})
-     */
-    defaultsState: PlainObject;
     /**
      * Defining shared selector options
      */
-    selectorOptions: SharedSelectorOptions;
-    constructor();
+    selectorOptions: ɵSharedSelectorOptions;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgxsConfig, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NgxsConfig>;
 }
@@ -76,43 +61,16 @@ export interface StateContext<T> {
     /**
      * Reset the state to a new value.
      */
-    setState(val: T | StateOperator<T>): T;
+    setState(val: T | StateOperator<T>): void;
     /**
      * Patch the existing state with the provided value.
      */
-    patchState(val: Partial<T>): T;
+    patchState(val: Partial<T>): void;
     /**
      * Dispatch a new action and return the dispatched observable.
      */
     dispatch(actions: any | any[]): Observable<void>;
 }
-export declare type NgxsNextPluginFn = (state: any, mutation: any) => any;
-/**
- * Plugin interface
- */
-export interface NgxsPlugin {
-    /**
-     * Handle the state/action before its submitted to the state handlers.
-     */
-    handle(state: any, action: any, next: NgxsNextPluginFn): any;
-}
-/**
- * Options that can be provided to the store.
- */
-export interface StoreOptions<T> {
-    /**
-     * Name of the state. Required.
-     */
-    name: string | StateToken<T>;
-    /**
-     * Default values for the state. If not provided, uses empty object.
-     */
-    defaults?: T;
-    /**
-     * Sub states for the given state.
-     */
-    children?: StateClass[];
-}
 /**
  * Represents a basic change from a previous to a new value for a single state instance.
  * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
@@ -141,4 +99,4 @@ export interface NgxsOnChanges {
 export interface NgxsAfterBootstrap {
     ngxsAfterBootstrap(ctx: StateContext<any>): void;
 }
-export declare type NgxsModuleOptions = Partial<NgxsConfig>;
+export type NgxsModuleOptions = Partial<NgxsConfig>;

package/src/utils/compose.d.ts

@@ -1,4 +1,4 @@
-export declare type StateFn = (...args: any[]) => any;
+export type StateFn = (...args: any[]) => any;
 /**
  * Composes a array of functions from left to right. Example:
  *

package/src/utils/create-dispatch-map.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import { ActionDef } from '../actions/symbols';
+export type ActionMap = Record<string, ActionDef<any>>;
+export declare function createDispatchMap<T extends ActionMap>(actionMap: T): { readonly [K in keyof T]: (...args: ConstructorParameters<T[K]>) => Observable<void>; };

package/src/utils/create-select-map.d.ts

@@ -0,0 +1,4 @@
+import { Signal } from '@angular/core';
+import { TypedSelector, ɵSelectorReturnType } from '../selectors';
+export type SelectorMap = Record<string, TypedSelector<unknown>>;
+export declare function createSelectMap<T extends SelectorMap>(selectorMap: T): { readonly [K in keyof T]: Signal<ɵSelectorReturnType<T[K]>>; };

package/src/utils/dispatch.d.ts

@@ -0,0 +1,2 @@
+import { ActionDef } from '../actions/symbols';
+export declare function dispatch<TArgs extends any[]>(ActionType: ActionDef<TArgs>): (...args: TArgs) => import("rxjs").Observable<void>;

package/src/utils/public_api.d.ts

@@ -0,0 +1,4 @@
+export { select } from './select';
+export { dispatch } from './dispatch';
+export { SelectorMap, createSelectMap } from './create-select-map';
+export { ActionMap, createDispatchMap } from './create-dispatch-map';

package/src/utils/select.d.ts

@@ -0,0 +1,16 @@
+import { Signal } from '@angular/core';
+import { TypedSelector } from '../selectors';
+/**
+ * This function serves as a utility and has multiple purposes.
+ * Firstly, it allows you to select properties from the state class
+ * without having to inject the store class and use `this.store.selectSignal`,
+ * resulting in a more concise implementation. Secondly, it can be used with
+ * other solutions such as NgRx signal store with its `signalStoreFeature` or
+ * `withComputed` functionalities.
+ *
+ * Please note that it's named `select` instead of `selectSignal` because
+ * signals are evolving into first-class primitives in Angular, displacing other
+ * primitives such as observables. Observables represent a stream of events,
+ * whereas signals represent a single value changing over time.
+ */
+export declare function select<T>(selector: TypedSelector<T>): Signal<T>;

package/src/utils/store-validators.d.ts

@@ -1,4 +1,5 @@
-import { StateClassInternal, StatesByName } from '../internal/internals';
+import { ɵStateClassInternal } from '@ngxs/store/internals';
+import { StatesByName } from '../internal/internals';
 export declare function ensureStateNameIsValid(name: string | null): void | never;
-export declare function ensureStateNameIsUnique(stateName: string, state: StateClassInternal, statesByName: StatesByName): void | never;
-export declare function ensureStatesAreDecorated(stateClasses: StateClassInternal[]): void | never;
+export declare function ensureStateNameIsUnique(stateName: string, state: ɵStateClassInternal, statesByName: StatesByName): void | never;
+export declare function ensureStatesAreDecorated(stateClasses: ɵStateClassInternal[]): void | never;