@ngxs/store 3.7.3 → 3.7.4

package/fesm5/ngxs-store.js

@@ -1,112 +1,88 @@
 import { __assign, __spread, __extends, __values } from 'tslib';
-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';
 
-var _a;
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
-/** @enum {string} */
-var 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 {?} */
-var CONFIG_MESSAGES = (_a = {},
-    _a[VALIDATION_CODE.STATE_NAME] = (/**
-     * @param {?} name
-     * @return {?}
-     */
-    function (name) {
-        return name + " is not a valid state name. It needs to be a valid object property name.";
-    }),
-    _a[VALIDATION_CODE.STATE_NAME_PROPERTY] = (/**
-     * @return {?}
-     */
-    function () { return "States must register a 'name' property"; }),
-    _a[VALIDATION_CODE.STATE_UNIQUE] = (/**
-     * @param {?} current
-     * @param {?} newName
-     * @param {?} oldName
-     * @return {?}
-     */
-    function (current, newName, oldName) {
-        return "State name '" + current + "' from " + newName + " already exists in " + oldName;
-    }),
-    _a[VALIDATION_CODE.STATE_DECORATOR] = (/**
-     * @return {?}
-     */
-    function () { return 'States must be decorated with @State() decorator'; }),
-    _a[VALIDATION_CODE.INCORRECT_PRODUCTION] = (/**
-     * @return {?}
-     */
-    function () {
-        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 })';
-    }),
-    _a[VALIDATION_CODE.INCORRECT_DEVELOPMENT] = (/**
-     * @return {?}
-     */
-    function () {
-        return 'RECOMMENDATION: Set developmentMode to true on the NgxsModule when Angular is running in development mode.\n' +
-            'NgxsModule.forRoot(states, { developmentMode: !environment.production })';
-    }),
-    _a[VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED] = (/**
-     * @return {?}
-     */
-    function () {
-        return 'You have forgotten to import the NGXS module!';
-    }),
-    _a[VALIDATION_CODE.ACTION_DECORATOR] = (/**
-     * @return {?}
-     */
-    function () {
-        return '@Action() decorator cannot be used with static methods';
-    }),
-    _a[VALIDATION_CODE.SELECTOR_DECORATOR] = (/**
-     * @return {?}
-     */
-    function () { return 'Selectors only work on methods'; }),
-    _a[VALIDATION_CODE.ZONE_WARNING] = (/**
-     * @return {?}
-     */
-    function () {
-        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 })';
-    }),
-    _a[VALIDATION_CODE.PATCHING_ARRAY] = (/**
-     * @return {?}
-     */
-    function () { return 'Patching arrays is not supported.'; }),
-    _a[VALIDATION_CODE.PATCHING_PRIMITIVE] = (/**
-     * @return {?}
-     */
-    function () { return 'Patching primitives is not supported.'; }),
-    _a[VALIDATION_CODE.UNDECORATED_STATE_IN_IVY] = (/**
-     * @param {?} name
-     * @return {?}
-     */
-    function (name) {
-        return "'" + name + "' class should be decorated with @Injectable() right after the @State() decorator";
-    }),
-    _a);
+/**
+ * @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 })');
+}
+/**
+ * @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
@@ -116,7 +92,11 @@ var DispatchOutsideZoneNgxsExecutionStrategy = /** @class */ (function () {
     function DispatchOutsideZoneNgxsExecutionStrategy(_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
@@ -183,33 +163,15 @@ var DispatchOutsideZoneNgxsExecutionStrategy = /** @class */ (function () {
         }
         return func();
     };
-    /**
-     * @private
-     * @param {?} ngZone
-     * @return {?}
-     */
-    DispatchOutsideZoneNgxsExecutionStrategy.prototype.verifyZoneIsNotNooped = /**
-     * @private
-     * @param {?} ngZone
-     * @return {?}
-     */
-    function (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 = function () { return [
         { 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" });
     return DispatchOutsideZoneNgxsExecutionStrategy;
 }());
 if (false) {
@@ -223,6 +185,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());
 }
 
 /**
@@ -236,10 +213,6 @@ var FEATURE_STATE_TOKEN = new InjectionToken('FEATURE_STATE_TOKEN');
 /** @type {?} */
 var NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');
 /** @type {?} */
-var NG_TEST_MODE = new InjectionToken('NG_TEST_MODE');
-/** @type {?} */
-var NG_DEV_MODE = new InjectionToken('NG_DEV_MODE');
-/** @type {?} */
 var META_KEY = 'NGXS_META';
 /** @type {?} */
 var META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
@@ -282,6 +255,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;
@@ -450,11 +426,72 @@ if (false) {
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
+var NoopNgxsExecutionStrategy = /** @class */ (function () {
+    function NoopNgxsExecutionStrategy() {
+    }
+    /**
+     * @template T
+     * @param {?} func
+     * @return {?}
+     */
+    NoopNgxsExecutionStrategy.prototype.enter = /**
+     * @template T
+     * @param {?} func
+     * @return {?}
+     */
+    function (func) {
+        return func();
+    };
+    /**
+     * @template T
+     * @param {?} func
+     * @return {?}
+     */
+    NoopNgxsExecutionStrategy.prototype.leave = /**
+     * @template T
+     * @param {?} func
+     * @return {?}
+     */
+    function (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" });
+    return NoopNgxsExecutionStrategy;
+}());
+
+/**
+ * @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 {?}
+ */
+var USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');
 /*
  * Internal execution strategy injection token
  */
 /** @type {?} */
-var NGXS_EXECUTION_STRATEGY = new InjectionToken('NGXS_EXECUTION_STRATEGY');
+var NGXS_EXECUTION_STRATEGY = new InjectionToken('NGXS_EXECUTION_STRATEGY', {
+    providedIn: 'root',
+    factory: (/**
+     * @return {?}
+     */
+    function () {
+        /** @type {?} */
+        var injector = inject(INJECTOR);
+        /** @type {?} */
+        var executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);
+        return executionStrategy
+            ? injector.get(executionStrategy)
+            : injector.get(typeof ɵglobal.Zone !== 'undefined'
+                ? DispatchOutsideZoneNgxsExecutionStrategy
+                : NoopNgxsExecutionStrategy);
+    })
+});
 /**
  * @record
  */
@@ -935,10 +972,12 @@ function buildGraph(stateClasses) {
          * @return {?}
          */
         function (g) { return 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
@@ -1070,7 +1109,9 @@ function topologicalSort(graph) {
          * @return {?}
          */
         function (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]) {
@@ -1664,6 +1705,18 @@ var StateStream = /** @class */ (function (_super) {
     function StateStream() {
         return _super.call(this, {}) || this;
     }
+    /**
+     * @return {?}
+     */
+    StateStream.prototype.ngOnDestroy = /**
+     * @return {?}
+     */
+    function () {
+        // 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 }
     ];
@@ -2025,103 +2078,6 @@ function (o) {
     return o;
 });
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var HostEnvironment = /** @class */ (function () {
-    function HostEnvironment(isDevMode, isTestMode) {
-        this.isDevMode = isDevMode;
-        this.isTestMode = isTestMode;
-    }
-    HostEnvironment.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    HostEnvironment.ctorParameters = function () { return [
-        { type: undefined, decorators: [{ type: Inject, args: [NG_DEV_MODE,] }] },
-        { type: undefined, decorators: [{ type: Inject, args: [NG_TEST_MODE,] }] }
-    ]; };
-    return HostEnvironment;
-}());
-if (false) {
-    /** @type {?} */
-    HostEnvironment.prototype.isDevMode;
-    /** @type {?} */
-    HostEnvironment.prototype.isTestMode;
-}
-
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var ConfigValidator = /** @class */ (function () {
-    function ConfigValidator(_host, _config) {
-        this._host = _host;
-        this._config = _config;
-    }
-    Object.defineProperty(ConfigValidator.prototype, "isIncorrectProduction", {
-        get: /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            return !this._host.isDevMode() && this._config.developmentMode;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(ConfigValidator.prototype, "isIncorrectDevelopment", {
-        get: /**
-         * @private
-         * @return {?}
-         */
-        function () {
-            return this._host.isDevMode() && !this._config.developmentMode;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * @return {?}
-     */
-    ConfigValidator.prototype.verifyDevMode = /**
-     * @return {?}
-     */
-    function () {
-        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 = function () { return [
-        { type: HostEnvironment },
-        { type: NgxsConfig }
-    ]; };
-    return ConfigValidator;
-}());
-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
@@ -2131,11 +2087,10 @@ if (false) {
  * @ignore
  */
 var InternalStateOperations = /** @class */ (function () {
-    function InternalStateOperations(_stateStream, _dispatcher, _config, configValidator) {
+    function InternalStateOperations(_stateStream, _dispatcher, _config) {
         this._stateStream = _stateStream;
         this._dispatcher = _dispatcher;
         this._config = _config;
-        configValidator.verifyDevMode();
     }
     /**
      * Returns the root state operators.
@@ -2167,44 +2122,22 @@ var InternalStateOperations = /** @class */ (function () {
              */
             function (actionOrActions) { return _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 {?}
-     */
-    InternalStateOperations.prototype.ensureStateAndActionsAreImmutable = /**
-     * @private
-     * @param {?} root
-     * @return {?}
-     */
-    function (root) {
-        return {
-            getState: (/**
-             * @return {?}
-             */
-            function () { return root.getState(); }),
-            setState: (/**
-             * @param {?} value
-             * @return {?}
-             */
-            function (value) {
-                /** @type {?} */
-                var frozenValue = deepFreeze(value);
-                return root.setState(frozenValue);
-            }),
-            dispatch: (/**
-             * @param {?} actions
-             * @return {?}
-             */
-            function (actions) {
-                return root.dispatch(actions);
-            })
-        };
     };
     /**
      * @param {?} results
@@ -2230,8 +2163,7 @@ var InternalStateOperations = /** @class */ (function () {
     InternalStateOperations.ctorParameters = function () { return [
         { type: StateStream },
         { type: InternalDispatcher },
-        { type: NgxsConfig },
-        { type: ConfigValidator }
+        { type: NgxsConfig }
     ]; };
     return InternalStateOperations;
 }());
@@ -2251,6 +2183,34 @@ if (false) {
      * @private
      */
     InternalStateOperations.prototype._config;
+}
+/**
+ * @param {?} root
+ * @return {?}
+ */
+function ensureStateAndActionsAreImmutable(root) {
+    return {
+        getState: (/**
+         * @return {?}
+         */
+        function () { return root.getState(); }),
+        setState: (/**
+         * @param {?} value
+         * @return {?}
+         */
+        function (value) {
+            /** @type {?} */
+            var frozenValue = deepFreeze(value);
+            return root.setState(frozenValue);
+        }),
+        dispatch: (/**
+         * @param {?} actions
+         * @return {?}
+         */
+        function (actions) {
+            return root.dispatch(actions);
+        })
+    };
 }
 
 /**
@@ -2269,10 +2229,10 @@ function simplePatch(val) {
      */
     function (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 {?} */
         var newState = __assign({}, ((/** @type {?} */ (existingState))));
@@ -2439,72 +2399,64 @@ var StoreValidators = /** @class */ (function () {
      * @param {?} name
      * @return {?}
      */
-    StoreValidators.stateNameErrorMessage = /**
-     * @param {?} name
-     * @return {?}
-     */
-    function (name) {
-        return CONFIG_MESSAGES[VALIDATION_CODE.STATE_NAME](name);
-    };
-    /**
-     * @param {?} name
-     * @return {?}
-     */
-    StoreValidators.checkCorrectStateName = /**
+    StoreValidators.checkThatStateIsNamedCorrectly = /**
      * @param {?} name
      * @return {?}
      */
     function (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 {?}
      */
-    StoreValidators.checkStateNameIsUnique = /**
+    StoreValidators.checkThatStateNameIsUnique = /**
+     * @param {?} stateName
      * @param {?} state
      * @param {?} statesByName
      * @return {?}
      */
-    function (state, statesByName) {
-        /** @type {?} */
-        var meta = this.getValidStateMeta(state);
-        /** @type {?} */
-        var stateName = (/** @type {?} */ ((/** @type {?} */ (meta)).name));
+    function (stateName, state, statesByName) {
         /** @type {?} */
         var 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 {?}
      */
-    StoreValidators.getValidStateMeta = /**
-     * @param {?} state
+    StoreValidators.checkThatStateClassesHaveBeenDecorated = /**
+     * @param {?} stateClasses
      * @return {?}
      */
-    function (state) {
-        /** @type {?} */
-        var meta = getStoreMetadata(state);
-        if (!meta) {
-            throw new Error(CONFIG_MESSAGES[VALIDATION_CODE.STATE_DECORATOR]());
-        }
-        return meta;
+    function (stateClasses) {
+        stateClasses.forEach((/**
+         * @param {?} stateClass
+         * @return {?}
+         */
+        function (stateClass) {
+            if (!getStoreMetadata(stateClass)) {
+                throwStateDecoratorError(stateClass.name);
+            }
+        }));
     };
     StoreValidators.stateNameRegex = new RegExp('^[a-zA-Z0-9_]+$');
     return StoreValidators;
 }());
 if (false) {
-    /** @type {?} */
+    /**
+     * @type {?}
+     * @private
+     */
     StoreValidators.stateNameRegex;
 }
 
@@ -2646,19 +2598,6 @@ var StateFactory = /** @class */ (function () {
         }
         return value;
     };
-    /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    StateFactory.checkStatesAreValid = /**
-     * @private
-     * @param {?} stateClasses
-     * @return {?}
-     */
-    function (stateClasses) {
-        stateClasses.forEach(StoreValidators.getValidStateMeta);
-    };
     /**
      * @return {?}
      */
@@ -2687,7 +2626,11 @@ var StateFactory = /** @class */ (function () {
      */
     function (stateClasses) {
         var e_1, _a;
-        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);
+        }
         var newStates = this.addToStatesMap(stateClasses).newStates;
         if (!newStates.length)
             return [];
@@ -2782,18 +2725,22 @@ var StateFactory = /** @class */ (function () {
         var _this = this;
         if (this._actionsSubscription !== null)
             return;
+        /** @type {?} */
+        var dispatched$ = new Subject();
         this._actionsSubscription = this._actions
             .pipe(filter((/**
          * @param {?} ctx
          * @return {?}
          */
         function (ctx) { return ctx.status === "DISPATCHED" /* Dispatched */; })), mergeMap((/**
-         * @param {?} __0
+         * @param {?} ctx
          * @return {?}
          */
-        function (_a) {
-            var action = _a.action;
-            return _this.invokeActions(_this._actions, (/** @type {?} */ (action))).pipe(map((/**
+        function (ctx) {
+            dispatched$.next(ctx);
+            /** @type {?} */
+            var action = ctx.action;
+            return _this.invokeActions(dispatched$, (/** @type {?} */ (action))).pipe(map((/**
              * @return {?}
              */
             function () { return (/** @type {?} */ ({ action: action, status: "SUCCESSFUL" /* Successful */ })); })), defaultIfEmpty((/** @type {?} */ ({ action: action, status: "CANCELED" /* Canceled */ }))), catchError((/**
@@ -2815,17 +2762,17 @@ var StateFactory = /** @class */ (function () {
      */
     /**
      * Invoke actions on the states.
-     * @param {?} actions$
+     * @param {?} dispatched$
      * @param {?} action
      * @return {?}
      */
     StateFactory.prototype.invokeActions = /**
      * Invoke actions on the states.
-     * @param {?} actions$
+     * @param {?} dispatched$
      * @param {?} action
      * @return {?}
      */
-    function (actions$, action) {
+    function (dispatched$, action) {
         var e_2, _a, e_3, _b;
         /** @type {?} */
         var type = (/** @type {?} */ (getActionTypeFromInstance(action)));
@@ -2857,10 +2804,22 @@ var StateFactory = /** @class */ (function () {
                                     // `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 {?}
+                                     */
+                                    function (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 {
@@ -2915,7 +2874,12 @@ var StateFactory = /** @class */ (function () {
             for (var stateClasses_1 = __values(stateClasses), stateClasses_1_1 = stateClasses_1.next(); !stateClasses_1_1.done; stateClasses_1_1 = stateClasses_1.next()) {
                 var stateClass = stateClasses_1_1.value;
                 /** @type {?} */
-                var stateName = StoreValidators.checkStateNameIsUnique(stateClass, statesMap);
+                var 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 {?} */
                 var unmountedState = !statesMap[stateName];
                 if (unmountedState) {
@@ -3464,6 +3428,12 @@ var Store = /** @class */ (function () {
         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);
     }
     /**
@@ -3494,7 +3464,7 @@ var Store = /** @class */ (function () {
         var _this = this;
         /** @type {?} */
         var selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._stateStream.pipe(map(selectorFn), catchError((/**
+        return this._selectableStateStream.pipe(map(selectorFn), catchError((/**
          * @param {?} err
          * @return {?}
          */
@@ -3546,7 +3516,9 @@ var Store = /** @class */ (function () {
      * @return {?}
      */
     function (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.
@@ -3637,6 +3609,14 @@ var Store = /** @class */ (function () {
     return Store;
 }());
 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
@@ -3669,9 +3649,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.
  */
 var SelectFactory = /** @class */ (function () {
     function SelectFactory(store, config) {
@@ -3691,13 +3670,14 @@ var SelectFactory = /** @class */ (function () {
     SelectFactory.store = null;
     SelectFactory.config = null;
     SelectFactory.decorators = [
-        { type: Injectable }
+        { type: Injectable, args: [{ providedIn: 'root' },] }
     ];
     /** @nocollapse */
     SelectFactory.ctorParameters = function () { return [
         { type: Store },
         { type: NgxsConfig }
     ]; };
+    /** @nocollapse */ SelectFactory.ngInjectableDef = defineInjectable({ factory: function SelectFactory_Factory() { return new SelectFactory(inject(Store), inject(NgxsConfig)); }, token: SelectFactory, providedIn: "root" });
     return SelectFactory;
 }());
 if (false) {
@@ -3761,44 +3741,6 @@ if (false) {
     UpdateState.prototype.addedStates;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @type {?} */
-var 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 {?} */
-        var ng = ((/** @type {?} */ (window))).ng;
-        /** @type {?} */
-        var _viewEngineEnabled = !!ng.probe && !!ng.coreTokens;
-        /** @type {?} */
-        var _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
@@ -3808,10 +3750,11 @@ function setIvyEnabledInDevMode() {
  * @ignore
  */
 var NgxsRootModule = /** @class */ (function () {
-    function NgxsRootModule(factory, internalStateOperations, _store, _select, states, lifecycleStateManager) {
+    function NgxsRootModule(factory, internalStateOperations, _store, injector, states, lifecycleStateManager) {
         if (states === void 0) { states = []; }
-        // Validate states on having the `@Injectable()` decorator in Ivy
-        setIvyEnabledInDevMode();
+        // 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 {?} */
         var results = factory.addAndReturnDefaults(states);
@@ -3829,7 +3772,7 @@ var NgxsRootModule = /** @class */ (function () {
         { type: StateFactory },
         { type: InternalStateOperations },
         { type: Store },
-        { type: SelectFactory },
+        { type: Injector },
         { type: Array, decorators: [{ type: Optional }, { type: Inject, args: [ROOT_STATE_TOKEN,] }] },
         { type: LifecycleStateManager }
     ]; };
@@ -3929,8 +3872,6 @@ var NgxsModule = /** @class */ (function () {
                 Actions,
                 InternalActions,
                 NgxsBootstrapper,
-                ConfigValidator,
-                HostEnvironment,
                 LifecycleStateManager,
                 InternalDispatcher,
                 InternalDispatchedActionResults,
@@ -3938,7 +3879,6 @@ var NgxsModule = /** @class */ (function () {
                 InternalNgxsExecutionStrategy,
                 Store,
                 StateStream,
-                SelectFactory,
                 PluginManager
             ], states, NgxsModule.ngxsTokenProviders(states, options))
         };
@@ -3987,16 +3927,8 @@ var NgxsModule = /** @class */ (function () {
     function (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,
@@ -4103,10 +4035,14 @@ function Action(actions, options) {
      */
     function (target, name) {
         var e_1, _a;
-        /** @type {?} */
-        var 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 {?} */
+            var isStaticMethod = target.hasOwnProperty('prototype');
+            if (isStaticMethod) {
+                throwActionDecoratorError();
+            }
         }
         /** @type {?} */
         var meta = ensureStoreMetadata(target.constructor);
@@ -4154,20 +4090,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 {?}
-     */
-    function (_ivyEnabledInDevMode) {
-        if (_ivyEnabledInDevMode) {
-            /** @type {?} */
-            /** @nocollapse */ var 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 */ var ngInjectableDef = target.ɵprov;
+        if (!ngInjectableDef) {
+            // Don't warn if Ivy is disabled or `ɵprov` exists on the class
+            console.warn(getUndecoratedStateInIvyWarningMessage(target.name));
         }
-    }));
+    }
 }
 
 /**
@@ -4212,7 +4142,11 @@ function State(options) {
         var children = optionsWithInheritance.children, defaults = optionsWithInheritance.defaults, name = optionsWithInheritance.name;
         /** @type {?} */
         var 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 {?} */
             var inheritedMeta = inheritedStateClass[META_KEY] || {};
@@ -4227,7 +4161,11 @@ function State(options) {
      * @return {?}
      */
     function (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 {?} */
         var stateClass = target;
         /** @type {?} */
@@ -4250,30 +4188,37 @@ var 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) {
+function createSelectorFn(config, name, rawSelector, paths) {
     if (paths === void 0) { paths = []; }
-    rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;
-    if (typeof rawSelector === 'string') {
+    rawSelector = rawSelector || removeDollarAtTheEnd(name);
+    if (typeof rawSelector !== 'string') {
+        return rawSelector;
+    }
+    else {
         /** @type {?} */
         var propsArray = paths.length
             ? __spread([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`
@@ -4286,6 +4231,42 @@ function removeDollarAtTheEnd(name) {
     /** @type {?} */
     var 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)));
 }
 
 /**
@@ -4316,7 +4297,12 @@ function Select(rawSelector) {
         /** @type {?} */
         var selectorId = "__" + name + "__selector";
         /** @type {?} */
-        var selector = createSelectorFn(name, rawSelector, paths);
+        var selector = null;
+        /** @type {?} */
+        var injectorNotifier$ = null;
+        if (ɵivyEnabled) {
+            injectorNotifier$ = ensureInjectorNotifierIsCaptured(target);
+        }
         Object.defineProperties(target, (_a = {},
             _a[selectorId] = {
                 writable: true,
@@ -4330,10 +4316,37 @@ function Select(rawSelector) {
                  * @return {?}
                  */
                 function () {
-                    return this[selectorId] || (this[selectorId] = createSelectObservable(selector));
+                    var _this = this;
+                    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 {?}
+                         */
+                        function () {
+                            /** @type {?} */
+                            var store = localInject(_this, Store);
+                            /** @type {?} */
+                            var 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];
                 }
             },
             _a));
+        // 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);
+        }
     });
 }
 
@@ -4452,10 +4465,14 @@ function Selector(selectors) {
      * @return {?}
      */
     function (target, key, descriptor) {
-        /** @type {?} */
-        var 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 {?} */
+            var isNotMethod = !(descriptor && descriptor.value !== null);
+            if (isNotMethod) {
+                throwSelectorDecoratorError();
+            }
         }
         /** @type {?} */
         var originalFn = descriptor.value;
@@ -4486,45 +4503,6 @@ function Selector(selectors) {
     });
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-var NoopNgxsExecutionStrategy = /** @class */ (function () {
-    function NoopNgxsExecutionStrategy() {
-    }
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NoopNgxsExecutionStrategy.prototype.enter = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        return func();
-    };
-    /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    NoopNgxsExecutionStrategy.prototype.leave = /**
-     * @template T
-     * @param {?} func
-     * @return {?}
-     */
-    function (func) {
-        return func();
-    };
-    NoopNgxsExecutionStrategy.decorators = [
-        { type: Injectable }
-    ];
-    return NoopNgxsExecutionStrategy;
-}());
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4597,5 +4575,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