@ngxs/store 3.7.3-dev.master-10b0883 → 3.7.4

package/esm2015/src/internal/lifecycle-state-manager.js

@@ -1,129 +1,129 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-import { Injectable } from '@angular/core';
-import { NgxsBootstrapper } from '@ngxs/store/internals';
-import { filter, mergeMap, tap } from 'rxjs/operators';
-import { StateContextFactory } from './state-context-factory';
-import { InternalStateOperations } from './state-operations';
-import { getStateDiffChanges } from './internals';
-export class LifecycleStateManager {
-    /**
-     * @param {?} internalStateOperations
-     * @param {?} stateContextFactory
-     * @param {?} bootstrapper
-     */
-    constructor(internalStateOperations, stateContextFactory, bootstrapper) {
-        this.internalStateOperations = internalStateOperations;
-        this.stateContextFactory = stateContextFactory;
-        this.bootstrapper = bootstrapper;
-    }
-    /**
-     * @template T
-     * @param {?} action
-     * @param {?} results
-     * @return {?}
-     */
-    ngxsBootstrap(action, results) {
-        this.internalStateOperations
-            .getRootStateOperations()
-            .dispatch(action)
-            .pipe(filter((/**
-         * @return {?}
-         */
-        () => !!results)), tap((/**
-         * @return {?}
-         */
-        () => this.invokeInit((/** @type {?} */ (results)).states))), mergeMap((/**
-         * @return {?}
-         */
-        () => this.bootstrapper.appBootstrapped$)), filter((/**
-         * @param {?} appBootstrapped
-         * @return {?}
-         */
-        appBootstrapped => !!appBootstrapped)))
-            .subscribe((/**
-         * @return {?}
-         */
-        () => this.invokeBootstrap((/** @type {?} */ (results)).states)));
-    }
-    /**
-     * Invoke the init function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    invokeInit(mappedStores) {
-        for (const mappedStore of mappedStores) {
-            /** @type {?} */
-            const instance = mappedStore.instance;
-            if (instance.ngxsOnChanges) {
-                /** @type {?} */
-                const currentAppState = {};
-                /** @type {?} */
-                const newAppState = this.internalStateOperations
-                    .getRootStateOperations()
-                    .getState();
-                /** @type {?} */
-                const firstDiffChange = getStateDiffChanges(mappedStore, {
-                    currentAppState,
-                    newAppState
-                });
-                instance.ngxsOnChanges(firstDiffChange);
-            }
-            if (instance.ngxsOnInit) {
-                instance.ngxsOnInit(this.getStateContext(mappedStore));
-            }
-            mappedStore.isInitialised = true;
-        }
-    }
-    /**
-     * Invoke the bootstrap function on the states.
-     * @param {?} mappedStores
-     * @return {?}
-     */
-    invokeBootstrap(mappedStores) {
-        for (const mappedStore of mappedStores) {
-            /** @type {?} */
-            const instance = mappedStore.instance;
-            if (instance.ngxsAfterBootstrap) {
-                instance.ngxsAfterBootstrap(this.getStateContext(mappedStore));
-            }
-        }
-    }
-    /**
-     * @private
-     * @param {?} mappedStore
-     * @return {?}
-     */
-    getStateContext(mappedStore) {
-        return this.stateContextFactory.createStateContext(mappedStore);
-    }
-}
-LifecycleStateManager.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-LifecycleStateManager.ctorParameters = () => [
-    { type: InternalStateOperations },
-    { type: StateContextFactory },
-    { type: NgxsBootstrapper }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype.internalStateOperations;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype.stateContextFactory;
-    /**
-     * @type {?}
-     * @private
-     */
-    LifecycleStateManager.prototype.bootstrapper;
-}
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+import { NgxsBootstrapper } from '@ngxs/store/internals';
+import { filter, mergeMap, tap } from 'rxjs/operators';
+import { StateContextFactory } from './state-context-factory';
+import { InternalStateOperations } from './state-operations';
+import { getStateDiffChanges } from './internals';
+export class LifecycleStateManager {
+    /**
+     * @param {?} internalStateOperations
+     * @param {?} stateContextFactory
+     * @param {?} bootstrapper
+     */
+    constructor(internalStateOperations, stateContextFactory, bootstrapper) {
+        this.internalStateOperations = internalStateOperations;
+        this.stateContextFactory = stateContextFactory;
+        this.bootstrapper = bootstrapper;
+    }
+    /**
+     * @template T
+     * @param {?} action
+     * @param {?} results
+     * @return {?}
+     */
+    ngxsBootstrap(action, results) {
+        this.internalStateOperations
+            .getRootStateOperations()
+            .dispatch(action)
+            .pipe(filter((/**
+         * @return {?}
+         */
+        () => !!results)), tap((/**
+         * @return {?}
+         */
+        () => this.invokeInit((/** @type {?} */ (results)).states))), mergeMap((/**
+         * @return {?}
+         */
+        () => this.bootstrapper.appBootstrapped$)), filter((/**
+         * @param {?} appBootstrapped
+         * @return {?}
+         */
+        appBootstrapped => !!appBootstrapped)))
+            .subscribe((/**
+         * @return {?}
+         */
+        () => this.invokeBootstrap((/** @type {?} */ (results)).states)));
+    }
+    /**
+     * Invoke the init function on the states.
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    invokeInit(mappedStores) {
+        for (const mappedStore of mappedStores) {
+            /** @type {?} */
+            const instance = mappedStore.instance;
+            if (instance.ngxsOnChanges) {
+                /** @type {?} */
+                const currentAppState = {};
+                /** @type {?} */
+                const newAppState = this.internalStateOperations
+                    .getRootStateOperations()
+                    .getState();
+                /** @type {?} */
+                const firstDiffChange = getStateDiffChanges(mappedStore, {
+                    currentAppState,
+                    newAppState
+                });
+                instance.ngxsOnChanges(firstDiffChange);
+            }
+            if (instance.ngxsOnInit) {
+                instance.ngxsOnInit(this.getStateContext(mappedStore));
+            }
+            mappedStore.isInitialised = true;
+        }
+    }
+    /**
+     * Invoke the bootstrap function on the states.
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    invokeBootstrap(mappedStores) {
+        for (const mappedStore of mappedStores) {
+            /** @type {?} */
+            const instance = mappedStore.instance;
+            if (instance.ngxsAfterBootstrap) {
+                instance.ngxsAfterBootstrap(this.getStateContext(mappedStore));
+            }
+        }
+    }
+    /**
+     * @private
+     * @param {?} mappedStore
+     * @return {?}
+     */
+    getStateContext(mappedStore) {
+        return this.stateContextFactory.createStateContext(mappedStore);
+    }
+}
+LifecycleStateManager.decorators = [
+    { type: Injectable }
+];
+/** @nocollapse */
+LifecycleStateManager.ctorParameters = () => [
+    { type: InternalStateOperations },
+    { type: StateContextFactory },
+    { type: NgxsBootstrapper }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype.internalStateOperations;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype.stateContextFactory;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype.bootstrapper;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/src/internal/state-context-factory.js

@@ -1,138 +1,138 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-import { Injectable } from '@angular/core';
-import { getStateDiffChanges } from '../internal/internals';
-import { setValue, getValue } from '../utils/utils';
-import { InternalStateOperations } from '../internal/state-operations';
-import { simplePatch } from './state-operators';
-/**
- * State Context factory class
- * @ignore
- */
-export class StateContextFactory {
-    /**
-     * @param {?} _internalStateOperations
-     */
-    constructor(_internalStateOperations) {
-        this._internalStateOperations = _internalStateOperations;
-    }
-    /**
-     * Create the state context
-     * @template T
-     * @param {?} mappedStore
-     * @return {?}
-     */
-    createStateContext(mappedStore) {
-        /** @type {?} */
-        const root = this._internalStateOperations.getRootStateOperations();
-        /**
-         * @param {?} currentAppState
-         * @return {?}
-         */
-        function getState(currentAppState) {
-            return getValue(currentAppState, mappedStore.path);
-        }
-        /**
-         * @param {?} currentAppState
-         * @param {?} newValue
-         * @return {?}
-         */
-        function setStateValue(currentAppState, newValue) {
-            /** @type {?} */
-            const newAppState = setValue(currentAppState, mappedStore.path, newValue);
-            /** @type {?} */
-            const instance = mappedStore.instance;
-            if (instance.ngxsOnChanges) {
-                /** @type {?} */
-                const change = getStateDiffChanges(mappedStore, {
-                    currentAppState,
-                    newAppState
-                });
-                instance.ngxsOnChanges(change);
-            }
-            root.setState(newAppState);
-            return newAppState;
-            // In doing this refactoring I noticed that there is a 'bug' where the
-            // application state is returned instead of this state slice.
-            // This has worked this way since the beginning see:
-            // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts
-            // This needs to be fixed, but is a 'breaking' change.
-            // I will do this fix in a subsequent PR and we can decide how to handle it.
-        }
-        /**
-         * @param {?} currentAppState
-         * @param {?} stateOperator
-         * @return {?}
-         */
-        function setStateFromOperator(currentAppState, stateOperator) {
-            /** @type {?} */
-            const local = getState(currentAppState);
-            /** @type {?} */
-            const newValue = stateOperator(local);
-            return setStateValue(currentAppState, newValue);
-        }
-        /**
-         * @param {?} value
-         * @return {?}
-         */
-        function isStateOperator(value) {
-            return typeof value === 'function';
-        }
-        return {
-            /**
-             * @return {?}
-             */
-            getState() {
-                /** @type {?} */
-                const currentAppState = root.getState();
-                return getState(currentAppState);
-            },
-            /**
-             * @param {?} val
-             * @return {?}
-             */
-            patchState(val) {
-                /** @type {?} */
-                const currentAppState = root.getState();
-                /** @type {?} */
-                const patchOperator = simplePatch(val);
-                return setStateFromOperator(currentAppState, patchOperator);
-            },
-            /**
-             * @param {?} val
-             * @return {?}
-             */
-            setState(val) {
-                /** @type {?} */
-                const currentAppState = root.getState();
-                return isStateOperator(val)
-                    ? setStateFromOperator(currentAppState, val)
-                    : setStateValue(currentAppState, val);
-            },
-            /**
-             * @param {?} actions
-             * @return {?}
-             */
-            dispatch(actions) {
-                return root.dispatch(actions);
-            }
-        };
-    }
-}
-StateContextFactory.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-StateContextFactory.ctorParameters = () => [
-    { type: InternalStateOperations }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    StateContextFactory.prototype._internalStateOperations;
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGUtY29udGV4dC1mYWN0b3J5LmpzIiwic291cmNlUm9vdCI6Im5nOi8vQG5neHMvc3RvcmUvIiwic291cmNlcyI6WyJzcmMvaW50ZXJuYWwvc3RhdGUtY29udGV4dC1mYWN0b3J5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7QUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBSTNDLE9BQU8sRUFBRSxtQkFBbUIsRUFBZSxNQUFNLHVCQUF1QixDQUFDO0FBQ3pFLE9BQU8sRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDcEQsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDdkUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG1CQUFtQixDQUFDOzs7OztBQU9oRCxNQUFNLE9BQU8sbUJBQW1COzs7O0lBQzlCLFlBQW9CLHdCQUFpRDtRQUFqRCw2QkFBd0IsR0FBeEIsd0JBQXdCLENBQXlCO0lBQUcsQ0FBQzs7Ozs7OztJQUt6RSxrQkFBa0IsQ0FBSSxXQUF3Qjs7Y0FDdEMsSUFBSSxHQUFHLElBQUksQ0FBQyx3QkFBd0IsQ0FBQyxzQkFBc0IsRUFBRTs7Ozs7UUFFbkUsU0FBUyxRQUFRLENBQUMsZUFBb0I7WUFDcEMsT0FBTyxRQUFRLENBQUMsZUFBZSxFQUFFLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUNyRCxDQUFDOzs7Ozs7UUFFRCxTQUFTLGFBQWEsQ0FBQyxlQUFvQixFQUFFLFFBQVc7O2tCQUNoRCxXQUFXLEdBQUcsUUFBUSxDQUFDLGVBQWUsRUFBRSxXQUFXLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQzs7a0JBQ25FLFFBQVEsR0FBa0IsV0FBVyxDQUFDLFFBQVE7WUFFcEQsSUFBSSxRQUFRLENBQUMsYUFBYSxFQUFFOztzQkFDcEIsTUFBTSxHQUFxQixtQkFBbUIsQ0FBSSxXQUFXLEVBQUU7b0JBQ25FLGVBQWU7b0JBQ2YsV0FBVztpQkFDWixDQUFDO2dCQUVGLFFBQVEsQ0FBQyxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUM7YUFDaEM7WUFFRCxJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxDQUFDO1lBQzNCLE9BQU8sV0FBVyxDQUFDO1lBQ25CLHNFQUFzRTtZQUN0RSw2REFBNkQ7WUFDN0Qsb0RBQW9EO1lBQ3BELG9HQUFvRztZQUNwRyxzREFBc0Q7WUFDdEQsNEVBQTRFO1FBQzlFLENBQUM7Ozs7OztRQUVELFNBQVMsb0JBQW9CLENBQUMsZUFBb0IsRUFBRSxhQUErQjs7a0JBQzNFLEtBQUssR0FBRyxRQUFRLENBQUMsZUFBZSxDQUFDOztrQkFDakMsUUFBUSxHQUFHLGFBQWEsQ0FBQyxLQUFLLENBQUM7WUFDckMsT0FBTyxhQUFhLENBQUMsZUFBZSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ2xELENBQUM7Ozs7O1FBRUQsU0FBUyxlQUFlLENBQUMsS0FBMkI7WUFDbEQsT0FBTyxPQUFPLEtBQUssS0FBSyxVQUFVLENBQUM7UUFDckMsQ0FBQztRQUVELE9BQU87Ozs7WUFDTCxRQUFROztzQkFDQSxlQUFlLEdBQUcsSUFBSSxDQUFDLFFBQVEsRUFBRTtnQkFDdkMsT0FBTyxRQUFRLENBQUMsZUFBZSxDQUFDLENBQUM7WUFDbkMsQ0FBQzs7Ozs7WUFDRCxVQUFVLENBQUMsR0FBZTs7c0JBQ2xCLGVBQWUsR0FBRyxJQUFJLENBQUMsUUFBUSxFQUFFOztzQkFDakMsYUFBYSxHQUFHLFdBQVcsQ0FBSSxHQUFHLENBQUM7Z0JBQ3pDLE9BQU8sb0JBQW9CLENBQUMsZUFBZSxFQUFFLGFBQWEsQ0FBQyxDQUFDO1lBQzlELENBQUM7Ozs7O1lBQ0QsUUFBUSxDQUFDLEdBQXlCOztzQkFDMUIsZUFBZSxHQUFHLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0JBQ3ZDLE9BQU8sZUFBZSxDQUFDLEdBQUcsQ0FBQztvQkFDekIsQ0FBQyxDQUFDLG9CQUFvQixDQUFDLGVBQWUsRUFBRSxHQUFHLENBQUM7b0JBQzVDLENBQUMsQ0FBQyxhQUFhLENBQUMsZUFBZSxFQUFFLEdBQUcsQ0FBQyxDQUFDO1lBQzFDLENBQUM7Ozs7O1lBQ0QsUUFBUSxDQUFDLE9BQW9CO2dCQUMzQixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLENBQUM7WUFDaEMsQ0FBQztTQUNGLENBQUM7SUFDSixDQUFDOzs7WUFuRUYsVUFBVTs7OztZQVBGLHVCQUF1Qjs7Ozs7OztJQVNsQix1REFBeUQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcyc7XG5cbmltcG9ydCB7IE5neHNMaWZlQ3ljbGUsIE5neHNTaW1wbGVDaGFuZ2UsIFN0YXRlQ29udGV4dCwgU3RhdGVPcGVyYXRvciB9IGZyb20gJy4uL3N5bWJvbHMnO1xuaW1wb3J0IHsgZ2V0U3RhdGVEaWZmQ2hhbmdlcywgTWFwcGVkU3RvcmUgfSBmcm9tICcuLi9pbnRlcm5hbC9pbnRlcm5hbHMnO1xuaW1wb3J0IHsgc2V0VmFsdWUsIGdldFZhbHVlIH0gZnJvbSAnLi4vdXRpbHMvdXRpbHMnO1xuaW1wb3J0IHsgSW50ZXJuYWxTdGF0ZU9wZXJhdGlvbnMgfSBmcm9tICcuLi9pbnRlcm5hbC9zdGF0ZS1vcGVyYXRpb25zJztcbmltcG9ydCB7IHNpbXBsZVBhdGNoIH0gZnJvbSAnLi9zdGF0ZS1vcGVyYXRvcnMnO1xuXG4vKipcbiAqIFN0YXRlIENvbnRleHQgZmFjdG9yeSBjbGFzc1xuICogQGlnbm9yZVxuICovXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgU3RhdGVDb250ZXh0RmFjdG9yeSB7XG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX2ludGVybmFsU3RhdGVPcGVyYXRpb25zOiBJbnRlcm5hbFN0YXRlT3BlcmF0aW9ucykge31cblxuICAvKipcbiAgICogQ3JlYXRlIHRoZSBzdGF0ZSBjb250ZXh0XG4gICAqL1xuICBjcmVhdGVTdGF0ZUNvbnRleHQ8VD4obWFwcGVkU3RvcmU6IE1hcHBlZFN0b3JlKTogU3RhdGVDb250ZXh0PFQ+IHtcbiAgICBjb25zdCByb290ID0gdGhpcy5faW50ZXJuYWxTdGF0ZU9wZXJhdGlvbnMuZ2V0Um9vdFN0YXRlT3BlcmF0aW9ucygpO1xuXG4gICAgZnVuY3Rpb24gZ2V0U3RhdGUoY3VycmVudEFwcFN0YXRlOiBhbnkpOiBUIHtcbiAgICAgIHJldHVybiBnZXRWYWx1ZShjdXJyZW50QXBwU3RhdGUsIG1hcHBlZFN0b3JlLnBhdGgpO1xuICAgIH1cblxuICAgIGZ1bmN0aW9uIHNldFN0YXRlVmFsdWUoY3VycmVudEFwcFN0YXRlOiBhbnksIG5ld1ZhbHVlOiBUKTogYW55IHtcbiAgICAgIGNvbnN0IG5ld0FwcFN0YXRlID0gc2V0VmFsdWUoY3VycmVudEFwcFN0YXRlLCBtYXBwZWRTdG9yZS5wYXRoLCBuZXdWYWx1ZSk7XG4gICAgICBjb25zdCBpbnN0YW5jZTogTmd4c0xpZmVDeWNsZSA9IG1hcHBlZFN0b3JlLmluc3RhbmNlO1xuXG4gICAgICBpZiAoaW5zdGFuY2Uubmd4c09uQ2hhbmdlcykge1xuICAgICAgICBjb25zdCBjaGFuZ2U6IE5neHNTaW1wbGVDaGFuZ2UgPSBnZXRTdGF0ZURpZmZDaGFuZ2VzPFQ+KG1hcHBlZFN0b3JlLCB7XG4gICAgICAgICAgY3VycmVudEFwcFN0YXRlLFxuICAgICAgICAgIG5ld0FwcFN0YXRlXG4gICAgICAgIH0pO1xuXG4gICAgICAgIGluc3RhbmNlLm5neHNPbkNoYW5nZXMoY2hhbmdlKTtcbiAgICAgIH1cblxuICAgICAgcm9vdC5zZXRTdGF0ZShuZXdBcHBTdGF0ZSk7XG4gICAgICByZXR1cm4gbmV3QXBwU3RhdGU7XG4gICAgICAvLyBJbiBkb2luZyB0aGlzIHJlZmFjdG9yaW5nIEkgbm90aWNlZCB0aGF0IHRoZXJlIGlzIGEgJ2J1Zycgd2hlcmUgdGhlXG4gICAgICAvLyBhcHBsaWNhdGlvbiBzdGF0ZSBpcyByZXR1cm5lZCBpbnN0ZWFkIG9mIHRoaXMgc3RhdGUgc2xpY2UuXG4gICAgICAvLyBUaGlzIGhhcyB3b3JrZWQgdGhpcyB3YXkgc2luY2UgdGhlIGJlZ2lubmluZyBzZWU6XG4gICAgICAvLyBodHRwczovL2dpdGh1Yi5jb20vbmd4cy9zdG9yZS9ibGFtZS8zMjRjNjY3YjRiN2RlYmQ4ZWI5NzkwMDZjNjdjYTBhZTM0N2Q4OGNkL3NyYy9zdGF0ZS1mYWN0b3J5LnRzXG4gICAgICAvLyBUaGlzIG5lZWRzIHRvIGJlIGZpeGVkLCBidXQgaXMgYSAnYnJlYWtpbmcnIGNoYW5nZS5cbiAgICAgIC8vIEkgd2lsbCBkbyB0aGlzIGZpeCBpbiBhIHN1YnNlcXVlbnQgUFIgYW5kIHdlIGNhbiBkZWNpZGUgaG93IHRvIGhhbmRsZSBpdC5cbiAgICB9XG5cbiAgICBmdW5jdGlvbiBzZXRTdGF0ZUZyb21PcGVyYXRvcihjdXJyZW50QXBwU3RhdGU6IGFueSwgc3RhdGVPcGVyYXRvcjogU3RhdGVPcGVyYXRvcjxUPikge1xuICAgICAgY29uc3QgbG9jYWwgPSBnZXRTdGF0ZShjdXJyZW50QXBwU3RhdGUpO1xuICAgICAgY29uc3QgbmV3VmFsdWUgPSBzdGF0ZU9wZXJhdG9yKGxvY2FsKTtcbiAgICAgIHJldHVybiBzZXRTdGF0ZVZhbHVlKGN1cnJlbnRBcHBTdGF0ZSwgbmV3VmFsdWUpO1xuICAgIH1cblxuICAgIGZ1bmN0aW9uIGlzU3RhdGVPcGVyYXRvcih2YWx1ZTogVCB8IFN0YXRlT3BlcmF0b3I8VD4pOiB2YWx1ZSBpcyBTdGF0ZU9wZXJhdG9yPFQ+IHtcbiAgICAgIHJldHVybiB0eXBlb2YgdmFsdWUgPT09ICdmdW5jdGlvbic7XG4gICAgfVxuXG4gICAgcmV0dXJuIHtcbiAgICAgIGdldFN0YXRlKCk6IFQge1xuICAgICAgICBjb25zdCBjdXJyZW50QXBwU3RhdGUgPSByb290LmdldFN0YXRlKCk7XG4gICAgICAgIHJldHVybiBnZXRTdGF0ZShjdXJyZW50QXBwU3RhdGUpO1xuICAgICAgfSxcbiAgICAgIHBhdGNoU3RhdGUodmFsOiBQYXJ0aWFsPFQ+KTogVCB7XG4gICAgICAgIGNvbnN0IGN1cnJlbnRBcHBTdGF0ZSA9IHJvb3QuZ2V0U3RhdGUoKTtcbiAgICAgICAgY29uc3QgcGF0Y2hPcGVyYXRvciA9IHNpbXBsZVBhdGNoPFQ+KHZhbCk7XG4gICAgICAgIHJldHVybiBzZXRTdGF0ZUZyb21PcGVyYXRvcihjdXJyZW50QXBwU3RhdGUsIHBhdGNoT3BlcmF0b3IpO1xuICAgICAgfSxcbiAgICAgIHNldFN0YXRlKHZhbDogVCB8IFN0YXRlT3BlcmF0b3I8VD4pOiBUIHtcbiAgICAgICAgY29uc3QgY3VycmVudEFwcFN0YXRlID0gcm9vdC5nZXRTdGF0ZSgpO1xuICAgICAgICByZXR1cm4gaXNTdGF0ZU9wZXJhdG9yKHZhbClcbiAgICAgICAgICA/IHNldFN0YXRlRnJvbU9wZXJhdG9yKGN1cnJlbnRBcHBTdGF0ZSwgdmFsKVxuICAgICAgICAgIDogc2V0U3RhdGVWYWx1ZShjdXJyZW50QXBwU3RhdGUsIHZhbCk7XG4gICAgICB9LFxuICAgICAgZGlzcGF0Y2goYWN0aW9uczogYW55IHwgYW55W10pOiBPYnNlcnZhYmxlPHZvaWQ+IHtcbiAgICAgICAgcmV0dXJuIHJvb3QuZGlzcGF0Y2goYWN0aW9ucyk7XG4gICAgICB9XG4gICAgfTtcbiAgfVxufVxuIl19
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import { Injectable } from '@angular/core';
+import { getStateDiffChanges } from '../internal/internals';
+import { setValue, getValue } from '../utils/utils';
+import { InternalStateOperations } from '../internal/state-operations';
+import { simplePatch } from './state-operators';
+/**
+ * State Context factory class
+ * @ignore
+ */
+export class StateContextFactory {
+    /**
+     * @param {?} _internalStateOperations
+     */
+    constructor(_internalStateOperations) {
+        this._internalStateOperations = _internalStateOperations;
+    }
+    /**
+     * Create the state context
+     * @template T
+     * @param {?} mappedStore
+     * @return {?}
+     */
+    createStateContext(mappedStore) {
+        /** @type {?} */
+        const root = this._internalStateOperations.getRootStateOperations();
+        /**
+         * @param {?} currentAppState
+         * @return {?}
+         */
+        function getState(currentAppState) {
+            return getValue(currentAppState, mappedStore.path);
+        }
+        /**
+         * @param {?} currentAppState
+         * @param {?} newValue
+         * @return {?}
+         */
+        function setStateValue(currentAppState, newValue) {
+            /** @type {?} */
+            const newAppState = setValue(currentAppState, mappedStore.path, newValue);
+            /** @type {?} */
+            const instance = mappedStore.instance;
+            if (instance.ngxsOnChanges) {
+                /** @type {?} */
+                const change = getStateDiffChanges(mappedStore, {
+                    currentAppState,
+                    newAppState
+                });
+                instance.ngxsOnChanges(change);
+            }
+            root.setState(newAppState);
+            return newAppState;
+            // In doing this refactoring I noticed that there is a 'bug' where the
+            // application state is returned instead of this state slice.
+            // This has worked this way since the beginning see:
+            // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts
+            // This needs to be fixed, but is a 'breaking' change.
+            // I will do this fix in a subsequent PR and we can decide how to handle it.
+        }
+        /**
+         * @param {?} currentAppState
+         * @param {?} stateOperator
+         * @return {?}
+         */
+        function setStateFromOperator(currentAppState, stateOperator) {
+            /** @type {?} */
+            const local = getState(currentAppState);
+            /** @type {?} */
+            const newValue = stateOperator(local);
+            return setStateValue(currentAppState, newValue);
+        }
+        /**
+         * @param {?} value
+         * @return {?}
+         */
+        function isStateOperator(value) {
+            return typeof value === 'function';
+        }
+        return {
+            /**
+             * @return {?}
+             */
+            getState() {
+                /** @type {?} */
+                const currentAppState = root.getState();
+                return getState(currentAppState);
+            },
+            /**
+             * @param {?} val
+             * @return {?}
+             */
+            patchState(val) {
+                /** @type {?} */
+                const currentAppState = root.getState();
+                /** @type {?} */
+                const patchOperator = simplePatch(val);
+                return setStateFromOperator(currentAppState, patchOperator);
+            },
+            /**
+             * @param {?} val
+             * @return {?}
+             */
+            setState(val) {
+                /** @type {?} */
+                const currentAppState = root.getState();
+                return isStateOperator(val)
+                    ? setStateFromOperator(currentAppState, val)
+                    : setStateValue(currentAppState, val);
+            },
+            /**
+             * @param {?} actions
+             * @return {?}
+             */
+            dispatch(actions) {
+                return root.dispatch(actions);
+            }
+        };
+    }
+}
+StateContextFactory.decorators = [
+    { type: Injectable }
+];
+/** @nocollapse */
+StateContextFactory.ctorParameters = () => [
+    { type: InternalStateOperations }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    StateContextFactory.prototype._internalStateOperations;
+}
+//# sourceMappingURL=data:application/json;base64,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