@ngxs/store 18.1.1-dev.master-e935e57 → 18.1.1-dev.master-d6b076c

package/fesm2022/ngxs-store.mjs

@@ -1,12 +1,12 @@
 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 { 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 { Injectable, NgZone, PLATFORM_ID, Inject, InjectionToken, inject, INJECTOR, ErrorHandler, Injector, ɵisPromise as _isPromise, computed, Optional, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import { Subject, filter, Observable, share, config, of, forkJoin, throwError, EMPTY, mergeMap, map as map$1, defaultIfEmpty, catchError, from, isObservable, takeUntil, shareReplay as shareReplay$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';
 export { StateToken } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
-import { share, map, shareReplay, filter, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, tap, startWith, pairwise } from 'rxjs/operators';
-import { NGXS_PLUGINS, getActionTypeFromInstance, setValue, getValue, InitState, UpdateState } from '@ngxs/store/plugins';
+import { map, shareReplay, filter as filter$1, take, exhaustMap, tap, mergeMap as mergeMap$1, takeUntil as takeUntil$1, startWith, pairwise } from 'rxjs/operators';
+import { NGXS_PLUGINS, getActionTypeFromInstance, InitState, UpdateState, setValue, getValue } from '@ngxs/store/plugins';
 export { InitState, NGXS_PLUGINS, UpdateState, actionMatcher, getActionTypeFromInstance, getValue, setValue } from '@ngxs/store/plugins';
 import { isStateOperator } from '@ngxs/store/operators';
 
@@ -209,16 +209,25 @@ function leaveNgxs(ngxsExecutionStrategy) {
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
 class InternalActions extends _OrderedSubject {
+    constructor() {
+        super();
+        // This subject will be the first to know about the dispatched action, its purpose is for
+        // any logic that must be executed before action handlers are invoked (i.e., cancelation).
+        this.dispatched$ = new Subject();
+        this.pipe(filter(ctx => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */)).subscribe(ctx => {
+            this.dispatched$.next(ctx);
+        });
+    }
     ngOnDestroy() {
         this.complete();
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalActions, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalActions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalActions, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalActions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }] });
+        }], ctorParameters: () => [] });
 /**
  * Action stream that is emitted anytime an action is dispatched.
  *
@@ -250,38 +259,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;
@@ -412,7 +417,7 @@ class InternalDispatcher {
         ])(prevState, action).pipe(shareReplay());
     }
     getActionResultStream(action) {
-        return this._actionResults.pipe(filter((ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* ActionStatus.Dispatched */), take(1), shareReplay());
+        return this._actionResults.pipe(filter$1((ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* ActionStatus.Dispatched */), take(1), shareReplay());
     }
     createDispatchObservable(actionResult$) {
         return actionResult$
@@ -893,190 +898,37 @@ function topologicalSort(graph) {
     return sorted.reverse();
 }
 
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will grab actions that have just been dispatched as well as actions that have completed
- */
-function ofAction(...allowedTypes) {
-    return ofActionOperator(allowedTypes);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been dispatched
- */
-function ofActionDispatched(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["DISPATCHED" /* ActionStatus.Dispatched */]);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been successfully completed
- */
-function ofActionSuccessful(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["SUCCESSFUL" /* ActionStatus.Successful */]);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been canceled
- */
-function ofActionCanceled(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["CANCELED" /* ActionStatus.Canceled */]);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been completed
- */
-function ofActionCompleted(...allowedTypes) {
-    const allowedStatuses = [
-        "SUCCESSFUL" /* ActionStatus.Successful */,
-        "CANCELED" /* ActionStatus.Canceled */,
-        "ERRORED" /* ActionStatus.Errored */
-    ];
-    return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just thrown an error
- */
-function ofActionErrored(...allowedTypes) {
-    return ofActionOperator(allowedTypes, ["ERRORED" /* ActionStatus.Errored */], mapActionResult);
-}
-function ofActionOperator(allowedTypes, statuses, 
-// This could have been written as
-// `OperatorFunction<ActionContext, ActionCompletion | any>`, as it maps
-// either to `ctx.action` or to `ActionCompletion`. However,
-// `ActionCompletion | any` defaults to `any`, rendering the union
-// type meaningless.
-mapOperator = mapAction) {
-    const allowedMap = createAllowedActionTypesMap(allowedTypes);
-    const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);
-    return function (o) {
-        return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());
-    };
-}
-function filterStatus(allowedTypes, allowedStatuses) {
-    return filter((ctx) => {
-        const actionType = getActionTypeFromInstance(ctx.action);
-        const typeMatch = allowedTypes[actionType];
-        const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;
-        return typeMatch && statusMatch;
-    });
-}
-function mapActionResult() {
-    return map(({ action, status, error }) => {
-        return {
-            action,
-            result: {
-                successful: "SUCCESSFUL" /* ActionStatus.Successful */ === status,
-                canceled: "CANCELED" /* ActionStatus.Canceled */ === status,
-                error
-            }
-        };
-    });
-}
-function mapAction() {
-    return map((ctx) => ctx.action);
-}
-function createAllowedActionTypesMap(types) {
-    return types.reduce((filterMap, klass) => {
-        filterMap[getActionTypeFromInstance(klass)] = true;
-        return filterMap;
-    }, {});
-}
-function createAllowedStatusesMap(statuses) {
-    return statuses.reduce((filterMap, status) => {
-        filterMap[status] = true;
-        return filterMap;
-    }, {});
-}
-
-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(_internalStateOperations) {
-        this._internalStateOperations = _internalStateOperations;
+class NgxsActionRegistry {
+    constructor() {
+        // 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._actionTypeToHandlersMap = new Map();
     }
-    /**
-     * 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);
-            }
+    ngOnDestroy() {
+        this._actionTypeToHandlersMap.clear();
+    }
+    get(type) {
+        return this._actionTypeToHandlersMap.get(type);
+    }
+    register(type, handler) {
+        const handlers = this._actionTypeToHandlersMap.get(type) ?? new Set();
+        handlers.add(handler);
+        this._actionTypeToHandlersMap.set(type, handlers);
+        return () => {
+            const handlers = this._actionTypeToHandlersMap.get(type);
+            handlers.delete(handler);
         };
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateContextFactory, deps: [{ token: InternalStateOperations }], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateContextFactory, providedIn: 'root' }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: NgxsActionRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: NgxsActionRegistry, providedIn: 'root' }); }
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateContextFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: NgxsActionRegistry, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: InternalStateOperations }] });
-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);
-}
+        }] });
 
 const stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');
 function ensureStateNameIsValid(name) {
@@ -1199,6 +1051,191 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", 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(_internalStateOperations) {
+        this._internalStateOperations = _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: "18.0.6", ngImport: i0, type: StateContextFactory, deps: [{ token: InternalStateOperations }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateContextFactory, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateContextFactory, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: InternalStateOperations }] });
+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.
+ *
+ * This will grab actions that have just been dispatched as well as actions that have completed
+ */
+function ofAction(...allowedTypes) {
+    return ofActionOperator(allowedTypes);
+}
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been dispatched
+ */
+function ofActionDispatched(...allowedTypes) {
+    return ofActionOperator(allowedTypes, ["DISPATCHED" /* ActionStatus.Dispatched */]);
+}
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been successfully completed
+ */
+function ofActionSuccessful(...allowedTypes) {
+    return ofActionOperator(allowedTypes, ["SUCCESSFUL" /* ActionStatus.Successful */]);
+}
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been canceled
+ */
+function ofActionCanceled(...allowedTypes) {
+    return ofActionOperator(allowedTypes, ["CANCELED" /* ActionStatus.Canceled */]);
+}
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been completed
+ */
+function ofActionCompleted(...allowedTypes) {
+    const allowedStatuses = [
+        "SUCCESSFUL" /* ActionStatus.Successful */,
+        "CANCELED" /* ActionStatus.Canceled */,
+        "ERRORED" /* ActionStatus.Errored */
+    ];
+    return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);
+}
+/**
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just thrown an error
+ */
+function ofActionErrored(...allowedTypes) {
+    return ofActionOperator(allowedTypes, ["ERRORED" /* ActionStatus.Errored */], mapActionResult);
+}
+function ofActionOperator(allowedTypes, statuses, 
+// This could have been written as
+// `OperatorFunction<ActionContext, ActionCompletion | any>`, as it maps
+// either to `ctx.action` or to `ActionCompletion`. However,
+// `ActionCompletion | any` defaults to `any`, rendering the union
+// type meaningless.
+mapOperator = mapAction) {
+    const allowedMap = createAllowedActionTypesMap(allowedTypes);
+    const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);
+    return function (o) {
+        return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());
+    };
+}
+function filterStatus(allowedTypes, allowedStatuses) {
+    return filter$1((ctx) => {
+        const actionType = getActionTypeFromInstance(ctx.action);
+        const typeMatch = allowedTypes[actionType];
+        const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;
+        return typeMatch && statusMatch;
+    });
+}
+function mapActionResult() {
+    return map(({ action, status, error }) => {
+        return {
+            action,
+            result: {
+                successful: "SUCCESSFUL" /* ActionStatus.Successful */ === status,
+                canceled: "CANCELED" /* ActionStatus.Canceled */ === status,
+                error
+            }
+        };
+    });
+}
+function mapAction() {
+    return map((ctx) => ctx.action);
+}
+function createAllowedActionTypesMap(types) {
+    return types.reduce((filterMap, klass) => {
+        filterMap[getActionTypeFromInstance(klass)] = true;
+        return filterMap;
+    }, {});
+}
+function createAllowedStatusesMap(statuses) {
+    return statuses.reduce((filterMap, status) => {
+        filterMap[status] = true;
+        return filterMap;
+    }, {});
+}
+
 const NG_DEV_MODE$3 = typeof ngDevMode !== 'undefined' && ngDevMode;
 function cloneDefaults(defaults) {
     let value = defaults === undefined ? {} : defaults;
@@ -1226,23 +1263,18 @@ function cloneDefaults(defaults) {
  * @ignore
  */
 class StateFactory {
-    constructor(_injector, _config, _parentFactory, _actions, _actionResults, _stateContextFactory, _initialState) {
-        this._injector = _injector;
-        this._config = _config;
-        this._parentFactory = _parentFactory;
-        this._actions = _actions;
-        this._actionResults = _actionResults;
-        this._stateContextFactory = _stateContextFactory;
-        this._initialState = _initialState;
-        this._actionsSubscription = null;
+    constructor() {
+        this._injector = inject(Injector);
+        this._config = inject(NgxsConfig);
+        this._parentFactory = inject(StateFactory, { optional: true, skipSelf: true });
+        this._stateContextFactory = inject(StateContextFactory);
+        this._actions = inject(InternalActions);
+        this._actionResults = inject(InternalDispatchedActionResults);
+        this._initialState = inject(_INITIAL_STATE_TOKEN, { optional: true });
+        this._actionRegistry = inject(NgxsActionRegistry);
         this._propGetter = inject(ɵPROP_GETTER);
+        this._actionsSubscription = null;
         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 = {};
@@ -1283,11 +1315,6 @@ class StateFactory {
             return context;
         });
     }
-    get actionTypeToMetasMap() {
-        return this._parentFactory
-            ? this._parentFactory.actionTypeToMetasMap
-            : this._actionTypeToMetasMap;
-    }
     get states() {
         return this._parentFactory ? this._parentFactory.states : this._states;
     }
@@ -1362,12 +1389,10 @@ class StateFactory {
         if (this._parentFactory || this._actionsSubscription !== null) {
             return;
         }
-        const dispatched$ = new Subject();
         this._actionsSubscription = this._actions
             .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */), mergeMap(ctx => {
-            dispatched$.next(ctx);
             const action = ctx.action;
-            return this.invokeActions(dispatched$, action).pipe(map(() => ({ action, status: "SUCCESSFUL" /* ActionStatus.Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* ActionStatus.Canceled */ }), catchError(error => {
+            return this.invokeActions(action).pipe(map$1(() => ({ action, status: "SUCCESSFUL" /* ActionStatus.Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* ActionStatus.Canceled */ }), catchError(error => {
                 const ngxsUnhandledErrorHandler = (this._ngxsUnhandledErrorHandler ||=
                     this._injector.get(NgxsUnhandledErrorHandler));
                 const handleableError = assignUnhandledCallback(error, () => ngxsUnhandledErrorHandler.handleError(error, { action }));
@@ -1383,53 +1408,18 @@ class StateFactory {
     /**
      * Invoke actions on the states.
      */
-    invokeActions(dispatched$, action) {
+    invokeActions(action) {
         const type = getActionTypeFromInstance(action);
         const results = [];
         // 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;
-        const actionMetas = this.actionTypeToMetasMap.get(type);
-        if (actionMetas) {
-            for (const actionMeta of actionMetas) {
-                const stateContext = this._stateContextFactory.createStateContext(actionMeta.path);
+        const actionHandlers = this._actionRegistry.get(type);
+        if (actionHandlers) {
+            for (const actionHandler of actionHandlers) {
                 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());
-                    }
+                    result = actionHandler(action);
                 }
                 catch (e) {
                     result = throwError(e);
@@ -1482,42 +1472,60 @@ class StateFactory {
         return this.statesByName[name] && valueIsBootstrappedInInitialState;
     }
     hydrateActionMetasMap({ path, actions, instance }) {
-        const actionTypeToMetasMap = this.actionTypeToMetasMap;
+        const { dispatched$ } = this._actions;
         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 actionHandlers = actions[actionType].map(actionMeta => {
+                // action: Instance<ActionType>
+                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)) {
+                                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) {
+                            result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched(action))));
+                        }
+                    }
+                    else {
+                        result = of({}).pipe(shareReplay$1());
+                    }
+                    return result;
+                };
+            });
+            for (const actionHandler of actionHandlers) {
+                this._actionRegistry.register(actionType, actionHandler);
             }
-            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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: i0.Injector }, { type: NgxsConfig }, { type: StateFactory, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }, { type: InternalActions }, { type: InternalDispatchedActionResults }, { type: StateContextFactory }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [_INITIAL_STATE_TOKEN]
-                }] }] });
+        }] });
 
 class Store {
     constructor(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {
@@ -1545,7 +1553,7 @@ class Store {
      */
     select(selector) {
         const selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._selectableStateStream.pipe(map$1(selectorFn), catchError$1((error) => {
+        return this._selectableStateStream.pipe(map$1(selectorFn), catchError((error) => {
             // if error is TypeError we swallow it to prevent usual errors with property access
             if (this._config.selectorOptions.suppressErrors && error instanceof TypeError) {
                 return of(undefined);
@@ -1705,7 +1713,7 @@ class LifecycleStateManager {
         this._internalStateOperations
             .getRootStateOperations()
             .dispatch(action)
-            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._appBootstrappedState), filter(appBootstrapped => !!appBootstrapped), takeUntil(this._destroy$))
+            .pipe(filter$1(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap$1(() => this._appBootstrappedState), filter$1(appBootstrapped => !!appBootstrapped), takeUntil$1(this._destroy$))
             .subscribe(() => this._invokeBootstrapOnStates(results.states));
     }
     _invokeInitOnStates(mappedStores) {
@@ -1714,7 +1722,7 @@ class LifecycleStateManager {
             if (instance.ngxsOnChanges) {
                 this._store
                     .select(state => getValue(state, mappedStore.path))
-                    .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))
+                    .pipe(startWith(undefined), pairwise(), takeUntil$1(this._destroy$))
                     .subscribe(([previousValue, currentValue]) => {
                     const change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
                     instance.ngxsOnChanges(change);
@@ -2323,7 +2331,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 }
+    ]);
 }
 
 /**