@ngxs/store 3.7.2 → 3.7.3-dev.master-8834f50

package/bundles/ngxs-store-internals.umd.js

@@ -4,232 +4,443 @@
     (global = global || self, factory((global.ngxs = global.ngxs || {}, global.ngxs.store = global.ngxs.store || {}, global.ngxs.store.internals = {}), global.ng.core, global.rxjs));
 }(this, function (exports, core, rxjs) { 'use strict';
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @param {?} a
-     * @param {?} b
-     * @return {?}
-     */
-    function defaultEqualityCheck(a, b) {
-        return a === b;
-    }
-    /**
-     * @param {?} equalityCheck
-     * @param {?} prev
-     * @param {?} next
-     * @return {?}
-     */
-    function areArgumentsShallowlyEqual(equalityCheck, prev, next) {
-        if (prev === null || next === null || prev.length !== next.length) {
-            return false;
-        }
-        // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.
-        /** @type {?} */
-        var length = prev.length;
-        for (var i = 0; i < length; i++) {
-            if (!equalityCheck(prev[i], next[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    /**
-     * Memoize a function on its last inputs only.
-     * Originally from: https://github.com/reduxjs/reselect/blob/master/src/index.js
-     *
-     * @ignore
-     * @template T
-     * @param {?} func
-     * @param {?=} equalityCheck
-     * @return {?}
-     */
-    function memoize(func, equalityCheck) {
-        if (equalityCheck === void 0) { equalityCheck = defaultEqualityCheck; }
-        /** @type {?} */
-        var lastArgs = null;
-        /** @type {?} */
-        var lastResult = null;
-        // we reference arguments instead of spreading them for performance reasons
-        /**
-         * @return {?}
-         */
-        function memoized() {
-            if (!areArgumentsShallowlyEqual(equalityCheck, lastArgs, arguments)) {
-                // apply arguments instead of spreading for performance.
-                lastResult = ((/** @type {?} */ (func))).apply(null, arguments);
-            }
-            lastArgs = arguments;
-            return lastResult;
-        }
-        ((/** @type {?} */ (memoized))).reset = (/**
-         * @return {?}
-         */
-        function () {
-            // The hidden (for now) ability to reset the memoization
-            lastArgs = null;
-            lastResult = null;
-        });
-        return (/** @type {?} */ (memoized));
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @param {?} a
+     * @param {?} b
+     * @return {?}
+     */
+    function defaultEqualityCheck(a, b) {
+        return a === b;
+    }
+    /**
+     * @param {?} equalityCheck
+     * @param {?} prev
+     * @param {?} next
+     * @return {?}
+     */
+    function areArgumentsShallowlyEqual(equalityCheck, prev, next) {
+        if (prev === null || next === null || prev.length !== next.length) {
+            return false;
+        }
+        // Do this in a for loop (and not a `forEach` or an `every`) so we can determine equality as fast as possible.
+        /** @type {?} */
+        var length = prev.length;
+        for (var i = 0; i < length; i++) {
+            if (!equalityCheck(prev[i], next[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Memoize a function on its last inputs only.
+     * Originally from: https://github.com/reduxjs/reselect/blob/master/src/index.js
+     *
+     * @ignore
+     * @template T
+     * @param {?} func
+     * @param {?=} equalityCheck
+     * @return {?}
+     */
+    function memoize(func, equalityCheck) {
+        if (equalityCheck === void 0) { equalityCheck = defaultEqualityCheck; }
+        /** @type {?} */
+        var lastArgs = null;
+        /** @type {?} */
+        var lastResult = null;
+        // we reference arguments instead of spreading them for performance reasons
+        /**
+         * @return {?}
+         */
+        function memoized() {
+            if (!areArgumentsShallowlyEqual(equalityCheck, lastArgs, arguments)) {
+                // apply arguments instead of spreading for performance.
+                lastResult = ((/** @type {?} */ (func))).apply(null, arguments);
+            }
+            lastArgs = arguments;
+            return lastResult;
+        }
+        ((/** @type {?} */ (memoized))).reset = (/**
+         * @return {?}
+         */
+        function () {
+            // The hidden (for now) ability to reset the memoization
+            lastArgs = null;
+            lastResult = null;
+        });
+        return (/** @type {?} */ (memoized));
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @return {?}
-     */
-    function _isAngularInTestMode() {
-        /** @type {?} */
-        var platformRef = core.getPlatform();
-        if (!platformRef)
-            return false;
-        /** @type {?} */
-        var compilerOptions = platformRef.injector.get(core.COMPILER_OPTIONS, null);
-        if (!compilerOptions)
-            return false;
-        /** @type {?} */
-        var isInTestMode = compilerOptions.some((/**
-         * @param {?} item
-         * @return {?}
-         */
-        function (item) {
-            /** @type {?} */
-            var providers = (item && item.providers) || [];
-            return providers.some((/**
-             * @param {?} provider
-             * @return {?}
-             */
-            function (provider) {
-                return ((provider && provider.provide && provider.provide.name === 'MockNgModuleResolver') ||
-                    false);
-            }));
-        }));
-        return isInTestMode;
-    }
-    /** @type {?} */
-    var isAngularInTestMode = memoize(_isAngularInTestMode);
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @return {?}
+     */
+    function _isAngularInTestMode() {
+        /** @type {?} */
+        var platformRef = core.getPlatform();
+        if (!platformRef)
+            return false;
+        /** @type {?} */
+        var compilerOptions = platformRef.injector.get(core.COMPILER_OPTIONS, null);
+        if (!compilerOptions)
+            return false;
+        /** @type {?} */
+        var isInTestMode = compilerOptions.some((/**
+         * @param {?} item
+         * @return {?}
+         */
+        function (item) {
+            /** @type {?} */
+            var providers = (item && item.providers) || [];
+            return providers.some((/**
+             * @param {?} provider
+             * @return {?}
+             */
+            function (provider) {
+                return ((provider && provider.provide && provider.provide.name === 'MockNgModuleResolver') ||
+                    false);
+            }));
+        }));
+        return isInTestMode;
+    }
+    /** @type {?} */
+    var isAngularInTestMode = 
+    // 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.
+    typeof ngDevMode === 'undefined' || ngDevMode ? memoize(_isAngularInTestMode) : (/**
+     * @return {?}
+     */
+    function () { return false; });
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    var NgxsBootstrapper = /** @class */ (function () {
-        function NgxsBootstrapper() {
-            /**
-             * Use `ReplaySubject`, thus we can get cached value even if the stream is completed
-             */
-            this.bootstrap$ = new rxjs.ReplaySubject(1);
-        }
-        Object.defineProperty(NgxsBootstrapper.prototype, "appBootstrapped$", {
-            get: /**
-             * @return {?}
-             */
-            function () {
-                return this.bootstrap$.asObservable();
-            },
-            enumerable: true,
-            configurable: true
-        });
-        /**
-         * This event will be emitted after attaching `ComponentRef` of the root component
-         * to the tree of views, that's a signal that application has been fully rendered
-         */
-        /**
-         * This event will be emitted after attaching `ComponentRef` of the root component
-         * to the tree of views, that's a signal that application has been fully rendered
-         * @return {?}
-         */
-        NgxsBootstrapper.prototype.bootstrap = /**
-         * This event will be emitted after attaching `ComponentRef` of the root component
-         * to the tree of views, that's a signal that application has been fully rendered
-         * @return {?}
-         */
-        function () {
-            this.bootstrap$.next(true);
-            this.bootstrap$.complete();
-        };
-        NgxsBootstrapper.decorators = [
-            { type: core.Injectable }
-        ];
-        return NgxsBootstrapper;
-    }());
-    if (false) {
-        /**
-         * Use `ReplaySubject`, thus we can get cached value even if the stream is completed
-         * @type {?}
-         * @private
-         */
-        NgxsBootstrapper.prototype.bootstrap$;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    var NgxsBootstrapper = /** @class */ (function () {
+        function NgxsBootstrapper() {
+            /**
+             * Use `ReplaySubject`, thus we can get cached value even if the stream is completed
+             */
+            this.bootstrap$ = new rxjs.ReplaySubject(1);
+        }
+        Object.defineProperty(NgxsBootstrapper.prototype, "appBootstrapped$", {
+            get: /**
+             * @return {?}
+             */
+            function () {
+                return this.bootstrap$.asObservable();
+            },
+            enumerable: true,
+            configurable: true
+        });
+        /**
+         * This event will be emitted after attaching `ComponentRef` of the root component
+         * to the tree of views, that's a signal that application has been fully rendered
+         */
+        /**
+         * This event will be emitted after attaching `ComponentRef` of the root component
+         * to the tree of views, that's a signal that application has been fully rendered
+         * @return {?}
+         */
+        NgxsBootstrapper.prototype.bootstrap = /**
+         * This event will be emitted after attaching `ComponentRef` of the root component
+         * to the tree of views, that's a signal that application has been fully rendered
+         * @return {?}
+         */
+        function () {
+            this.bootstrap$.next(true);
+            this.bootstrap$.complete();
+        };
+        NgxsBootstrapper.decorators = [
+            { type: core.Injectable }
+        ];
+        return NgxsBootstrapper;
+    }());
+    if (false) {
+        /**
+         * Use `ReplaySubject`, thus we can get cached value even if the stream is completed
+         * @type {?}
+         * @private
+         */
+        NgxsBootstrapper.prototype.bootstrap$;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /** @type {?} */
-    var INITIAL_STATE_TOKEN = new core.InjectionToken('INITIAL_STATE_TOKEN');
-    var InitialState = /** @class */ (function () {
-        function InitialState() {
-        }
-        /**
-         * @param {?} state
-         * @return {?}
-         */
-        InitialState.set = /**
-         * @param {?} state
-         * @return {?}
-         */
-        function (state) {
-            this.value = state;
-        };
-        /**
-         * @return {?}
-         */
-        InitialState.pop = /**
-         * @return {?}
-         */
-        function () {
-            /** @type {?} */
-            var state = this.value;
-            this.value = {};
-            return state;
-        };
-        InitialState.value = {};
-        return InitialState;
-    }());
-    if (false) {
-        /**
-         * @type {?}
-         * @private
-         */
-        InitialState.value;
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /** @type {?} */
+    var INITIAL_STATE_TOKEN = new core.InjectionToken('INITIAL_STATE_TOKEN');
+    var InitialState = /** @class */ (function () {
+        function InitialState() {
+        }
+        /**
+         * @param {?} state
+         * @return {?}
+         */
+        InitialState.set = /**
+         * @param {?} state
+         * @return {?}
+         */
+        function (state) {
+            this.value = state;
+        };
+        /**
+         * @return {?}
+         */
+        InitialState.pop = /**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var state = this.value;
+            this.value = {};
+            return state;
+        };
+        InitialState.value = {};
+        return InitialState;
+    }());
+    if (false) {
+        /**
+         * @type {?}
+         * @private
+         */
+        InitialState.value;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @see StateContextFactory as it's referenced by this token to be accessed by plugins internally
-     * @type {?}
-     */
-    var NGXS_STATE_CONTEXT_FACTORY = new core.InjectionToken('Internals.StateContextFactory');
-    /**
-     * @see StateFactory as it's referenced by this token to be accessed by plugins internally
-     * @type {?}
-     */
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @see StateContextFactory as it's referenced by this token to be accessed by plugins internally
+     * @type {?}
+     */
+    var NGXS_STATE_CONTEXT_FACTORY = new core.InjectionToken('Internals.StateContextFactory');
+    /**
+     * @see StateFactory as it's referenced by this token to be accessed by plugins internally
+     * @type {?}
+     */
     var NGXS_STATE_FACTORY = new core.InjectionToken('Internals.StateFactory');
 
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    // Angular doesn't export `NG_FACTORY_DEF`.
+    /** @type {?} */
+    var NG_FACTORY_DEF = 'ɵfac';
+    // A `Symbol` which is used to save the `Injector` onto the class instance.
+    /** @type {?} */
+    var InjectorInstance = Symbol('InjectorInstance');
+    // A `Symbol` which is used to determine if factory has been decorated previously or not.
+    /** @type {?} */
+    var FactoryHasBeenDecorated = Symbol('FactoryHasBeenDecorated');
+    // A `Symbol` which is used to save the notifier on the class instance. The `InjectorInstance` cannot
+    // be retrieved within the `constructor` since it's set after the `factory()` is called.
+    /** @type {?} */
+    var InjectorNotifier = Symbol('InjectorNotifier');
+    /**
+     * @record
+     */
+    function PrototypeWithInjectorNotifier() { }
+    if (false) {
+        /* Skipping unnamed member:
+        [InjectorNotifier]?: ReplaySubject<boolean>;*/
+    }
+    /**
+     * @param {?} target
+     * @return {?}
+     */
+    function ensureInjectorNotifierIsCaptured(target) {
+        if (target[InjectorNotifier]) {
+            return (/** @type {?} */ (target[InjectorNotifier]));
+        }
+        else {
+            /** @type {?} */
+            var injectorNotifier$_1 = new rxjs.ReplaySubject(1);
+            Object.defineProperty(target, InjectorNotifier, {
+                get: (/**
+                 * @return {?}
+                 */
+                function () { return injectorNotifier$_1; })
+            });
+            return injectorNotifier$_1;
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    /**
+     * @param {?} target
+     * @return {?}
+     */
+    function ensureLocalInjectorCaptured(target) {
+        if (FactoryHasBeenDecorated in target.constructor.prototype) {
+            return;
+        }
+        /** @type {?} */
+        var constructor = target.constructor;
+        // Means we're in AOT mode.
+        if (typeof constructor[NG_FACTORY_DEF] === 'function') {
+            decorateFactory(constructor);
+        }
+        else if (ngDevMode) {
+            // We're running in JIT mode and that means we're not able to get the compiled definition
+            // on the class inside the property decorator during the current message loop tick. We have
+            // to wait for the next message loop tick. Note that this is safe since this Promise will be
+            // resolved even before the `APP_INITIALIZER` is resolved.
+            // The below code also will be executed only in development mode, since it's never recommended
+            // to use the JIT compiler in production mode (by setting "aot: false").
+            decorateFactoryLater(constructor);
+        }
+        target.constructor.prototype[FactoryHasBeenDecorated] = true;
+    }
+    /**
+     * @template T
+     * @param {?} instance
+     * @param {?} token
+     * @return {?}
+     */
+    function localInject(instance, token) {
+        /** @type {?} */
+        var injector = instance[InjectorInstance];
+        return injector ? injector.get(token) : null;
+    }
+    /**
+     * @param {?} constructor
+     * @return {?}
+     */
+    function decorateFactory(constructor) {
+        /** @type {?} */
+        var factory = constructor[NG_FACTORY_DEF];
+        if (typeof factory !== 'function') {
+            return;
+        }
+        // Let's try to get any definition.
+        // Caretaker note: this will be compatible only with Angular 9+, since Angular 9 is the first
+        // Ivy-stable version. Previously definition properties were named differently (e.g. `ngComponentDef`).
+        /** @type {?} */
+        var def = constructor.ɵprov || constructor.ɵpipe || constructor.ɵcmp || constructor.ɵdir;
+        /** @type {?} */
+        var decoratedFactory = (/**
+         * @return {?}
+         */
+        function () {
+            /** @type {?} */
+            var instance = factory();
+            // Caretaker note: `inject()` won't work here.
+            // We can use the `directiveInject` only during the component
+            // construction, since Angular captures the currently active injector.
+            // We're not able to use this function inside the getter (when the `selectorId` property is
+            // requested for the first time), since the currently active injector will be null.
+            instance[InjectorInstance] = core.ɵɵdirectiveInject(
+            // We're using `INJECTOR` token except of the `Injector` class since the compiler
+            // throws: `Cannot assign an abstract constructor type to a non-abstract constructor type.`.
+            // Caretaker note: that this is the same way of getting the injector.
+            core.INJECTOR);
+            // Caretaker note: the notifier will be available only if consumers call the `ensureInjectorNotifierIsCaptured()`.
+            /** @type {?} */
+            var injectorNotifier$ = instance[InjectorNotifier];
+            if (injectorNotifier$) {
+                injectorNotifier$.next(true);
+                injectorNotifier$.complete();
+            }
+            return instance;
+        });
+        // If we've found any definition then it's enough to override the `def.factory` since Angular
+        // code uses the `def.factory` and then fallbacks to `ɵfac`.
+        if (def) {
+            def.factory = decoratedFactory;
+        }
+        // `@NgModule()` doesn't doesn't have definition factory, also providers have definitions but Angular
+        // still uses the `ɵfac`.
+        Object.defineProperty(constructor, NG_FACTORY_DEF, {
+            get: (/**
+             * @return {?}
+             */
+            function () { return decoratedFactory; })
+        });
+    }
+    /**
+     * @param {?} constructor
+     * @return {?}
+     */
+    function decorateFactoryLater(constructor) {
+        // This function actually will be tree-shaken away when building for production since it's guarded with `ngDevMode`.
+        // We're having the `try-catch` here because of the `SyncTestZoneSpec`, which throws
+        // an error when micro or macrotask is used within a synchronous test. E.g. `Cannot call
+        // Promise.then from within a sync test`.
+        try {
+            Promise.resolve().then((/**
+             * @return {?}
+             */
+            function () {
+                decorateFactory(constructor);
+            }));
+        }
+        catch (_a) {
+            // This is kind of a "hack", but we try to be backwards-compatible,
+            // tho this `catch` block will only be executed when tests are run with Jasmine or Jest.
+            core.ɵglobal.process &&
+                core.ɵglobal.process.nextTick &&
+                core.ɵglobal.process.nextTick((/**
+                 * @return {?}
+                 */
+                function () {
+                    decorateFactory(constructor);
+                }));
+        }
+    }
+    /**
+     * @record
+     */
+    function Definition() { }
+    if (false) {
+        /** @type {?} */
+        Definition.prototype.factory;
+    }
+    /**
+     * @record
+     */
+    function ConstructorWithDefinitionAndFactory() { }
+    if (false) {
+        /** @type {?|undefined} */
+        ConstructorWithDefinitionAndFactory.prototype.ɵprov;
+        /** @type {?|undefined} */
+        ConstructorWithDefinitionAndFactory.prototype.ɵpipe;
+        /** @type {?|undefined} */
+        ConstructorWithDefinitionAndFactory.prototype.ɵcmp;
+        /** @type {?|undefined} */
+        ConstructorWithDefinitionAndFactory.prototype.ɵdir;
+        /* Skipping unnamed member:
+        [NG_FACTORY_DEF]?: Factory;*/
+    }
+    /**
+     * @record
+     */
+    function PrivateInstance() { }
+    if (false) {
+        /* Skipping unnamed member:
+        [InjectorInstance]?: Injector;*/
+        /* Skipping unnamed member:
+        [InjectorNotifier]?: ReplaySubject<boolean>;*/
+    }
+
     exports.INITIAL_STATE_TOKEN = INITIAL_STATE_TOKEN;
     exports.InitialState = InitialState;
     exports.NGXS_STATE_CONTEXT_FACTORY = NGXS_STATE_CONTEXT_FACTORY;
     exports.NGXS_STATE_FACTORY = NGXS_STATE_FACTORY;
     exports.NgxsBootstrapper = NgxsBootstrapper;
+    exports.ensureInjectorNotifierIsCaptured = ensureInjectorNotifierIsCaptured;
+    exports.ensureLocalInjectorCaptured = ensureLocalInjectorCaptured;
     exports.isAngularInTestMode = isAngularInTestMode;
+    exports.localInject = localInject;
     exports.memoize = memoize;
 
     Object.defineProperty(exports, '__esModule', { value: true });