@ngxs/store 3.7.3 → 3.7.4-dev.master-327646e

package/fesm5/ngxs-store-internals.js

@@ -1,235 +1,419 @@
-import { getPlatform, COMPILER_OPTIONS, Injectable, InjectionToken } from '@angular/core';
+import { Injectable, InjectionToken, ɵɵdirectiveInject, INJECTOR, ɵglobal } from '@angular/core';
 import { ReplaySubject } from 'rxjs';
 
-/**
- * @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() {
+    // This is safe to check for these properties in the following way since `typeof` does not
+    // throw an exception if the value does not exist in the scope.
+    // We should not try to read these values from the global scope (e.g. `ɵglobal` from the `@angular/core`).
+    // This is related to how these frameworks compile and execute modules. E.g. Jest wraps the module into
+    // its internal code where `jest` variable exists in the scope. It cannot be read from the global scope, e.g.
+    // this will return undefined `global.jest`, but `jest` will not equal undefined.
+    return (typeof __karma__ !== 'undefined' ||
+        typeof jasmine !== 'undefined' ||
+        typeof jest !== 'undefined' ||
+        typeof Mocha !== 'undefined');
 }
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @return {?}
- */
-function _isAngularInTestMode() {
-    /** @type {?} */
-    var platformRef = getPlatform();
-    if (!platformRef)
-        return false;
-    /** @type {?} */
-    var compilerOptions = platformRef.injector.get(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
+ */
+var NgxsBootstrapper = /** @class */ (function () {
+    function NgxsBootstrapper() {
+        /**
+         * Use `ReplaySubject`, thus we can get cached value even if the stream is completed
+         */
+        this.bootstrap$ = new 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: 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 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: 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
+ */
+/**
+ * @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
- */
-/** @type {?} */
-var INITIAL_STATE_TOKEN = new 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 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 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 InjectionToken('Internals.StateContextFactory');
+/**
+ * @see StateFactory as it's referenced by this token to be accessed by plugins internally
+ * @type {?}
+ */
 var NGXS_STATE_FACTORY = new InjectionToken('Internals.StateFactory');
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+/**
+ * @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 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] = ɵɵ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.
+        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.
+        ɵglobal.process &&
+            ɵglobal.process.nextTick &&
+            ɵ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>;*/
+}
+
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
  */
 
-export { INITIAL_STATE_TOKEN, InitialState, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, NgxsBootstrapper, isAngularInTestMode, memoize };
+export { INITIAL_STATE_TOKEN, InitialState, NGXS_STATE_CONTEXT_FACTORY, NGXS_STATE_FACTORY, NgxsBootstrapper, ensureInjectorNotifierIsCaptured, ensureLocalInjectorCaptured, isAngularInTestMode, localInject, memoize };
 //# sourceMappingURL=ngxs-store-internals.js.map