@ngxs/store 19.0.0-dev.master-ae76ef6 → 19.0.0-dev.master-c739a26

package/fesm2022/ngxs-store.mjs

@@ -1,6 +1,6 @@
 import * as i0 from '@angular/core';
 import { inject, Injectable, DestroyRef, NgZone, Injector, runInInjectionContext, InjectionToken, ErrorHandler, ɵisPromise as _isPromise, computed, makeEnvironmentProviders, provideEnvironmentInitializer, NgModule, APP_BOOTSTRAP_LISTENER, ApplicationRef, PendingTasks, assertInInjectionContext, EnvironmentInjector, createEnvironmentInjector } from '@angular/core';
-import { config, Observable, Subject, of, forkJoin, map, shareReplay, filter, take, mergeMap, EMPTY, defaultIfEmpty, catchError, from, isObservable, takeUntil, finalize, distinctUntilChanged, startWith, skip, buffer, debounceTime } from 'rxjs';
+import { config, Observable, Subject, of, forkJoin, map, shareReplay, filter, take, mergeMap, EMPTY, from, isObservable, defaultIfEmpty, takeUntil, finalize, catchError, distinctUntilChanged, startWith, skip, buffer, debounceTime } from 'rxjs';
 import { ɵwrapObserverCalls as _wrapObserverCalls, ɵOrderedSubject as _OrderedSubject, ɵStateStream as _StateStream, ɵhasOwnProperty as _hasOwnProperty, ɵmemoize as _memoize, ɵgetStoreMetadata as _getStoreMetadata, ɵgetSelectorMetadata as _getSelectorMetadata, ɵMETA_KEY as _META_KEY, ɵINITIAL_STATE_TOKEN as _INITIAL_STATE_TOKEN, ɵNgxsActionRegistry as _NgxsActionRegistry, ɵNgxsAppBootstrappedState as _NgxsAppBootstrappedState, ɵensureStoreMetadata as _ensureStoreMetadata, ɵMETA_OPTIONS_KEY as _META_OPTIONS_KEY, ɵensureSelectorMetadata as _ensureSelectorMetadata, ɵNGXS_STATE_CONTEXT_FACTORY as _NGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY as _NGXS_STATE_FACTORY } from '@ngxs/store/internals';
 export { StateToken } from '@ngxs/store/internals';
 import { NGXS_PLUGINS, getActionTypeFromInstance, InitState, UpdateState, setValue, getValue, ɵisPluginClass as _isPluginClass } from '@ngxs/store/plugins';
@@ -921,89 +921,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-function simplePatch(value) {
-    return (existingState) => {
-        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-            if (Array.isArray(value)) {
-                throwPatchingArrayError();
-            }
-            else if (typeof value !== 'object') {
-                throwPatchingPrimitiveError();
-            }
-        }
-        const newState = { ...existingState };
-        for (const key in value) {
-            // deep clone for patch compatibility
-            newState[key] = value[key];
-        }
-        return newState;
-    };
-}
-
-/**
- * State Context factory class
- * @ignore
- */
-class StateContextFactory {
-    constructor() {
-        this._internalStateOperations = inject(InternalStateOperations);
-    }
-    /**
-     * Create the state context
-     */
-    createStateContext(path) {
-        const root = this._internalStateOperations.getRootStateOperations();
-        return {
-            getState() {
-                const currentAppState = root.getState();
-                return getState(currentAppState, path);
-            },
-            patchState(val) {
-                const currentAppState = root.getState();
-                const patchOperator = simplePatch(val);
-                setStateFromOperator(root, currentAppState, patchOperator, path);
-            },
-            setState(val) {
-                const currentAppState = root.getState();
-                if (isStateOperator(val)) {
-                    setStateFromOperator(root, currentAppState, val, path);
-                }
-                else {
-                    setStateValue(root, currentAppState, val, path);
-                }
-            },
-            dispatch(actions) {
-                return root.dispatch(actions);
-            }
-        };
-    }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, providedIn: 'root' }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-function setStateValue(root, currentAppState, newValue, path) {
-    const newAppState = setValue(currentAppState, path, newValue);
-    root.setState(newAppState);
-    return newAppState;
-    // In doing this refactoring I noticed that there is a 'bug' where the
-    // application state is returned instead of this state slice.
-    // This has worked this way since the beginning see:
-    // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts
-    // This needs to be fixed, but is a 'breaking' change.
-    // I will do this fix in a subsequent PR and we can decide how to handle it.
-}
-function setStateFromOperator(root, currentAppState, stateOperator, path) {
-    const local = getState(currentAppState, path);
-    const newValue = stateOperator(local);
-    return setStateValue(root, currentAppState, newValue, path);
-}
-function getState(currentAppState, path) {
-    return getValue(currentAppState, path);
-}
-
 /**
  * RxJS operator for selecting out specific actions.
  *
@@ -1106,6 +1023,164 @@ function createAllowedStatusesMap(statuses) {
     }, {});
 }
 
+function simplePatch(value) {
+    return (existingState) => {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+            if (Array.isArray(value)) {
+                throwPatchingArrayError();
+            }
+            else if (typeof value !== 'object') {
+                throwPatchingPrimitiveError();
+            }
+        }
+        const newState = { ...existingState };
+        for (const key in value) {
+            // deep clone for patch compatibility
+            newState[key] = value[key];
+        }
+        return newState;
+    };
+}
+
+/**
+ * State Context factory class
+ * @ignore
+ */
+class StateContextFactory {
+    constructor() {
+        this._internalStateOperations = inject(InternalStateOperations);
+    }
+    /**
+     * Create the state context
+     */
+    createStateContext(path) {
+        const root = this._internalStateOperations.getRootStateOperations();
+        return {
+            getState() {
+                const currentAppState = root.getState();
+                return getState(currentAppState, path);
+            },
+            patchState(val) {
+                const currentAppState = root.getState();
+                const patchOperator = simplePatch(val);
+                setStateFromOperator(root, currentAppState, patchOperator, path);
+            },
+            setState(val) {
+                const currentAppState = root.getState();
+                if (isStateOperator(val)) {
+                    setStateFromOperator(root, currentAppState, val, path);
+                }
+                else {
+                    setStateValue(root, currentAppState, val, path);
+                }
+            },
+            dispatch(actions) {
+                return root.dispatch(actions);
+            }
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: StateContextFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+function setStateValue(root, currentAppState, newValue, path) {
+    const newAppState = setValue(currentAppState, path, newValue);
+    root.setState(newAppState);
+    return newAppState;
+    // In doing this refactoring I noticed that there is a 'bug' where the
+    // application state is returned instead of this state slice.
+    // This has worked this way since the beginning see:
+    // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts
+    // This needs to be fixed, but is a 'breaking' change.
+    // I will do this fix in a subsequent PR and we can decide how to handle it.
+}
+function setStateFromOperator(root, currentAppState, stateOperator, path) {
+    const local = getState(currentAppState, path);
+    const newValue = stateOperator(local);
+    return setStateValue(root, currentAppState, newValue, path);
+}
+function getState(currentAppState, path) {
+    return getValue(currentAppState, path);
+}
+
+class InternalActionHandlerFactory {
+    constructor() {
+        this._actions = inject(InternalActions);
+        this._stateContextFactory = inject(StateContextFactory);
+    }
+    createActionHandler(path, handlerFn, options) {
+        const { dispatched$ } = this._actions;
+        return (action) => {
+            const stateContext = this._stateContextFactory.createStateContext(path);
+            let result = handlerFn(stateContext, action);
+            // We need to use `isPromise` instead of checking whether
+            // `result instanceof Promise`. In zone.js patched environments, `global.Promise`
+            // is the `ZoneAwarePromise`. Some APIs, which are likely not patched by zone.js
+            // for certain reasons, might not work with `instanceof`. For instance, the dynamic
+            // import returns a native promise (not a `ZoneAwarePromise`), causing this check to
+            // be falsy.
+            if (_isPromise(result)) {
+                result = from(result);
+            }
+            if (isObservable(result)) {
+                result = result.pipe(mergeMap(value => (_isPromise(value) || isObservable(value) ? value : of(value))), 
+                // If this observable has completed without emitting any values,
+                // we wouldn't want to complete the entire chain of actions.
+                // If any observable completes, then the action will be canceled.
+                // For instance, if any action handler had a statement like
+                // `handler(ctx) { return EMPTY; }`, then the action would be canceled.
+                // See https://github.com/ngxs/store/issues/1568
+                // Note that we actually don't care about the return type; we only care
+                // about emission, and thus `undefined` is applicable by the framework.
+                defaultIfEmpty(undefined));
+                if (options.cancelUncompleted) {
+                    const canceled = dispatched$.pipe(ofActionDispatched(action));
+                    result = result.pipe(takeUntil(canceled));
+                }
+                result = result.pipe(
+                // Note that we use the `finalize` operator only when the action handler
+                // explicitly returns an observable (or a promise) to wait for. This means
+                // the action handler is written in a "fire & wait" style. If the handler’s
+                // result is unsubscribed (either because the observable has completed or
+                // it was unsubscribed by `takeUntil` due to a new action being dispatched),
+                // we prevent writing to the state context.
+                finalize(() => {
+                    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+                        function noopAndWarn() {
+                            console.warn(`"${action}" attempted to change the state, but the change was ignored because state updates are not allowed after the action handler has completed.`);
+                        }
+                        stateContext.setState = noopAndWarn;
+                        stateContext.patchState = noopAndWarn;
+                    }
+                    else {
+                        stateContext.setState = noop;
+                        stateContext.patchState = noop;
+                    }
+                }));
+            }
+            else {
+                // If the action handler is synchronous and returns nothing (`void`), we
+                // still have to convert the result to a synchronous observable.
+                result = of(undefined);
+            }
+            return result;
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalActionHandlerFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalActionHandlerFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: InternalActionHandlerFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+// This is used to replace `setState` and `patchState` once the action
+// handler has been unsubscribed or completed, to prevent writing
+// to the state context.
+function noop() { }
+
 function cloneDefaults(defaults) {
     let value = defaults === undefined ? {} : defaults;
     if (defaults) {
@@ -1133,7 +1208,7 @@ class StateFactory {
     constructor() {
         this._injector = inject(Injector);
         this._config = inject(NgxsConfig);
-        this._stateContextFactory = inject(StateContextFactory);
+        this._actionHandlerFactory = inject(InternalActionHandlerFactory);
         this._actions = inject(InternalActions);
         this._actionResults = inject(InternalDispatchedActionResults);
         this._initialState = inject(_INITIAL_STATE_TOKEN, { optional: true });
@@ -1315,72 +1390,10 @@ class StateFactory {
         return this._statesByName[name] && valueIsBootstrappedInInitialState;
     }
     hydrateActionMetasMap({ path, actions, instance }) {
-        const { dispatched$ } = this._actions;
         for (const actionType of Object.keys(actions)) {
             const actionHandlers = actions[actionType].map(actionMeta => {
-                const cancelable = !!actionMeta.options.cancelUncompleted;
-                return (action) => {
-                    const stateContext = this._stateContextFactory.createStateContext(path);
-                    let result = instance[actionMeta.fn](stateContext, action);
-                    // We need to use `isPromise` instead of checking whether
-                    // `result instanceof Promise`. In zone.js patched environments, `global.Promise`
-                    // is the `ZoneAwarePromise`. Some APIs, which are likely not patched by zone.js
-                    // for certain reasons, might not work with `instanceof`. For instance, the dynamic
-                    // import returns a native promise (not a `ZoneAwarePromise`), causing this check to
-                    // be falsy.
-                    if (_isPromise(result)) {
-                        result = from(result);
-                    }
-                    if (isObservable(result)) {
-                        result = result.pipe(mergeMap((value) => {
-                            if (_isPromise(value) || isObservable(value)) {
-                                return value;
-                            }
-                            else {
-                                return of(value);
-                            }
-                        }), 
-                        // If this observable has completed without emitting any values,
-                        // we wouldn't want to complete the entire chain of actions.
-                        // If any observable completes, then the action will be canceled.
-                        // For instance, if any action handler had a statement like
-                        // `handler(ctx) { return EMPTY; }`, then the action would be canceled.
-                        // See https://github.com/ngxs/store/issues/1568
-                        // Note that we actually don't care about the return type; we only care
-                        // about emission, and thus `undefined` is applicable by the framework.
-                        defaultIfEmpty(undefined));
-                        if (cancelable) {
-                            const canceled = dispatched$.pipe(ofActionDispatched(action));
-                            result = result.pipe(takeUntil(canceled));
-                        }
-                        result = result.pipe(
-                        // Note that we use the `finalize` operator only when the action handler
-                        // explicitly returns an observable (or a promise) to wait for. This means
-                        // the action handler is written in a "fire & wait" style. If the handler’s
-                        // result is unsubscribed (either because the observable has completed or
-                        // it was unsubscribed by `takeUntil` due to a new action being dispatched),
-                        // we prevent writing to the state context.
-                        finalize(() => {
-                            if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-                                function noopAndWarn() {
-                                    console.warn(`"${actionType}" attempted to change the state, but the change was ignored because state updates are not allowed after the action handler has completed.`);
-                                }
-                                stateContext.setState = noopAndWarn;
-                                stateContext.patchState = noopAndWarn;
-                            }
-                            else {
-                                stateContext.setState = noop;
-                                stateContext.patchState = noop;
-                            }
-                        }));
-                    }
-                    else {
-                        // If the action handler is synchronous and returns nothing (`void`), we
-                        // still have to convert the result to a synchronous observable.
-                        result = of(undefined);
-                    }
-                    return result;
-                };
+                const handlerFn = (ctx, action) => instance[actionMeta.fn](ctx, action);
+                return this._actionHandlerFactory.createActionHandler(path, handlerFn, actionMeta.options);
             });
             for (const actionHandler of actionHandlers) {
                 this._actionRegistry.register(actionType, actionHandler);
@@ -1394,10 +1407,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImpor
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
-// This is used to replace `setState` and `patchState` once the action
-// handler has been unsubscribed or completed, to prevent writing
-// to the state context.
-function noop() { }
 
 class Store {
     constructor() {
@@ -1952,6 +1961,23 @@ function Selector(selectors) {
     };
 }
 
+class ActionDirector {
+    constructor() {
+        this._registry = inject(_NgxsActionRegistry);
+        this._actionHandlerFactory = inject(InternalActionHandlerFactory);
+    }
+    attachAction(stateToken, Action, handlerFn, options = {}) {
+        const actionHandler = this._actionHandlerFactory.createActionHandler(stateToken.getName(), handlerFn, options);
+        this._registry.register(Action.type, actionHandler);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: ActionDirector, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: ActionDirector, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.0.0", ngImport: i0, type: ActionDirector, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class NgxsDevelopmentModule {
     static forRoot(options) {
         return {
@@ -2344,5 +2370,5 @@ function ɵprovideNgxsInternalStateTokens() {
  * Generated bundle index. Do not edit.
  */
 
-export { Action, ActionStatus, Actions, NgxsConfig, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, Selector, SelectorOptions, State, Store, createDispatchMap, createModelSelector, createPickSelector, createPropertySelectors, createSelectMap, createSelector, dispatch, lazyProvider, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, select, withNgxsDevelopmentOptions, withNgxsPendingTasks, withNgxsPlugin, withNgxsPreboot, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule, ɵprovideNgxsInternalStateTokens };
+export { Action, ActionDirector, ActionStatus, Actions, NgxsConfig, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, Selector, SelectorOptions, State, Store, createDispatchMap, createModelSelector, createPickSelector, createPropertySelectors, createSelectMap, createSelector, dispatch, lazyProvider, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, select, withNgxsDevelopmentOptions, withNgxsPendingTasks, withNgxsPlugin, withNgxsPreboot, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule, ɵprovideNgxsInternalStateTokens };
 //# sourceMappingURL=ngxs-store.mjs.map