@ngxs/store 3.7.3 → 3.7.4

package/fesm2015/ngxs-store.js

@@ -1,94 +1,87 @@
-import { NgZone, Injectable, Inject, PLATFORM_ID, InjectionToken, Optional, SkipSelf, ErrorHandler, Injector, isDevMode, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
-import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, isAngularInTestMode, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
+import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, InjectionToken, INJECTOR, ɵglobal, Optional, SkipSelf, ErrorHandler, Injector, ɵivyEnabled, NgModule, APP_BOOTSTRAP_LISTENER } from '@angular/core';
+import { isAngularInTestMode, memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, InitialState, ensureInjectorNotifierIsCaptured, localInject, ensureLocalInjectorCaptured } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
-import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, ReplaySubject } from 'rxjs';
-import { filter, map, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, tap, distinctUntilChanged } from 'rxjs/operators';
+import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from } from 'rxjs';
+import { filter, map, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, tap, publishReplay, refCount, distinctUntilChanged } from 'rxjs/operators';
 
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
-/** @enum {string} */
-const VALIDATION_CODE = {
-    STATE_NAME: 'STATE_NAME',
-    STATE_UNIQUE: 'STATE_UNIQUE',
-    STATE_NAME_PROPERTY: 'STATE_NAME_PROPERTY',
-    STATE_DECORATOR: 'STATE_DECORATOR',
-    INCORRECT_PRODUCTION: 'INCORRECT_PRODUCTION',
-    INCORRECT_DEVELOPMENT: 'INCORRECT_DEVELOPMENT',
-    SELECT_FACTORY_NOT_CONNECTED: 'SELECT_FACTORY_NOT_CONNECTED',
-    ACTION_DECORATOR: 'ACTION_DECORATOR',
-    SELECTOR_DECORATOR: 'SELECTOR_DECORATOR',
-    ZONE_WARNING: 'ZONE_WARNING',
-    PATCHING_ARRAY: 'PATCHING_ARRAY',
-    PATCHING_PRIMITIVE: 'PATCHING_PRIMITIVE',
-    UNDECORATED_STATE_IN_IVY: 'UNDECORATED_STATE_IN_IVY',
-};
-/** @type {?} */
-const CONFIG_MESSAGES = {
-    [VALIDATION_CODE.STATE_NAME]: (/**
-     * @param {?} name
-     * @return {?}
-     */
-    (name) => `${name} is not a valid state name. It needs to be a valid object property name.`),
-    [VALIDATION_CODE.STATE_NAME_PROPERTY]: (/**
-     * @return {?}
-     */
-    () => `States must register a 'name' property`),
-    [VALIDATION_CODE.STATE_UNIQUE]: (/**
-     * @param {?} current
-     * @param {?} newName
-     * @param {?} oldName
-     * @return {?}
-     */
-    (current, newName, oldName) => `State name '${current}' from ${newName} already exists in ${oldName}`),
-    [VALIDATION_CODE.STATE_DECORATOR]: (/**
-     * @return {?}
-     */
-    () => 'States must be decorated with @State() decorator'),
-    [VALIDATION_CODE.INCORRECT_PRODUCTION]: (/**
-     * @return {?}
-     */
-    () => 'Angular is running in production mode but NGXS is still running in the development mode!\n' +
-        'Please set developmentMode to false on the NgxsModule options when in production mode.\n' +
-        'NgxsModule.forRoot(states, { developmentMode: !environment.production })'),
-    [VALIDATION_CODE.INCORRECT_DEVELOPMENT]: (/**
-     * @return {?}
-     */
-    () => 'RECOMMENDATION: Set developmentMode to true on the NgxsModule when Angular is running in development mode.\n' +
-        'NgxsModule.forRoot(states, { developmentMode: !environment.production })'),
-    [VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED]: (/**
-     * @return {?}
-     */
-    () => 'You have forgotten to import the NGXS module!'),
-    [VALIDATION_CODE.ACTION_DECORATOR]: (/**
-     * @return {?}
-     */
-    () => '@Action() decorator cannot be used with static methods'),
-    [VALIDATION_CODE.SELECTOR_DECORATOR]: (/**
-     * @return {?}
-     */
-    () => 'Selectors only work on methods'),
-    [VALIDATION_CODE.ZONE_WARNING]: (/**
-     * @return {?}
-     */
-    () => 'Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
+/**
+ * @param {?} name
+ * @return {?}
+ */
+function throwStateNameError(name) {
+    throw new Error(`${name} is not a valid state name. It needs to be a valid object property name.`);
+}
+/**
+ * @return {?}
+ */
+function throwStateNamePropertyError() {
+    throw new Error(`States must register a 'name' property.`);
+}
+/**
+ * @param {?} current
+ * @param {?} newName
+ * @param {?} oldName
+ * @return {?}
+ */
+function throwStateUniqueError(current, newName, oldName) {
+    throw new Error(`State name '${current}' from ${newName} already exists in ${oldName}.`);
+}
+/**
+ * @param {?} name
+ * @return {?}
+ */
+function throwStateDecoratorError(name) {
+    throw new Error(`States must be decorated with @State() decorator, but "${name}" isn't.`);
+}
+/**
+ * @return {?}
+ */
+function throwActionDecoratorError() {
+    throw new Error('@Action() decorator cannot be used with static methods.');
+}
+/**
+ * @return {?}
+ */
+function throwSelectorDecoratorError() {
+    throw new Error('Selectors only work on methods.');
+}
+/**
+ * @return {?}
+ */
+function getZoneWarningMessage() {
+    return ('Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
         'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
-        'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })'),
-    [VALIDATION_CODE.PATCHING_ARRAY]: (/**
-     * @return {?}
-     */
-    () => 'Patching arrays is not supported.'),
-    [VALIDATION_CODE.PATCHING_PRIMITIVE]: (/**
-     * @return {?}
-     */
-    () => 'Patching primitives is not supported.'),
-    [VALIDATION_CODE.UNDECORATED_STATE_IN_IVY]: (/**
-     * @param {?} name
-     * @return {?}
-     */
-    (name) => `'${name}' class should be decorated with @Injectable() right after the @State() decorator`)
-};
+        'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })');
+}
+/**
+ * @param {?} name
+ * @return {?}
+ */
+function getUndecoratedStateInIvyWarningMessage(name) {
+    return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;
+}
+/**
+ * @return {?}
+ */
+function throwSelectFactoryNotConnectedError() {
+    throw new Error('You have forgotten to import the NGXS module!');
+}
+/**
+ * @return {?}
+ */
+function throwPatchingArrayError() {
+    throw new Error('Patching arrays is not supported.');
+}
+/**
+ * @return {?}
+ */
+function throwPatchingPrimitiveError() {
+    throw new Error('Patching primitives is not supported.');
+}
 
 /**
  * @fileoverview added by tsickle
@@ -102,7 +95,11 @@ class DispatchOutsideZoneNgxsExecutionStrategy {
     constructor(_ngZone, _platformId) {
         this._ngZone = _ngZone;
         this._platformId = _platformId;
-        this.verifyZoneIsNotNooped(this._ngZone);
+        // 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) {
+            verifyZoneIsNotNooped(_ngZone);
+        }
     }
     /**
      * @template T
@@ -147,29 +144,16 @@ class DispatchOutsideZoneNgxsExecutionStrategy {
         }
         return func();
     }
-    /**
-     * @private
-     * @param {?} ngZone
-     * @return {?}
-     */
-    verifyZoneIsNotNooped(ngZone) {
-        // `NoopNgZone` is not exposed publicly as it doesn't expect
-        // to be used outside of the core Angular code, thus we just have
-        // to check if the zone doesn't extend or instanceof `NgZone`
-        if (ngZone instanceof NgZone) {
-            return;
-        }
-        console.warn(CONFIG_MESSAGES[VALIDATION_CODE.ZONE_WARNING]());
-    }
 }
 DispatchOutsideZoneNgxsExecutionStrategy.decorators = [
-    { type: Injectable }
+    { type: Injectable, args: [{ providedIn: 'root' },] }
 ];
 /** @nocollapse */
 DispatchOutsideZoneNgxsExecutionStrategy.ctorParameters = () => [
     { type: NgZone },
     { type: String, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
 ];
+/** @nocollapse */ DispatchOutsideZoneNgxsExecutionStrategy.ngInjectableDef = defineInjectable({ factory: function DispatchOutsideZoneNgxsExecutionStrategy_Factory() { return new DispatchOutsideZoneNgxsExecutionStrategy(inject(NgZone), inject(PLATFORM_ID)); }, token: DispatchOutsideZoneNgxsExecutionStrategy, providedIn: "root" });
 if (false) {
     /**
      * @type {?}
@@ -181,6 +165,21 @@ if (false) {
      * @private
      */
     DispatchOutsideZoneNgxsExecutionStrategy.prototype._platformId;
+}
+// Caretaker note: this should exist as a separate function and not a class method,
+// since class methods are not tree-shakable.
+/**
+ * @param {?} ngZone
+ * @return {?}
+ */
+function verifyZoneIsNotNooped(ngZone) {
+    // `NoopNgZone` is not exposed publicly as it doesn't expect
+    // to be used outside of the core Angular code, thus we just have
+    // to check if the zone doesn't extend or instanceof `NgZone`.
+    if (ngZone instanceof NgZone) {
+        return;
+    }
+    console.warn(getZoneWarningMessage());
 }
 
 /**
@@ -194,10 +193,6 @@ const FEATURE_STATE_TOKEN = new InjectionToken('FEATURE_STATE_TOKEN');
 /** @type {?} */
 const NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');
 /** @type {?} */
-const NG_TEST_MODE = new InjectionToken('NG_TEST_MODE');
-/** @type {?} */
-const NG_DEV_MODE = new InjectionToken('NG_DEV_MODE');
-/** @type {?} */
 const META_KEY = 'NGXS_META';
 /** @type {?} */
 const META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
@@ -239,6 +234,9 @@ if (false) {
      * Run in development mode. This will add additional debugging features:
      * - Object.freeze on the state and actions to guarantee immutability
      * (default: false)
+     *
+     * @deprecated This property is no longer necessary when the Ivy compiler is used.
+     * We'll determine the development mode through the `ngDevMode`. It's still essential with View Engine.
      * @type {?}
      */
     NgxsConfig.prototype.developmentMode;
@@ -406,11 +404,59 @@ if (false) {
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+class NoopNgxsExecutionStrategy {
+    /**
+     * @template T
+     * @param {?} func
+     * @return {?}
+     */
+    enter(func) {
+        return func();
+    }
+    /**
+     * @template T
+     * @param {?} func
+     * @return {?}
+     */
+    leave(func) {
+        return func();
+    }
+}
+NoopNgxsExecutionStrategy.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */ NoopNgxsExecutionStrategy.ngInjectableDef = defineInjectable({ factory: function NoopNgxsExecutionStrategy_Factory() { return new NoopNgxsExecutionStrategy(); }, token: NoopNgxsExecutionStrategy, providedIn: "root" });
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * The strategy that might be provided by users through `options.executionStrategy`.
+ * @type {?}
+ */
+const USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');
 /*
  * Internal execution strategy injection token
  */
 /** @type {?} */
-const NGXS_EXECUTION_STRATEGY = new InjectionToken('NGXS_EXECUTION_STRATEGY');
+const NGXS_EXECUTION_STRATEGY = new InjectionToken('NGXS_EXECUTION_STRATEGY', {
+    providedIn: 'root',
+    factory: (/**
+     * @return {?}
+     */
+    () => {
+        /** @type {?} */
+        const injector = inject(INJECTOR);
+        /** @type {?} */
+        const executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);
+        return executionStrategy
+            ? injector.get(executionStrategy)
+            : injector.get(typeof ɵglobal.Zone !== 'undefined'
+                ? DispatchOutsideZoneNgxsExecutionStrategy
+                : NoopNgxsExecutionStrategy);
+    })
+});
 /**
  * @record
  */
@@ -884,10 +930,12 @@ function buildGraph(stateClasses) {
          * @return {?}
          */
         g => g === stateClass));
-        if (!meta) {
+        // 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 (/** @type {?} */ ((/** @type {?} */ (meta[META_KEY])).name));
+        return (/** @type {?} */ ((/** @type {?} */ ((/** @type {?} */ (meta))[META_KEY])).name));
     });
     return stateClasses.reduce((/**
      * @param {?} result
@@ -1017,7 +1065,9 @@ function topologicalSort(graph) {
          * @return {?}
          */
         (dep) => {
-            if (ancestors.indexOf(dep) >= 0) {
+            // 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]) {
@@ -1540,6 +1590,15 @@ class StateStream extends BehaviorSubject {
     constructor() {
         super({});
     }
+    /**
+     * @return {?}
+     */
+    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();
+    }
 }
 StateStream.decorators = [
     { type: Injectable }
@@ -1857,98 +1916,6 @@ const deepFreeze = (/**
     return o;
 });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class HostEnvironment {
-    /**
-     * @param {?} isDevMode
-     * @param {?} isTestMode
-     */
-    constructor(isDevMode, isTestMode) {
-        this.isDevMode = isDevMode;
-        this.isTestMode = isTestMode;
-    }
-}
-HostEnvironment.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-HostEnvironment.ctorParameters = () => [
-    { type: undefined, decorators: [{ type: Inject, args: [NG_DEV_MODE,] }] },
-    { type: undefined, decorators: [{ type: Inject, args: [NG_TEST_MODE,] }] }
-];
-if (false) {
-    /** @type {?} */
-    HostEnvironment.prototype.isDevMode;
-    /** @type {?} */
-    HostEnvironment.prototype.isTestMode;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class ConfigValidator {
-    /**
-     * @param {?} _host
-     * @param {?} _config
-     */
-    constructor(_host, _config) {
-        this._host = _host;
-        this._config = _config;
-    }
-    /**
-     * @private
-     * @return {?}
-     */
-    get isIncorrectProduction() {
-        return !this._host.isDevMode() && this._config.developmentMode;
-    }
-    /**
-     * @private
-     * @return {?}
-     */
-    get isIncorrectDevelopment() {
-        return this._host.isDevMode() && !this._config.developmentMode;
-    }
-    /**
-     * @return {?}
-     */
-    verifyDevMode() {
-        if (this._host.isTestMode()) {
-            return;
-        }
-        if (this.isIncorrectProduction) {
-            console.warn(CONFIG_MESSAGES[VALIDATION_CODE.INCORRECT_PRODUCTION]());
-        }
-        else if (this.isIncorrectDevelopment) {
-            console.warn(CONFIG_MESSAGES[VALIDATION_CODE.INCORRECT_DEVELOPMENT]());
-        }
-    }
-}
-ConfigValidator.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-ConfigValidator.ctorParameters = () => [
-    { type: HostEnvironment },
-    { type: NgxsConfig }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    ConfigValidator.prototype._host;
-    /**
-     * @type {?}
-     * @private
-     */
-    ConfigValidator.prototype._config;
-}
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -1962,13 +1929,11 @@ class InternalStateOperations {
      * @param {?} _stateStream
      * @param {?} _dispatcher
      * @param {?} _config
-     * @param {?} configValidator
      */
-    constructor(_stateStream, _dispatcher, _config, configValidator) {
+    constructor(_stateStream, _dispatcher, _config) {
         this._stateStream = _stateStream;
         this._dispatcher = _dispatcher;
         this._config = _config;
-        configValidator.verifyDevMode();
     }
     /**
      * Returns the root state operators.
@@ -1992,39 +1957,22 @@ class InternalStateOperations {
              */
             (actionOrActions) => this._dispatcher.dispatch(actionOrActions))
         };
-        if (this._config.developmentMode) {
-            return this.ensureStateAndActionsAreImmutable(rootStateOperations);
+        // We have to have that duplication since this will allow us to tree-shake `ensureStateAndActionsAreImmutable`
+        // and `deepFreeze` in Ivy production build.
+        // The below `if` condition checks 2 things:
+        // 1) if we're in View Engine (`ngDevMode` is `undefined`)
+        // 2) if we're running tests, we should fallback to `config.developmentMode` to be backwards-compatible
+        if (typeof ngDevMode === 'undefined' || (ngDevMode && isAngularInTestMode())) {
+            return this._config.developmentMode
+                ? ensureStateAndActionsAreImmutable(rootStateOperations)
+                : rootStateOperations;
+        }
+        else {
+            // If we're in Ivy and not running tests, then tree-shake `ensureStateAndActionsAreImmutable` and `deepFreeze`.
+            return ngDevMode
+                ? ensureStateAndActionsAreImmutable(rootStateOperations)
+                : rootStateOperations;
         }
-        return rootStateOperations;
-    }
-    /**
-     * @private
-     * @param {?} root
-     * @return {?}
-     */
-    ensureStateAndActionsAreImmutable(root) {
-        return {
-            getState: (/**
-             * @return {?}
-             */
-            () => root.getState()),
-            setState: (/**
-             * @param {?} value
-             * @return {?}
-             */
-            value => {
-                /** @type {?} */
-                const frozenValue = deepFreeze(value);
-                return root.setState(frozenValue);
-            }),
-            dispatch: (/**
-             * @param {?} actions
-             * @return {?}
-             */
-            actions => {
-                return root.dispatch(actions);
-            })
-        };
     }
     /**
      * @param {?} results
@@ -2047,8 +1995,7 @@ InternalStateOperations.decorators = [
 InternalStateOperations.ctorParameters = () => [
     { type: StateStream },
     { type: InternalDispatcher },
-    { type: NgxsConfig },
-    { type: ConfigValidator }
+    { type: NgxsConfig }
 ];
 if (false) {
     /**
@@ -2066,6 +2013,34 @@ if (false) {
      * @private
      */
     InternalStateOperations.prototype._config;
+}
+/**
+ * @param {?} root
+ * @return {?}
+ */
+function ensureStateAndActionsAreImmutable(root) {
+    return {
+        getState: (/**
+         * @return {?}
+         */
+        () => root.getState()),
+        setState: (/**
+         * @param {?} value
+         * @return {?}
+         */
+        value => {
+            /** @type {?} */
+            const frozenValue = deepFreeze(value);
+            return root.setState(frozenValue);
+        }),
+        dispatch: (/**
+         * @param {?} actions
+         * @return {?}
+         */
+        actions => {
+            return root.dispatch(actions);
+        })
+    };
 }
 
 /**
@@ -2084,10 +2059,10 @@ function simplePatch(val) {
      */
     (existingState) => {
         if (Array.isArray(val)) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.PATCHING_ARRAY]());
+            throwPatchingArrayError();
         }
         else if (typeof val !== 'object') {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.PATCHING_PRIMITIVE]());
+            throwPatchingPrimitiveError();
         }
         /** @type {?} */
         const newState = Object.assign({}, ((/** @type {?} */ (existingState))));
@@ -2245,54 +2220,49 @@ class StoreValidators {
      * @param {?} name
      * @return {?}
      */
-    static stateNameErrorMessage(name) {
-        return CONFIG_MESSAGES[VALIDATION_CODE.STATE_NAME](name);
-    }
-    /**
-     * @param {?} name
-     * @return {?}
-     */
-    static checkCorrectStateName(name) {
+    static checkThatStateIsNamedCorrectly(name) {
         if (!name) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.STATE_NAME_PROPERTY]());
+            throwStateNamePropertyError();
         }
-        if (!this.stateNameRegex.test(name)) {
-            throw new Error(this.stateNameErrorMessage(name));
+        else if (!this.stateNameRegex.test(name)) {
+            throwStateNameError(name);
         }
     }
     /**
+     * @param {?} stateName
      * @param {?} state
      * @param {?} statesByName
      * @return {?}
      */
-    static checkStateNameIsUnique(state, statesByName) {
-        /** @type {?} */
-        const meta = this.getValidStateMeta(state);
-        /** @type {?} */
-        const stateName = (/** @type {?} */ ((/** @type {?} */ (meta)).name));
+    static checkThatStateNameIsUnique(stateName, state, statesByName) {
         /** @type {?} */
         const existingState = statesByName[stateName];
         if (existingState && existingState !== state) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.STATE_UNIQUE](stateName, state.name, existingState.name));
+            throwStateUniqueError(stateName, state.name, existingState.name);
         }
-        return stateName;
     }
     /**
-     * @param {?} state
+     * @param {?} stateClasses
      * @return {?}
      */
-    static getValidStateMeta(state) {
-        /** @type {?} */
-        const meta = getStoreMetadata(state);
-        if (!meta) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.STATE_DECORATOR]());
-        }
-        return meta;
+    static checkThatStateClassesHaveBeenDecorated(stateClasses) {
+        stateClasses.forEach((/**
+         * @param {?} stateClass
+         * @return {?}
+         */
+        (stateClass) => {
+            if (!getStoreMetadata(stateClass)) {
+                throwStateDecoratorError(stateClass.name);
+            }
+        }));
     }
 }
 StoreValidators.stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');
 if (false) {
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     StoreValidators.stateNameRegex;
 }
 
@@ -2421,14 +2391,6 @@ class StateFactory {
         }
         return value;
     }
-    /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    static checkStatesAreValid(stateClasses) {
-        stateClasses.forEach(StoreValidators.getValidStateMeta);
-    }
     /**
      * @return {?}
      */
@@ -2445,7 +2407,11 @@ class StateFactory {
      * @return {?}
      */
     add(stateClasses) {
-        StateFactory.checkStatesAreValid(stateClasses);
+        // 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) {
+            StoreValidators.checkThatStateClassesHaveBeenDecorated(stateClasses);
+        }
         const { newStates } = this.addToStatesMap(stateClasses);
         if (!newStates.length)
             return [];
@@ -2512,23 +2478,30 @@ class StateFactory {
     connectActionHandlers() {
         if (this._actionsSubscription !== null)
             return;
+        /** @type {?} */
+        const dispatched$ = new Subject();
         this._actionsSubscription = this._actions
             .pipe(filter((/**
          * @param {?} ctx
          * @return {?}
          */
         (ctx) => ctx.status === "DISPATCHED" /* Dispatched */)), mergeMap((/**
-         * @param {?} __0
-         * @return {?}
-         */
-        ({ action }) => this.invokeActions(this._actions, (/** @type {?} */ (action))).pipe(map((/**
-         * @return {?}
-         */
-        () => (/** @type {?} */ ({ action, status: "SUCCESSFUL" /* Successful */ })))), defaultIfEmpty((/** @type {?} */ ({ action, status: "CANCELED" /* Canceled */ }))), catchError((/**
-         * @param {?} error
+         * @param {?} ctx
          * @return {?}
          */
-        error => of((/** @type {?} */ ({ action, status: "ERRORED" /* Errored */, error })))))))))
+        ctx => {
+            dispatched$.next(ctx);
+            /** @type {?} */
+            const action = ctx.action;
+            return this.invokeActions(dispatched$, (/** @type {?} */ (action))).pipe(map((/**
+             * @return {?}
+             */
+            () => (/** @type {?} */ ({ action, status: "SUCCESSFUL" /* Successful */ })))), defaultIfEmpty((/** @type {?} */ ({ action, status: "CANCELED" /* Canceled */ }))), catchError((/**
+             * @param {?} error
+             * @return {?}
+             */
+            error => of((/** @type {?} */ ({ action, status: "ERRORED" /* Errored */, error }))))));
+        })))
             .subscribe((/**
          * @param {?} ctx
          * @return {?}
@@ -2537,11 +2510,11 @@ class StateFactory {
     }
     /**
      * Invoke actions on the states.
-     * @param {?} actions$
+     * @param {?} dispatched$
      * @param {?} action
      * @return {?}
      */
-    invokeActions(actions$, action) {
+    invokeActions(dispatched$, action) {
         /** @type {?} */
         const type = (/** @type {?} */ (getActionTypeFromInstance(action)));
         /** @type {?} */
@@ -2568,10 +2541,22 @@ class StateFactory {
                             // `handler(ctx) { return EMPTY; }`
                             // then the action will be canceled.
                             // See https://github.com/ngxs/store/issues/1568
-                            result = result.pipe(defaultIfEmpty({}));
+                            result = result.pipe(mergeMap((/**
+                             * @param {?} value
+                             * @return {?}
+                             */
+                            (value) => {
+                                if (value instanceof Promise) {
+                                    return from(value);
+                                }
+                                if (value instanceof Observable) {
+                                    return value;
+                                }
+                                return of(value);
+                            })), defaultIfEmpty({}));
                             if (actionMeta.options.cancelUncompleted) {
                                 // todo: ofActionDispatched should be used with action class
-                                result = result.pipe(takeUntil(actions$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
+                                result = result.pipe(takeUntil(dispatched$.pipe(ofActionDispatched((/** @type {?} */ (action))))));
                             }
                         }
                         else {
@@ -2602,7 +2587,12 @@ class StateFactory {
         const statesMap = this.statesByName;
         for (const stateClass of stateClasses) {
             /** @type {?} */
-            const stateName = StoreValidators.checkStateNameIsUnique(stateClass, statesMap);
+            const stateName = (/** @type {?} */ (getStoreMetadata(stateClass).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) {
+                StoreValidators.checkThatStateNameIsUnique(stateName, stateClass, statesMap);
+            }
             /** @type {?} */
             const unmountedState = !statesMap[stateName];
             if (unmountedState) {
@@ -3074,6 +3064,12 @@ class Store {
         this._config = _config;
         this._internalExecutionStrategy = _internalExecutionStrategy;
         this._stateFactory = _stateFactory;
+        /**
+         * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+         * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+         * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+         */
+        this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), publishReplay(1), refCount());
         this.initStateStream(initialStateValue);
     }
     /**
@@ -3091,7 +3087,7 @@ class Store {
     select(selector) {
         /** @type {?} */
         const selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._stateStream.pipe(map(selectorFn), catchError((/**
+        return this._selectableStateStream.pipe(map(selectorFn), catchError((/**
          * @param {?} err
          * @return {?}
          */
@@ -3127,7 +3123,9 @@ class Store {
      * @return {?}
      */
     subscribe(fn) {
-        return this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy)).subscribe(fn);
+        return this._selectableStateStream
+            .pipe(leaveNgxs(this._internalExecutionStrategy))
+            .subscribe(fn);
     }
     /**
      * Return the raw value of the state.
@@ -3190,6 +3188,14 @@ Store.ctorParameters = () => [
     { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
 ];
 if (false) {
+    /**
+     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+     * @type {?}
+     * @private
+     */
+    Store.prototype._selectableStateStream;
     /**
      * @type {?}
      * @private
@@ -3222,9 +3228,8 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 /**
- * Allows the select decorator to get access to the DI store.
- * \@internal only use in \@Select decorator
- * @ignore
+ * Allows the select decorator to get access to the DI store, this is used internally
+ * in `\@Select` decorator.
  */
 class SelectFactory {
     /**
@@ -3246,13 +3251,14 @@ class SelectFactory {
 SelectFactory.store = null;
 SelectFactory.config = null;
 SelectFactory.decorators = [
-    { type: Injectable }
+    { type: Injectable, args: [{ providedIn: 'root' },] }
 ];
 /** @nocollapse */
 SelectFactory.ctorParameters = () => [
     { type: Store },
     { type: NgxsConfig }
 ];
+/** @nocollapse */ SelectFactory.ngInjectableDef = defineInjectable({ factory: function SelectFactory_Factory() { return new SelectFactory(inject(Store), inject(NgxsConfig)); }, token: SelectFactory, providedIn: "root" });
 if (false) {
     /** @type {?} */
     SelectFactory.store;
@@ -3299,44 +3305,6 @@ if (false) {
     UpdateState.prototype.addedStates;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-const ivyEnabledInDevMode$ = new ReplaySubject(1);
-/**
- * Ivy exposes helper functions to the global `window.ng` object.
- * Those functions are `getComponent, getContext,
- * getListeners, getViewComponent, getHostElement, getInjector,
- * getRootComponents, getDirectives, getDebugNode`
- * Previously, old view engine exposed `window.ng.coreTokens` and
- * `window.ng.probe` if an application was in development/production.
- * Ivy doesn't expose these functions in production. Developers will be able
- * to see warnings in both JIT/AOT modes, but only if an application
- * is in development.
- * @return {?}
- */
-function setIvyEnabledInDevMode() {
-    try {
-        // `try-catch` will also handle server-side rendering, as
-        // `window is not defined` will not be thrown.
-        /** @type {?} */
-        const ng = ((/** @type {?} */ (window))).ng;
-        /** @type {?} */
-        const _viewEngineEnabled = !!ng.probe && !!ng.coreTokens;
-        /** @type {?} */
-        const _ivyEnabledInDevMode = !_viewEngineEnabled && isDevMode();
-        ivyEnabledInDevMode$.next(_ivyEnabledInDevMode);
-    }
-    catch (_a) {
-        ivyEnabledInDevMode$.next(false);
-    }
-    finally {
-        ivyEnabledInDevMode$.complete();
-    }
-}
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -3350,13 +3318,14 @@ class NgxsRootModule {
      * @param {?} factory
      * @param {?} internalStateOperations
      * @param {?} _store
-     * @param {?} _select
+     * @param {?} injector
      * @param {?=} states
      * @param {?=} lifecycleStateManager
      */
-    constructor(factory, internalStateOperations, _store, _select, states = [], lifecycleStateManager) {
-        // Validate states on having the `@Injectable()` decorator in Ivy
-        setIvyEnabledInDevMode();
+    constructor(factory, internalStateOperations, _store, injector, states = [], lifecycleStateManager) {
+        // If the user is running View Engine then we create the `SelectFactory` instance,
+        // otherwise it'll be tree-shaken away in Ivy.
+        !ɵivyEnabled && injector.get(SelectFactory);
         // Add stores to the state graph and return their defaults
         /** @type {?} */
         const results = factory.addAndReturnDefaults(states);
@@ -3375,7 +3344,7 @@ NgxsRootModule.ctorParameters = () => [
     { type: StateFactory },
     { type: InternalStateOperations },
     { type: Store },
-    { type: SelectFactory },
+    { type: Injector },
     { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [ROOT_STATE_TOKEN,] }] },
     { type: LifecycleStateManager }
 ];
@@ -3459,8 +3428,6 @@ class NgxsModule {
                 Actions,
                 InternalActions,
                 NgxsBootstrapper,
-                ConfigValidator,
-                HostEnvironment,
                 LifecycleStateManager,
                 InternalDispatcher,
                 InternalDispatchedActionResults,
@@ -3468,7 +3435,6 @@ class NgxsModule {
                 InternalNgxsExecutionStrategy,
                 Store,
                 StateStream,
-                SelectFactory,
                 PluginManager,
                 ...states,
                 ...NgxsModule.ngxsTokenProviders(states, options)
@@ -3504,16 +3470,8 @@ class NgxsModule {
     static ngxsTokenProviders(states, options) {
         return [
             {
-                provide: NG_TEST_MODE,
-                useValue: isAngularInTestMode
-            },
-            {
-                provide: NG_DEV_MODE,
-                useValue: isDevMode
-            },
-            {
-                provide: NGXS_EXECUTION_STRATEGY,
-                useClass: options.executionStrategy || DispatchOutsideZoneNgxsExecutionStrategy
+                provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,
+                useValue: options.executionStrategy
             },
             {
                 provide: ROOT_STATE_TOKEN,
@@ -3604,10 +3562,14 @@ function Action(actions, options) {
      * @return {?}
      */
     (target, name) => {
-        /** @type {?} */
-        const isStaticMethod = target.hasOwnProperty('prototype');
-        if (isStaticMethod) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.ACTION_DECORATOR]());
+        // 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) {
+            /** @type {?} */
+            const isStaticMethod = target.hasOwnProperty('prototype');
+            if (isStaticMethod) {
+                throwActionDecoratorError();
+            }
         }
         /** @type {?} */
         const meta = ensureStoreMetadata(target.constructor);
@@ -3645,20 +3607,14 @@ function ensureStateClassIsInjectable(target) {
     // AOT mode because this property is added before runtime. If an application is running in
     // JIT mode then this property can be added by the `@Injectable()` decorator. The `@Injectable()`
     // decorator has to go after the `@State()` decorator, thus we prevent users from unwanted DI errors.
-    ivyEnabledInDevMode$.subscribe((/**
-     * @param {?} _ivyEnabledInDevMode
-     * @return {?}
-     */
-    _ivyEnabledInDevMode => {
-        if (_ivyEnabledInDevMode) {
-            /** @type {?} */
-            /** @nocollapse */ const ngInjectableDef = target.ɵprov;
-            if (!ngInjectableDef) {
-                // Don't warn if Ivy is disabled or `ɵprov` exists on the class
-                console.warn(CONFIG_MESSAGES[VALIDATION_CODE.UNDECORATED_STATE_IN_IVY](target.name));
-            }
+    if (ɵivyEnabled) {
+        /** @type {?} */
+        /** @nocollapse */ const ngInjectableDef = target.ɵprov;
+        if (!ngInjectableDef) {
+            // Don't warn if Ivy is disabled or `ɵprov` exists on the class
+            console.warn(getUndecoratedStateInIvyWarningMessage(target.name));
         }
-    }));
+    }
 }
 
 /**
@@ -3703,7 +3659,11 @@ function State(options) {
         const { children, defaults, name } = optionsWithInheritance;
         /** @type {?} */
         const stateName = typeof name === 'string' ? name : (name && name.getName()) || null;
-        StoreValidators.checkCorrectStateName(stateName);
+        // 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) {
+            StoreValidators.checkThatStateIsNamedCorrectly(stateName);
+        }
         if (inheritedStateClass.hasOwnProperty(META_KEY)) {
             /** @type {?} */
             const inheritedMeta = inheritedStateClass[META_KEY] || {};
@@ -3718,7 +3678,11 @@ function State(options) {
      * @return {?}
      */
     (target) => {
-        ensureStateClassIsInjectable(target);
+        // 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) {
+            ensureStateClassIsInjectable(target);
+        }
         /** @type {?} */
         const stateClass = target;
         /** @type {?} */
@@ -3741,30 +3705,37 @@ const DOLLAR_CHAR_CODE = 36;
 /**
  * @template T
  * @param {?} selector
+ * @param {?} store
  * @return {?}
  */
-function createSelectObservable(selector) {
-    if (!SelectFactory.store) {
-        throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED]());
-    }
-    return SelectFactory.store.select(selector);
+function createSelectObservable(selector, store) {
+    // We're doing this stuff to tree-shake the `SelectFactory` when the user
+    // is running Ivy since NGXS will select the state from the provided `store` argument.
+    return ɵivyEnabled
+        ? createSelectObservableIvy(selector, store)
+        : createSelectObservableViewEngine(selector);
 }
 /**
+ * @param {?} config
  * @param {?} name
  * @param {?=} rawSelector
  * @param {?=} paths
  * @return {?}
  */
-function createSelectorFn(name, rawSelector, paths = []) {
-    rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;
-    if (typeof rawSelector === 'string') {
+function createSelectorFn(config, name, rawSelector, paths = []) {
+    rawSelector = rawSelector || removeDollarAtTheEnd(name);
+    if (typeof rawSelector !== 'string') {
+        return rawSelector;
+    }
+    else {
         /** @type {?} */
         const propsArray = paths.length
             ? [rawSelector, ...paths]
             : rawSelector.split('.');
-        return propGetter(propsArray, (/** @type {?} */ (SelectFactory.config)));
+        return ɵivyEnabled
+            ? createSelectorFnIvy(propsArray, config)
+            : createSelectorFnViewEngine(propsArray);
     }
-    return rawSelector;
 }
 /**
  * \@example If `foo$` => make it just `foo`
@@ -3777,6 +3748,42 @@ function removeDollarAtTheEnd(name) {
     /** @type {?} */
     const dollarAtTheEnd = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;
     return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;
+}
+/**
+ * @template T
+ * @param {?} selector
+ * @param {?} store
+ * @return {?}
+ */
+function createSelectObservableIvy(selector, store) {
+    return ngDevMode && !store ? throwSelectFactoryNotConnectedError() : (/** @type {?} */ (store)).select(selector);
+}
+/**
+ * @template T
+ * @param {?} selector
+ * @return {?}
+ */
+function createSelectObservableViewEngine(selector) {
+    return SelectFactory.store
+        ? SelectFactory.store.select(selector)
+        : throwSelectFactoryNotConnectedError();
+}
+/**
+ * @param {?} propsArray
+ * @param {?} config
+ * @return {?}
+ */
+function createSelectorFnIvy(propsArray, config) {
+    return ngDevMode && !config
+        ? throwSelectFactoryNotConnectedError()
+        : propGetter(propsArray, (/** @type {?} */ (config)));
+}
+/**
+ * @param {?} propsArray
+ * @return {?}
+ */
+function createSelectorFnViewEngine(propsArray) {
+    return propGetter(propsArray, (/** @type {?} */ (SelectFactory.config)));
 }
 
 /**
@@ -3802,7 +3809,12 @@ function Select(rawSelector, ...paths) {
         /** @type {?} */
         const selectorId = `__${name}__selector`;
         /** @type {?} */
-        const selector = createSelectorFn(name, rawSelector, paths);
+        let selector = null;
+        /** @type {?} */
+        let injectorNotifier$ = null;
+        if (ɵivyEnabled) {
+            injectorNotifier$ = ensureInjectorNotifierIsCaptured(target);
+        }
         Object.defineProperties(target, {
             [selectorId]: {
                 writable: true,
@@ -3816,10 +3828,36 @@ function Select(rawSelector, ...paths) {
                  * @return {?}
                  */
                 get() {
-                    return this[selectorId] || (this[selectorId] = createSelectObservable(selector));
+                    if (this[selectorId]) {
+                        return this[selectorId];
+                    }
+                    // The `localInject` will be tree-shaken away in apps that
+                    // still use the View Engine.
+                    if (ɵivyEnabled) {
+                        this[selectorId] = (/** @type {?} */ (injectorNotifier$)).pipe(mergeMap((/**
+                         * @return {?}
+                         */
+                        () => {
+                            /** @type {?} */
+                            const store = localInject(this, Store);
+                            /** @type {?} */
+                            const config = localInject(this, NgxsConfig);
+                            selector = selector || createSelectorFn(config, name, rawSelector, paths);
+                            return createSelectObservable(selector, store);
+                        })));
+                    }
+                    else {
+                        selector = selector || createSelectorFn(null, name, rawSelector, paths);
+                        this[selectorId] = createSelectObservable(selector, null);
+                    }
+                    return this[selectorId];
                 }
             }
         });
+        // Keep this `if` guard here so the below stuff will be tree-shaken away in apps that still use the View Engine.
+        if (ɵivyEnabled) {
+            ensureLocalInjectorCaptured(target);
+        }
     });
 }
 
@@ -3938,10 +3976,14 @@ function Selector(selectors) {
      * @return {?}
      */
     (target, key, descriptor) => {
-        /** @type {?} */
-        const isNotMethod = !(descriptor && descriptor.value !== null);
-        if (isNotMethod) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.SELECTOR_DECORATOR]());
+        // 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) {
+            /** @type {?} */
+            const isNotMethod = !(descriptor && descriptor.value !== null);
+            if (isNotMethod) {
+                throwSelectorDecoratorError();
+            }
         }
         /** @type {?} */
         const originalFn = descriptor.value;
@@ -3972,32 +4014,6 @@ function Selector(selectors) {
     });
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-class NoopNgxsExecutionStrategy {
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    enter(func) {
-        return func();
-    }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    leave(func) {
-        return func();
-    }
-}
-NoopNgxsExecutionStrategy.decorators = [
-    { type: Injectable }
-];
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4062,5 +4078,5 @@ if (false) {
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { Action, Actions, InitState, NGXS_PLUGINS, NgxsModule, NgxsSimpleChange, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, SelectFactory as ɵba, LifecycleStateManager as ɵbb, NgxsFeatureModule as ɵbc, DispatchOutsideZoneNgxsExecutionStrategy as ɵbd, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, NG_TEST_MODE as ɵe, NG_DEV_MODE as ɵf, SELECTOR_META_KEY as ɵg, NgxsConfig as ɵh, mergeDeep as ɵi, NGXS_EXECUTION_STRATEGY as ɵj, NgxsRootModule as ɵk, StateFactory as ɵl, InternalDispatchedActionResults as ɵm, InternalDispatcher as ɵn, StateContextFactory as ɵo, InternalStateOperations as ɵp, PluginManager as ɵq, InternalNgxsExecutionStrategy as ɵr, ConfigValidator as ɵs, HostEnvironment as ɵt, ensureStoreMetadata as ɵw, getStoreMetadata as ɵx, ensureSelectorMetadata as ɵy, getSelectorMetadata as ɵz };
+export { Action, Actions, InitState, NGXS_PLUGINS, NgxsModule, NgxsSimpleChange, NoopNgxsExecutionStrategy, Select, Selector, SelectorOptions, State, StateStream, StateToken, Store, UpdateState, actionMatcher, createSelector, ensureSelectorMetadata$1 as ensureSelectorMetadata, ensureStoreMetadata$1 as ensureStoreMetadata, getActionTypeFromInstance, getSelectorMetadata$1 as getSelectorMetadata, getStoreMetadata$1 as getStoreMetadata, getValue, ofAction, ofActionCanceled, ofActionCompleted, ofActionDispatched, ofActionErrored, ofActionSuccessful, setValue, OrderedSubject as ɵa, InternalActions as ɵb, ROOT_STATE_TOKEN as ɵc, FEATURE_STATE_TOKEN as ɵd, SELECTOR_META_KEY as ɵe, NgxsConfig as ɵf, mergeDeep as ɵg, USER_PROVIDED_NGXS_EXECUTION_STRATEGY as ɵh, NGXS_EXECUTION_STRATEGY as ɵi, NgxsRootModule as ɵj, StateFactory as ɵk, InternalDispatchedActionResults as ɵl, InternalDispatcher as ɵm, StateContextFactory as ɵn, InternalStateOperations as ɵo, PluginManager as ɵp, InternalNgxsExecutionStrategy as ɵq, ensureStoreMetadata as ɵs, getStoreMetadata as ɵt, ensureSelectorMetadata as ɵu, getSelectorMetadata as ɵv, LifecycleStateManager as ɵw, NgxsFeatureModule as ɵx };
 //# sourceMappingURL=ngxs-store.js.map