@ngxs/store 18.1.1-dev.master-2833d17 → 18.1.1-dev.master-a8f62df

package/fesm2022/ngxs-store.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { Injectable, NgZone, PLATFORM_ID, Inject, InjectionToken, inject, INJECTOR, Optional, SkipSelf, ErrorHandler, ɵisPromise as _isPromise, computed, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import { Injectable, NgZone, PLATFORM_ID, Inject, InjectionToken, inject, INJECTOR, ErrorHandler, ɵisPromise as _isPromise, Optional, SkipSelf, computed, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
 import { Observable, config, Subject, of, forkJoin, throwError, EMPTY, from, isObservable, shareReplay as shareReplay$1, map as map$1, catchError as catchError$1, distinctUntilChanged, take as take$1, ReplaySubject } from 'rxjs';
 import * as i1 from '@ngxs/store/internals';
 import { ɵwrapObserverCalls as _wrapObserverCalls, ɵOrderedSubject as _OrderedSubject, ɵmemoize as _memoize, ɵgetStoreMetadata as _getStoreMetadata, ɵgetSelectorMetadata as _getSelectorMetadata, ɵMETA_KEY as _META_KEY, ɵINITIAL_STATE_TOKEN as _INITIAL_STATE_TOKEN, ɵNgxsAppBootstrappedState as _NgxsAppBootstrappedState, ɵNGXS_STATE_CONTEXT_FACTORY as _NGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY as _NGXS_STATE_FACTORY, ɵensureStoreMetadata as _ensureStoreMetadata, ɵMETA_OPTIONS_KEY as _META_OPTIONS_KEY, ɵensureSelectorMetadata as _ensureSelectorMetadata } from '@ngxs/store/internals';
@@ -250,38 +250,34 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
         }], ctorParameters: () => [{ type: InternalActions }, { type: InternalNgxsExecutionStrategy }] });
 
 class PluginManager {
-    constructor(_parentManager, _pluginHandlers) {
-        this._parentManager = _parentManager;
-        this._pluginHandlers = _pluginHandlers;
+    constructor() {
         this.plugins = [];
+        this._parentManager = inject(PluginManager, {
+            optional: true,
+            skipSelf: true
+        });
+        this._pluginHandlers = inject(NGXS_PLUGINS, {
+            optional: true
+        });
         this.registerHandlers();
     }
-    get rootPlugins() {
-        return (this._parentManager && this._parentManager.plugins) || this.plugins;
+    get _rootPlugins() {
+        return this._parentManager?.plugins || this.plugins;
     }
     registerHandlers() {
         const pluginHandlers = this.getPluginHandlers();
-        this.rootPlugins.push(...pluginHandlers);
+        this._rootPlugins.push(...pluginHandlers);
     }
     getPluginHandlers() {
         const handlers = this._pluginHandlers || [];
         return handlers.map((plugin) => (plugin.handle ? plugin.handle.bind(plugin) : plugin));
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: PluginManager, deps: [{ token: PluginManager, optional: true, skipSelf: true }, { token: NGXS_PLUGINS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: PluginManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: PluginManager }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: PluginManager, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: PluginManager, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [NGXS_PLUGINS]
-                }, {
-                    type: Optional
-                }] }] });
+        }], ctorParameters: () => [] });
 
 const ɵɵunhandledRxjsErrorCallbacks = new WeakMap();
 const existingHandler = config.onUnhandledError;
@@ -1025,25 +1021,25 @@ class StateContextFactory {
     /**
      * Create the state context
      */
-    createStateContext(mappedStore) {
+    createStateContext(path) {
         const root = this._internalStateOperations.getRootStateOperations();
         return {
             getState() {
                 const currentAppState = root.getState();
-                return getState(currentAppState, mappedStore.path);
+                return getState(currentAppState, path);
             },
             patchState(val) {
                 const currentAppState = root.getState();
                 const patchOperator = simplePatch(val);
-                setStateFromOperator(root, currentAppState, patchOperator, mappedStore.path);
+                setStateFromOperator(root, currentAppState, patchOperator, path);
             },
             setState(val) {
                 const currentAppState = root.getState();
                 if (isStateOperator(val)) {
-                    setStateFromOperator(root, currentAppState, val, mappedStore.path);
+                    setStateFromOperator(root, currentAppState, val, path);
                 }
                 else {
-                    setStateValue(root, currentAppState, val, mappedStore.path);
+                    setStateValue(root, currentAppState, val, path);
                 }
             },
             dispatch(actions) {
@@ -1237,6 +1233,12 @@ class StateFactory {
         this._actionsSubscription = null;
         this._propGetter = inject(ɵPROP_GETTER);
         this._ngxsUnhandledErrorHandler = null;
+        // Instead of going over the states list every time an action is dispatched,
+        // we are constructing a map of action types to lists of action metadata.
+        // If the `@@Init` action is handled in two different states, the action
+        // metadata list will contain two objects that have the state `instance` and
+        // method names to be used as action handlers (decorated with `@Action(InitState)`).
+        this._actionTypeToMetasMap = new Map();
         this._states = [];
         this._statesByName = {};
         this._statePaths = {};
@@ -1277,6 +1279,11 @@ class StateFactory {
             return context;
         });
     }
+    get actionTypeToMetasMap() {
+        return this._parentFactory
+            ? this._parentFactory.actionTypeToMetasMap
+            : this._actionTypeToMetasMap;
+    }
     get states() {
         return this._parentFactory ? this._parentFactory.states : this._states;
     }
@@ -1331,6 +1338,7 @@ class StateFactory {
                 bootstrappedStores.push(stateMap);
             }
             this.states.push(stateMap);
+            this.hydrateActionMetasMap(stateMap);
         }
         return bootstrappedStores;
     }
@@ -1377,55 +1385,53 @@ class StateFactory {
         // Determines whether the dispatched action has been handled, this is assigned
         // to `true` within the below `for` loop if any `actionMetas` has been found.
         let actionHasBeenHandled = false;
-        for (const metadata of this.states) {
-            const actionMetas = metadata.actions[type];
-            if (actionMetas) {
-                for (const actionMeta of actionMetas) {
-                    const stateContext = this._stateContextFactory.createStateContext(metadata);
-                    try {
-                        let result = metadata.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)) {
-                            // If this observable has been completed w/o emitting
-                            // any value then we wouldn't want to complete the whole chain
-                            // of actions. Since if any observable completes then
-                            // action will be canceled.
-                            // For instance if any action handler would've had such statement:
-                            // `handler(ctx) { return EMPTY; }`
-                            // then the action will be canceled.
-                            // See https://github.com/ngxs/store/issues/1568
-                            result = result.pipe(mergeMap((value) => {
-                                if (_isPromise(value)) {
-                                    return from(value);
-                                }
-                                if (isObservable(value)) {
-                                    return value;
-                                }
-                                return of(value);
-                            }), defaultIfEmpty({}));
-                            if (actionMeta.options.cancelUncompleted) {
-                                // todo: ofActionDispatched should be used with action class
-                                result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched(action))));
+        const actionMetas = this.actionTypeToMetasMap.get(type);
+        if (actionMetas) {
+            for (const actionMeta of actionMetas) {
+                const stateContext = this._stateContextFactory.createStateContext(actionMeta.path);
+                let result;
+                try {
+                    result = actionMeta.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)) {
+                                return from(value);
                             }
+                            if (isObservable(value)) {
+                                return value;
+                            }
+                            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
+                        defaultIfEmpty({}));
+                        if (actionMeta.options.cancelUncompleted) {
+                            // todo: ofActionDispatched should be used with action class
+                            result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched(action))));
                         }
-                        else {
-                            result = of({}).pipe(shareReplay());
-                        }
-                        results.push(result);
                     }
-                    catch (e) {
-                        results.push(throwError(e));
+                    else {
+                        result = of({}).pipe(shareReplay());
                     }
-                    actionHasBeenHandled = true;
                 }
+                catch (e) {
+                    result = throwError(e);
+                }
+                results.push(result);
+                actionHasBeenHandled = true;
             }
         }
         // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions
@@ -1435,9 +1441,7 @@ class StateFactory {
             // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the
             // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`
             // didn't return `null` so we may ensure the module has been imported.
-            if (unhandledActionsLogger) {
-                unhandledActionsLogger.warn(action);
-            }
+            unhandledActionsLogger?.warn(action);
         }
         if (!results.length) {
             results.push(of({}));
@@ -1473,6 +1477,28 @@ class StateFactory {
         // its lifecycle is in 'bootstrapped' state.
         return this.statesByName[name] && valueIsBootstrappedInInitialState;
     }
+    hydrateActionMetasMap({ path, actions, instance }) {
+        const actionTypeToMetasMap = this.actionTypeToMetasMap;
+        for (const actionType of Object.keys(actions)) {
+            // Initialize the map entry if it does not already exist for that
+            // action type. Note that action types may overlap between states,
+            // as the same action can be handled by different states.
+            if (!actionTypeToMetasMap.has(actionType)) {
+                actionTypeToMetasMap.set(actionType, []);
+            }
+            const extendedActionMetas = actionTypeToMetasMap.get(actionType);
+            extendedActionMetas.push(
+            // This involves combining each individual action metadata with
+            // the state instance and the path—essentially everything needed
+            // to invoke an action. This eliminates the need to loop over states
+            // every time an action is dispatched.
+            ...actions[actionType].map(actionMeta => ({
+                ...actionMeta,
+                path,
+                instance
+            })));
+        }
+    }
     /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, deps: [{ token: i0.Injector }, { token: NgxsConfig }, { token: StateFactory, optional: true, skipSelf: true }, { token: InternalActions }, { token: InternalDispatchedActionResults }, { token: StateContextFactory }, { token: _INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory }); }
 }
@@ -1705,7 +1731,7 @@ class LifecycleStateManager {
         }
     }
     _getStateContext(mappedStore) {
-        return this._stateContextFactory.createStateContext(mappedStore);
+        return this._stateContextFactory.createStateContext(mappedStore.path);
     }
     /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: LifecycleStateManager, deps: [{ token: Store }, { token: InternalStateOperations }, { token: StateContextFactory }, { token: i1.ɵNgxsAppBootstrappedState }], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' }); }
@@ -2293,7 +2319,13 @@ function provideStates(states, ...features) {
  * ```
  */
 function withNgxsPlugin(plugin) {
-    return makeEnvironmentProviders([{ provide: NGXS_PLUGINS, useClass: plugin, multi: true }]);
+    return makeEnvironmentProviders([
+        { provide: NGXS_PLUGINS, useClass: plugin, multi: true },
+        // We should inject the `PluginManager` to retrieve `NGXS_PLUGINS` and
+        // register those plugins. The plugin can be added from inside the child
+        // route, so the plugin manager should be re-injected.
+        { provide: ENVIRONMENT_INITIALIZER, useValue: () => inject(PluginManager), multi: true }
+    ]);
 }
 
 /**