@ngxs/store 18.1.5 → 18.1.6

package/fesm2022/ngxs-store.mjs

@@ -1,12 +1,11 @@
 import * as i0 from '@angular/core';
-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, finalize, 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, ɵ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';
+import { Injectable, inject, NgZone, PLATFORM_ID, InjectionToken, INJECTOR, Injector, runInInjectionContext, ErrorHandler, ɵisPromise as _isPromise, computed, makeEnvironmentProviders, ENVIRONMENT_INITIALIZER, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import { Subject, filter, Observable, share, config, of, forkJoin, throwError, mergeMap as mergeMap$1, map as map$1, defaultIfEmpty, catchError, from, isObservable, takeUntil, finalize, shareReplay as shareReplay$1, distinctUntilChanged, take as take$1, ReplaySubject } from 'rxjs';
+import { ɵwrapObserverCalls as _wrapObserverCalls, ɵOrderedSubject as _OrderedSubject, ɵStateStream as _StateStream, ɵmemoize as _memoize, ɵgetStoreMetadata as _getStoreMetadata, ɵgetSelectorMetadata as _getSelectorMetadata, ɵMETA_KEY as _META_KEY, ɵINITIAL_STATE_TOKEN as _INITIAL_STATE_TOKEN, ɵ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 { isPlatformServer } from '@angular/common';
-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';
+import { map, shareReplay, filter as filter$1, take, mergeMap, tap, takeUntil as takeUntil$1, startWith, pairwise } from 'rxjs/operators';
+import { NGXS_PLUGINS, getActionTypeFromInstance, InitState, UpdateState, setValue, getValue, ɵisPluginClass as _isPluginClass } from '@ngxs/store/plugins';
 export { InitState, NGXS_PLUGINS, UpdateState, actionMatcher, getActionTypeFromInstance, getValue, setValue } from '@ngxs/store/plugins';
 import { isStateOperator } from '@ngxs/store/operators';
 
@@ -74,15 +73,15 @@ function throwPatchingPrimitiveError() {
 }
 
 class DispatchOutsideZoneNgxsExecutionStrategy {
-    constructor(_ngZone, _platformId) {
-        this._ngZone = _ngZone;
-        this._platformId = _platformId;
+    constructor() {
+        this._ngZone = inject(NgZone);
+        this._isServer = isPlatformServer(inject(PLATFORM_ID));
         if (typeof ngDevMode !== 'undefined' && ngDevMode) {
-            verifyZoneIsNotNooped(_ngZone);
+            verifyZoneIsNotNooped(this._ngZone);
         }
     }
     enter(func) {
-        if (isPlatformServer(this._platformId)) {
+        if (this._isServer) {
             return this.runInsideAngular(func);
         }
         return this.runOutsideAngular(func);
@@ -102,16 +101,13 @@ class DispatchOutsideZoneNgxsExecutionStrategy {
         }
         return func();
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i0.NgZone }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [PLATFORM_ID]
-                }] }] });
+        }], ctorParameters: () => [] });
 // Caretaker note: this should exist as a separate function and not a class method,
 // since class methods are not tree-shakable.
 function verifyZoneIsNotNooped(ngZone) {
@@ -124,18 +120,17 @@ function verifyZoneIsNotNooped(ngZone) {
     console.warn(getZoneWarningMessage());
 }
 
-const NG_DEV_MODE$9 = typeof ngDevMode !== 'undefined' && ngDevMode;
 /**
  * Consumers have the option to utilize the execution strategy provided by
  * `NgxsModule.forRoot({executionStrategy})` or `provideStore([], {executionStrategy})`.
  */
-const CUSTOM_NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$9 ? 'CUSTOM_NGXS_EXECUTION_STRATEGY' : '');
+const CUSTOM_NGXS_EXECUTION_STRATEGY = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'CUSTOM_NGXS_EXECUTION_STRATEGY' : '');
 /**
  * The injection token is used internally to resolve an instance of the execution
  * strategy. It checks whether consumers have provided their own `executionStrategy`
  * and also verifies if we are operating in a zone-aware environment.
  */
-const NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$9 ? 'NGXS_EXECUTION_STRATEGY' : '', {
+const NGXS_EXECUTION_STRATEGY = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_EXECUTION_STRATEGY' : '', {
     providedIn: 'root',
     factory: () => {
         const ngZone = inject(NgZone);
@@ -151,8 +146,8 @@ const NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$9 ? 'NGXS_EXECUTI
 });
 
 class InternalNgxsExecutionStrategy {
-    constructor(_executionStrategy) {
-        this._executionStrategy = _executionStrategy;
+    constructor() {
+        this._executionStrategy = inject(NGXS_EXECUTION_STRATEGY);
     }
     enter(func) {
         return this._executionStrategy.enter(func);
@@ -160,42 +155,13 @@ class InternalNgxsExecutionStrategy {
     leave(func) {
         return this._executionStrategy.leave(func);
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [{ token: NGXS_EXECUTION_STRATEGY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalNgxsExecutionStrategy, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [NGXS_EXECUTION_STRATEGY]
-                }] }] });
-
-/**
- * Composes a array of functions from left to right. Example:
- *
- *      compose([fn, final])(state, action);
- *
- * then the funcs have a signature like:
- *
- *      function fn (state, action, next) {
- *          console.log('here', state, action, next);
- *          return next(state, action);
- *      }
- *
- *      function final (state, action) {
- *          console.log('here', state, action);
- *          return state;
- *      }
- *
- * the last function should not call `next`.
- *
- * @ignore
- */
-const compose = (funcs) => (...args) => {
-    const curr = funcs.shift();
-    return curr(...args, (...nextArgs) => compose(funcs)(...nextArgs));
-};
+        }] });
 
 /**
  * Returns operator that will run
@@ -234,7 +200,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
  * You can listen to this in services to react without stores.
  */
 class Actions extends Observable {
-    constructor(internalActions$, internalExecutionStrategy) {
+    constructor() {
+        const internalActions$ = inject(InternalActions);
+        const internalExecutionStrategy = inject(InternalNgxsExecutionStrategy);
         const sharedInternalActions$ = internalActions$.pipe(leaveNgxs(internalExecutionStrategy), 
         // The `InternalActions` subject emits outside of the Angular zone.
         // We have to re-enter the Angular zone for any incoming consumer.
@@ -250,13 +218,13 @@ class Actions extends Observable {
             observer.add(childSubscription);
         });
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: Actions, deps: [{ token: InternalActions }, { token: InternalNgxsExecutionStrategy }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: Actions, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: Actions, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: Actions, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: InternalActions }, { type: InternalNgxsExecutionStrategy }] });
+        }], ctorParameters: () => [] });
 
 class PluginManager {
     constructor() {
@@ -282,26 +250,34 @@ class PluginManager {
         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: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: PluginManager }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: PluginManager, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: PluginManager, decorators: [{
-            type: Injectable
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [] });
 
 const ɵɵunhandledRxjsErrorCallbacks = new WeakMap();
-const existingHandler = config.onUnhandledError;
-config.onUnhandledError = function (error) {
-    const unhandledErrorCallback = ɵɵunhandledRxjsErrorCallbacks.get(error);
-    if (unhandledErrorCallback) {
-        unhandledErrorCallback();
-    }
-    else if (existingHandler) {
-        existingHandler.call(this, error);
-    }
-    else {
-        throw error;
+let installed = false;
+function installOnUnhandhedErrorHandler() {
+    if (installed) {
+        return;
     }
-};
+    const existingHandler = config.onUnhandledError;
+    config.onUnhandledError = function (error) {
+        const unhandledErrorCallback = ɵɵunhandledRxjsErrorCallbacks.get(error);
+        if (unhandledErrorCallback) {
+            unhandledErrorCallback();
+        }
+        else if (existingHandler) {
+            existingHandler.call(this, error);
+        }
+        else {
+            throw error;
+        }
+    };
+    installed = true;
+}
 function executeUnhandledCallback(error) {
     const unhandledErrorCallback = ɵɵunhandledRxjsErrorCallbacks.get(error);
     if (unhandledErrorCallback) {
@@ -368,13 +344,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 class InternalDispatcher {
-    constructor(_ngZone, _actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy) {
-        this._ngZone = _ngZone;
-        this._actions = _actions;
-        this._actionResults = _actionResults;
-        this._pluginManager = _pluginManager;
-        this._stateStream = _stateStream;
-        this._ngxsExecutionStrategy = _ngxsExecutionStrategy;
+    constructor() {
+        this._ngZone = inject(NgZone);
+        this._actions = inject(InternalActions);
+        this._actionResults = inject(InternalDispatchedActionResults);
+        this._pluginManager = inject(PluginManager);
+        this._stateStream = inject(_StateStream);
+        this._ngxsExecutionStrategy = inject(InternalNgxsExecutionStrategy);
+        this._injector = inject(Injector);
     }
     /**
      * Dispatches event(s).
@@ -403,7 +380,7 @@ class InternalDispatcher {
         }
         const prevState = this._stateStream.getValue();
         const plugins = this._pluginManager.plugins;
-        return compose([
+        return compose(this._injector, [
             ...plugins,
             (nextState, nextAction) => {
                 if (nextState !== prevState) {
@@ -420,41 +397,63 @@ class InternalDispatcher {
         return this._actionResults.pipe(filter$1((ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* ActionStatus.Dispatched */), take(1), shareReplay());
     }
     createDispatchObservable(actionResult$) {
-        return actionResult$
-            .pipe(exhaustMap((ctx) => {
+        return actionResult$.pipe(mergeMap((ctx) => {
             switch (ctx.status) {
                 case "SUCCESSFUL" /* ActionStatus.Successful */:
                     // The `createDispatchObservable` function should return the
-                    // state, as its result is utilized by plugins.
+                    // state, as its result is used by plugins.
                     return of(this._stateStream.getValue());
                 case "ERRORED" /* ActionStatus.Errored */:
                     return throwError(() => ctx.error);
                 default:
-                    return EMPTY;
+                    // Once dispatched or canceled, we complete it immediately because
+                    // `dispatch()` should emit (or error, or complete) as soon as it succeeds or fails.
+                    return of();
             }
-        }))
-            .pipe(shareReplay());
+        }), shareReplay());
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalDispatcher, deps: [{ token: i0.NgZone }, { token: InternalActions }, { token: InternalDispatchedActionResults }, { token: PluginManager }, { token: i1.ɵStateStream }, { token: InternalNgxsExecutionStrategy }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalDispatcher, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalDispatcher, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalDispatcher, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i0.NgZone }, { type: InternalActions }, { type: InternalDispatchedActionResults }, { type: PluginManager }, { type: i1.ɵStateStream }, { type: InternalNgxsExecutionStrategy }] });
+        }] });
+/**
+ * Composes a array of functions from left to right. Example:
+ *
+ *      compose([fn, final])(state, action);
+ *
+ * then the funcs have a signature like:
+ *
+ *      function fn (state, action, next) {
+ *          console.log('here', state, action, next);
+ *          return next(state, action);
+ *      }
+ *
+ *      function final (state, action) {
+ *          console.log('here', state, action);
+ *          return state;
+ *      }
+ *
+ * the last function should not call `next`.
+ */
+const compose = (injector, funcs) => (...args) => {
+    const curr = funcs.shift();
+    return runInInjectionContext(injector, () => curr(...args, (...nextArgs) => compose(injector, funcs)(...nextArgs)));
+};
 
-const NG_DEV_MODE$8 = typeof ngDevMode !== 'undefined' && ngDevMode;
 // The injection token is used to resolve a list of states provided at
 // the root level through either `NgxsModule.forRoot` or `provideStore`.
-const ROOT_STATE_TOKEN = new InjectionToken(NG_DEV_MODE$8 ? 'ROOT_STATE_TOKEN' : '');
+const ROOT_STATE_TOKEN = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'ROOT_STATE_TOKEN' : '');
 // The injection token is used to resolve a list of states provided at
 // the feature level through either `NgxsModule.forFeature` or `provideStates`.
 // The Array<Array> is used to overload the resolved value of the token because
 // it is a multi-provider token.
-const FEATURE_STATE_TOKEN = new InjectionToken(NG_DEV_MODE$8 ? 'FEATURE_STATE_TOKEN' : '');
+const FEATURE_STATE_TOKEN = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'FEATURE_STATE_TOKEN' : '');
 // The injection token is used to resolve to options provided at the root
 // level through either `NgxsModule.forRoot` or `provideStore`.
-const NGXS_OPTIONS = new InjectionToken(NG_DEV_MODE$8 ? 'NGXS_OPTIONS' : '');
+const NGXS_OPTIONS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_OPTIONS' : '');
 /**
  * The NGXS config settings.
  */
@@ -551,10 +550,10 @@ const deepFreeze = (o) => {
  * @ignore
  */
 class InternalStateOperations {
-    constructor(_stateStream, _dispatcher, _config) {
-        this._stateStream = _stateStream;
-        this._dispatcher = _dispatcher;
-        this._config = _config;
+    constructor() {
+        this._stateStream = inject(_StateStream);
+        this._dispatcher = inject(InternalDispatcher);
+        this._config = inject(NgxsConfig);
     }
     /**
      * Returns the root state operators.
@@ -581,13 +580,13 @@ class InternalStateOperations {
         // Set the state to the current + new
         stateOperations.setState({ ...currentState, ...results.defaults });
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalStateOperations, deps: [{ token: i1.ɵStateStream }, { token: InternalDispatcher }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalStateOperations, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalStateOperations, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: InternalStateOperations, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1.ɵStateStream }, { type: InternalDispatcher }, { type: NgxsConfig }] });
+        }] });
 function ensureStateAndActionsAreImmutable(root) {
     return {
         getState: () => root.getState(),
@@ -601,7 +600,6 @@ function ensureStateAndActionsAreImmutable(root) {
     };
 }
 
-const NG_DEV_MODE$7 = typeof ngDevMode !== 'undefined' && ngDevMode;
 function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {
     return (context) => {
         const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(context, selectorMetaData, selectors);
@@ -622,7 +620,7 @@ function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelector
                 // We're logging an error in this function because it may be used by `select`,
                 // `selectSignal`, and `selectSnapshot`. Therefore, there's no need to catch
                 // exceptions there to log errors.
-                if (NG_DEV_MODE$7) {
+                if (typeof ngDevMode !== 'undefined' && ngDevMode) {
                     const message = 'The selector below has thrown an error upon invocation. ' +
                         'Please check for any unsafe property access that may result in null ' +
                         'or undefined values.';
@@ -696,7 +694,6 @@ function getRootSelectorFactory(selector) {
     return (metadata && metadata.makeRootSelector) || (() => selector);
 }
 
-const NG_DEV_MODE$6 = typeof ngDevMode !== 'undefined' && ngDevMode;
 /**
  * Get a deeply nested value. Example:
  *
@@ -761,7 +758,7 @@ function propGetter(paths, config) {
 // `createSelectorFn`, which, in turn, is solely used by the `Select` decorator.
 // We've been trying to deprecate the `Select` decorator because it's unstable with
 // server-side rendering and micro-frontend applications.
-const ɵPROP_GETTER = new InjectionToken(NG_DEV_MODE$6 ? 'PROP_GETTER' : '', {
+const ɵPROP_GETTER = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'PROP_GETTER' : '', {
     providedIn: 'root',
     factory: () => inject(NgxsConfig).compatibility?.strictContentSecurityPolicy
         ? compliantPropGetter
@@ -788,7 +785,7 @@ const ɵPROP_GETTER = new InjectionToken(NG_DEV_MODE$6 ? 'PROP_GETTER' : '', {
 function buildGraph(stateClasses) {
     const findName = (stateClass) => {
         const meta = stateClasses.find(g => g === stateClass);
-        if (NG_DEV_MODE$6 && !meta) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode && !meta) {
             throw new Error(`Child state not found: ${stateClass}. \r\nYou may have forgotten to add states to module`);
         }
         return meta[_META_KEY].name;
@@ -883,7 +880,7 @@ function topologicalSort(graph) {
         ancestors.push(name);
         visited[name] = true;
         graph[name].forEach((dep) => {
-            if (NG_DEV_MODE$6 && ancestors.indexOf(dep) >= 0) {
+            if (typeof ngDevMode !== 'undefined' && ngDevMode && ancestors.indexOf(dep) >= 0) {
                 throw new Error(`Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`);
             }
             if (visited[dep]) {
@@ -978,19 +975,20 @@ function jit_hasInjectableAnnotation(stateClass) {
     return annotations.some((annotation) => annotation?.ngMetadataName === 'Injectable');
 }
 
-const NG_DEV_MODE$5 = typeof ngDevMode !== 'undefined' && ngDevMode;
-const NGXS_DEVELOPMENT_OPTIONS = new InjectionToken(NG_DEV_MODE$5 ? 'NGXS_DEVELOPMENT_OPTIONS' : '', {
+const NGXS_DEVELOPMENT_OPTIONS = 
+/* @__PURE__ */ new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_DEVELOPMENT_OPTIONS' : '', {
     providedIn: 'root',
     factory: () => ({ warnOnUnhandledActions: true })
 });
 
 class NgxsUnhandledActionsLogger {
-    constructor(options) {
+    constructor() {
         /**
          * These actions should be ignored by default; the user can increase this
          * list in the future via the `ignoreActions` method.
          */
         this._ignoredActions = new Set([InitState.type, UpdateState.type]);
+        const options = inject(NGXS_DEVELOPMENT_OPTIONS);
         if (typeof options.warnOnUnhandledActions === 'object') {
             this.ignoreActions(...options.warnOnUnhandledActions.ignore);
         }
@@ -1015,15 +1013,12 @@ class NgxsUnhandledActionsLogger {
                 : action.type;
         console.warn(`The ${action} action has been dispatched but hasn't been handled. This may happen if the state with an action handler for this action is not registered.`);
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [{ token: NGXS_DEVELOPMENT_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: NgxsUnhandledActionsLogger }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
             type: Injectable
-        }], ctorParameters: () => [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [NGXS_DEVELOPMENT_OPTIONS]
-                }] }] });
+        }], ctorParameters: () => [] });
 
 class NgxsUnhandledErrorHandler {
     constructor() {
@@ -1076,8 +1071,8 @@ function simplePatch(value) {
  * @ignore
  */
 class StateContextFactory {
-    constructor(_internalStateOperations) {
-        this._internalStateOperations = _internalStateOperations;
+    constructor() {
+        this._internalStateOperations = inject(InternalStateOperations);
     }
     /**
      * Create the state context
@@ -1108,13 +1103,13 @@ class StateContextFactory {
             }
         };
     }
-    /** @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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateContextFactory, deps: [], 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);
@@ -1237,7 +1232,6 @@ function createAllowedStatusesMap(statuses) {
     }, {});
 }
 
-const NG_DEV_MODE$4 = typeof ngDevMode !== 'undefined' && ngDevMode;
 function cloneDefaults(defaults) {
     let value = defaults === undefined ? {} : defaults;
     if (defaults) {
@@ -1254,20 +1248,17 @@ function cloneDefaults(defaults) {
  * The `StateFactory` class adds root and feature states to the graph.
  * This extracts state names from state classes, checks if they already
  * exist in the global graph, throws errors if their names are invalid, etc.
- * See its constructor, state factories inject state factories that are
- * parent-level providers. This is required to get feature states from the
- * injector on the same level.
  *
- * The `NgxsModule.forFeature(...)` returns `providers: [StateFactory, ...states]`.
- * The `StateFactory` is initialized on the feature level and goes through `...states`
- * to get them from the injector through `injector.get(state)`.
+ * Root and feature initializers call `addAndReturnDefaults()` to add those states
+ * to the global graph. Since `addAndReturnDefaults` runs within the injection
+ * context (which might be the root injector or a feature injector), we can
+ * retrieve an instance of the state class using `inject(StateClass)`.
  * @ignore
  */
 class StateFactory {
     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);
@@ -1284,47 +1275,36 @@ class StateFactory {
             const stateFactory = this;
             const propGetter = stateFactory._propGetter;
             function resolveGetter(key) {
-                const path = stateFactory.statePaths[key];
+                const path = stateFactory._statePaths[key];
                 return path ? propGetter(path.split('.')) : null;
             }
-            const context = this._parentFactory
-                ? this._parentFactory.getRuntimeSelectorContext()
-                : {
-                    getStateGetter(key) {
-                        // Use `@__INLINE__` annotation to forcely inline `resolveGetter`.
-                        // This is a Terser annotation, which will function only in the production mode.
-                        let getter = /*@__INLINE__*/ resolveGetter(key);
-                        if (getter) {
-                            return getter;
-                        }
-                        return (...args) => {
-                            // Late loaded getter
-                            if (!getter) {
-                                getter = /*@__INLINE__*/ resolveGetter(key);
-                            }
-                            return getter ? getter(...args) : undefined;
-                        };
-                    },
-                    getSelectorOptions(localOptions) {
-                        const globalSelectorOptions = stateFactory._config.selectorOptions;
-                        return {
-                            ...globalSelectorOptions,
-                            ...(localOptions || {})
-                        };
+            const context = {
+                getStateGetter(key) {
+                    // Use `@__INLINE__` annotation to forcely inline `resolveGetter`.
+                    // This is a Terser annotation, which will function only in the production mode.
+                    let getter = /*@__INLINE__*/ resolveGetter(key);
+                    if (getter) {
+                        return getter;
                     }
-                };
+                    return (...args) => {
+                        // Late loaded getter
+                        if (!getter) {
+                            getter = /*@__INLINE__*/ resolveGetter(key);
+                        }
+                        return getter ? getter(...args) : undefined;
+                    };
+                },
+                getSelectorOptions(localOptions) {
+                    const globalSelectorOptions = stateFactory._config.selectorOptions;
+                    return {
+                        ...globalSelectorOptions,
+                        ...(localOptions || {})
+                    };
+                }
+            };
             return context;
         });
     }
-    get states() {
-        return this._parentFactory ? this._parentFactory.states : this._states;
-    }
-    get statesByName() {
-        return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;
-    }
-    get statePaths() {
-        return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
-    }
     ngOnDestroy() {
         this._actionsSubscription?.unsubscribe();
     }
@@ -1332,7 +1312,7 @@ class StateFactory {
      * Add a new state to the global defs.
      */
     add(stateClasses) {
-        if (NG_DEV_MODE$4) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             ensureStatesAreDecorated(stateClasses);
         }
         const { newStates } = this.addToStatesMap(stateClasses);
@@ -1352,7 +1332,7 @@ class StateFactory {
             // `State` decorator. This check is moved here because the `ɵprov` property
             // will not exist on the class in JIT mode (because it's set asynchronously
             // during JIT compilation through `Object.defineProperty`).
-            if (NG_DEV_MODE$4) {
+            if (typeof ngDevMode !== 'undefined' && ngDevMode) {
                 ensureStateClassIsInjectable(stateClass);
             }
             const stateMap = {
@@ -1360,7 +1340,7 @@ class StateFactory {
                 path,
                 isInitialised: false,
                 actions: meta.actions,
-                instance: this._injector.get(stateClass),
+                instance: inject(stateClass),
                 defaults: cloneDefaults(meta.defaults)
             };
             // ensure our store hasn't already been added
@@ -1369,7 +1349,7 @@ class StateFactory {
             if (!this.hasBeenMountedAndBootstrapped(name, path)) {
                 bootstrappedStores.push(stateMap);
             }
-            this.states.push(stateMap);
+            this._states.push(stateMap);
             this.hydrateActionMetasMap(stateMap);
         }
         return bootstrappedStores;
@@ -1384,14 +1364,8 @@ class StateFactory {
         return { defaults, states: mappedStores };
     }
     connectActionHandlers() {
-        // Note: We have to connect actions only once when the `StateFactory`
-        //       is being created for the first time. This checks if we're in
-        //       a child state factory and the parent state factory already exists.
-        if (this._parentFactory || this._actionsSubscription !== null) {
-            return;
-        }
         this._actionsSubscription = this._actions
-            .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */), mergeMap(ctx => {
+            .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* ActionStatus.Dispatched */), mergeMap$1(ctx => {
             const action = ctx.action;
             return this.invokeActions(action).pipe(map$1(() => ({ action, status: "SUCCESSFUL" /* ActionStatus.Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* ActionStatus.Canceled */ }), catchError(error => {
                 const ngxsUnhandledErrorHandler = (this._ngxsUnhandledErrorHandler ||=
@@ -1431,7 +1405,7 @@ class StateFactory {
         }
         // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions
         // only during development.
-        if (NG_DEV_MODE$4 && !actionHasBeenHandled) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode && !actionHasBeenHandled) {
             const unhandledActionsLogger = this._injector.get(NgxsUnhandledActionsLogger, null);
             // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the
             // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`
@@ -1445,10 +1419,10 @@ class StateFactory {
     }
     addToStatesMap(stateClasses) {
         const newStates = [];
-        const statesMap = this.statesByName;
+        const statesMap = this._statesByName;
         for (const stateClass of stateClasses) {
             const stateName = _getStoreMetadata(stateClass).name;
-            if (NG_DEV_MODE$4) {
+            if (typeof ngDevMode !== 'undefined' && ngDevMode) {
                 ensureStateNameIsUnique(stateName, stateClass, statesMap);
             }
             const unmountedState = !statesMap[stateName];
@@ -1460,7 +1434,7 @@ class StateFactory {
         return { newStates };
     }
     addRuntimeInfoToMeta(meta, path) {
-        this.statePaths[meta.name] = path;
+        this._statePaths[meta.name] = path;
         // TODO: versions after v3 - we plan to get rid of the `path` property because it is non-deterministic
         // we can do this when we get rid of the incorrectly exposed getStoreMetadata
         // We will need to come up with an alternative to what was exposed in v3 because this is used by many plugins
@@ -1470,7 +1444,7 @@ class StateFactory {
         const valueIsBootstrappedInInitialState = getValue(this._initialState, path) !== undefined;
         // This checks whether a state has been already added to the global graph and
         // its lifecycle is in 'bootstrapped' state.
-        return this.statesByName[name] && valueIsBootstrappedInInitialState;
+        return this._statesByName[name] && valueIsBootstrappedInInitialState;
     }
     hydrateActionMetasMap({ path, actions, instance }) {
         const { dispatched$ } = this._actions;
@@ -1490,7 +1464,7 @@ class StateFactory {
                         result = from(result);
                     }
                     if (isObservable(result)) {
-                        result = result.pipe(mergeMap((value) => {
+                        result = result.pipe(mergeMap$1((value) => {
                             if (_isPromise(value)) {
                                 return from(value);
                             }
@@ -1541,37 +1515,37 @@ class StateFactory {
         }
     }
     /** @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 }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: StateFactory, decorators: [{
-            type: Injectable
+            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() { }
 
-const NG_DEV_MODE$3 = typeof ngDevMode !== 'undefined' && ngDevMode;
 class Store {
-    constructor(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {
-        this._stateStream = _stateStream;
-        this._internalStateOperations = _internalStateOperations;
-        this._config = _config;
-        this._internalExecutionStrategy = _internalExecutionStrategy;
-        this._stateFactory = _stateFactory;
+    constructor() {
+        this._stateStream = inject(_StateStream);
+        this._internalStateOperations = inject(InternalStateOperations);
+        this._config = inject(NgxsConfig);
+        this._internalExecutionStrategy = inject(InternalNgxsExecutionStrategy);
+        this._stateFactory = inject(StateFactory);
         /**
          * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
          * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
          * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
          */
         this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), shareReplay$1({ bufferSize: 1, refCount: true }));
-        this.initStateStream(initialStateValue);
+        this.initStateStream();
     }
     /**
      * Dispatches action(s).
      */
     dispatch(actionOrActions) {
-        if (NG_DEV_MODE$3) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             if (
             // If a single action is dispatched and it's nullable.
             actionOrActions == null ||
@@ -1643,31 +1617,26 @@ class Store {
         const runtimeContext = this._stateFactory.getRuntimeSelectorContext();
         return makeSelectorFn(runtimeContext);
     }
-    initStateStream(initialStateValue) {
+    initStateStream() {
+        const initialStateValue = inject(_INITIAL_STATE_TOKEN);
         const value = this._stateStream.value;
         const storeIsEmpty = !value || Object.keys(value).length === 0;
         if (storeIsEmpty) {
             this._stateStream.next(initialStateValue);
         }
     }
-    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: Store, deps: [{ token: i1.ɵStateStream }, { token: InternalStateOperations }, { token: NgxsConfig }, { token: InternalNgxsExecutionStrategy }, { token: StateFactory }, { 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: Store, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: Store, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: Store, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: i1.ɵStateStream }, { type: InternalStateOperations }, { type: NgxsConfig }, { type: InternalNgxsExecutionStrategy }, { type: StateFactory }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [_INITIAL_STATE_TOKEN]
-                }] }] });
+        }], ctorParameters: () => [] });
 
-const NG_DEV_MODE$2 = typeof ngDevMode !== 'undefined' && ngDevMode;
 /**
  * InjectionToken that registers preboot functions (called before the root initializer).
  */
-const NGXS_PREBOOT_FNS = new InjectionToken(NG_DEV_MODE$2 ? 'NGXS_PREBOOT_FNS' : '');
+const NGXS_PREBOOT_FNS = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_PREBOOT_FNS' : '');
 /**
  * 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
@@ -1717,20 +1686,19 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
             args: [{ providedIn: 'root' }]
         }], ctorParameters: () => [{ type: Store }, { type: NgxsConfig }] });
 
-const NG_DEV_MODE$1 = typeof ngDevMode !== 'undefined' && ngDevMode;
 class LifecycleStateManager {
-    constructor(_store, _internalStateOperations, _stateContextFactory, _appBootstrappedState) {
-        this._store = _store;
-        this._internalStateOperations = _internalStateOperations;
-        this._stateContextFactory = _stateContextFactory;
-        this._appBootstrappedState = _appBootstrappedState;
+    constructor() {
+        this._store = inject(Store);
+        this._internalStateOperations = inject(InternalStateOperations);
+        this._stateContextFactory = inject(StateContextFactory);
+        this._appBootstrappedState = inject(_NgxsAppBootstrappedState);
         this._destroy$ = new ReplaySubject(1);
     }
     ngOnDestroy() {
         this._destroy$.next();
     }
     ngxsBootstrap(action, results) {
-        if (NG_DEV_MODE$1) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             if (action instanceof InitState) {
                 this._initStateHasBeenDispatched = true;
             }
@@ -1748,7 +1716,7 @@ class LifecycleStateManager {
         this._internalStateOperations
             .getRootStateOperations()
             .dispatch(action)
-            .pipe(filter$1(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap$1(() => this._appBootstrappedState), filter$1(appBootstrapped => !!appBootstrapped), takeUntil$1(this._destroy$))
+            .pipe(filter$1(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._appBootstrappedState), filter$1(appBootstrapped => !!appBootstrapped), takeUntil$1(this._destroy$))
             .subscribe(() => this._invokeBootstrapOnStates(results.states));
     }
     _invokeInitOnStates(mappedStores) {
@@ -1780,21 +1748,25 @@ class LifecycleStateManager {
     _getStateContext(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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: LifecycleStateManager, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImport: i0, type: LifecycleStateManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: Store }, { type: InternalStateOperations }, { type: StateContextFactory }, { type: i1.ɵNgxsAppBootstrappedState }] });
+        }] });
 
-const NG_DEV_MODE = typeof ngDevMode !== 'undefined' && ngDevMode;
 /**
  * This function is shared by both NgModule and standalone features.
  * When using `NgxsModule.forRoot` and `provideStore`, we can depend on the
  * same initialization functionality.
  */
 function rootStoreInitializer() {
+    // Override the RxJS `config.onUnhandledError` within the root store initializer,
+    // but only after other code has already executed.
+    // If users have a custom `config.onUnhandledError`, we might overwrite it too
+    // early and capture the original `config.onUnhandledError` before it is properly set.
+    installOnUnhandhedErrorHandler();
     const prebootFns = inject(NGXS_PREBOOT_FNS, { optional: true }) || [];
     prebootFns.forEach(prebootFn => prebootFn());
     const factory = inject(StateFactory);
@@ -1836,11 +1808,11 @@ function featureStatesInitializer() {
 /**
  * InjectionToken that registers the global Store.
  */
-const NGXS_ROOT_STORE_INITIALIZER = new InjectionToken(NG_DEV_MODE ? 'NGXS_ROOT_STORE_INITIALIZER' : '');
+const NGXS_ROOT_STORE_INITIALIZER = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_ROOT_STORE_INITIALIZER' : '');
 /**
  * InjectionToken that registers feature states.
  */
-const NGXS_FEATURE_STORE_INITIALIZER = new InjectionToken(NG_DEV_MODE ? 'NGXS_FEATURE_STORE_INITIALIZER' : '');
+const NGXS_FEATURE_STORE_INITIALIZER = new InjectionToken(typeof ngDevMode !== 'undefined' && ngDevMode ? 'NGXS_FEATURE_STORE_INITIALIZER' : '');
 const NGXS_ROOT_ENVIRONMENT_INITIALIZER = [
     { provide: NGXS_ROOT_STORE_INITIALIZER, useFactory: rootStoreInitializer },
     {
@@ -1904,8 +1876,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.0.6", ngImpor
  */
 function getRootProviders(states, options) {
     return [
-        StateFactory,
-        PluginManager,
         ...states,
         {
             provide: ROOT_STATE_TOKEN,
@@ -1936,7 +1906,6 @@ function getRootProviders(states, options) {
  */
 function getFeatureProviders(states) {
     return [
-        StateFactory,
         PluginManager,
         ...states,
         {
@@ -2359,11 +2328,17 @@ function provideStates(states, ...features) {
  */
 function withNgxsPlugin(plugin) {
     return makeEnvironmentProviders([
-        { provide: NGXS_PLUGINS, useClass: plugin, multi: true },
+        _isPluginClass(plugin)
+            ? { provide: NGXS_PLUGINS, useClass: plugin, multi: true }
+            : { provide: NGXS_PLUGINS, useValue: 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 }
+        {
+            provide: ENVIRONMENT_INITIALIZER,
+            useValue: () => inject(PluginManager),
+            multi: true
+        }
     ]);
 }