@ngxs/store 18.1.1-dev.master-76347ef → 18.1.1-dev.master-e935e57

package/fesm2022/ngxs-store.mjs

@@ -1025,25 +1025,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 +1237,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 +1283,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 +1342,7 @@ class StateFactory {
                 bootstrappedStores.push(stateMap);
             }
             this.states.push(stateMap);
+            this.hydrateActionMetasMap(stateMap);
         }
         return bootstrappedStores;
     }
@@ -1377,55 +1389,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 +1445,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 +1481,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 +1735,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' }); }