@ngxs/store 3.8.2 → 18.0.0-dev.master-f4c2c19

package/{fesm2015/ngxs-store.js → fesm2022/ngxs-store.mjs}

@@ -1,103 +1,29 @@
 import * as i0 from '@angular/core';
-import { NgZone, PLATFORM_ID, Injectable, Inject, InjectionToken, inject, INJECTOR, ɵglobal, ErrorHandler, Optional, SkipSelf, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
-import * as i5 from '@ngxs/store/internals';
-import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, ɵNGXS_STATE_CONTEXT_FACTORY, ɵNGXS_STATE_FACTORY } from '@ngxs/store/internals';
+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, ReplaySubject } from 'rxjs';
+import { share, map, shareReplay, filter, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
+import * as i1 from '@ngxs/store/internals';
+import { ɵ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 { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable } from 'rxjs';
-import { filter, map, share, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
+import { NGXS_PLUGINS, getActionTypeFromInstance, setValue, getValue, InitState, UpdateState } from '@ngxs/store/plugins';
+export { InitState, NGXS_PLUGINS, UpdateState, actionMatcher, getActionTypeFromInstance, getValue, setValue } from '@ngxs/store/plugins';
 import { isStateOperator } from '@ngxs/store/operators';
 
-/**
- * Returns the type from an action instance/class.
- * @ignore
- */
-function getActionTypeFromInstance(action) {
-    if (action.constructor && action.constructor.type) {
-        return action.constructor.type;
+class NoopNgxsExecutionStrategy {
+    enter(func) {
+        return func();
     }
-    else {
-        return action.type;
+    leave(func) {
+        return func();
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NoopNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NoopNgxsExecutionStrategy, providedIn: 'root' }); }
 }
-/**
- * Matches a action
- * @ignore
- */
-function actionMatcher(action1) {
-    const type1 = getActionTypeFromInstance(action1);
-    return function (action2) {
-        return type1 === getActionTypeFromInstance(action2);
-    };
-}
-/**
- * Set a deeply nested value. Example:
- *
- *   setValue({ foo: { bar: { eat: false } } },
- *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
- *
- * While it traverses it also creates new objects from top down.
- *
- * @ignore
- */
-const setValue = (obj, prop, val) => {
-    obj = Object.assign({}, obj);
-    const split = prop.split('.');
-    const lastIndex = split.length - 1;
-    split.reduce((acc, part, index) => {
-        if (index === lastIndex) {
-            acc[part] = val;
-        }
-        else {
-            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : Object.assign({}, acc[part]);
-        }
-        return acc && acc[part];
-    }, obj);
-    return obj;
-};
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- */
-const getValue = (obj, prop) => prop.split('.').reduce((acc, part) => acc && acc[part], obj);
-/**
- * Simple object check.
- *
- *    isObject({a:1}) //=> true
- *    isObject(1) //=> false
- *
- * @ignore
- */
-const isObject$1 = (item) => {
-    return item && typeof item === 'object' && !Array.isArray(item);
-};
-/**
- * Deep merge two objects.
- *
- *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
- *
- * @param base base object onto which `sources` will be applied
- */
-const mergeDeep = (base, ...sources) => {
-    if (!sources.length)
-        return base;
-    const source = sources.shift();
-    if (isObject$1(base) && isObject$1(source)) {
-        for (const key in source) {
-            if (isObject$1(source[key])) {
-                if (!base[key])
-                    Object.assign(base, { [key]: {} });
-                mergeDeep(base[key], source[key]);
-            }
-            else {
-                Object.assign(base, { [key]: source[key] });
-            }
-        }
-    }
-    return mergeDeep(base, ...sources);
-};
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NoopNgxsExecutionStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
 function throwStateNameError(name) {
     throw new Error(`${name} is not a valid state name. It needs to be a valid object property name.`);
@@ -122,9 +48,21 @@ function getZoneWarningMessage() {
         'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
         'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })');
 }
-function getUndecoratedStateInIvyWarningMessage(name) {
+function getUndecoratedStateWithInjectableWarningMessage(name) {
     return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;
 }
+function getInvalidInitializationOrderMessage(addedStates) {
+    let message = 'You have an invalid state initialization order. This typically occurs when `NgxsModule.forFeature`\n' +
+        'or `provideStates` is called before `NgxsModule.forRoot` or `provideStore`.\n' +
+        'One example is when `NgxsRouterPluginModule.forRoot` is called before `NgxsModule.forRoot`.';
+    if (addedStates) {
+        const stateNames = Object.keys(addedStates).map(stateName => `"${stateName}"`);
+        message +=
+            '\nFeature states added before the store initialization is complete: ' +
+                `${stateNames.join(', ')}.`;
+    }
+    return message;
+}
 function throwSelectFactoryNotConnectedError() {
     throw new Error('You have forgotten to import the NGXS module!');
 }
@@ -139,9 +77,7 @@ class DispatchOutsideZoneNgxsExecutionStrategy {
     constructor(_ngZone, _platformId) {
         this._ngZone = _ngZone;
         this._platformId = _platformId;
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             verifyZoneIsNotNooped(_ngZone);
         }
     }
@@ -166,16 +102,16 @@ class DispatchOutsideZoneNgxsExecutionStrategy {
         }
         return func();
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: 'root' }); }
 }
-/** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: DispatchOutsideZoneNgxsExecutionStrategy, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: i0.NgZone }, { type: undefined, decorators: [{
                     type: Inject,
                     args: [PLATFORM_ID]
-                }] }]; } });
+                }] }] });
 // Caretaker note: this should exist as a separate function and not a class method,
 // since class methods are not tree-shakable.
 function verifyZoneIsNotNooped(ngZone) {
@@ -188,245 +124,702 @@ function verifyZoneIsNotNooped(ngZone) {
     console.warn(getZoneWarningMessage());
 }
 
-const ROOT_OPTIONS = new InjectionToken('ROOT_OPTIONS');
-const ROOT_STATE_TOKEN = new InjectionToken('ROOT_STATE_TOKEN');
-const FEATURE_STATE_TOKEN = new InjectionToken('FEATURE_STATE_TOKEN');
-const NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');
-const META_KEY = 'NGXS_META';
-const META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
-const SELECTOR_META_KEY = 'NGXS_SELECTOR_META';
-/**
- * The NGXS config settings.
- */
-class NgxsConfig {
-    constructor() {
-        /**
-         * Defining the default state before module initialization
-         * This is convenient if we need to create a define our own set of states.
-         * @deprecated will be removed after v4
-         * (default: {})
-         */
-        this.defaultsState = {};
-        /**
-         * Defining shared selector options
-         */
-        this.selectorOptions = {
-            injectContainerState: true,
-            suppressErrors: true // TODO: default is true in v3, will change in v4
-        };
-        this.compatibility = {
-            strictContentSecurityPolicy: false
-        };
-        this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;
-    }
-}
-/** @nocollapse */ NgxsConfig.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ NgxsConfig.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: (options) => mergeDeep(new NgxsConfig(), options), deps: [{ token: ROOT_OPTIONS }] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsConfig, decorators: [{
-            type: Injectable,
-            args: [{
-                    providedIn: 'root',
-                    useFactory: (options) => mergeDeep(new NgxsConfig(), options),
-                    deps: [ROOT_OPTIONS]
-                }]
-        }], ctorParameters: function () { return []; } });
+const NG_DEV_MODE$8 = typeof ngDevMode !== 'undefined' && ngDevMode;
 /**
- * Represents a basic change from a previous to a new value for a single state instance.
- * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
+ * Consumers have the option to utilize the execution strategy provided by
+ * `NgxsModule.forRoot({executionStrategy})` or `provideStore([], {executionStrategy})`.
  */
-class NgxsSimpleChange {
-    constructor(previousValue, currentValue, firstChange) {
-        this.previousValue = previousValue;
-        this.currentValue = currentValue;
-        this.firstChange = firstChange;
-    }
-}
-
-class NoopNgxsExecutionStrategy {
-    enter(func) {
-        return func();
-    }
-    leave(func) {
-        return func();
-    }
-}
-/** @nocollapse */ NoopNgxsExecutionStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NoopNgxsExecutionStrategy, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ NoopNgxsExecutionStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NoopNgxsExecutionStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NoopNgxsExecutionStrategy, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-
+const CUSTOM_NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$8 ? 'CUSTOM_NGXS_EXECUTION_STRATEGY' : '');
 /**
- * The strategy that might be provided by users through `options.executionStrategy`.
- */
-const USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');
-/*
- * Internal execution strategy injection token
+ * 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('NGXS_EXECUTION_STRATEGY', {
+const NGXS_EXECUTION_STRATEGY = new InjectionToken(NG_DEV_MODE$8 ? 'NGXS_EXECUTION_STRATEGY' : '', {
     providedIn: 'root',
     factory: () => {
+        const ngZone = inject(NgZone);
         const injector = inject(INJECTOR);
-        const executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);
+        const executionStrategy = injector.get(CUSTOM_NGXS_EXECUTION_STRATEGY);
+        const isNgZoneEnabled = ngZone instanceof NgZone;
         return executionStrategy
             ? injector.get(executionStrategy)
-            : injector.get(typeof ɵglobal.Zone !== 'undefined'
+            : injector.get(isNgZoneEnabled
                 ? DispatchOutsideZoneNgxsExecutionStrategy
                 : NoopNgxsExecutionStrategy);
     }
 });
 
-/**
- * Ensures metadata is attached to the class and returns it.
- *
- * @ignore
- */
-function ensureStoreMetadata$1(target) {
-    if (!target.hasOwnProperty(META_KEY)) {
-        const defaultMetadata = {
-            name: null,
-            actions: {},
-            defaults: {},
-            path: null,
-            makeRootSelector(context) {
-                return context.getStateGetter(defaultMetadata.name);
-            },
-            children: []
-        };
-        Object.defineProperty(target, META_KEY, { value: defaultMetadata });
+class InternalNgxsExecutionStrategy {
+    constructor(_executionStrategy) {
+        this._executionStrategy = _executionStrategy;
+    }
+    enter(func) {
+        return this._executionStrategy.enter(func);
     }
-    return getStoreMetadata$1(target);
+    leave(func) {
+        return this._executionStrategy.leave(func);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [{ token: NGXS_EXECUTION_STRATEGY }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalNgxsExecutionStrategy, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [NGXS_EXECUTION_STRATEGY]
+                }] }] });
+
 /**
- * Get the metadata attached to the state class if it exists.
+ * Composes a array of functions from left to right. Example:
  *
- * @ignore
- */
-function getStoreMetadata$1(target) {
-    return target[META_KEY];
-}
-/**
- * Ensures metadata is attached to the selector and returns it.
+ *      compose([fn, final])(state, action);
  *
- * @ignore
- */
-function ensureSelectorMetadata$1(target) {
-    if (!target.hasOwnProperty(SELECTOR_META_KEY)) {
-        const defaultMetadata = {
-            makeRootSelector: null,
-            originalFn: null,
-            containerClass: null,
-            selectorName: null,
-            getSelectorOptions: () => ({})
-        };
-        Object.defineProperty(target, SELECTOR_META_KEY, { value: defaultMetadata });
-    }
-    return getSelectorMetadata$1(target);
-}
-/**
- * Get the metadata attached to the selector if it exists.
+ * then the funcs have a signature like:
  *
- * @ignore
- */
-function getSelectorMetadata$1(target) {
-    return target[SELECTOR_META_KEY];
-}
-/**
- * Get a deeply nested value. Example:
+ *      function fn (state, action, next) {
+ *          console.log('here', state, action, next);
+ *          return next(state, action);
+ *      }
  *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *      function final (state, action) {
+ *          console.log('here', state, action);
+ *          return state;
+ *      }
  *
- * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.
- * See perf hit: https://jsperf.com/fast-value-getter-given-path/1
+ * the last function should not call `next`.
  *
  * @ignore
  */
-function compliantPropGetter(paths) {
-    const copyOfPaths = paths.slice();
-    return obj => copyOfPaths.reduce((acc, part) => acc && acc[part], obj);
-}
+const compose = (funcs) => (...args) => {
+    const curr = funcs.shift();
+    return curr(...args, (...nextArgs) => compose(funcs)(...nextArgs));
+};
+
 /**
- * The generated function is faster than:
- * - pluck (Observable operator)
- * - memoize
- *
- * @ignore
+ * Returns operator that will run
+ * `subscribe` outside of the ngxs execution context
  */
-function fastPropGetter(paths) {
-    const segments = paths;
-    let seg = 'store.' + segments[0];
-    let i = 0;
-    const l = segments.length;
-    let expr = seg;
-    while (++i < l) {
-        expr = expr + ' && ' + (seg = seg + '.' + segments[i]);
-    }
-    const fn = new Function('store', 'return ' + expr + ';');
-    return fn;
+function leaveNgxs(ngxsExecutionStrategy) {
+    return (source) => {
+        return new Observable((sink) => {
+            return source.subscribe({
+                next(value) {
+                    ngxsExecutionStrategy.leave(() => sink.next(value));
+                },
+                error(error) {
+                    ngxsExecutionStrategy.leave(() => sink.error(error));
+                },
+                complete() {
+                    ngxsExecutionStrategy.leave(() => sink.complete());
+                }
+            });
+        });
+    };
 }
+
 /**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
+ * Internal Action stream that is emitted anytime an action is dispatched.
  */
-function propGetter(paths, config) {
-    if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {
-        return compliantPropGetter(paths);
-    }
-    else {
-        return fastPropGetter(paths);
+class InternalActions extends _OrderedSubject {
+    ngOnDestroy() {
+        this.complete();
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalActions, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalActions, providedIn: 'root' }); }
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalActions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 /**
- * Given an array of states, it will return a object graph. Example:
- *    const states = [
- *      Cart,
- *      CartSaved,
- *      CartSavedItems
- *    ]
- *
- * would return:
- *
- *  const graph = {
- *    cart: ['saved'],
- *    saved: ['items'],
- *    items: []
- *  };
+ * Action stream that is emitted anytime an action is dispatched.
  *
- * @ignore
+ * You can listen to this in services to react without stores.
  */
-function buildGraph(stateClasses) {
-    const findName = (stateClass) => {
-        const meta = stateClasses.find(g => g === stateClass);
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        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;
-    };
-    return stateClasses.reduce((result, stateClass) => {
-        const { name, children } = stateClass[META_KEY];
-        result[name] = (children || []).map(findName);
-        return result;
-    }, {});
+class Actions extends Observable {
+    constructor(internalActions$, internalExecutionStrategy) {
+        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.
+        // The `share()` operator reduces the number of change detections.
+        // This would call leave only once for any stream emission across all active subscribers.
+        share());
+        super(observer => {
+            const childSubscription = sharedInternalActions$.subscribe({
+                next: ctx => observer.next(ctx),
+                error: error => observer.error(error),
+                complete: () => observer.complete()
+            });
+            observer.add(childSubscription);
+        });
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: Actions, deps: [{ token: InternalActions }, { token: InternalNgxsExecutionStrategy }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: Actions, providedIn: 'root' }); }
 }
-/**
- * Given a states array, returns object graph
- * returning the name and state metadata. Example:
- *
- *  const graph = {
- *    cart: { metadata }
- *  };
- *
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: Actions, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: InternalActions }, { type: InternalNgxsExecutionStrategy }] });
+
+class PluginManager {
+    constructor(_parentManager, _pluginHandlers) {
+        this._parentManager = _parentManager;
+        this._pluginHandlers = _pluginHandlers;
+        this.plugins = [];
+        this.registerHandlers();
+    }
+    get rootPlugins() {
+        return (this._parentManager && this._parentManager.plugins) || this.plugins;
+    }
+    registerHandlers() {
+        const pluginHandlers = this.getPluginHandlers();
+        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: "17.3.3", ngImport: i0, type: PluginManager, deps: [{ token: PluginManager, optional: true, skipSelf: true }, { token: NGXS_PLUGINS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: PluginManager }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", 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
+                }] }] });
+
+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;
+    }
+};
+function executeUnhandledCallback(error) {
+    const unhandledErrorCallback = ɵɵunhandledRxjsErrorCallbacks.get(error);
+    if (unhandledErrorCallback) {
+        unhandledErrorCallback();
+        return true;
+    }
+    return false;
+}
+function assignUnhandledCallback(error, callback) {
+    // Since the error can be essentially anything, we must ensure that we only
+    // handle objects, as weak maps do not allow any other key type besides objects.
+    // The error can also be a string if thrown in the following manner: `throwError('My Error')`.
+    if (error !== null && typeof error === 'object') {
+        let hasBeenCalled = false;
+        ɵɵunhandledRxjsErrorCallbacks.set(error, () => {
+            if (!hasBeenCalled) {
+                hasBeenCalled = true;
+                callback();
+            }
+        });
+    }
+    return error;
+}
+
+function fallbackSubscriber(ngZone) {
+    return (source) => {
+        let subscription = source.subscribe({
+            error: error => {
+                ngZone.runOutsideAngular(() => {
+                    // This is necessary to schedule a microtask to ensure that synchronous
+                    // errors are not reported before the real subscriber arrives. If an error
+                    // is thrown synchronously in any action, it will be reported to the error
+                    // handler regardless. Since RxJS reports unhandled errors asynchronously,
+                    // implementing a microtask ensures that we are also safe in this scenario.
+                    queueMicrotask(() => {
+                        if (subscription) {
+                            executeUnhandledCallback(error);
+                        }
+                    });
+                });
+            }
+        });
+        return new Observable(subscriber => {
+            // Now that there is a real subscriber, we can unsubscribe our pro-active subscription
+            subscription?.unsubscribe();
+            subscription = null;
+            return source.subscribe(subscriber);
+        });
+    };
+}
+
+/**
+ * Internal Action result stream that is emitted when an action is completed.
+ * This is used as a method of returning the action result to the dispatcher
+ * for the observable returned by the dispatch(...) call.
+ * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
+ */
+class InternalDispatchedActionResults extends Subject {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalDispatchedActionResults, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalDispatchedActionResults, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalDispatchedActionResults, decorators: [{
+            type: Injectable,
+            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;
+    }
+    /**
+     * Dispatches event(s).
+     */
+    dispatch(actionOrActions) {
+        const result = this._ngxsExecutionStrategy.enter(() => this.dispatchByEvents(actionOrActions));
+        return result.pipe(fallbackSubscriber(this._ngZone), leaveNgxs(this._ngxsExecutionStrategy));
+    }
+    dispatchByEvents(actionOrActions) {
+        if (Array.isArray(actionOrActions)) {
+            if (actionOrActions.length === 0)
+                return of(undefined);
+            return forkJoin(actionOrActions.map(action => this.dispatchSingle(action))).pipe(map(() => undefined));
+        }
+        else {
+            return this.dispatchSingle(actionOrActions);
+        }
+    }
+    dispatchSingle(action) {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+            const type = getActionTypeFromInstance(action);
+            if (!type) {
+                const error = new Error(`This action doesn't have a type property: ${action.constructor.name}`);
+                return throwError(() => error);
+            }
+        }
+        const prevState = this._stateStream.getValue();
+        const plugins = this._pluginManager.plugins;
+        return compose([
+            ...plugins,
+            (nextState, nextAction) => {
+                if (nextState !== prevState) {
+                    this._stateStream.next(nextState);
+                }
+                const actionResult$ = this.getActionResultStream(nextAction);
+                actionResult$.subscribe(ctx => this._actions.next(ctx));
+                this._actions.next({ action: nextAction, status: "DISPATCHED" /* ActionStatus.Dispatched */ });
+                return this.createDispatchObservable(actionResult$);
+            }
+        ])(prevState, action).pipe(shareReplay());
+    }
+    getActionResultStream(action) {
+        return this._actionResults.pipe(filter((ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* ActionStatus.Dispatched */), take(1), shareReplay());
+    }
+    createDispatchObservable(actionResult$) {
+        return actionResult$
+            .pipe(exhaustMap((ctx) => {
+            switch (ctx.status) {
+                case "SUCCESSFUL" /* ActionStatus.Successful */:
+                    // The `createDispatchObservable` function should return the
+                    // state, as its result is utilized by plugins.
+                    return of(this._stateStream.getValue());
+                case "ERRORED" /* ActionStatus.Errored */:
+                    return throwError(() => ctx.error);
+                default:
+                    return EMPTY;
+            }
+        }))
+            .pipe(shareReplay());
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", 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.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalDispatcher, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", 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 }] });
+
+const NG_DEV_MODE$7 = 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$7 ? '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$7 ? '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$7 ? 'NGXS_OPTIONS' : '');
+/**
+ * The NGXS config settings.
+ */
+class NgxsConfig {
+    constructor() {
+        this.compatibility = {
+            strictContentSecurityPolicy: false
+        };
+        /**
+         * Determines the execution context to perform async operations inside. An implementation can be
+         * provided to override the default behaviour where the async operations are run
+         * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.
+         * These observable behaviours are from:
+         *   `store.selectSignal(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`
+         * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your
+         * application doesn't rely on zone.js running change detection then you can switch to the
+         * `NoopNgxsExecutionStrategy` that doesn't interact with zones.
+         * (default: null)
+         */
+        this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;
+        /**
+         * Defining shared selector options
+         */
+        this.selectorOptions = {
+            injectContainerState: false,
+            suppressErrors: false
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsConfig, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsConfig, providedIn: 'root', useFactory: () => {
+            const defaultConfig = new NgxsConfig();
+            const config = inject(NGXS_OPTIONS);
+            return {
+                ...defaultConfig,
+                ...config,
+                selectorOptions: {
+                    ...defaultConfig.selectorOptions,
+                    ...config.selectorOptions
+                }
+            };
+        } }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsConfig, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                    useFactory: () => {
+                        const defaultConfig = new NgxsConfig();
+                        const config = inject(NGXS_OPTIONS);
+                        return {
+                            ...defaultConfig,
+                            ...config,
+                            selectorOptions: {
+                                ...defaultConfig.selectorOptions,
+                                ...config.selectorOptions
+                            }
+                        };
+                    }
+                }]
+        }] });
+/**
+ * Represents a basic change from a previous to a new value for a single state instance.
+ * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.
+ */
+class NgxsSimpleChange {
+    constructor(previousValue, currentValue, firstChange) {
+        this.previousValue = previousValue;
+        this.currentValue = currentValue;
+        this.firstChange = firstChange;
+    }
+}
+
+/**
+ * Object freeze code
+ * https://github.com/jsdf/deep-freeze
+ */
+const deepFreeze = (o) => {
+    Object.freeze(o);
+    const oIsFunction = typeof o === 'function';
+    const hasOwnProp = Object.prototype.hasOwnProperty;
+    Object.getOwnPropertyNames(o).forEach(function (prop) {
+        if (hasOwnProp.call(o, prop) &&
+            (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&
+            o[prop] !== null &&
+            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
+            !Object.isFrozen(o[prop])) {
+            deepFreeze(o[prop]);
+        }
+    });
+    return o;
+};
+
+/**
+ * @ignore
+ */
+class InternalStateOperations {
+    constructor(_stateStream, _dispatcher, _config) {
+        this._stateStream = _stateStream;
+        this._dispatcher = _dispatcher;
+        this._config = _config;
+    }
+    /**
+     * Returns the root state operators.
+     */
+    getRootStateOperations() {
+        const rootStateOperations = {
+            getState: () => this._stateStream.getValue(),
+            setState: (newState) => this._stateStream.next(newState),
+            dispatch: (actionOrActions) => this._dispatcher.dispatch(actionOrActions)
+        };
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
+            return this._config.developmentMode
+                ? ensureStateAndActionsAreImmutable(rootStateOperations)
+                : rootStateOperations;
+        }
+        else {
+            return rootStateOperations;
+        }
+    }
+    setStateToTheCurrentWithNew(results) {
+        const stateOperations = this.getRootStateOperations();
+        // Get our current stream
+        const currentState = stateOperations.getState();
+        // Set the state to the current + new
+        stateOperations.setState({ ...currentState, ...results.defaults });
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalStateOperations, deps: [{ token: i1.ɵStateStream }, { token: InternalDispatcher }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: InternalStateOperations, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", 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(),
+        setState: value => {
+            const frozenValue = deepFreeze(value);
+            return root.setState(frozenValue);
+        },
+        dispatch: actions => {
+            return root.dispatch(actions);
+        }
+    };
+}
+
+const NG_DEV_MODE$6 = typeof ngDevMode !== 'undefined' && ngDevMode;
+function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {
+    return (context) => {
+        const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(context, selectorMetaData, selectors);
+        const { suppressErrors } = selectorOptions;
+        return function selectFromRoot(rootState) {
+            // Determine arguments from the app state using the selectors
+            const results = argumentSelectorFunctions.map(argFn => argFn(rootState));
+            // If the lambda attempts to access something in the state that doesn't exist,
+            // it will throw a `TypeError`. Since this behavior is common, we simply return
+            // `undefined` in such cases.
+            try {
+                return memoizedSelectorFn(...results);
+            }
+            catch (ex) {
+                if (suppressErrors && ex instanceof TypeError) {
+                    return undefined;
+                }
+                // 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$6) {
+                    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.';
+                    // Avoid concatenating the message with the original function, as this will
+                    // invoke `toString()` on the function. Instead, log it as the second argument.
+                    // This way, developers will be able to navigate to the actual code in the browser.
+                    console.error(message, selectorMetaData.originalFn);
+                }
+                throw ex;
+            }
+        };
+    };
+}
+function createMemoizedSelectorFn(originalFn, creationMetadata) {
+    const containerClass = creationMetadata && creationMetadata.containerClass;
+    const wrappedFn = function wrappedSelectorFn(...args) {
+        const returnValue = originalFn.apply(containerClass, args);
+        if (returnValue instanceof Function) {
+            const innerMemoizedFn = _memoize.apply(null, [returnValue]);
+            return innerMemoizedFn;
+        }
+        return returnValue;
+    };
+    const memoizedFn = _memoize(wrappedFn);
+    Object.setPrototypeOf(memoizedFn, originalFn);
+    return memoizedFn;
+}
+function getRuntimeSelectorInfo(context, selectorMetaData, selectors = []) {
+    const localSelectorOptions = selectorMetaData.getSelectorOptions();
+    const selectorOptions = context.getSelectorOptions(localSelectorOptions);
+    const selectorsToApply = getSelectorsToApply(selectors, selectorOptions, selectorMetaData.containerClass);
+    const argumentSelectorFunctions = selectorsToApply.map(selector => {
+        const factory = getRootSelectorFactory(selector);
+        return factory(context);
+    });
+    return {
+        selectorOptions,
+        argumentSelectorFunctions
+    };
+}
+function getSelectorsToApply(selectors = [], selectorOptions, containerClass) {
+    const selectorsToApply = [];
+    // The container state refers to the state class that includes the
+    // definition of the selector function, for example:
+    // @State()
+    // class AnimalsState {
+    //   @Selector()
+    //   static getAnimals(state: AnimalsStateModel) {}
+    // }
+    // The `AnimalsState` serves as the container state. Additionally, the
+    // selector may reside within a namespace or another class lacking the
+    // `@State` decorator, thus not being treated as the container state.
+    const canInjectContainerState = selectorOptions.injectContainerState || selectors.length === 0;
+    if (containerClass && canInjectContainerState) {
+        // If we are on a state class, add it as the first selector parameter
+        const metadata = _getStoreMetadata(containerClass);
+        if (metadata) {
+            selectorsToApply.push(containerClass);
+        }
+    }
+    selectorsToApply.push(...selectors);
+    return selectorsToApply;
+}
+/**
+ * This function gets the factory function to create the selector to get the selected slice from the app state
+ * @ignore
+ */
+function getRootSelectorFactory(selector) {
+    const metadata = _getSelectorMetadata(selector) || _getStoreMetadata(selector);
+    return (metadata && metadata.makeRootSelector) || (() => selector);
+}
+
+const NG_DEV_MODE$5 = typeof ngDevMode !== 'undefined' && ngDevMode;
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.
+ * See perf hit: https://jsperf.com/fast-value-getter-given-path/1
+ *
+ * @ignore
+ */
+function compliantPropGetter(paths) {
+    return obj => {
+        for (let i = 0; i < paths.length; i++) {
+            if (!obj)
+                return undefined;
+            obj = obj[paths[i]];
+        }
+        return obj;
+    };
+}
+/**
+ * The generated function is faster than:
+ * - pluck (Observable operator)
+ * - memoize
+ *
+ * @ignore
+ */
+function fastPropGetter(paths) {
+    const segments = paths;
+    let seg = 'store.' + segments[0];
+    let i = 0;
+    const l = segments.length;
+    let expr = seg;
+    while (++i < l) {
+        expr = expr + ' && ' + (seg = seg + '.' + segments[i]);
+    }
+    const fn = new Function('store', 'return ' + expr + ';');
+    return fn;
+}
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * @ignore
+ *
+ * Marked for removal. It's only used within `createSelectorFn`.
+ */
+function propGetter(paths, config) {
+    if (config?.compatibility?.strictContentSecurityPolicy) {
+        return compliantPropGetter(paths);
+    }
+    else {
+        return fastPropGetter(paths);
+    }
+}
+// This injection token selects the prop getter implementation once the app is
+// bootstrapped, as the `propGetter` function's behavior determines the implementation
+// each time it's called. It accepts the config as the second argument. We no longer
+// need to check for the `strictContentSecurityPolicy` every time the prop getter
+// implementation is selected. Now, the `propGetter` function is only used within
+// `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$5 ? 'PROP_GETTER' : '', {
+    providedIn: 'root',
+    factory: () => inject(NgxsConfig).compatibility?.strictContentSecurityPolicy
+        ? compliantPropGetter
+        : fastPropGetter
+});
+/**
+ * Given an array of states, it will return a object graph. Example:
+ *    const states = [
+ *      Cart,
+ *      CartSaved,
+ *      CartSavedItems
+ *    ]
+ *
+ * would return:
+ *
+ *  const graph = {
+ *    cart: ['saved'],
+ *    saved: ['items'],
+ *    items: []
+ *  };
+ *
+ * @ignore
+ */
+function buildGraph(stateClasses) {
+    const findName = (stateClass) => {
+        const meta = stateClasses.find(g => g === stateClass);
+        if (NG_DEV_MODE$5 && !meta) {
+            throw new Error(`Child state not found: ${stateClass}. \r\nYou may have forgotten to add states to module`);
+        }
+        return meta[_META_KEY].name;
+    };
+    return stateClasses.reduce((result, stateClass) => {
+        const { name, children } = stateClass[_META_KEY];
+        result[name] = (children || []).map(findName);
+        return result;
+    }, {});
+}
+/**
+ * Given a states array, returns object graph
+ * returning the name and state metadata. Example:
+ *
+ *  const graph = {
+ *    cart: { metadata }
+ *  };
+ *
  * @ignore
  */
 function nameToState(states) {
     return states.reduce((result, stateClass) => {
-        const meta = stateClass[META_KEY];
+        const meta = stateClass[_META_KEY];
         result[meta.name] = stateClass;
         return result;
     }, {});
@@ -476,639 +869,149 @@ function findFullParentPath(obj, newObj = {}) {
  *    cart: ['saved'],
  *    saved: ['items'],
  *    items: []
- *  };
- *
- * would return:
- *
- *  const results = [
- *    'items',
- *    'saved',
- *    'cart'
- *  ];
- *
- * @ignore
- */
-function topologicalSort(graph) {
-    const sorted = [];
-    const visited = {};
-    const visit = (name, ancestors = []) => {
-        if (!Array.isArray(ancestors)) {
-            ancestors = [];
-        }
-        ancestors.push(name);
-        visited[name] = true;
-        graph[name].forEach((dep) => {
-            // Caretaker note: we have still left the `typeof` condition in order to avoid
-            // creating a breaking change for projects that still use the View Engine.
-            if ((typeof ngDevMode === 'undefined' || ngDevMode) && ancestors.indexOf(dep) >= 0) {
-                throw new Error(`Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`);
-            }
-            if (visited[dep]) {
-                return;
-            }
-            visit(dep, ancestors.slice(0));
-        });
-        if (sorted.indexOf(name) < 0) {
-            sorted.push(name);
-        }
-    };
-    Object.keys(graph).forEach(k => visit(k));
-    return sorted.reverse();
-}
-/**
- * Returns if the parameter is a object or not.
- *
- * @ignore
- */
-function isObject(obj) {
-    return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
-}
-
-/**
- * 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" /* 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" /* 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" /* Canceled */]);
-}
-/**
- * RxJS operator for selecting out specific actions.
- *
- * This will ONLY grab actions that have just been completed
- */
-function ofActionCompleted(...allowedTypes) {
-    const allowedStatuses = [
-        "SUCCESSFUL" /* Successful */,
-        "CANCELED" /* Canceled */,
-        "ERRORED" /* 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" /* Errored */]);
-}
-function ofActionOperator(allowedTypes, statuses, 
-// This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,
-// since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`
-// defaults to `any`, thus there is no sense from union type.
-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" /* Successful */ === status,
-                canceled: "CANCELED" /* 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;
-    }, {});
-}
-
-/**
- * Returns operator that will run
- * `subscribe` outside of the ngxs execution context
- */
-function leaveNgxs(ngxsExecutionStrategy) {
-    return (source) => {
-        return new Observable((sink) => {
-            return source.subscribe({
-                next(value) {
-                    ngxsExecutionStrategy.leave(() => sink.next(value));
-                },
-                error(error) {
-                    ngxsExecutionStrategy.leave(() => sink.error(error));
-                },
-                complete() {
-                    ngxsExecutionStrategy.leave(() => sink.complete());
-                }
-            });
-        });
-    };
-}
-
-class InternalNgxsExecutionStrategy {
-    constructor(_executionStrategy) {
-        this._executionStrategy = _executionStrategy;
-    }
-    enter(func) {
-        return this._executionStrategy.enter(func);
-    }
-    leave(func) {
-        return this._executionStrategy.leave(func);
-    }
-}
-/** @nocollapse */ InternalNgxsExecutionStrategy.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalNgxsExecutionStrategy, deps: [{ token: NGXS_EXECUTION_STRATEGY }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ InternalNgxsExecutionStrategy.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalNgxsExecutionStrategy, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalNgxsExecutionStrategy, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
-                    type: Inject,
-                    args: [NGXS_EXECUTION_STRATEGY]
-                }] }]; } });
-
-/**
- * This wraps the provided function, and will enforce the following:
- * - The calls will execute in the order that they are made
- * - A call will only be initiated when the previous call has completed
- * - If there is a call currently executing then the new call will be added
- *   to the queue and the function will return immediately
- *
- * NOTE: The following assumptions about the operation must hold true:
- * - The operation is synchronous in nature
- * - If any asynchronous side effects of the call exist, it should not
- *   have any bearing on the correctness of the next call in the queue
- * - The operation has a void return
- * - The caller should not assume that the call has completed upon
- *   return of the function
- * - The caller can assume that all the queued calls will complete
- *   within the current microtask
- * - The only way that a call will encounter another call in the queue
- *   would be if the call at the front of the queue initiated this call
- *   as part of its synchronous execution
- */
-function orderedQueueOperation(operation) {
-    const callsQueue = [];
-    let busyPushingNext = false;
-    return function callOperation(...args) {
-        if (busyPushingNext) {
-            callsQueue.unshift(args);
-            return;
-        }
-        busyPushingNext = true;
-        operation(...args);
-        while (callsQueue.length > 0) {
-            const nextCallArgs = callsQueue.pop();
-            nextCallArgs && operation(...nextCallArgs);
-        }
-        busyPushingNext = false;
-    };
-}
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-class OrderedSubject extends Subject {
-    constructor() {
-        super(...arguments);
-        this._orderedNext = orderedQueueOperation((value) => super.next(value));
-    }
-    next(value) {
-        this._orderedNext(value);
-    }
-}
-/**
- * Custom BehaviorSubject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard BehaviorSubject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new BehaviorSubject<string>();
-     subject.subscribe(value => {
-       if (value === 'start') subject.next('end');
-     });
-     subject.subscribe(value => { });
-     subject.next('start');
- * ```
- * When `subject` is a standard `BehaviorSubject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedBehaviorSubject<T>` the second subscriber would recieve `start` and then `end`.
- */
-class OrderedBehaviorSubject extends BehaviorSubject {
-    constructor(value) {
-        super(value);
-        this._orderedNext = orderedQueueOperation((value) => super.next(value));
-        this._currentValue = value;
-    }
-    getValue() {
-        return this._currentValue;
-    }
-    next(value) {
-        this._currentValue = value;
-        this._orderedNext(value);
-    }
-}
-
-/**
- * Internal Action stream that is emitted anytime an action is dispatched.
- */
-class InternalActions extends OrderedSubject {
-    ngOnDestroy() {
-        this.complete();
-    }
-}
-/** @nocollapse */ InternalActions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalActions, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ InternalActions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalActions, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalActions, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-/**
- * Action stream that is emitted anytime an action is dispatched.
- *
- * You can listen to this in services to react without stores.
- */
-class Actions extends Observable {
-    constructor(internalActions$, internalExecutionStrategy) {
-        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.
-        // The `share()` operator reduces the number of change detections.
-        // This would call leave only once for any stream emission across all active subscribers.
-        share());
-        super(observer => {
-            const childSubscription = sharedInternalActions$.subscribe({
-                next: ctx => observer.next(ctx),
-                error: error => observer.error(error),
-                complete: () => observer.complete()
-            });
-            observer.add(childSubscription);
-        });
-    }
-}
-/** @nocollapse */ Actions.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Actions, deps: [{ token: InternalActions }, { token: InternalNgxsExecutionStrategy }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ Actions.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Actions, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Actions, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: InternalActions }, { 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`.
+ * would return:
+ *
+ *  const results = [
+ *    'items',
+ *    'saved',
+ *    'cart'
+ *  ];
  *
  * @ignore
  */
-const compose = (funcs) => (...args) => {
-    const curr = funcs.shift();
-    return curr(...args, (...nextArgs) => compose(funcs)(...nextArgs));
-};
-
-/**
- * This operator is used for piping the observable result
- * from the `dispatch()`. It has a "smart" error handling
- * strategy that allows us to decide whether we propagate
- * errors to Angular's `ErrorHandler` or enable users to
- * handle them manually. We consider following cases:
- * 1) `store.dispatch()` (no subscribe) -> call `handleError()`
- * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`
- * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`
- * 4) `toPromise()` without `catch` -> do `handleError()`
- * 5) `toPromise()` with `catch` -> don't `handleError()`
- */
-function ngxsErrorHandler(internalErrorReporter, ngxsExecutionStrategy) {
-    return (source) => {
-        let subscribed = false;
-        source.subscribe({
-            error: error => {
-                // Do not trigger change detection for a microtask. This depends on the execution
-                // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`
-                // leaves the Angular zone.
-                ngxsExecutionStrategy.enter(() => Promise.resolve().then(() => {
-                    if (!subscribed) {
-                        ngxsExecutionStrategy.leave(() => internalErrorReporter.reportErrorSafely(error));
-                    }
-                }));
+function topologicalSort(graph) {
+    const sorted = [];
+    const visited = {};
+    const visit = (name, ancestors = []) => {
+        if (!Array.isArray(ancestors)) {
+            ancestors = [];
+        }
+        ancestors.push(name);
+        visited[name] = true;
+        graph[name].forEach((dep) => {
+            if (NG_DEV_MODE$5 && ancestors.indexOf(dep) >= 0) {
+                throw new Error(`Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`);
             }
+            if (visited[dep]) {
+                return;
+            }
+            visit(dep, ancestors.slice(0));
         });
-        return new Observable(subscriber => {
-            subscribed = true;
-            return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);
-        });
-    };
-}
-class InternalErrorReporter {
-    constructor(_injector) {
-        this._injector = _injector;
-        /** Will be set lazily to be backward compatible. */
-        this._errorHandler = null;
-    }
-    reportErrorSafely(error) {
-        if (this._errorHandler === null) {
-            this._errorHandler = this._injector.get(ErrorHandler);
-        }
-        // The `try-catch` is used to avoid handling the error twice. Suppose we call
-        // `handleError` which re-throws the error internally. The re-thrown error will
-        // be caught by zone.js which will then get to the `zone.onError.emit()` and the
-        // `onError` subscriber will call `handleError` again.
-        try {
-            this._errorHandler.handleError(error);
+        if (sorted.indexOf(name) < 0) {
+            sorted.push(name);
         }
-        catch (_a) { }
-    }
+    };
+    Object.keys(graph).forEach(k => visit(k));
+    return sorted.reverse();
 }
-/** @nocollapse */ InternalErrorReporter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalErrorReporter, deps: [{ token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ InternalErrorReporter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalErrorReporter, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalErrorReporter, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: i0.Injector }]; } });
 
 /**
- * BehaviorSubject of the entire state.
- * @ignore
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will grab actions that have just been dispatched as well as actions that have completed
  */
-class StateStream extends OrderedBehaviorSubject {
-    constructor() {
-        super({});
-    }
-    ngOnDestroy() {
-        // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.
-        // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users
-        // might forget to unsubscribe from `store.select` or `store.subscribe`, thus this will lead to huge memory leaks in SSR apps.
-        this.complete();
-    }
+function ofAction(...allowedTypes) {
+    return ofActionOperator(allowedTypes);
 }
-/** @nocollapse */ StateStream.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ StateStream.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateStream, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return []; } });
-
-class PluginManager {
-    constructor(_parentManager, _pluginHandlers) {
-        this._parentManager = _parentManager;
-        this._pluginHandlers = _pluginHandlers;
-        this.plugins = [];
-        this.registerHandlers();
-    }
-    get rootPlugins() {
-        return (this._parentManager && this._parentManager.plugins) || this.plugins;
-    }
-    registerHandlers() {
-        const pluginHandlers = this.getPluginHandlers();
-        this.rootPlugins.push(...pluginHandlers);
-    }
-    getPluginHandlers() {
-        const handlers = this._pluginHandlers || [];
-        return handlers.map((plugin) => (plugin.handle ? plugin.handle.bind(plugin) : plugin));
-    }
+/**
+ * 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 */]);
 }
-/** @nocollapse */ PluginManager.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PluginManager, deps: [{ token: PluginManager, optional: true, skipSelf: true }, { token: NGXS_PLUGINS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ PluginManager.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PluginManager });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: PluginManager, decorators: [{
-            type: Injectable
-        }], ctorParameters: function () { return [{ type: PluginManager, decorators: [{
-                    type: Optional
-                }, {
-                    type: SkipSelf
-                }] }, { type: undefined, decorators: [{
-                    type: Inject,
-                    args: [NGXS_PLUGINS]
-                }, {
-                    type: Optional
-                }] }]; } });
-
 /**
- * Internal Action result stream that is emitted when an action is completed.
- * This is used as a method of returning the action result to the dispatcher
- * for the observable returned by the dispatch(...) call.
- * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been successfully completed
  */
-class InternalDispatchedActionResults extends Subject {
+function ofActionSuccessful(...allowedTypes) {
+    return ofActionOperator(allowedTypes, ["SUCCESSFUL" /* ActionStatus.Successful */]);
 }
-/** @nocollapse */ InternalDispatchedActionResults.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatchedActionResults, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ InternalDispatchedActionResults.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatchedActionResults, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatchedActionResults, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-class InternalDispatcher {
-    constructor(_actions, _actionResults, _pluginManager, _stateStream, _ngxsExecutionStrategy, _internalErrorReporter) {
-        this._actions = _actions;
-        this._actionResults = _actionResults;
-        this._pluginManager = _pluginManager;
-        this._stateStream = _stateStream;
-        this._ngxsExecutionStrategy = _ngxsExecutionStrategy;
-        this._internalErrorReporter = _internalErrorReporter;
-    }
-    /**
-     * Dispatches event(s).
-     */
-    dispatch(actionOrActions) {
-        const result = this._ngxsExecutionStrategy.enter(() => this.dispatchByEvents(actionOrActions));
-        return result.pipe(ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy));
-    }
-    dispatchByEvents(actionOrActions) {
-        if (Array.isArray(actionOrActions)) {
-            if (actionOrActions.length === 0)
-                return of(this._stateStream.getValue());
-            return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));
-        }
-        else {
-            return this.dispatchSingle(actionOrActions);
-        }
-    }
-    dispatchSingle(action) {
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            const type = getActionTypeFromInstance(action);
-            if (!type) {
-                const error = new Error(`This action doesn't have a type property: ${action.constructor.name}`);
-                return throwError(error);
-            }
-        }
-        const prevState = this._stateStream.getValue();
-        const plugins = this._pluginManager.plugins;
-        return compose([
-            ...plugins,
-            (nextState, nextAction) => {
-                if (nextState !== prevState) {
-                    this._stateStream.next(nextState);
-                }
-                const actionResult$ = this.getActionResultStream(nextAction);
-                actionResult$.subscribe(ctx => this._actions.next(ctx));
-                this._actions.next({ action: nextAction, status: "DISPATCHED" /* Dispatched */ });
-                return this.createDispatchObservable(actionResult$);
-            }
-        ])(prevState, action).pipe(shareReplay());
-    }
-    getActionResultStream(action) {
-        return this._actionResults.pipe(filter((ctx) => ctx.action === action && ctx.status !== "DISPATCHED" /* Dispatched */), take(1), shareReplay());
-    }
-    createDispatchObservable(actionResult$) {
-        return actionResult$
-            .pipe(exhaustMap((ctx) => {
-            switch (ctx.status) {
-                case "SUCCESSFUL" /* Successful */:
-                    return of(this._stateStream.getValue());
-                case "ERRORED" /* Errored */:
-                    return throwError(ctx.error);
-                default:
-                    return EMPTY;
-            }
-        }))
-            .pipe(shareReplay());
-    }
+/**
+ * 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 */]);
 }
-/** @nocollapse */ InternalDispatcher.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatcher, deps: [{ token: InternalActions }, { token: InternalDispatchedActionResults }, { token: PluginManager }, { token: StateStream }, { token: InternalNgxsExecutionStrategy }, { token: InternalErrorReporter }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ InternalDispatcher.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatcher, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalDispatcher, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: InternalActions }, { type: InternalDispatchedActionResults }, { type: PluginManager }, { type: StateStream }, { type: InternalNgxsExecutionStrategy }, { type: InternalErrorReporter }]; } });
-
 /**
- * Object freeze code
- * https://github.com/jsdf/deep-freeze
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just been completed
  */
-const deepFreeze = (o) => {
-    Object.freeze(o);
-    const oIsFunction = typeof o === 'function';
-    const hasOwnProp = Object.prototype.hasOwnProperty;
-    Object.getOwnPropertyNames(o).forEach(function (prop) {
-        if (hasOwnProp.call(o, prop) &&
-            (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&
-            o[prop] !== null &&
-            (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&
-            !Object.isFrozen(o[prop])) {
-            deepFreeze(o[prop]);
-        }
-    });
-    return o;
-};
-
+function ofActionCompleted(...allowedTypes) {
+    const allowedStatuses = [
+        "SUCCESSFUL" /* ActionStatus.Successful */,
+        "CANCELED" /* ActionStatus.Canceled */,
+        "ERRORED" /* ActionStatus.Errored */
+    ];
+    return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);
+}
 /**
- * @ignore
+ * RxJS operator for selecting out specific actions.
+ *
+ * This will ONLY grab actions that have just thrown an error
  */
-class InternalStateOperations {
-    constructor(_stateStream, _dispatcher, _config) {
-        this._stateStream = _stateStream;
-        this._dispatcher = _dispatcher;
-        this._config = _config;
-    }
-    /**
-     * Returns the root state operators.
-     */
-    getRootStateOperations() {
-        const rootStateOperations = {
-            getState: () => this._stateStream.getValue(),
-            setState: (newState) => this._stateStream.next(newState),
-            dispatch: (actionOrActions) => this._dispatcher.dispatch(actionOrActions)
+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
+            }
         };
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
-            return this._config.developmentMode
-                ? ensureStateAndActionsAreImmutable(rootStateOperations)
-                : rootStateOperations;
-        }
-        else {
-            return rootStateOperations;
-        }
-    }
-    setStateToTheCurrentWithNew(results) {
-        const stateOperations = this.getRootStateOperations();
-        // Get our current stream
-        const currentState = stateOperations.getState();
-        // Set the state to the current + new
-        stateOperations.setState(Object.assign(Object.assign({}, currentState), results.defaults));
-    }
+    });
 }
-/** @nocollapse */ InternalStateOperations.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, deps: [{ token: StateStream }, { token: InternalDispatcher }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ InternalStateOperations.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: InternalStateOperations, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: StateStream }, { type: InternalDispatcher }, { type: NgxsConfig }]; } });
-function ensureStateAndActionsAreImmutable(root) {
-    return {
-        getState: () => root.getState(),
-        setState: value => {
-            const frozenValue = deepFreeze(value);
-            return root.setState(frozenValue);
-        },
-        dispatch: actions => {
-            return root.dispatch(actions);
-        }
-    };
+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 (typeof ngDevMode !== 'undefined' && ngDevMode) {
             if (Array.isArray(value)) {
                 throwPatchingArrayError();
             }
@@ -1116,7 +1019,7 @@ function simplePatch(value) {
                 throwPatchingPrimitiveError();
             }
         }
-        const newState = Object.assign({}, existingState);
+        const newState = { ...existingState };
         for (const key in value) {
             // deep clone for patch compatibility
             newState[key] = value[key];
@@ -1146,26 +1049,29 @@ class StateContextFactory {
             patchState(val) {
                 const currentAppState = root.getState();
                 const patchOperator = simplePatch(val);
-                return setStateFromOperator(root, currentAppState, patchOperator, mappedStore.path);
+                setStateFromOperator(root, currentAppState, patchOperator, mappedStore.path);
             },
             setState(val) {
                 const currentAppState = root.getState();
-                return isStateOperator(val)
-                    ? setStateFromOperator(root, currentAppState, val, mappedStore.path)
-                    : setStateValue(root, currentAppState, val, mappedStore.path);
+                if (isStateOperator(val)) {
+                    setStateFromOperator(root, currentAppState, val, mappedStore.path);
+                }
+                else {
+                    setStateValue(root, currentAppState, val, mappedStore.path);
+                }
             },
             dispatch(actions) {
                 return root.dispatch(actions);
             }
         };
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StateContextFactory, deps: [{ token: InternalStateOperations }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StateContextFactory, providedIn: 'root' }); }
 }
-/** @nocollapse */ StateContextFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateContextFactory, deps: [{ token: InternalStateOperations }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ StateContextFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateContextFactory, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateContextFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StateContextFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: InternalStateOperations }]; } });
+        }], ctorParameters: () => [{ type: InternalStateOperations }] });
 function setStateValue(root, currentAppState, newValue, path) {
     const newAppState = setValue(currentAppState, path, newValue);
     root.setState(newAppState);
@@ -1203,7 +1109,7 @@ function ensureStateNameIsUnique(stateName, state, statesByName) {
 }
 function ensureStatesAreDecorated(stateClasses) {
     stateClasses.forEach((stateClass) => {
-        if (!getStoreMetadata$1(stateClass)) {
+        if (!_getStoreMetadata(stateClass)) {
             throwStateDecoratorError(stateClass.name);
         }
     });
@@ -1218,7 +1124,7 @@ function ensureStateClassIsInjectable(stateClass) {
     if (jit_hasInjectableAnnotation(stateClass) || aot_hasNgInjectableDef(stateClass)) {
         return;
     }
-    console.warn(getUndecoratedStateInIvyWarningMessage(stateClass.name));
+    console.warn(getUndecoratedStateWithInjectableWarningMessage(stateClass.name));
 }
 function aot_hasNgInjectableDef(stateClass) {
     // `ɵprov` is a static property added by the NGCC compiler. It always exists in
@@ -1230,26 +1136,11 @@ function aot_hasNgInjectableDef(stateClass) {
 function jit_hasInjectableAnnotation(stateClass) {
     // `ɵprov` doesn't exist in JIT mode (for instance when running unit tests with Jest).
     const annotations = stateClass.__annotations__ || [];
-    return annotations.some((annotation) => (annotation === null || annotation === void 0 ? void 0 : annotation.ngMetadataName) === 'Injectable');
-}
-
-/**
- * Init action
- */
-class InitState {
-}
-InitState.type = '@@INIT';
-/**
- * Update action
- */
-class UpdateState {
-    constructor(addedStates) {
-        this.addedStates = addedStates;
-    }
+    return annotations.some((annotation) => annotation?.ngMetadataName === 'Injectable');
 }
-UpdateState.type = '@@UPDATE_STATE';
 
-const NGXS_DEVELOPMENT_OPTIONS = new InjectionToken('NGXS_DEVELOPMENT_OPTIONS', {
+const NG_DEV_MODE$4 = typeof ngDevMode !== 'undefined' && ngDevMode;
+const NGXS_DEVELOPMENT_OPTIONS = new InjectionToken(NG_DEV_MODE$4 ? 'NGXS_DEVELOPMENT_OPTIONS' : '', {
     providedIn: 'root',
     factory: () => ({ warnOnUnhandledActions: true })
 });
@@ -1285,17 +1176,56 @@ 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: "17.3.3", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [{ token: NGXS_DEVELOPMENT_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsUnhandledActionsLogger }); }
 }
-/** @nocollapse */ NgxsUnhandledActionsLogger.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsUnhandledActionsLogger, deps: [{ token: NGXS_DEVELOPMENT_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ NgxsUnhandledActionsLogger.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsUnhandledActionsLogger });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsUnhandledActionsLogger, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
                     type: Inject,
                     args: [NGXS_DEVELOPMENT_OPTIONS]
-                }] }]; } });
+                }] }] });
+
+class NgxsUnhandledErrorHandler {
+    constructor() {
+        this._ngZone = inject(NgZone);
+        this._errorHandler = inject(ErrorHandler);
+    }
+    /**
+     * The `_unhandledErrorContext` is left unused internally since we do not
+     * require it for internal operations. However, developers who wish to provide
+     * their own custom error handler may utilize this context information.
+     */
+    handleError(error, _unhandledErrorContext) {
+        // In order to avoid duplicate error handling, it is necessary to leave
+        // the Angular zone to ensure that errors are not caught twice. The `handleError`
+        // method may contain a `throw error` statement, which is used to re-throw the error.
+        // If the error is re-thrown within the Angular zone, it will be caught again by the
+        // Angular zone. By default, `@angular/core` leaves the Angular zone when invoking
+        // `handleError` (see `_callAndReportToErrorHandler`).
+        this._ngZone.runOutsideAngular(() => this._errorHandler.handleError(error));
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsUnhandledErrorHandler, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsUnhandledErrorHandler, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsUnhandledErrorHandler, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
 
-const NG_DEV_MODE = typeof ngDevMode === 'undefined' || ngDevMode;
+const NG_DEV_MODE$3 = typeof ngDevMode !== 'undefined' && ngDevMode;
+function cloneDefaults(defaults) {
+    let value = defaults === undefined ? {} : defaults;
+    if (defaults) {
+        if (Array.isArray(defaults)) {
+            value = defaults.slice();
+        }
+        else if (typeof defaults === 'object') {
+            value = { ...defaults };
+        }
+    }
+    return value;
+}
 /**
  * The `StateFactory` class adds root and feature states to the graph.
  * This extracts state names from state classes, checks if they already
@@ -1319,35 +1249,43 @@ class StateFactory {
         this._stateContextFactory = _stateContextFactory;
         this._initialState = _initialState;
         this._actionsSubscription = null;
+        this._propGetter = inject(ɵPROP_GETTER);
+        this._ngxsUnhandledErrorHandler = null;
         this._states = [];
         this._statesByName = {};
         this._statePaths = {};
-        this.getRuntimeSelectorContext = memoize(() => {
+        this.getRuntimeSelectorContext = _memoize(() => {
             // eslint-disable-next-line @typescript-eslint/no-this-alias
             const stateFactory = this;
+            const propGetter = stateFactory._propGetter;
             function resolveGetter(key) {
                 const path = stateFactory.statePaths[key];
-                return path ? propGetter(path.split('.'), stateFactory._config) : null;
+                return path ? propGetter(path.split('.')) : null;
             }
             const context = this._parentFactory
                 ? this._parentFactory.getRuntimeSelectorContext()
                 : {
                     getStateGetter(key) {
-                        let getter = resolveGetter(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 = resolveGetter(key);
+                                getter = /*@__INLINE__*/ resolveGetter(key);
                             }
                             return getter ? getter(...args) : undefined;
                         };
                     },
                     getSelectorOptions(localOptions) {
                         const globalSelectorOptions = stateFactory._config.selectorOptions;
-                        return Object.assign(Object.assign({}, globalSelectorOptions), (localOptions || {}));
+                        return {
+                            ...globalSelectorOptions,
+                            ...(localOptions || {})
+                        };
                     }
                 };
             return context;
@@ -1362,28 +1300,14 @@ class StateFactory {
     get statePaths() {
         return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;
     }
-    static _cloneDefaults(defaults) {
-        let value = defaults;
-        if (Array.isArray(defaults)) {
-            value = defaults.slice();
-        }
-        else if (isObject(defaults)) {
-            value = Object.assign({}, defaults);
-        }
-        else if (defaults === undefined) {
-            value = {};
-        }
-        return value;
-    }
     ngOnDestroy() {
-        var _a;
-        (_a = this._actionsSubscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+        this._actionsSubscription?.unsubscribe();
     }
     /**
      * Add a new state to the global defs.
      */
     add(stateClasses) {
-        if (NG_DEV_MODE) {
+        if (NG_DEV_MODE$3) {
             ensureStatesAreDecorated(stateClasses);
         }
         const { newStates } = this.addToStatesMap(stateClasses);
@@ -1397,13 +1321,13 @@ class StateFactory {
         for (const name of sortedStates) {
             const stateClass = nameGraph[name];
             const path = paths[name];
-            const meta = stateClass[META_KEY];
+            const meta = stateClass[_META_KEY];
             this.addRuntimeInfoToMeta(meta, path);
             // Note: previously we called `ensureStateClassIsInjectable` within the
             // `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) {
+            if (NG_DEV_MODE$3) {
                 ensureStateClassIsInjectable(stateClass);
             }
             const stateMap = {
@@ -1412,7 +1336,7 @@ class StateFactory {
                 isInitialised: false,
                 actions: meta.actions,
                 instance: this._injector.get(stateClass),
-                defaults: StateFactory._cloneDefaults(meta.defaults)
+                defaults: cloneDefaults(meta.defaults)
             };
             // ensure our store hasn't already been added
             // but don't throw since it could be lazy
@@ -1442,10 +1366,19 @@ class StateFactory {
         }
         const dispatched$ = new Subject();
         this._actionsSubscription = this._actions
-            .pipe(filter((ctx) => ctx.status === "DISPATCHED" /* Dispatched */), mergeMap(ctx => {
+            .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" /* Successful */ })), defaultIfEmpty({ action, status: "CANCELED" /* Canceled */ }), catchError(error => of({ action, status: "ERRORED" /* Errored */, error })));
+            return this.invokeActions(dispatched$, action).pipe(map(() => ({ 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 }));
+                return of({
+                    action,
+                    status: "ERRORED" /* ActionStatus.Errored */,
+                    error: handleableError
+                });
+            }));
         }))
             .subscribe(ctx => this._actionResults.next(ctx));
     }
@@ -1465,7 +1398,13 @@ class StateFactory {
                     const stateContext = this._stateContextFactory.createStateContext(metadata);
                     try {
                         let result = metadata.instance[actionMeta.fn](stateContext, action);
-                        if (result instanceof Promise) {
+                        // 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)) {
@@ -1478,7 +1417,7 @@ class StateFactory {
                             // then the action will be canceled.
                             // See https://github.com/ngxs/store/issues/1568
                             result = result.pipe(mergeMap((value) => {
-                                if (value instanceof Promise) {
+                                if (_isPromise(value)) {
                                     return from(value);
                                 }
                                 if (isObservable(value)) {
@@ -1505,7 +1444,7 @@ class StateFactory {
         }
         // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions
         // only during development.
-        if (NG_DEV_MODE && !actionHasBeenHandled) {
+        if (NG_DEV_MODE$3 && !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`
@@ -1523,8 +1462,8 @@ class StateFactory {
         const newStates = [];
         const statesMap = this.statesByName;
         for (const stateClass of stateClasses) {
-            const stateName = getStoreMetadata$1(stateClass).name;
-            if (NG_DEV_MODE) {
+            const stateName = _getStoreMetadata(stateClass).name;
+            if (NG_DEV_MODE$3) {
                 ensureStateNameIsUnique(stateName, stateClass, statesMap);
             }
             const unmountedState = !statesMap[stateName];
@@ -1548,12 +1487,12 @@ class StateFactory {
         // its lifecycle is in 'bootstrapped' state.
         return this.statesByName[name] && valueIsBootstrappedInInitialState;
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", 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: "17.3.3", ngImport: i0, type: StateFactory }); }
 }
-/** @nocollapse */ StateFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", 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 */ StateFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: StateFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: StateFactory, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: NgxsConfig }, { type: StateFactory, decorators: [{
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: NgxsConfig }, { type: StateFactory, decorators: [{
                     type: Optional
                 }, {
                     type: SkipSelf
@@ -1561,82 +1500,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImpo
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [INITIAL_STATE_TOKEN]
-                }] }]; } });
-
-function createRootSelectorFactory(selectorMetaData, selectors, memoizedSelectorFn) {
-    return (context) => {
-        const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(context, selectorMetaData, selectors);
-        return function selectFromRoot(rootState) {
-            // Determine arguments from the app state using the selectors
-            const results = argumentSelectorFunctions.map((argFn) => argFn(rootState));
-            // if the lambda tries to access a something on the
-            // state that doesn't exist, it will throw a TypeError.
-            // since this is quite usual behaviour, we simply return undefined if so.
-            try {
-                return memoizedSelectorFn(...results);
-            }
-            catch (ex) {
-                if (ex instanceof TypeError && selectorOptions.suppressErrors) {
-                    return undefined;
-                }
-                throw ex;
-            }
-        };
-    };
-}
-function createMemoizedSelectorFn(originalFn, creationMetadata) {
-    const containerClass = creationMetadata && creationMetadata.containerClass;
-    const wrappedFn = function wrappedSelectorFn(...args) {
-        const returnValue = originalFn.apply(containerClass, args);
-        if (returnValue instanceof Function) {
-            const innerMemoizedFn = memoize.apply(null, [returnValue]);
-            return innerMemoizedFn;
-        }
-        return returnValue;
-    };
-    const memoizedFn = memoize(wrappedFn);
-    Object.setPrototypeOf(memoizedFn, originalFn);
-    return memoizedFn;
-}
-function getRuntimeSelectorInfo(context, selectorMetaData, selectors = []) {
-    const localSelectorOptions = selectorMetaData.getSelectorOptions();
-    const selectorOptions = context.getSelectorOptions(localSelectorOptions);
-    const selectorsToApply = getSelectorsToApply(selectors, selectorOptions, selectorMetaData.containerClass);
-    const argumentSelectorFunctions = selectorsToApply.map((selector) => {
-        const factory = getRootSelectorFactory(selector);
-        return factory(context);
-    });
-    return {
-        selectorOptions,
-        argumentSelectorFunctions,
-    };
-}
-function getSelectorsToApply(selectors = [], selectorOptions, containerClass) {
-    const selectorsToApply = [];
-    const canInjectContainerState = selectors.length === 0 || selectorOptions.injectContainerState;
-    if (containerClass && canInjectContainerState) {
-        // If we are on a state class, add it as the first selector parameter
-        const metadata = getStoreMetadata$1(containerClass);
-        if (metadata) {
-            selectorsToApply.push(containerClass);
-        }
-    }
-    if (selectors) {
-        selectorsToApply.push(...selectors);
-    }
-    return selectorsToApply;
-}
-/**
- * This function gets the factory function to create the selector to get the selected slice from the app state
- * @ignore
- */
-function getRootSelectorFactory(selector) {
-    const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);
-    return (metadata && metadata.makeRootSelector) || (() => selector);
-}
+                    args: [_INITIAL_STATE_TOKEN]
+                }] }] });
 
-// tslint:disable:unified-signatures
 class Store {
     constructor(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {
         this._stateStream = _stateStream;
@@ -1658,25 +1524,40 @@ class Store {
     dispatch(actionOrActions) {
         return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);
     }
+    /**
+     * Selects a slice of data from the store.
+     */
     select(selector) {
         const selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._selectableStateStream.pipe(map(selectorFn), catchError((err) => {
+        return this._selectableStateStream.pipe(map(selectorFn), catchError((error) => {
             // if error is TypeError we swallow it to prevent usual errors with property access
-            const { suppressErrors } = this._config.selectorOptions;
-            if (err instanceof TypeError && suppressErrors) {
+            if (this._config.selectorOptions.suppressErrors && error instanceof TypeError) {
                 return of(undefined);
             }
             // rethrow other errors
-            return throwError(err);
+            return throwError(error);
         }), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));
     }
+    /**
+     * Select one slice of data from the store.
+     */
     selectOnce(selector) {
         return this.select(selector).pipe(take(1));
     }
+    /**
+     * Select a snapshot from the state.
+     */
     selectSnapshot(selector) {
         const selectorFn = this.getStoreBoundSelectorFn(selector);
         return selectorFn(this._stateStream.getValue());
     }
+    /**
+     * Select a signal from the state.
+     */
+    selectSignal(selector) {
+        const selectorFn = this.getStoreBoundSelectorFn(selector);
+        return computed(() => selectorFn(this._stateStream.state()));
+    }
     /**
      * Allow the user to subscribe to the root of the state
      */
@@ -1696,7 +1577,7 @@ class Store {
      * for plugin's who need to modify the state directly or unit testing.
      */
     reset(state) {
-        return this._internalStateOperations.getRootStateOperations().setState(state);
+        this._internalStateOperations.getRootStateOperations().setState(state);
     }
     getStoreBoundSelectorFn(selector) {
         const makeSelectorFn = getRootSelectorFactory(selector);
@@ -1707,30 +1588,60 @@ class Store {
         const value = this._stateStream.value;
         const storeIsEmpty = !value || Object.keys(value).length === 0;
         if (storeIsEmpty) {
-            const defaultStateNotEmpty = Object.keys(this._config.defaultsState).length > 0;
-            const storeValues = defaultStateNotEmpty
-                ? Object.assign(Object.assign({}, this._config.defaultsState), initialStateValue) : initialStateValue;
-            this._stateStream.next(storeValues);
+            this._stateStream.next(initialStateValue);
         }
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", 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.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: Store, providedIn: 'root' }); }
 }
-/** @nocollapse */ Store.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Store, deps: [{ token: StateStream }, { token: InternalStateOperations }, { token: NgxsConfig }, { token: InternalNgxsExecutionStrategy }, { token: StateFactory }, { token: INITIAL_STATE_TOKEN, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ Store.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Store, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: Store, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: Store, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: StateStream }, { type: InternalStateOperations }, { type: NgxsConfig }, { type: InternalNgxsExecutionStrategy }, { type: StateFactory }, { type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: i1.ɵStateStream }, { type: InternalStateOperations }, { type: NgxsConfig }, { type: InternalNgxsExecutionStrategy }, { type: StateFactory }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [INITIAL_STATE_TOKEN]
-                }] }]; } });
+                    args: [_INITIAL_STATE_TOKEN]
+                }] }] });
+
+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' : '');
+/**
+ * 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
+ * available for injection. This is useful for registering action stream listeners
+ * before any action is dispatched.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(
+ *       [CountriesState],
+ *       withNgxsPreboot(() => {
+ *         const actions$ = inject(Actions);
+ *         actions$.subscribe(ctx => console.log(ctx));
+ *       })
+ *     )
+ *   ]
+ * });
+ * ```
+ */
+function withNgxsPreboot(prebootFn) {
+    return makeEnvironmentProviders([
+        { provide: NGXS_PREBOOT_FNS, multi: true, useValue: prebootFn }
+    ]);
+}
 
 /**
  * Allows the select decorator to get access to the DI store, this is used internally
  * in `@Select` decorator.
  */
 class SelectFactory {
+    static { this.store = null; }
+    static { this.config = null; }
     constructor(store, config) {
         SelectFactory.store = store;
         SelectFactory.config = config;
@@ -1739,40 +1650,46 @@ class SelectFactory {
         SelectFactory.store = null;
         SelectFactory.config = null;
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SelectFactory, deps: [{ token: Store }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SelectFactory, providedIn: 'root' }); }
 }
-SelectFactory.store = null;
-SelectFactory.config = null;
-/** @nocollapse */ SelectFactory.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectFactory, deps: [{ token: Store }, { token: NgxsConfig }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ SelectFactory.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectFactory, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: SelectFactory, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: SelectFactory, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: Store }, { type: NgxsConfig }]; } });
+        }], ctorParameters: () => [{ type: Store }, { type: NgxsConfig }] });
 
+const NG_DEV_MODE$1 = typeof ngDevMode !== 'undefined' && ngDevMode;
 class LifecycleStateManager {
-    constructor(_store, _internalErrorReporter, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+    constructor(_store, _internalStateOperations, _stateContextFactory, _appBootstrappedState) {
         this._store = _store;
-        this._internalErrorReporter = _internalErrorReporter;
         this._internalStateOperations = _internalStateOperations;
         this._stateContextFactory = _stateContextFactory;
-        this._bootstrapper = _bootstrapper;
-        this._destroy$ = new Subject();
+        this._appBootstrappedState = _appBootstrappedState;
+        this._destroy$ = new ReplaySubject(1);
     }
     ngOnDestroy() {
         this._destroy$.next();
     }
     ngxsBootstrap(action, results) {
+        if (NG_DEV_MODE$1) {
+            if (action instanceof InitState) {
+                this._initStateHasBeenDispatched = true;
+            }
+            else if (
+            // This is a dev mode-only check that ensures the correct order of
+            // state initialization. The `NgxsModule.forRoot` or `provideStore` should
+            // always come first, followed by `forFeature` and `provideStates`. If the
+            // `UpdateState` is dispatched before the `InitState` is dispatched, it indicates
+            // that modules or providers are in an invalid order.
+            action instanceof UpdateState &&
+                !this._initStateHasBeenDispatched) {
+                console.error(getInvalidInitializationOrderMessage(action.addedStates));
+            }
+        }
         this._internalStateOperations
             .getRootStateOperations()
             .dispatch(action)
-            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._bootstrapper.appBootstrapped$), filter(appBootstrapped => !!appBootstrapped), catchError(error => {
-            // The `SafeSubscriber` (which is used by most RxJS operators) re-throws
-            // errors asynchronously (`setTimeout(() => { throw error })`). This might
-            // break existing user's code or unit tests. We catch the error manually to
-            // be backward compatible with the old behavior.
-            this._internalErrorReporter.reportErrorSafely(error);
-            return EMPTY;
-        }), takeUntil(this._destroy$))
+            .pipe(filter(() => !!results), tap(() => this._invokeInitOnStates(results.states)), mergeMap(() => this._appBootstrappedState), filter(appBootstrapped => !!appBootstrapped), takeUntil(this._destroy$))
             .subscribe(() => this._invokeBootstrapOnStates(results.states));
     }
     _invokeInitOnStates(mappedStores) {
@@ -1804,170 +1721,218 @@ class LifecycleStateManager {
     _getStateContext(mappedStore) {
         return this._stateContextFactory.createStateContext(mappedStore);
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", 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: "17.3.3", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' }); }
 }
-/** @nocollapse */ LifecycleStateManager.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LifecycleStateManager, deps: [{ token: Store }, { token: InternalErrorReporter }, { token: InternalStateOperations }, { token: StateContextFactory }, { token: i5.NgxsBootstrapper }], target: i0.ɵɵFactoryTarget.Injectable });
-/** @nocollapse */ LifecycleStateManager.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LifecycleStateManager, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: LifecycleStateManager, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: LifecycleStateManager, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: function () { return [{ type: Store }, { type: InternalErrorReporter }, { type: InternalStateOperations }, { type: StateContextFactory }, { type: i5.NgxsBootstrapper }]; } });
+        }], 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() {
+    const prebootFns = inject(NGXS_PREBOOT_FNS, { optional: true }) || [];
+    prebootFns.forEach(prebootFn => prebootFn());
+    const factory = inject(StateFactory);
+    const internalStateOperations = inject(InternalStateOperations);
+    inject(Store);
+    inject(SelectFactory);
+    const states = inject(ROOT_STATE_TOKEN, { optional: true }) || [];
+    const lifecycleStateManager = inject(LifecycleStateManager);
+    // Add stores to the state graph and return their defaults.
+    const results = factory.addAndReturnDefaults(states);
+    internalStateOperations.setStateToTheCurrentWithNew(results);
+    // Connect our actions stream.
+    factory.connectActionHandlers();
+    // Dispatch the init action and invoke init and bootstrap functions after.
+    lifecycleStateManager.ngxsBootstrap(new InitState(), results);
+}
+/**
+ * This function is utilized by both NgModule and standalone features.
+ * When using `NgxsModule.forFeature` and `provideStates`, we can depend on
+ * the same initialization functionality.
+ */
+function featureStatesInitializer() {
+    inject(Store);
+    const internalStateOperations = inject(InternalStateOperations);
+    const factory = inject(StateFactory);
+    const states = inject(FEATURE_STATE_TOKEN, { optional: true }) || [];
+    const lifecycleStateManager = inject(LifecycleStateManager);
+    // Since FEATURE_STATE_TOKEN is a multi token, we need to
+    // flatten it [[Feature1State, Feature2State], [Feature3State]].
+    const flattenedStates = states.reduce((total, values) => total.concat(values), []);
+    // add stores to the state graph and return their defaults.
+    const results = factory.addAndReturnDefaults(flattenedStates);
+    if (results.states.length) {
+        internalStateOperations.setStateToTheCurrentWithNew(results);
+        // Dispatch the update action and invoke init and bootstrap functions after.
+        lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);
+    }
+}
+/**
+ * InjectionToken that registers the global Store.
+ */
+const NGXS_ROOT_STORE_INITIALIZER = new InjectionToken(NG_DEV_MODE ? '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_ROOT_ENVIRONMENT_INITIALIZER = [
+    { provide: NGXS_ROOT_STORE_INITIALIZER, useFactory: rootStoreInitializer },
+    {
+        provide: ENVIRONMENT_INITIALIZER,
+        multi: true,
+        useFactory() {
+            return () => inject(NGXS_ROOT_STORE_INITIALIZER);
+        }
+    }
+];
+/**
+ * The `NGXS_FEATURE_ENVIRONMENT_INITIALIZER` functions as an environment initializer
+ * at the `Route` level. Angular Router creates an environment route injector for each
+ * matched route where navigation occurs. The injector is created once, ensuring that
+ * the feature states initialization only happens once as well.
+ */
+const NGXS_FEATURE_ENVIRONMENT_INITIALIZER = [
+    { provide: NGXS_FEATURE_STORE_INITIALIZER, useFactory: featureStatesInitializer },
+    {
+        provide: ENVIRONMENT_INITIALIZER,
+        multi: true,
+        useFactory() {
+            return () => inject(NGXS_FEATURE_STORE_INITIALIZER);
+        }
+    }
+];
 
 /**
- * Root module
  * @ignore
  */
 class NgxsRootModule {
-    constructor(factory, internalStateOperations, _store, _select, states = [], lifecycleStateManager) {
-        // Add stores to the state graph and return their defaults
-        const results = factory.addAndReturnDefaults(states);
-        internalStateOperations.setStateToTheCurrentWithNew(results);
-        // Connect our actions stream
-        factory.connectActionHandlers();
-        // Dispatch the init action and invoke init and bootstrap functions after
-        lifecycleStateManager.ngxsBootstrap(new InitState(), results);
+    constructor() {
+        rootStoreInitializer();
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsRootModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: NgxsRootModule }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsRootModule }); }
 }
-/** @nocollapse */ NgxsRootModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule, deps: [{ token: StateFactory }, { token: InternalStateOperations }, { token: Store }, { token: SelectFactory }, { token: ROOT_STATE_TOKEN, optional: true }, { token: LifecycleStateManager }], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ NgxsRootModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule });
-/** @nocollapse */ NgxsRootModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsRootModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsRootModule, decorators: [{
             type: NgModule
-        }], ctorParameters: function () { return [{ type: StateFactory }, { type: InternalStateOperations }, { type: Store }, { type: SelectFactory }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [ROOT_STATE_TOKEN]
-                }] }, { type: LifecycleStateManager }]; } });
+        }], ctorParameters: () => [] });
 
 /**
- * Feature module
  * @ignore
  */
 class NgxsFeatureModule {
-    constructor(_store, internalStateOperations, factory, states = [], lifecycleStateManager) {
-        // Since FEATURE_STATE_TOKEN is a multi token, we need to
-        // flatten it [[Feature1State, Feature2State], [Feature3State]]
-        const flattenedStates = NgxsFeatureModule.flattenStates(states);
-        // add stores to the state graph and return their defaults
-        const results = factory.addAndReturnDefaults(flattenedStates);
-        if (results.states.length) {
-            internalStateOperations.setStateToTheCurrentWithNew(results);
-            // dispatch the update action and invoke init and bootstrap functions after
-            lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);
-        }
-    }
-    static flattenStates(states = []) {
-        return states.reduce((total, values) => total.concat(values), []);
+    constructor() {
+        featureStatesInitializer();
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsFeatureModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: NgxsFeatureModule }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsFeatureModule }); }
 }
-/** @nocollapse */ NgxsFeatureModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule, deps: [{ token: Store }, { token: InternalStateOperations }, { token: StateFactory }, { token: FEATURE_STATE_TOKEN, optional: true }, { token: LifecycleStateManager }], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ NgxsFeatureModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule });
-/** @nocollapse */ NgxsFeatureModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsFeatureModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsFeatureModule, decorators: [{
             type: NgModule
-        }], ctorParameters: function () { return [{ type: Store }, { type: InternalStateOperations }, { type: StateFactory }, { type: undefined, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [FEATURE_STATE_TOKEN]
-                }] }, { type: LifecycleStateManager }]; } });
+        }], ctorParameters: () => [] });
+
+/**
+ * This function provides the required providers when invoking `NgxsModule.forRoot`
+ * or `provideStore`. It is shared between the NgModule and standalone APIs.
+ */
+function getRootProviders(states, options) {
+    return [
+        StateFactory,
+        PluginManager,
+        ...states,
+        {
+            provide: ROOT_STATE_TOKEN,
+            useValue: states
+        },
+        {
+            provide: APP_BOOTSTRAP_LISTENER,
+            useFactory: () => {
+                const appBootstrappedState = inject(_NgxsAppBootstrappedState);
+                return () => appBootstrappedState.bootstrap();
+            },
+            multi: true
+        },
+        {
+            provide: NGXS_OPTIONS,
+            useValue: options
+        },
+        {
+            provide: CUSTOM_NGXS_EXECUTION_STRATEGY,
+            useValue: options.executionStrategy
+        },
+        {
+            provide: _NGXS_STATE_CONTEXT_FACTORY,
+            useExisting: StateContextFactory
+        },
+        {
+            provide: _NGXS_STATE_FACTORY,
+            useExisting: StateFactory
+        }
+    ];
+}
 
 /**
- * Ngxs Module
+ * This function provides the required providers when calling `NgxsModule.forFeature`
+ * or `provideStates`. It is shared between the NgModule and standalone APIs.
  */
+function getFeatureProviders(states) {
+    return [
+        StateFactory,
+        PluginManager,
+        ...states,
+        {
+            provide: FEATURE_STATE_TOKEN,
+            multi: true,
+            useValue: states
+        }
+    ];
+}
+
 class NgxsModule {
-    /**
-     * Root module factory
-     */
     static forRoot(states = [], options = {}) {
         return {
             ngModule: NgxsRootModule,
-            providers: [
-                StateFactory,
-                PluginManager,
-                ...states,
-                ...NgxsModule.ngxsTokenProviders(states, options)
-            ]
+            providers: getRootProviders(states, options)
         };
     }
-    /**
-     * Feature module factory
-     */
     static forFeature(states = []) {
         return {
             ngModule: NgxsFeatureModule,
-            providers: [
-                // This is required on the feature level, see comments in `state-factory.ts`.
-                StateFactory,
-                PluginManager,
-                ...states,
-                {
-                    provide: FEATURE_STATE_TOKEN,
-                    multi: true,
-                    useValue: states
-                }
-            ]
+            providers: getFeatureProviders(states)
         };
     }
-    static ngxsTokenProviders(states, options) {
-        return [
-            {
-                provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,
-                useValue: options.executionStrategy
-            },
-            {
-                provide: ROOT_STATE_TOKEN,
-                useValue: states
-            },
-            {
-                provide: ROOT_OPTIONS,
-                useValue: options
-            },
-            {
-                provide: APP_BOOTSTRAP_LISTENER,
-                useFactory: NgxsModule.appBootstrapListenerFactory,
-                multi: true,
-                deps: [NgxsBootstrapper]
-            },
-            {
-                provide: ɵNGXS_STATE_CONTEXT_FACTORY,
-                useExisting: StateContextFactory
-            },
-            {
-                provide: ɵNGXS_STATE_FACTORY,
-                useExisting: StateFactory
-            }
-        ];
-    }
-    static appBootstrapListenerFactory(bootstrapper) {
-        return () => bootstrapper.bootstrap();
-    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: NgxsModule }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsModule }); }
 }
-/** @nocollapse */ NgxsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ NgxsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule });
-/** @nocollapse */ NgxsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsModule, decorators: [{
             type: NgModule
         }] });
 
 /**
- * Decorates a method with a action information.
+ * Decorates a method with action information.
  */
 function Action(actions, options) {
-    return (target, name) => {
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    return (target, name, 
+    // This parameter ensures that the decorated method has a call signature that could be passed an instance of the given action(s).
+    _descriptor) => {
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             const isStaticMethod = target.hasOwnProperty('prototype');
             if (isStaticMethod) {
                 throwActionDecoratorError();
             }
         }
-        const meta = ensureStoreMetadata$1(target.constructor);
-        if (!Array.isArray(actions)) {
-            actions = [actions];
-        }
-        for (const action of actions) {
+        const meta = _ensureStoreMetadata(target.constructor);
+        const actionArray = Array.isArray(actions) ? actions : [actions];
+        for (const action of actionArray) {
             const type = action.type;
             if (!meta.actions[type]) {
                 meta.actions[type] = [];
@@ -1987,27 +1952,27 @@ function Action(actions, options) {
 function State(options) {
     return (target) => {
         const stateClass = target;
-        const meta = ensureStoreMetadata$1(stateClass);
+        const meta = _ensureStoreMetadata(stateClass);
         const inheritedStateClass = Object.getPrototypeOf(stateClass);
         const optionsWithInheritance = getStateOptions(inheritedStateClass, options);
         mutateMetaData({ meta, inheritedStateClass, optionsWithInheritance });
-        stateClass[META_OPTIONS_KEY] = optionsWithInheritance;
+        stateClass[_META_OPTIONS_KEY] = optionsWithInheritance;
     };
 }
 function getStateOptions(inheritedStateClass, options) {
-    const inheritanceOptions = inheritedStateClass[META_OPTIONS_KEY] || {};
-    return Object.assign(Object.assign({}, inheritanceOptions), options);
+    const inheritanceOptions = inheritedStateClass[_META_OPTIONS_KEY] || {};
+    return { ...inheritanceOptions, ...options };
 }
 function mutateMetaData(params) {
     const { meta, inheritedStateClass, optionsWithInheritance } = params;
     const { children, defaults, name } = optionsWithInheritance;
     const stateName = typeof name === 'string' ? name : (name && name.getName()) || null;
-    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
         ensureStateNameIsValid(stateName);
     }
-    if (inheritedStateClass.hasOwnProperty(META_KEY)) {
-        const inheritedMeta = inheritedStateClass[META_KEY] || {};
-        meta.actions = Object.assign(Object.assign({}, meta.actions), inheritedMeta.actions);
+    if (inheritedStateClass.hasOwnProperty(_META_KEY)) {
+        const inheritedMeta = inheritedStateClass[_META_KEY] || {};
+        meta.actions = { ...meta.actions, ...inheritedMeta.actions };
     }
     meta.children = children;
     meta.defaults = defaults;
@@ -2042,6 +2007,9 @@ function removeDollarAtTheEnd(name) {
 
 /**
  * Decorator for selecting a slice of state from the store.
+ *
+ * @deprecated
+ * Read the deprecation notice at this link: https://ngxs.io/deprecations/select-decorator-deprecation.
  */
 function Select(rawSelector, ...paths) {
     return function (target, key) {
@@ -2074,10 +2042,10 @@ const selectorOptionsMetaAccessor = {
         if (!target)
             return;
         target[SELECTOR_OPTIONS_META_KEY] = options;
-    },
+    }
 };
 function setupSelectorMetadata(originalFn, creationMetadata) {
-    const selectorMetaData = ensureSelectorMetadata$1(originalFn);
+    const selectorMetaData = _ensureSelectorMetadata(originalFn);
     selectorMetaData.originalFn = originalFn;
     let getExplicitSelectorOptions = () => ({});
     if (creationMetadata) {
@@ -2086,12 +2054,17 @@ function setupSelectorMetadata(originalFn, creationMetadata) {
         getExplicitSelectorOptions =
             creationMetadata.getSelectorOptions || getExplicitSelectorOptions;
     }
-    const selectorMetaDataClone = Object.assign({}, selectorMetaData);
+    const selectorMetaDataClone = { ...selectorMetaData };
     selectorMetaData.getSelectorOptions = () => getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions());
     return selectorMetaData;
 }
 function getLocalSelectorOptions(selectorMetaData, explicitOptions) {
-    return Object.assign(Object.assign(Object.assign(Object.assign({}, (selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {})), (selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {})), (selectorMetaData.getSelectorOptions() || {})), explicitOptions);
+    return {
+        ...(selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {}),
+        ...(selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {}),
+        ...(selectorMetaData.getSelectorOptions() || {}),
+        ...explicitOptions
+    };
 }
 
 /**
@@ -2100,7 +2073,7 @@ function getLocalSelectorOptions(selectorMetaData, explicitOptions) {
 function SelectorOptions(options) {
     return (function decorate(target, methodName, descriptor) {
         if (methodName) {
-            descriptor || (descriptor = Object.getOwnPropertyDescriptor(target, methodName));
+            descriptor ||= Object.getOwnPropertyDescriptor(target, methodName);
             // Method Decorator
             const originalFn = descriptor.value || descriptor.originalFn;
             if (originalFn) {
@@ -2114,19 +2087,6 @@ function SelectorOptions(options) {
     });
 }
 
-function ensureStoreMetadata(target) {
-    return ensureStoreMetadata$1(target);
-}
-function getStoreMetadata(target) {
-    return getStoreMetadata$1(target);
-}
-function ensureSelectorMetadata(target) {
-    return ensureSelectorMetadata$1(target);
-}
-function getSelectorMetadata(target) {
-    return getSelectorMetadata$1(target);
-}
-
 function createSelector(selectors, projector, creationMetadata) {
     const memoizedFn = createMemoizedSelectorFn(projector, creationMetadata);
     const selectorMetaData = setupSelectorMetadata(projector, creationMetadata);
@@ -2136,11 +2096,9 @@ function createSelector(selectors, projector, creationMetadata) {
 
 function Selector(selectors) {
     return (target, key, descriptor) => {
-        descriptor || (descriptor = Object.getOwnPropertyDescriptor(target, key));
-        const originalFn = descriptor === null || descriptor === void 0 ? void 0 : descriptor.value;
-        // Caretaker note: we have still left the `typeof` condition in order to avoid
-        // creating a breaking change for projects that still use the View Engine.
-        if (typeof ngDevMode === 'undefined' || ngDevMode) {
+        descriptor ||= Object.getOwnPropertyDescriptor(target, key);
+        const originalFn = descriptor?.value;
+        if (typeof ngDevMode !== 'undefined' && ngDevMode) {
             if (originalFn && typeof originalFn !== 'function') {
                 throwSelectorDecoratorError();
             }
@@ -2150,36 +2108,19 @@ function Selector(selectors) {
             selectorName: key.toString(),
             getSelectorOptions() {
                 return {};
-            },
+            }
         });
         const newDescriptor = {
             configurable: true,
             get() {
                 return memoizedFn;
             },
+            originalFn
         };
-        // Add hidden property to descriptor
-        newDescriptor['originalFn'] = originalFn;
         return newDescriptor;
     };
 }
 
-class StateToken {
-    constructor(name) {
-        this.name = name;
-        const selectorMetadata = ensureSelectorMetadata$1(this);
-        selectorMetadata.makeRootSelector = (runtimeContext) => {
-            return runtimeContext.getStateGetter(this.name);
-        };
-    }
-    getName() {
-        return this.name;
-    }
-    toString() {
-        return `StateToken[${this.name}]`;
-    }
-}
-
 class NgxsDevelopmentModule {
     static forRoot(options) {
         return {
@@ -2190,19 +2131,25 @@ class NgxsDevelopmentModule {
             ]
         };
     }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsDevelopmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.3", ngImport: i0, type: NgxsDevelopmentModule }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsDevelopmentModule }); }
 }
-/** @nocollapse */ NgxsDevelopmentModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-/** @nocollapse */ NgxsDevelopmentModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule });
-/** @nocollapse */ NgxsDevelopmentModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.3", ngImport: i0, type: NgxsDevelopmentModule, decorators: [{
             type: NgModule
         }] });
+function withNgxsDevelopmentOptions(options) {
+    return makeEnvironmentProviders([
+        NgxsUnhandledActionsLogger,
+        { provide: NGXS_DEVELOPMENT_OPTIONS, useValue: options }
+    ]);
+}
 
 function ensureValidSelector(selector, context = {}) {
     const noun = context.noun || 'selector';
     const prefix = context.prefix ? context.prefix + ': ' : '';
     ensureValueProvided(selector, { noun, prefix: context.prefix });
-    const metadata = getSelectorMetadata$1(selector) || getStoreMetadata$1(selector);
+    const metadata = _getSelectorMetadata(selector) || _getStoreMetadata(selector);
     if (!metadata) {
         throw new Error(`${prefix}The value provided as the ${noun} is not a valid selector.`);
     }
@@ -2218,7 +2165,7 @@ function ensureValueProvided(value, context = {}) {
 function createModelSelector(selectorMap) {
     const selectorKeys = Object.keys(selectorMap);
     const selectors = Object.values(selectorMap);
-    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
         ensureValidSelectorMap({
             prefix: '[createModelSelector]',
             selectorMap,
@@ -2244,7 +2191,7 @@ function ensureValidSelectorMap({ prefix, selectorMap, selectorKeys, selectors }
 }
 
 function createPickSelector(selector, keys) {
-    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
         ensureValidSelector(selector, { prefix: '[createPickSelector]' });
     }
     const validKeys = keys.filter(Boolean);
@@ -2258,7 +2205,7 @@ function createPickSelector(selector, keys) {
 }
 
 function createPropertySelectors(parentSelector) {
-    if (typeof ngDevMode === 'undefined' || ngDevMode) {
+    if (typeof ngDevMode !== 'undefined' && ngDevMode) {
         ensureValidSelector(parentSelector, {
             prefix: '[createPropertySelectors]',
             noun: 'parent selector'
@@ -2268,13 +2215,120 @@ function createPropertySelectors(parentSelector) {
     return new Proxy({}, {
         get(_target, prop) {
             const selector = cache[prop] ||
-                createSelector([parentSelector], (s) => s === null || s === void 0 ? void 0 : s[prop]);
+                createSelector([parentSelector], (s) => s?.[prop]);
             cache[prop] = selector;
             return selector;
         }
     });
 }
 
+function provideStore(states = [], ...optionsAndFeatures) {
+    const features = [];
+    // Options are empty by default (see `forRoot`).
+    let options = {};
+    if (optionsAndFeatures.length > 0) {
+        if (isEnvironmentProvider(optionsAndFeatures[0])) {
+            features.push(...optionsAndFeatures);
+        }
+        else {
+            options = optionsAndFeatures[0];
+            features.push(...optionsAndFeatures.slice(1));
+        }
+    }
+    return makeEnvironmentProviders([
+        ...getRootProviders(states, options),
+        NGXS_ROOT_ENVIRONMENT_INITIALIZER,
+        features
+    ]);
+}
+function isEnvironmentProvider(target) {
+    return !!target.ɵproviders;
+}
+
+/**
+ * This version serves as a standalone alternative to `NgxsModule.forFeature`.
+ * It can be used in a similar manner to register feature states, but at the
+ * `Route` providers level:
+ *
+ * ```ts
+ * const routes: Routes = [
+ *   {
+ *     path: 'products',
+ *     loadComponent: async () => {...},
+ *     providers: [provideStates([ProductsState])]
+ *   }
+ * ];
+ * ```
+ */
+function provideStates(states, ...features) {
+    return makeEnvironmentProviders([
+        ...getFeatureProviders(states),
+        features,
+        NGXS_FEATURE_ENVIRONMENT_INITIALIZER
+    ]);
+}
+
+/**
+ * This function registers a custom global plugin for the state.
+ *
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     provideStore(
+ *       [CountriesState],
+ *       withNgxsPlugin(LogoutPlugin)
+ *     )
+ *   ]
+ * });
+ * ```
+ */
+function withNgxsPlugin(plugin) {
+    return makeEnvironmentProviders([{ provide: NGXS_PLUGINS, useClass: plugin, multi: true }]);
+}
+
+/**
+ * This function serves as a utility and has multiple purposes.
+ * Firstly, it allows you to select properties from the state class
+ * without having to inject the store class and use `this.store.selectSignal`,
+ * resulting in a more concise implementation. Secondly, it can be used with
+ * other solutions such as NgRx signal store with its `signalStoreFeature` or
+ * `withComputed` functionalities.
+ *
+ * Please note that it's named `select` instead of `selectSignal` because
+ * signals are evolving into first-class primitives in Angular, displacing other
+ * primitives such as observables. Observables represent a stream of events,
+ * whereas signals represent a single value changing over time.
+ */
+function select(selector) {
+    return inject(Store).selectSignal(selector);
+}
+
+function dispatch(ActionType) {
+    const store = inject(Store);
+    return (...args) => store.dispatch(new ActionType(...args));
+}
+
+function createSelectMap(selectorMap) {
+    const store = inject(Store);
+    return Object.entries(selectorMap).reduce((accumulator, [key, selector]) => {
+        Object.defineProperty(accumulator, key, {
+            enumerable: true,
+            value: store.selectSignal(selector)
+        });
+        return accumulator;
+    }, {});
+}
+
+function createDispatchMap(actionMap) {
+    return Object.entries(actionMap).reduce((accumulator, [key, ActionType]) => {
+        Object.defineProperty(accumulator, key, {
+            enumerable: true,
+            value: dispatch(ActionType)
+        });
+        return accumulator;
+    }, {});
+}
+
 /**
  * The public api for consumers of @ngxs/store
  */
@@ -2283,5 +2337,5 @@ function createPropertySelectors(parentSelector) {
  * Generated bundle index. Do not edit.
  */
 
-export { Action, Actions, InitState, NGXS_PLUGINS, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createModelSelector, createPickSelector, createPropertySelectors, createSelector, ensureSelectorMetadata, ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata, getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };
-//# sourceMappingURL=ngxs-store.js.map
+export { Action, Actions, NgxsConfig, NgxsDevelopmentModule, NgxsModule, NgxsSimpleChange, NgxsUnhandledActionsLogger, NgxsUnhandledErrorHandler, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, Store, createDispatchMap, createModelSelector, createPickSelector, createPropertySelectors, createSelectMap, createSelector, dispatch, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, provideStates, provideStore, select, withNgxsDevelopmentOptions, withNgxsPlugin, withNgxsPreboot, NgxsFeatureModule as ɵNgxsFeatureModule, NgxsRootModule as ɵNgxsRootModule };
+//# sourceMappingURL=ngxs-store.mjs.map