@ngxs/store 3.7.5-dev.master-708406e → 3.7.5-dev.master-0da56b4

package/fesm2015/ngxs-store.js

@@ -2,7 +2,7 @@ import { NgZone, Injectable, Inject, PLATFORM_ID, defineInjectable, inject, Inje
 import { memoize, INITIAL_STATE_TOKEN, NgxsBootstrapper, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, InitialState } from '@ngxs/store/internals';
 import { isPlatformServer } from '@angular/common';
 import { Observable, Subject, BehaviorSubject, of, forkJoin, throwError, EMPTY, from, isObservable, queueScheduler } from 'rxjs';
-import { filter, map, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, tap, observeOn, distinctUntilChanged } from 'rxjs/operators';
+import { filter, map, shareReplay, take, exhaustMap, mergeMap, defaultIfEmpty, catchError, takeUntil, observeOn, distinctUntilChanged, tap, startWith, pairwise } from 'rxjs/operators';
 
 /**
  * @fileoverview added by tsickle
@@ -477,149 +477,6 @@ if (false) {
     NgxsExecutionStrategy.prototype.leave = function (func) { };
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * Returns the type from an action instance/class.
- * @ignore
- * @param {?} action
- * @return {?}
- */
-function getActionTypeFromInstance(action) {
-    if (action.constructor && action.constructor.type) {
-        return action.constructor.type;
-    }
-    else {
-        return action.type;
-    }
-}
-/**
- * Matches a action
- * @ignore
- * @param {?} action1
- * @return {?}
- */
-function actionMatcher(action1) {
-    /** @type {?} */
-    const type1 = getActionTypeFromInstance(action1);
-    return (/**
-     * @param {?} action2
-     * @return {?}
-     */
-    function (action2) {
-        return type1 === getActionTypeFromInstance(action2);
-    });
-}
-/**
- * Set a deeply nested value. Example:
- *
- *   setValue({ foo: { bar: { eat: false } } },
- *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
- *
- * While it traverses it also creates new objects from top down.
- *
- * @ignore
- * @type {?}
- */
-const setValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @param {?} val
- * @return {?}
- */
-(obj, prop, val) => {
-    obj = Object.assign({}, obj);
-    /** @type {?} */
-    const split = prop.split('.');
-    /** @type {?} */
-    const lastIndex = split.length - 1;
-    split.reduce((/**
-     * @param {?} acc
-     * @param {?} part
-     * @param {?} index
-     * @return {?}
-     */
-    (acc, part, index) => {
-        if (index === lastIndex) {
-            acc[part] = val;
-        }
-        else {
-            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : Object.assign({}, acc[part]);
-        }
-        return acc && acc[part];
-    }), obj);
-    return obj;
-});
-/**
- * Get a deeply nested value. Example:
- *
- *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
- *
- * @ignore
- * @type {?}
- */
-const getValue = (/**
- * @param {?} obj
- * @param {?} prop
- * @return {?}
- */
-(obj, prop) => prop.split('.').reduce((/**
- * @param {?} acc
- * @param {?} part
- * @return {?}
- */
-(acc, part) => acc && acc[part]), obj));
-/**
- * Simple object check.
- *
- *    isObject({a:1}) //=> true
- *    isObject(1) //=> false
- *
- * @ignore
- * @type {?}
- */
-const isObject = (/**
- * @param {?} item
- * @return {?}
- */
-(item) => {
-    return item && typeof item === 'object' && !Array.isArray(item);
-});
-/**
- * Deep merge two objects.
- *
- *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
- *
- * \@param base base object onto which `sources` will be applied
- * @type {?}
- */
-const mergeDeep = (/**
- * @param {?} base
- * @param {...?} sources
- * @return {?}
- */
-(base, ...sources) => {
-    if (!sources.length)
-        return base;
-    /** @type {?} */
-    const source = sources.shift();
-    if (isObject(base) && isObject(source)) {
-        for (const key in source) {
-            if (isObject(source[key])) {
-                if (!base[key])
-                    Object.assign(base, { [key]: {} });
-                mergeDeep(base[key], source[key]);
-            }
-            else {
-                Object.assign(base, { [key]: source[key] });
-            }
-        }
-    }
-    return mergeDeep(base, ...sources);
-});
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -744,17 +601,6 @@ if (false) {
     /** @type {?} */
     StatesAndDefaults.prototype.states;
 }
-/**
- * @record
- * @template T
- */
-function RootStateDiff() { }
-if (false) {
-    /** @type {?} */
-    RootStateDiff.prototype.currentAppState;
-    /** @type {?} */
-    RootStateDiff.prototype.newAppState;
-}
 /**
  * Ensures metadata is attached to the class and returns it.
  *
@@ -1094,22 +940,152 @@ function topologicalSort(graph) {
  * @param {?} obj
  * @return {?}
  */
-function isObject$1(obj) {
+function isObject(obj) {
     return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';
 }
+
 /**
- * @template T
- * @param {?} mappedStore
- * @param {?} diff
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/**
+ * Returns the type from an action instance/class.
+ * @ignore
+ * @param {?} action
  * @return {?}
  */
-function getStateDiffChanges(mappedStore, diff) {
-    /** @type {?} */
-    const previousValue = getValue(diff.currentAppState, mappedStore.path);
+function getActionTypeFromInstance(action) {
+    if (action.constructor && action.constructor.type) {
+        return action.constructor.type;
+    }
+    else {
+        return action.type;
+    }
+}
+/**
+ * Matches a action
+ * @ignore
+ * @param {?} action1
+ * @return {?}
+ */
+function actionMatcher(action1) {
     /** @type {?} */
-    const currentValue = getValue(diff.newAppState, mappedStore.path);
-    return new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
+    const type1 = getActionTypeFromInstance(action1);
+    return (/**
+     * @param {?} action2
+     * @return {?}
+     */
+    function (action2) {
+        return type1 === getActionTypeFromInstance(action2);
+    });
 }
+/**
+ * Set a deeply nested value. Example:
+ *
+ *   setValue({ foo: { bar: { eat: false } } },
+ *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }
+ *
+ * While it traverses it also creates new objects from top down.
+ *
+ * @ignore
+ * @type {?}
+ */
+const setValue = (/**
+ * @param {?} obj
+ * @param {?} prop
+ * @param {?} val
+ * @return {?}
+ */
+(obj, prop, val) => {
+    obj = Object.assign({}, obj);
+    /** @type {?} */
+    const split = prop.split('.');
+    /** @type {?} */
+    const lastIndex = split.length - 1;
+    split.reduce((/**
+     * @param {?} acc
+     * @param {?} part
+     * @param {?} index
+     * @return {?}
+     */
+    (acc, part, index) => {
+        if (index === lastIndex) {
+            acc[part] = val;
+        }
+        else {
+            acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : Object.assign({}, acc[part]);
+        }
+        return acc && acc[part];
+    }), obj);
+    return obj;
+});
+/**
+ * Get a deeply nested value. Example:
+ *
+ *    getValue({ foo: bar: [] }, 'foo.bar') //=> []
+ *
+ * @ignore
+ * @type {?}
+ */
+const getValue = (/**
+ * @param {?} obj
+ * @param {?} prop
+ * @return {?}
+ */
+(obj, prop) => prop.split('.').reduce((/**
+ * @param {?} acc
+ * @param {?} part
+ * @return {?}
+ */
+(acc, part) => acc && acc[part]), obj));
+/**
+ * Simple object check.
+ *
+ *    isObject({a:1}) //=> true
+ *    isObject(1) //=> false
+ *
+ * @ignore
+ * @type {?}
+ */
+const isObject$1 = (/**
+ * @param {?} item
+ * @return {?}
+ */
+(item) => {
+    return item && typeof item === 'object' && !Array.isArray(item);
+});
+/**
+ * Deep merge two objects.
+ *
+ *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}
+ *
+ * \@param base base object onto which `sources` will be applied
+ * @type {?}
+ */
+const mergeDeep = (/**
+ * @param {?} base
+ * @param {...?} sources
+ * @return {?}
+ */
+(base, ...sources) => {
+    if (!sources.length)
+        return base;
+    /** @type {?} */
+    const source = sources.shift();
+    if (isObject$1(base) && isObject$1(source)) {
+        for (const key in source) {
+            if (isObject$1(source[key])) {
+                if (!base[key])
+                    Object.assign(base, { [key]: {} });
+                mergeDeep(base[key], source[key]);
+            }
+            else {
+                Object.assign(base, { [key]: source[key] });
+            }
+        }
+    }
+    return mergeDeep(base, ...sources);
+});
 
 /**
  * @fileoverview added by tsickle
@@ -1487,6 +1463,12 @@ if (false) {
  * Internal Action stream that is emitted anytime an action is dispatched.
  */
 class InternalActions extends OrderedSubject {
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this.complete();
+    }
 }
 InternalActions.decorators = [
     { type: Injectable }
@@ -2113,16 +2095,6 @@ class StateContextFactory {
         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
@@ -2405,7 +2377,7 @@ class StateFactory {
         if (Array.isArray(defaults)) {
             value = defaults.slice();
         }
-        else if (isObject$1(defaults)) {
+        else if (isObject(defaults)) {
             value = Object.assign({}, defaults);
         }
         else if (defaults === undefined) {
@@ -2735,129 +2707,6 @@ if (false) {
     StateFactory.prototype._initialState;
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-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;
-}
-
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
@@ -3255,6 +3104,155 @@ if (false) {
     Store.prototype._stateFactory;
 }
 
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+class LifecycleStateManager {
+    /**
+     * @param {?} _store
+     * @param {?} _internalStateOperations
+     * @param {?} _stateContextFactory
+     * @param {?} _bootstrapper
+     */
+    constructor(_store, _internalStateOperations, _stateContextFactory, _bootstrapper) {
+        this._store = _store;
+        this._internalStateOperations = _internalStateOperations;
+        this._stateContextFactory = _stateContextFactory;
+        this._bootstrapper = _bootstrapper;
+        this._destroy$ = new Subject();
+    }
+    /**
+     * @return {?}
+     */
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    /**
+     * @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)), takeUntil(this._destroy$))
+            .subscribe((/**
+         * @return {?}
+         */
+        () => this._invokeBootstrap((/** @type {?} */ (results)).states)));
+    }
+    /**
+     * Invoke the init function on the states.
+     * @private
+     * @param {?} mappedStores
+     * @return {?}
+     */
+    _invokeInit(mappedStores) {
+        for (const mappedStore of mappedStores) {
+            /** @type {?} */
+            const instance = mappedStore.instance;
+            if (instance.ngxsOnChanges) {
+                this._store
+                    .select((/**
+                 * @param {?} state
+                 * @return {?}
+                 */
+                state => getValue(state, mappedStore.path)))
+                    .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))
+                    .subscribe((/**
+                 * @param {?} __0
+                 * @return {?}
+                 */
+                ([previousValue, currentValue]) => {
+                    /** @type {?} */
+                    const change = new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);
+                    (/** @type {?} */ (instance.ngxsOnChanges))(change);
+                }));
+            }
+            if (instance.ngxsOnInit) {
+                instance.ngxsOnInit(this._getStateContext(mappedStore));
+            }
+            mappedStore.isInitialised = true;
+        }
+    }
+    /**
+     * Invoke the bootstrap function on the states.
+     * @private
+     * @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: Store },
+    { type: InternalStateOperations },
+    { type: StateContextFactory },
+    { type: NgxsBootstrapper }
+];
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._destroy$;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._store;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._internalStateOperations;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._stateContextFactory;
+    /**
+     * @type {?}
+     * @private
+     */
+    LifecycleStateManager.prototype._bootstrapper;
+}
+
 /**
  * @fileoverview added by tsickle
  * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc