@ngxs/storage-plugin 3.7.4 → 3.7.5

package/bundles/ngxs-storage-plugin.umd.js

@@ -223,393 +223,441 @@
         return value;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @enum {number} */
-    var StorageOption = {
-        LocalStorage: 0,
-        SessionStorage: 1,
-    };
-    /**
-     * @record
-     */
-    function NgxsStoragePluginOptions() { }
-    if (false) {
-        /**
-         * Key for the state slice to store in the storage engine.
-         * @type {?|undefined}
-         */
-        NgxsStoragePluginOptions.prototype.key;
-        /**
-         * Storage engine to use. Deaults to localStorage but can provide
-         *
-         * sessionStorage or custom implementation of the StorageEngine interface
-         * @type {?|undefined}
-         */
-        NgxsStoragePluginOptions.prototype.storage;
-        /**
-         * Migration strategies.
-         * @type {?|undefined}
-         */
-        NgxsStoragePluginOptions.prototype.migrations;
-        /**
-         * Serailizer for the object before its pushed into the engine.
-         * @param {?} obj
-         * @return {?}
-         */
-        NgxsStoragePluginOptions.prototype.serialize = function (obj) { };
-        /**
-         * Deserializer for the object before its pulled out of the engine.
-         * @param {?} obj
-         * @return {?}
-         */
-        NgxsStoragePluginOptions.prototype.deserialize = function (obj) { };
-        /**
-         * Method to alter object before serialization.
-         * @param {?} obj
-         * @param {?} key
-         * @return {?}
-         */
-        NgxsStoragePluginOptions.prototype.beforeSerialize = function (obj, key) { };
-        /**
-         * Method to alter object after deserialization.
-         * @param {?} obj
-         * @param {?} key
-         * @return {?}
-         */
-        NgxsStoragePluginOptions.prototype.afterDeserialize = function (obj, key) { };
-    }
-    /** @type {?} */
-    var NGXS_STORAGE_PLUGIN_OPTIONS = new core.InjectionToken('NGXS_STORAGE_PLUGIN_OPTION');
-    /** @type {?} */
-    var STORAGE_ENGINE = new core.InjectionToken('STORAGE_ENGINE');
-    /**
-     * @record
-     */
-    function StorageEngine() { }
-    if (false) {
-        /** @type {?} */
-        StorageEngine.prototype.length;
-        /**
-         * @param {?} key
-         * @return {?}
-         */
-        StorageEngine.prototype.getItem = function (key) { };
-        /**
-         * @param {?} key
-         * @param {?} val
-         * @return {?}
-         */
-        StorageEngine.prototype.setItem = function (key, val) { };
-        /**
-         * @param {?} key
-         * @return {?}
-         */
-        StorageEngine.prototype.removeItem = function (key) { };
-        /**
-         * @return {?}
-         */
-        StorageEngine.prototype.clear = function () { };
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @enum {number} */
+    var StorageOption = {
+        LocalStorage: 0,
+        SessionStorage: 1,
+    };
+    /**
+     * @record
+     */
+    function NgxsStoragePluginOptions() { }
+    if (false) {
+        /**
+         * Key for the state slice to store in the storage engine.
+         * @type {?|undefined}
+         */
+        NgxsStoragePluginOptions.prototype.key;
+        /**
+         * Storage engine to use. Deaults to localStorage but can provide
+         *
+         * sessionStorage or custom implementation of the StorageEngine interface
+         * @type {?|undefined}
+         */
+        NgxsStoragePluginOptions.prototype.storage;
+        /**
+         * Migration strategies.
+         * @type {?|undefined}
+         */
+        NgxsStoragePluginOptions.prototype.migrations;
+        /**
+         * Serailizer for the object before its pushed into the engine.
+         * @param {?} obj
+         * @return {?}
+         */
+        NgxsStoragePluginOptions.prototype.serialize = function (obj) { };
+        /**
+         * Deserializer for the object before its pulled out of the engine.
+         * @param {?} obj
+         * @return {?}
+         */
+        NgxsStoragePluginOptions.prototype.deserialize = function (obj) { };
+        /**
+         * Method to alter object before serialization.
+         * @param {?} obj
+         * @param {?} key
+         * @return {?}
+         */
+        NgxsStoragePluginOptions.prototype.beforeSerialize = function (obj, key) { };
+        /**
+         * Method to alter object after deserialization.
+         * @param {?} obj
+         * @param {?} key
+         * @return {?}
+         */
+        NgxsStoragePluginOptions.prototype.afterDeserialize = function (obj, key) { };
+    }
+    /** @type {?} */
+    var NGXS_STORAGE_PLUGIN_OPTIONS = new core.InjectionToken('NGXS_STORAGE_PLUGIN_OPTION');
+    /** @type {?} */
+    var STORAGE_ENGINE = new core.InjectionToken('STORAGE_ENGINE');
+    /**
+     * @record
+     */
+    function StorageEngine() { }
+    if (false) {
+        /** @type {?} */
+        StorageEngine.prototype.length;
+        /**
+         * @param {?} key
+         * @return {?}
+         */
+        StorageEngine.prototype.getItem = function (key) { };
+        /**
+         * @param {?} key
+         * @param {?} val
+         * @return {?}
+         */
+        StorageEngine.prototype.setItem = function (key, val) { };
+        /**
+         * @param {?} key
+         * @return {?}
+         */
+        StorageEngine.prototype.removeItem = function (key) { };
+        /**
+         * @return {?}
+         */
+        StorageEngine.prototype.clear = function () { };
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * If the `key` option is not provided then the below constant
-     * will be used as a default key
-     * @type {?}
-     */
-    var DEFAULT_STATE_KEY = '@@STATE';
-    /**
-     * This key is used to retrieve static metadatas on state classes.
-     * This constant is taken from the core codebase
-     * @type {?}
-     */
-    var META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
-    /**
-     * @param {?} key
-     * @return {?}
-     */
-    function transformKeyOption(key) {
-        if (!Array.isArray(key)) {
-            key = [key];
-        }
-        return key.map((/**
-         * @param {?} token
-         * @return {?}
-         */
-        function (token) {
-            // If it has the `NGXS_OPTIONS_META` key then it means the developer
-            // has provided state class like `key: [AuthState]`.
-            if (token.hasOwnProperty(META_OPTIONS_KEY)) {
-                // The `name` property will be an actual state name or a `StateToken`.
-                token = ((/** @type {?} */ (token)))[META_OPTIONS_KEY].name;
-            }
-            return token instanceof store.StateToken ? token.getName() : ((/** @type {?} */ (token)));
-        }));
-    }
-    /**
-     * @param {?} options
-     * @return {?}
-     */
-    function storageOptionsFactory(options) {
-        if (options !== undefined && options.key) {
-            options.key = transformKeyOption(options.key);
-        }
-        return __assign({ key: [DEFAULT_STATE_KEY], storage: 0 /* LocalStorage */, serialize: JSON.stringify, deserialize: JSON.parse, beforeSerialize: (/**
-             * @param {?} obj
-             * @return {?}
-             */
-            function (obj) { return obj; }), afterDeserialize: (/**
-             * @param {?} obj
-             * @return {?}
-             */
-            function (obj) { return obj; }) }, options);
-    }
-    /**
-     * @param {?} options
-     * @param {?} platformId
-     * @return {?}
-     */
-    function engineFactory(options, platformId) {
-        if (common.isPlatformServer(platformId)) {
-            return null;
-        }
-        if (options.storage === 0 /* LocalStorage */) {
-            return localStorage;
-        }
-        else if (options.storage === 1 /* SessionStorage */) {
-            return sessionStorage;
-        }
-        return null;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * If the `key` option is not provided then the below constant
+     * will be used as a default key
+     * @type {?}
+     */
+    var DEFAULT_STATE_KEY = '@@STATE';
+    /**
+     * This key is used to retrieve static metadatas on state classes.
+     * This constant is taken from the core codebase
+     * @type {?}
+     */
+    var META_OPTIONS_KEY = 'NGXS_OPTIONS_META';
+    /**
+     * @param {?} key
+     * @return {?}
+     */
+    function transformKeyOption(key) {
+        if (!Array.isArray(key)) {
+            key = [key];
+        }
+        return key.map((/**
+         * @param {?} token
+         * @return {?}
+         */
+        function (token) {
+            // If it has the `NGXS_OPTIONS_META` key then it means the developer
+            // has provided state class like `key: [AuthState]`.
+            if (token.hasOwnProperty(META_OPTIONS_KEY)) {
+                // The `name` property will be an actual state name or a `StateToken`.
+                token = ((/** @type {?} */ (token)))[META_OPTIONS_KEY].name;
+            }
+            return token instanceof store.StateToken ? token.getName() : ((/** @type {?} */ (token)));
+        }));
+    }
+    /**
+     * @param {?} options
+     * @return {?}
+     */
+    function storageOptionsFactory(options) {
+        if (options !== undefined && options.key) {
+            options.key = transformKeyOption(options.key);
+        }
+        return __assign({ key: [DEFAULT_STATE_KEY], storage: 0 /* LocalStorage */, serialize: JSON.stringify, deserialize: JSON.parse, beforeSerialize: (/**
+             * @param {?} obj
+             * @return {?}
+             */
+            function (obj) { return obj; }), afterDeserialize: (/**
+             * @param {?} obj
+             * @return {?}
+             */
+            function (obj) { return obj; }) }, options);
+    }
+    /**
+     * @param {?} options
+     * @param {?} platformId
+     * @return {?}
+     */
+    function engineFactory(options, platformId) {
+        if (common.isPlatformServer(platformId)) {
+            return null;
+        }
+        if (options.storage === 0 /* LocalStorage */) {
+            return localStorage;
+        }
+        else if (options.storage === 1 /* SessionStorage */) {
+            return sessionStorage;
+        }
+        return null;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    var NgxsStoragePlugin = /** @class */ (function () {
-        function NgxsStoragePlugin(_options, _engine, _platformId) {
-            this._options = _options;
-            this._engine = _engine;
-            this._platformId = _platformId;
-        }
-        /**
-         * @param {?} state
-         * @param {?} event
-         * @param {?} next
-         * @return {?}
-         */
-        NgxsStoragePlugin.prototype.handle = /**
-         * @param {?} state
-         * @param {?} event
-         * @param {?} next
-         * @return {?}
-         */
-        function (state, event, next) {
-            var _this = this;
-            var e_1, _a;
-            if (common.isPlatformServer(this._platformId) && this._engine === null) {
-                return next(state, event);
-            }
-            // We cast to `string[]` here as we're sure that this option has been
-            // transformed by the `storageOptionsFactory` function that provided token
-            /** @type {?} */
-            var keys = (/** @type {?} */ (this._options.key));
-            /** @type {?} */
-            var matches = store.actionMatcher(event);
-            /** @type {?} */
-            var isInitAction = matches(store.InitState);
-            /** @type {?} */
-            var isUpdateAction = matches(store.UpdateState);
-            /** @type {?} */
-            var isInitOrUpdateAction = isInitAction || isUpdateAction;
-            /** @type {?} */
-            var hasMigration = false;
-            if (isInitOrUpdateAction) {
-                var _loop_1 = function (key) {
-                    // We're checking what states have been added by NGXS and if any of these states should be handled by
-                    // the storage plugin. For instance, we only want to deserialize the `auth` state, NGXS has added
-                    // the `user` state, the storage plugin will be rerun and will do redundant deserialization.
-                    if (isUpdateAction && event.addedStates && !event.addedStates.hasOwnProperty(key)) {
-                        return "continue";
-                    }
-                    /** @type {?} */
-                    var isMaster = key === DEFAULT_STATE_KEY;
-                    /** @type {?} */
-                    var val = this_1._engine.getItem((/** @type {?} */ (key)));
-                    if (val !== 'undefined' && val != null) {
-                        try {
-                            /** @type {?} */
-                            var newVal = (/** @type {?} */ (this_1._options.deserialize))(val);
-                            val = (/** @type {?} */ (this_1._options.afterDeserialize))(newVal, key);
-                        }
-                        catch (e) {
-                            // 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) {
-                                console.error("Error ocurred while deserializing the " + key + " store value, falling back to empty object, the value obtained from the store: ", val);
-                            }
-                            val = {};
-                        }
-                        if (this_1._options.migrations) {
-                            this_1._options.migrations.forEach((/**
-                             * @param {?} strategy
-                             * @return {?}
-                             */
-                            function (strategy) {
-                                /** @type {?} */
-                                var versionMatch = strategy.version === store.getValue(val, strategy.versionKey || 'version');
-                                /** @type {?} */
-                                var keyMatch = (!strategy.key && isMaster) || strategy.key === key;
-                                if (versionMatch && keyMatch) {
-                                    val = strategy.migrate(val);
-                                    hasMigration = true;
-                                }
-                            }));
-                        }
-                        if (!isMaster) {
-                            state = store.setValue(state, (/** @type {?} */ (key)), val);
-                        }
-                        else {
-                            state = __assign({}, state, val);
-                        }
-                    }
-                };
-                var this_1 = this;
-                try {
-                    for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
-                        var key = keys_1_1.value;
-                        _loop_1(key);
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-            }
-            return next(state, event).pipe(operators.tap((/**
-             * @param {?} nextState
-             * @return {?}
-             */
-            function (nextState) {
-                var e_2, _a;
-                if (!isInitOrUpdateAction || (isInitOrUpdateAction && hasMigration)) {
-                    try {
-                        for (var keys_2 = __values(keys), keys_2_1 = keys_2.next(); !keys_2_1.done; keys_2_1 = keys_2.next()) {
-                            var key = keys_2_1.value;
-                            /** @type {?} */
-                            var val = nextState;
-                            if (key !== DEFAULT_STATE_KEY) {
-                                val = store.getValue(nextState, (/** @type {?} */ (key)));
-                            }
-                            try {
-                                /** @type {?} */
-                                var newVal = (/** @type {?} */ (_this._options.beforeSerialize))(val, key);
-                                _this._engine.setItem((/** @type {?} */ (key)), (/** @type {?} */ (_this._options.serialize))(newVal));
-                            }
-                            catch (e) {
-                                // 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) {
-                                    console.error("Error ocurred while serializing the " + key + " store value, value not updated, the value obtained from the store: ", val);
-                                }
-                            }
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (keys_2_1 && !keys_2_1.done && (_a = keys_2.return)) _a.call(keys_2);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                }
-            })));
-        };
-        NgxsStoragePlugin.decorators = [
-            { type: core.Injectable }
-        ];
-        /** @nocollapse */
-        NgxsStoragePlugin.ctorParameters = function () { return [
-            { type: undefined, decorators: [{ type: core.Inject, args: [NGXS_STORAGE_PLUGIN_OPTIONS,] }] },
-            { type: undefined, decorators: [{ type: core.Inject, args: [STORAGE_ENGINE,] }] },
-            { type: String, decorators: [{ type: core.Inject, args: [core.PLATFORM_ID,] }] }
-        ]; };
-        return NgxsStoragePlugin;
-    }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        NgxsStoragePlugin.prototype._options;
-        /**
-         * @type {?}
-         * @private
-         */
-        NgxsStoragePlugin.prototype._engine;
-        /**
-         * @type {?}
-         * @private
-         */
-        NgxsStoragePlugin.prototype._platformId;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var NgxsStoragePlugin = /** @class */ (function () {
+        function NgxsStoragePlugin(_options, _engine, _platformId) {
+            this._options = _options;
+            this._engine = _engine;
+            this._platformId = _platformId;
+            // We cast to `string[]` here as we're sure that this option has been
+            // transformed by the `storageOptionsFactory` function that provided token.
+            this._keys = (/** @type {?} */ (this._options.key));
+            // We default to `[DEFAULT_STATE_KEY]` if the user explicitly does not provide the `key` option.
+            this._usesDefaultStateKey = this._keys.length === 1 && this._keys[0] === DEFAULT_STATE_KEY;
+        }
+        /**
+         * @param {?} state
+         * @param {?} event
+         * @param {?} next
+         * @return {?}
+         */
+        NgxsStoragePlugin.prototype.handle = /**
+         * @param {?} state
+         * @param {?} event
+         * @param {?} next
+         * @return {?}
+         */
+        function (state, event, next) {
+            var _this = this;
+            var e_1, _a;
+            if (common.isPlatformServer(this._platformId) && this._engine === null) {
+                return next(state, event);
+            }
+            /** @type {?} */
+            var matches = store.actionMatcher(event);
+            /** @type {?} */
+            var isInitAction = matches(store.InitState);
+            /** @type {?} */
+            var isUpdateAction = matches(store.UpdateState);
+            /** @type {?} */
+            var isInitOrUpdateAction = isInitAction || isUpdateAction;
+            /** @type {?} */
+            var hasMigration = false;
+            if (isInitOrUpdateAction) {
+                /** @type {?} */
+                var addedStates = isUpdateAction && event.addedStates;
+                var _loop_1 = function (key) {
+                    // We're checking what states have been added by NGXS and if any of these states should be handled by
+                    // the storage plugin. For instance, we only want to deserialize the `auth` state, NGXS has added
+                    // the `user` state, the storage plugin will be rerun and will do redundant deserialization.
+                    // `usesDefaultStateKey` is necessary to check since `event.addedStates` never contains `@@STATE`.
+                    if (!this_1._usesDefaultStateKey && addedStates && !addedStates.hasOwnProperty(key)) {
+                        return "continue";
+                    }
+                    /** @type {?} */
+                    var storedValue = this_1._engine.getItem((/** @type {?} */ (key)));
+                    if (storedValue !== 'undefined' && storedValue != null) {
+                        try {
+                            /** @type {?} */
+                            var newVal = (/** @type {?} */ (this_1._options.deserialize))(storedValue);
+                            storedValue = (/** @type {?} */ (this_1._options.afterDeserialize))(newVal, key);
+                        }
+                        catch (_a) {
+                            // 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) {
+                                console.error("Error ocurred while deserializing the " + key + " store value, falling back to empty object, the value obtained from the store: ", storedValue);
+                            }
+                            storedValue = {};
+                        }
+                        if (this_1._options.migrations) {
+                            this_1._options.migrations.forEach((/**
+                             * @param {?} strategy
+                             * @return {?}
+                             */
+                            function (strategy) {
+                                /** @type {?} */
+                                var versionMatch = strategy.version === store.getValue(storedValue, strategy.versionKey || 'version');
+                                /** @type {?} */
+                                var keyMatch = (!strategy.key && _this._usesDefaultStateKey) || strategy.key === key;
+                                if (versionMatch && keyMatch) {
+                                    storedValue = strategy.migrate(storedValue);
+                                    hasMigration = true;
+                                }
+                            }));
+                        }
+                        if (!this_1._usesDefaultStateKey) {
+                            state = store.setValue(state, (/** @type {?} */ (key)), storedValue);
+                        }
+                        else {
+                            // The `UpdateState` action is dispatched whenever the feature state is added.
+                            // The below condition is met only when the `UpdateState` is dispatched.
+                            // Let's assume that we have 2 states `counter` and `@ngxs/router-plugin` state.
+                            // `CounterState` is provided on the root level when calling `NgxsModule.forRoot()`
+                            // and `@ngxs/router-plugin` is provided as a feature state.
+                            // The storage plugin may save the `counter` state value as `10` before.
+                            // The `CounterState` may implement the `ngxsOnInit` hook and call `ctx.setState(999)`.
+                            // The storage plugin will re-hydrate the whole state when the `RouterState` is registered,
+                            // and the `counter` state will again equal `10` (not `999`).
+                            if (storedValue && addedStates && Object.keys(addedStates).length > 0) {
+                                storedValue = Object.keys(addedStates).reduce((/**
+                                 * @param {?} accumulator
+                                 * @param {?} addedState
+                                 * @return {?}
+                                 */
+                                function (accumulator, addedState) {
+                                    // The `storedValue` may equal the whole state (when the default state key is used).
+                                    // If `addedStates` contains only `router` then we want to merge the state only
+                                    // with the `router` value.
+                                    // Let's assume that the `storedValue` is an object:
+                                    // `{ counter: 10, router: {...} }`
+                                    // This will pick only the `router` object from the `storedValue` and `counter`
+                                    // state will not be re-hydrated unnecessary.
+                                    if (storedValue.hasOwnProperty(addedState)) {
+                                        accumulator[addedState] = storedValue[addedState];
+                                    }
+                                    return accumulator;
+                                }), (/** @type {?} */ ({})));
+                            }
+                            state = __assign({}, state, storedValue);
+                        }
+                    }
+                };
+                var this_1 = this;
+                try {
+                    for (var _b = __values(this._keys), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var key = _c.value;
+                        _loop_1(key);
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            return next(state, event).pipe(operators.tap((/**
+             * @param {?} nextState
+             * @return {?}
+             */
+            function (nextState) {
+                var e_2, _a;
+                if (!isInitOrUpdateAction || (isInitOrUpdateAction && hasMigration)) {
+                    try {
+                        for (var _b = __values(_this._keys), _c = _b.next(); !_c.done; _c = _b.next()) {
+                            var key = _c.value;
+                            /** @type {?} */
+                            var val = nextState;
+                            if (key !== DEFAULT_STATE_KEY) {
+                                val = store.getValue(nextState, (/** @type {?} */ (key)));
+                            }
+                            try {
+                                /** @type {?} */
+                                var newVal = (/** @type {?} */ (_this._options.beforeSerialize))(val, key);
+                                _this._engine.setItem((/** @type {?} */ (key)), (/** @type {?} */ (_this._options.serialize))(newVal));
+                            }
+                            catch (error) {
+                                // Caretaker note: we have still left the `typeof` condition in order to avoid
+                                // creating a breaking change for projects that still use the View Engine.
+                                if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                                    if (error &&
+                                        (error.name === 'QuotaExceededError' ||
+                                            error.name === 'NS_ERROR_DOM_QUOTA_REACHED')) {
+                                        console.error("The " + key + " store value exceeds the browser storage quota: ", val);
+                                    }
+                                    else {
+                                        console.error("Error ocurred while serializing the " + key + " store value, value not updated, the value obtained from the store: ", val);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            })));
+        };
+        NgxsStoragePlugin.decorators = [
+            { type: core.Injectable }
+        ];
+        /** @nocollapse */
+        NgxsStoragePlugin.ctorParameters = function () { return [
+            { type: undefined, decorators: [{ type: core.Inject, args: [NGXS_STORAGE_PLUGIN_OPTIONS,] }] },
+            { type: undefined, decorators: [{ type: core.Inject, args: [STORAGE_ENGINE,] }] },
+            { type: String, decorators: [{ type: core.Inject, args: [core.PLATFORM_ID,] }] }
+        ]; };
+        return NgxsStoragePlugin;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        NgxsStoragePlugin.prototype._keys;
+        /**
+         * @type {?}
+         * @private
+         */
+        NgxsStoragePlugin.prototype._usesDefaultStateKey;
+        /**
+         * @type {?}
+         * @private
+         */
+        NgxsStoragePlugin.prototype._options;
+        /**
+         * @type {?}
+         * @private
+         */
+        NgxsStoragePlugin.prototype._engine;
+        /**
+         * @type {?}
+         * @private
+         */
+        NgxsStoragePlugin.prototype._platformId;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
-    var USER_OPTIONS = new core.InjectionToken('USER_OPTIONS');
-    var NgxsStoragePluginModule = /** @class */ (function () {
-        function NgxsStoragePluginModule() {
-        }
-        /**
-         * @param {?=} options
-         * @return {?}
-         */
-        NgxsStoragePluginModule.forRoot = /**
-         * @param {?=} options
-         * @return {?}
-         */
-        function (options) {
-            return {
-                ngModule: NgxsStoragePluginModule,
-                providers: [
-                    {
-                        provide: store.NGXS_PLUGINS,
-                        useClass: NgxsStoragePlugin,
-                        multi: true
-                    },
-                    {
-                        provide: USER_OPTIONS,
-                        useValue: options
-                    },
-                    {
-                        provide: NGXS_STORAGE_PLUGIN_OPTIONS,
-                        useFactory: storageOptionsFactory,
-                        deps: [USER_OPTIONS]
-                    },
-                    {
-                        provide: STORAGE_ENGINE,
-                        useFactory: engineFactory,
-                        deps: [NGXS_STORAGE_PLUGIN_OPTIONS, core.PLATFORM_ID]
-                    }
-                ]
-            };
-        };
-        NgxsStoragePluginModule.decorators = [
-            { type: core.NgModule }
-        ];
-        return NgxsStoragePluginModule;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var USER_OPTIONS = new core.InjectionToken('USER_OPTIONS');
+    var NgxsStoragePluginModule = /** @class */ (function () {
+        function NgxsStoragePluginModule() {
+        }
+        /**
+         * @param {?=} options
+         * @return {?}
+         */
+        NgxsStoragePluginModule.forRoot = /**
+         * @param {?=} options
+         * @return {?}
+         */
+        function (options) {
+            return {
+                ngModule: NgxsStoragePluginModule,
+                providers: [
+                    {
+                        provide: store.NGXS_PLUGINS,
+                        useClass: NgxsStoragePlugin,
+                        multi: true
+                    },
+                    {
+                        provide: USER_OPTIONS,
+                        useValue: options
+                    },
+                    {
+                        provide: NGXS_STORAGE_PLUGIN_OPTIONS,
+                        useFactory: storageOptionsFactory,
+                        deps: [USER_OPTIONS]
+                    },
+                    {
+                        provide: STORAGE_ENGINE,
+                        useFactory: engineFactory,
+                        deps: [NGXS_STORAGE_PLUGIN_OPTIONS, core.PLATFORM_ID]
+                    }
+                ]
+            };
+        };
+        NgxsStoragePluginModule.decorators = [
+            { type: core.NgModule }
+        ];
+        return NgxsStoragePluginModule;
     }());
 
     exports.NGXS_STORAGE_PLUGIN_OPTIONS = NGXS_STORAGE_PLUGIN_OPTIONS;