@ngxs/store 3.7.6-dev.master-7c829a7 → 3.7.6-dev.master-fb318b1

package/bundles/ngxs-store.umd.js

@@ -2781,6 +2781,175 @@
         }
     }
 
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * Init action
+     */
+    var   /**
+     * Init action
+     */
+    InitState = /** @class */ (function () {
+        function InitState() {
+        }
+        Object.defineProperty(InitState, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '@@INIT';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return InitState;
+    }());
+    /**
+     * Update action
+     */
+    var   /**
+     * Update action
+     */
+    UpdateState = /** @class */ (function () {
+        function UpdateState(addedStates) {
+            this.addedStates = addedStates;
+        }
+        Object.defineProperty(UpdateState, "type", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
+                return '@@UPDATE_STATE';
+            },
+            enumerable: true,
+            configurable: true
+        });
+        return UpdateState;
+    }());
+    if (false) {
+        /** @type {?} */
+        UpdateState.prototype.addedStates;
+    }
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @record
+     */
+    function NgxsDevelopmentOptions() { }
+    if (false) {
+        /** @type {?} */
+        NgxsDevelopmentOptions.prototype.warnOnUnhandledActions;
+    }
+    /** @type {?} */
+    var NGXS_DEVELOPMENT_OPTIONS = new core.InjectionToken('NGXS_DEVELOPMENT_OPTIONS', {
+        providedIn: 'root',
+        factory: (/**
+         * @return {?}
+         */
+        function () { return ({ warnOnUnhandledActions: true }); })
+    });
+
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var NgxsUnhandledActionsLogger = /** @class */ (function () {
+        function NgxsUnhandledActionsLogger(options) {
+            /**
+             * These actions should be ignored by default; the user can increase this
+             * list in the future via the `ignoreActions` method.
+             */
+            this._ignoredActions = new Set([InitState.type, UpdateState.type]);
+            if (typeof options.warnOnUnhandledActions === 'object') {
+                this.ignoreActions.apply(this, __spread(options.warnOnUnhandledActions.ignore));
+            }
+        }
+        /**
+         * Adds actions to the internal list of actions that should be ignored.
+         */
+        /**
+         * Adds actions to the internal list of actions that should be ignored.
+         * @param {...?} actions
+         * @return {?}
+         */
+        NgxsUnhandledActionsLogger.prototype.ignoreActions = /**
+         * Adds actions to the internal list of actions that should be ignored.
+         * @param {...?} actions
+         * @return {?}
+         */
+        function () {
+            var actions = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                actions[_i] = arguments[_i];
+            }
+            var e_1, _a;
+            try {
+                for (var actions_1 = __values(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {
+                    var action = actions_1_1.value;
+                    this._ignoredActions.add(action.type);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        };
+        /** @internal */
+        /**
+         * \@internal
+         * @param {?} action
+         * @return {?}
+         */
+        NgxsUnhandledActionsLogger.prototype.warn = /**
+         * \@internal
+         * @param {?} action
+         * @return {?}
+         */
+        function (action) {
+            /** @type {?} */
+            var actionShouldBeIgnored = Array.from(this._ignoredActions).some((/**
+             * @param {?} type
+             * @return {?}
+             */
+            function (type) { return type === getActionTypeFromInstance(action); }));
+            if (actionShouldBeIgnored) {
+                return;
+            }
+            action =
+                action.constructor && action.constructor.name !== 'Object'
+                    ? action.constructor.name
+                    : action.type;
+            console.warn("The " + action + " action has been dispatched but hasn't been handled. This may happen if the state with an action handler for this action is not registered.");
+        };
+        NgxsUnhandledActionsLogger.decorators = [
+            { type: core.Injectable }
+        ];
+        /** @nocollapse */
+        NgxsUnhandledActionsLogger.ctorParameters = function () { return [
+            { type: undefined, decorators: [{ type: core.Inject, args: [NGXS_DEVELOPMENT_OPTIONS,] }] }
+        ]; };
+        return NgxsUnhandledActionsLogger;
+    }());
+    if (false) {
+        /**
+         * These actions should be ignored by default; the user can increase this
+         * list in the future via the `ignoreActions` method.
+         * @type {?}
+         * @private
+         */
+        NgxsUnhandledActionsLogger.prototype._ignoredActions;
+    }
+
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -2926,10 +3095,8 @@
          * @return {?}
          */
         function () {
-            // I'm using non-null assertion here since `_actionsSubscrition` will
-            // be 100% defined. This is because `ngOnDestroy()` cannot be invoked
-            // on the `StateFactory` until its initialized :) An it's initialized
-            // for the first time along with the `NgxsRootModule`.
+            // This is being non-null asserted since `_actionsSubscrition` is
+            // initialized within the constructor.
             (/** @type {?} */ (this._actionsSubscription)).unsubscribe();
         };
         /**
@@ -3106,6 +3273,10 @@
             var type = (/** @type {?} */ (getActionTypeFromInstance(action)));
             /** @type {?} */
             var results = [];
+            // Determines whether the dispatched action has been handled, this is assigned
+            // to `true` within the below `for` loop if any `actionMetas` has been found.
+            /** @type {?} */
+            var actionHasBeenHandled = false;
             try {
                 for (var _c = __values(this.states), _d = _c.next(); !_d.done; _d = _c.next()) {
                     var metadata = _d.value;
@@ -3158,6 +3329,7 @@
                                 catch (e) {
                                     results.push(rxjs.throwError(e));
                                 }
+                                actionHasBeenHandled = true;
                             }
                         }
                         catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -3177,6 +3349,18 @@
                 }
                 finally { if (e_2) throw e_2.error; }
             }
+            // The `NgxsUnhandledActionsLogger` is a tree-shakable class which functions
+            // only during development.
+            if ((typeof ngDevMode === 'undefined' || ngDevMode) && !actionHasBeenHandled) {
+                /** @type {?} */
+                var unhandledActionsLogger = this._injector.get(NgxsUnhandledActionsLogger, null);
+                // The `NgxsUnhandledActionsLogger` will not be resolved by the injector if the
+                // `NgxsDevelopmentModule` is not provided. It's enough to check whether the `injector.get`
+                // didn't return `null` so we may ensure the module has been imported.
+                if (unhandledActionsLogger) {
+                    unhandledActionsLogger.warn(action);
+                }
+            }
             if (!results.length) {
                 results.push(rxjs.of({}));
             }
@@ -4057,60 +4241,6 @@
         SelectFactory.config;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * Init action
-     */
-    var   /**
-     * Init action
-     */
-    InitState = /** @class */ (function () {
-        function InitState() {
-        }
-        Object.defineProperty(InitState, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '@@INIT';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return InitState;
-    }());
-    /**
-     * Update action
-     */
-    var   /**
-     * Update action
-     */
-    UpdateState = /** @class */ (function () {
-        function UpdateState(addedStates) {
-            this.addedStates = addedStates;
-        }
-        Object.defineProperty(UpdateState, "type", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138
-                return '@@UPDATE_STATE';
-            },
-            enumerable: true,
-            configurable: true
-        });
-        return UpdateState;
-    }());
-    if (false) {
-        /** @type {?} */
-        UpdateState.prototype.addedStates;
-    }
-
     /**
      * @fileoverview added by tsickle
      * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -4817,12 +4947,44 @@
         StateToken.prototype.name;
     }
 
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var NgxsDevelopmentModule = /** @class */ (function () {
+        function NgxsDevelopmentModule() {
+        }
+        /**
+         * @param {?} options
+         * @return {?}
+         */
+        NgxsDevelopmentModule.forRoot = /**
+         * @param {?} options
+         * @return {?}
+         */
+        function (options) {
+            return {
+                ngModule: NgxsDevelopmentModule,
+                providers: [
+                    NgxsUnhandledActionsLogger,
+                    { provide: NGXS_DEVELOPMENT_OPTIONS, useValue: options }
+                ]
+            };
+        };
+        NgxsDevelopmentModule.decorators = [
+            { type: core.NgModule }
+        ];
+        return NgxsDevelopmentModule;
+    }());
+
     exports.Action = Action;
     exports.Actions = Actions;
     exports.InitState = InitState;
     exports.NGXS_PLUGINS = NGXS_PLUGINS;
+    exports.NgxsDevelopmentModule = NgxsDevelopmentModule;
     exports.NgxsModule = NgxsModule;
     exports.NgxsSimpleChange = NgxsSimpleChange;
+    exports.NgxsUnhandledActionsLogger = NgxsUnhandledActionsLogger;
     exports.NoopNgxsExecutionStrategy = NoopNgxsExecutionStrategy;
     exports.Select = Select;
     exports.Selector = Selector;
@@ -4849,6 +5011,7 @@
     exports.setValue = setValue;
     exports.ɵa = OrderedSubject;
     exports.ɵb = InternalActions;
+    exports.ɵba = NgxsFeatureModule;
     exports.ɵc = ROOT_STATE_TOKEN;
     exports.ɵd = FEATURE_STATE_TOKEN;
     exports.ɵe = SELECTOR_META_KEY;
@@ -4856,22 +5019,22 @@
     exports.ɵg = mergeDeep;
     exports.ɵh = USER_PROVIDED_NGXS_EXECUTION_STRATEGY;
     exports.ɵi = NGXS_EXECUTION_STRATEGY;
-    exports.ɵj = NgxsRootModule;
-    exports.ɵk = StateFactory;
-    exports.ɵl = InternalDispatchedActionResults;
-    exports.ɵm = InternalDispatcher;
-    exports.ɵn = StateContextFactory;
-    exports.ɵo = InternalStateOperations;
-    exports.ɵp = PluginManager;
-    exports.ɵq = InternalNgxsExecutionStrategy;
-    exports.ɵr = InternalErrorReporter;
-    exports.ɵs = SelectFactory;
-    exports.ɵu = ensureStoreMetadata;
-    exports.ɵv = getStoreMetadata;
-    exports.ɵw = ensureSelectorMetadata;
-    exports.ɵx = getSelectorMetadata;
-    exports.ɵy = LifecycleStateManager;
-    exports.ɵz = NgxsFeatureModule;
+    exports.ɵj = NGXS_DEVELOPMENT_OPTIONS;
+    exports.ɵk = NgxsRootModule;
+    exports.ɵl = StateFactory;
+    exports.ɵm = InternalDispatchedActionResults;
+    exports.ɵn = InternalDispatcher;
+    exports.ɵo = StateContextFactory;
+    exports.ɵp = InternalStateOperations;
+    exports.ɵq = PluginManager;
+    exports.ɵr = InternalNgxsExecutionStrategy;
+    exports.ɵs = InternalErrorReporter;
+    exports.ɵt = SelectFactory;
+    exports.ɵv = ensureStoreMetadata;
+    exports.ɵw = getStoreMetadata;
+    exports.ɵx = ensureSelectorMetadata;
+    exports.ɵy = getSelectorMetadata;
+    exports.ɵz = LifecycleStateManager;
 
     Object.defineProperty(exports, '__esModule', { value: true });