@ngxs/store/bundles/ngxs-store.umd.js.map

{"version":3,"file":"ngxs-store.umd.js","sources":["../../../node_modules/tslib/tslib.es6.js","ng://@ngxs/store/src/configs/messages.config.ts","ng://@ngxs/store/src/execution/dispatch-outside-zone-ngxs-execution-strategy.ts","ng://@ngxs/store/src/symbols.ts","ng://@ngxs/store/src/execution/symbols.ts","ng://@ngxs/store/src/utils/utils.ts","ng://@ngxs/store/src/internal/internals.ts","ng://@ngxs/store/src/operators/of-action.ts","ng://@ngxs/store/src/operators/leave-ngxs.ts","ng://@ngxs/store/src/execution/internal-ngxs-execution-strategy.ts","ng://@ngxs/store/src/actions-stream.ts","ng://@ngxs/store/src/utils/compose.ts","ng://@ngxs/store/src/internal/state-stream.ts","ng://@ngxs/store/src/plugin-manager.ts","ng://@ngxs/store/src/internal/dispatcher.ts","ng://@ngxs/store/src/utils/freeze.ts","ng://@ngxs/store/src/host-environment/host-environment.ts","ng://@ngxs/store/src/internal/config-validator.ts","ng://@ngxs/store/src/internal/state-operations.ts","ng://@ngxs/store/src/internal/state-operators.ts","ng://@ngxs/store/src/internal/state-context-factory.ts","ng://@ngxs/store/src/utils/store-validators.ts","ng://@ngxs/store/src/internal/state-factory.ts","ng://@ngxs/store/src/internal/lifecycle-state-manager.ts","ng://@ngxs/store/src/utils/selector-utils.ts","ng://@ngxs/store/src/store.ts","ng://@ngxs/store/src/decorators/select/select-factory.ts","ng://@ngxs/store/src/actions/actions.ts","ng://@ngxs/store/src/ivy/ivy-enabled-in-dev-mode.ts","ng://@ngxs/store/src/modules/ngxs-root.module.ts","ng://@ngxs/store/src/modules/ngxs-feature.module.ts","ng://@ngxs/store/src/module.ts","ng://@ngxs/store/src/decorators/action.ts","ng://@ngxs/store/src/ivy/ensure-state-class-is-injectable.ts","ng://@ngxs/store/src/decorators/state.ts","ng://@ngxs/store/src/decorators/select/symbols.ts","ng://@ngxs/store/src/decorators/select/select.ts","ng://@ngxs/store/src/decorators/selector-options.ts","ng://@ngxs/store/src/public_to_deprecate.ts","ng://@ngxs/store/src/decorators/selector/selector.ts","ng://@ngxs/store/src/execution/noop-ngxs-execution-strategy.ts","ng://@ngxs/store/src/state-token/state-token.ts"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport function __createBinding(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n}\r\n\r\nexport function __exportStar(m, exports) {\r\n    for (var p in m) if (p !== \"default\" && !exports.hasOwnProperty(p)) exports[p] = m[p];\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];\r\n    result.default = mod;\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","export enum VALIDATION_CODE {\r\n  STATE_NAME = 'STATE_NAME',\r\n  STATE_UNIQUE = 'STATE_UNIQUE',\r\n  STATE_NAME_PROPERTY = 'STATE_NAME_PROPERTY',\r\n  STATE_DECORATOR = 'STATE_DECORATOR',\r\n  INCORRECT_PRODUCTION = 'INCORRECT_PRODUCTION',\r\n  INCORRECT_DEVELOPMENT = 'INCORRECT_DEVELOPMENT',\r\n  SELECT_FACTORY_NOT_CONNECTED = 'SELECT_FACTORY_NOT_CONNECTED',\r\n  ACTION_DECORATOR = 'ACTION_DECORATOR',\r\n  SELECTOR_DECORATOR = 'SELECTOR_DECORATOR',\r\n  ZONE_WARNING = 'ZONE_WARNING',\r\n  PATCHING_ARRAY = 'PATCHING_ARRAY',\r\n  PATCHING_PRIMITIVE = 'PATCHING_PRIMITIVE',\r\n  UNDECORATED_STATE_IN_IVY = 'UNDECORATED_STATE_IN_IVY'\r\n}\r\n\r\nexport const CONFIG_MESSAGES = {\r\n  [VALIDATION_CODE.STATE_NAME]: (name: string) =>\r\n    `${name} is not a valid state name. It needs to be a valid object property name.`,\r\n  [VALIDATION_CODE.STATE_NAME_PROPERTY]: () => `States must register a 'name' property`,\r\n  [VALIDATION_CODE.STATE_UNIQUE]: (current: string, newName: string, oldName: string) =>\r\n    `State name '${current}' from ${newName} already exists in ${oldName}`,\r\n  [VALIDATION_CODE.STATE_DECORATOR]: () => 'States must be decorated with @State() decorator',\r\n  [VALIDATION_CODE.INCORRECT_PRODUCTION]: () =>\r\n    'Angular is running in production mode but NGXS is still running in the development mode!\\n' +\r\n    'Please set developmentMode to false on the NgxsModule options when in production mode.\\n' +\r\n    'NgxsModule.forRoot(states, { developmentMode: !environment.production })',\r\n  [VALIDATION_CODE.INCORRECT_DEVELOPMENT]: () =>\r\n    'RECOMMENDATION: Set developmentMode to true on the NgxsModule when Angular is running in development mode.\\n' +\r\n    'NgxsModule.forRoot(states, { developmentMode: !environment.production })',\r\n  [VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED]: () =>\r\n    'You have forgotten to import the NGXS module!',\r\n  [VALIDATION_CODE.ACTION_DECORATOR]: () =>\r\n    '@Action() decorator cannot be used with static methods',\r\n  [VALIDATION_CODE.SELECTOR_DECORATOR]: () => 'Selectors only work on methods',\r\n  [VALIDATION_CODE.ZONE_WARNING]: () =>\r\n    'Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\\n' +\r\n    'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\\n' +\r\n    'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })',\r\n  [VALIDATION_CODE.PATCHING_ARRAY]: () => 'Patching arrays is not supported.',\r\n  [VALIDATION_CODE.PATCHING_PRIMITIVE]: () => 'Patching primitives is not supported.',\r\n  [VALIDATION_CODE.UNDECORATED_STATE_IN_IVY]: (name: string) =>\r\n    `'${name}' class should be decorated with @Injectable() right after the @State() decorator`\r\n};\r\n","import { Inject, Injectable, NgZone, PLATFORM_ID } from '@angular/core';\r\nimport { isPlatformServer } from '@angular/common';\r\n\r\nimport { NgxsExecutionStrategy } from './symbols';\r\nimport { CONFIG_MESSAGES, VALIDATION_CODE } from '../configs/messages.config';\r\n\r\n@Injectable()\r\nexport class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {\r\n  constructor(private _ngZone: NgZone, @Inject(PLATFORM_ID) private _platformId: string) {\r\n    this.verifyZoneIsNotNooped(this._ngZone);\r\n  }\r\n\r\n  enter<T>(func: () => T): T {\r\n    if (isPlatformServer(this._platformId)) {\r\n      return this.runInsideAngular(func);\r\n    }\r\n    return this.runOutsideAngular(func);\r\n  }\r\n\r\n  leave<T>(func: () => T): T {\r\n    return this.runInsideAngular(func);\r\n  }\r\n\r\n  private runInsideAngular<T>(func: () => T): T {\r\n    if (NgZone.isInAngularZone()) {\r\n      return func();\r\n    }\r\n    return this._ngZone.run(func);\r\n  }\r\n\r\n  private runOutsideAngular<T>(func: () => T): T {\r\n    if (NgZone.isInAngularZone()) {\r\n      return this._ngZone.runOutsideAngular(func);\r\n    }\r\n    return func();\r\n  }\r\n\r\n  private verifyZoneIsNotNooped(ngZone: NgZone): void {\r\n    // `NoopNgZone` is not exposed publicly as it doesn't expect\r\n    // to be used outside of the core Angular code, thus we just have\r\n    // to check if the zone doesn't extend or instanceof `NgZone`\r\n    if (ngZone instanceof NgZone) {\r\n      return;\r\n    }\r\n\r\n    console.warn(CONFIG_MESSAGES[VALIDATION_CODE.ZONE_WARNING]());\r\n  }\r\n}\r\n","import { Injectable, InjectionToken, Type } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { PlainObject, StateClass } from '@ngxs/store/internals';\r\nimport { SharedSelectorOptions, Callback } from './internal/internals';\r\nimport { NgxsExecutionStrategy } from './execution/symbols';\r\nimport { DispatchOutsideZoneNgxsExecutionStrategy } from './execution/dispatch-outside-zone-ngxs-execution-strategy';\r\nimport { StateToken } from './state-token/state-token';\r\n\r\nexport const ROOT_STATE_TOKEN = new InjectionToken<any>('ROOT_STATE_TOKEN');\r\nexport const FEATURE_STATE_TOKEN = new InjectionToken<any>('FEATURE_STATE_TOKEN');\r\nexport const NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');\r\nexport const NG_TEST_MODE = new InjectionToken<Callback<boolean>>('NG_TEST_MODE');\r\nexport const NG_DEV_MODE = new InjectionToken<Callback<boolean>>('NG_DEV_MODE');\r\n\r\nexport const META_KEY = 'NGXS_META';\r\nexport const META_OPTIONS_KEY = 'NGXS_OPTIONS_META';\r\nexport const SELECTOR_META_KEY = 'NGXS_SELECTOR_META';\r\n\r\nexport type NgxsLifeCycle = Partial<NgxsOnChanges> &\r\n  Partial<NgxsOnInit> &\r\n  Partial<NgxsAfterBootstrap>;\r\n\r\nexport type NgxsPluginFn = (state: any, mutation: any, next: NgxsNextPluginFn) => any;\r\n\r\n/**\r\n * The NGXS config settings.\r\n */\r\n@Injectable()\r\nexport class NgxsConfig {\r\n  /**\r\n   * Run in development mode. This will add additional debugging features:\r\n   * - Object.freeze on the state and actions to guarantee immutability\r\n   * (default: false)\r\n   */\r\n  developmentMode: boolean;\r\n  compatibility: {\r\n    /**\r\n     * Support a strict Content Security Policy.\r\n     * This will circumvent some optimisations that violate a strict CSP through the use of `new Function(...)`.\r\n     * (default: false)\r\n     */\r\n    strictContentSecurityPolicy: boolean;\r\n  };\r\n  /**\r\n   * Determines the execution context to perform async operations inside. An implementation can be\r\n   * provided to override the default behaviour where the async operations are run\r\n   * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.\r\n   * These observable behaviours are from:\r\n   *   `@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`\r\n   * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your\r\n   * application doesn't rely on zone.js running change detection then you can switch to the\r\n   * `NoopNgxsExecutionStrategy` that doesn't interact with zones.\r\n   * (default: null)\r\n   */\r\n  executionStrategy: Type<NgxsExecutionStrategy>;\r\n  /**\r\n   * Defining the default state before module initialization\r\n   * This is convenient if we need to create a define our own set of states.\r\n   * @deprecated will be removed after v4\r\n   * (default: {})\r\n   */\r\n  defaultsState: PlainObject = {};\r\n  /**\r\n   * Defining shared selector options\r\n   */\r\n  selectorOptions: SharedSelectorOptions = {\r\n    injectContainerState: true, // TODO: default is true in v3, will change in v4\r\n    suppressErrors: true // TODO: default is true in v3, will change in v4\r\n  };\r\n\r\n  constructor() {\r\n    this.compatibility = {\r\n      strictContentSecurityPolicy: false\r\n    };\r\n    this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;\r\n  }\r\n}\r\n\r\nexport type StateOperator<T> = (existing: Readonly<T>) => T;\r\n\r\n/**\r\n * State context provided to the actions in the state.\r\n */\r\nexport interface StateContext<T> {\r\n  /**\r\n   * Get the current state.\r\n   */\r\n  getState(): T;\r\n\r\n  /**\r\n   * Reset the state to a new value.\r\n   */\r\n  setState(val: T | StateOperator<T>): T;\r\n\r\n  /**\r\n   * Patch the existing state with the provided value.\r\n   */\r\n  patchState(val: Partial<T>): T;\r\n\r\n  /**\r\n   * Dispatch a new action and return the dispatched observable.\r\n   */\r\n  dispatch(actions: any | any[]): Observable<void>;\r\n}\r\n\r\nexport type NgxsNextPluginFn = (state: any, mutation: any) => any;\r\n\r\n/**\r\n * Plugin interface\r\n */\r\nexport interface NgxsPlugin {\r\n  /**\r\n   * Handle the state/action before its submitted to the state handlers.\r\n   */\r\n  handle(state: any, action: any, next: NgxsNextPluginFn): any;\r\n}\r\n\r\n/**\r\n * Options that can be provided to the store.\r\n */\r\nexport interface StoreOptions<T> {\r\n  /**\r\n   * Name of the state. Required.\r\n   */\r\n  name: string | StateToken<T>;\r\n\r\n  /**\r\n   * Default values for the state. If not provided, uses empty object.\r\n   */\r\n  defaults?: T;\r\n\r\n  /**\r\n   * Sub states for the given state.\r\n   */\r\n  children?: StateClass[];\r\n}\r\n\r\n/**\r\n * Represents a basic change from a previous to a new value for a single state instance.\r\n * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.\r\n */\r\nexport class NgxsSimpleChange<T = any> {\r\n  constructor(\r\n    public readonly previousValue: T,\r\n    public readonly currentValue: T,\r\n    public readonly firstChange: boolean\r\n  ) {}\r\n}\r\n\r\n/**\r\n * On init interface\r\n */\r\nexport interface NgxsOnInit {\r\n  ngxsOnInit(ctx?: StateContext<any>): void | any;\r\n}\r\n\r\n/**\r\n * On change interface\r\n */\r\nexport interface NgxsOnChanges {\r\n  ngxsOnChanges(change: NgxsSimpleChange): void;\r\n}\r\n\r\n/**\r\n * After bootstrap interface\r\n */\r\nexport interface NgxsAfterBootstrap {\r\n  ngxsAfterBootstrap(ctx?: StateContext<any>): void;\r\n}\r\n\r\nexport type NgxsModuleOptions = Partial<NgxsConfig>;\r\n","import { InjectionToken } from '@angular/core';\r\n\r\n/*\r\n * Internal execution strategy injection token\r\n */\r\nexport const NGXS_EXECUTION_STRATEGY = new InjectionToken<NgxsExecutionStrategy>(\r\n  'NGXS_EXECUTION_STRATEGY'\r\n);\r\n\r\n/*\r\n * Execution strategy interface\r\n */\r\nexport interface NgxsExecutionStrategy {\r\n  enter<T>(func: () => T): T;\r\n  leave<T>(func: () => T): T;\r\n}\r\n","/**\r\n * Returns the type from an action instance/class.\r\n * @ignore\r\n */\r\nexport function getActionTypeFromInstance(action: any): string | undefined {\r\n  if (action.constructor && action.constructor.type) {\r\n    return action.constructor.type;\r\n  } else {\r\n    return action.type;\r\n  }\r\n}\r\n\r\n/**\r\n * Matches a action\r\n * @ignore\r\n */\r\nexport function actionMatcher(action1: any) {\r\n  const type1 = getActionTypeFromInstance(action1);\r\n\r\n  return function(action2: any) {\r\n    return type1 === getActionTypeFromInstance(action2);\r\n  };\r\n}\r\n\r\n/**\r\n * Set a deeply nested value. Example:\r\n *\r\n *   setValue({ foo: { bar: { eat: false } } },\r\n *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }\r\n *\r\n * While it traverses it also creates new objects from top down.\r\n *\r\n * @ignore\r\n */\r\nexport const setValue = (obj: any, prop: string, val: any) => {\r\n  obj = { ...obj };\r\n\r\n  const split = prop.split('.');\r\n  const lastIndex = split.length - 1;\r\n\r\n  split.reduce((acc, part, index) => {\r\n    if (index === lastIndex) {\r\n      acc[part] = val;\r\n    } else {\r\n      acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : { ...acc[part] };\r\n    }\r\n\r\n    return acc && acc[part];\r\n  }, obj);\r\n\r\n  return obj;\r\n};\r\n\r\n/**\r\n * Get a deeply nested value. Example:\r\n *\r\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\r\n *\r\n * @ignore\r\n */\r\nexport const getValue = (obj: any, prop: string): any =>\r\n  prop.split('.').reduce((acc: any, part: string) => acc && acc[part], obj);\r\n\r\n/**\r\n * Simple object check.\r\n *\r\n *    isObject({a:1}) //=> true\r\n *    isObject(1) //=> false\r\n *\r\n * @ignore\r\n */\r\nexport const isObject = (item: any) => {\r\n  return item && typeof item === 'object' && !Array.isArray(item);\r\n};\r\n\r\n/**\r\n * Deep merge two objects.\r\n *\r\n *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}\r\n *\r\n * @param base base object onto which `sources` will be applied\r\n */\r\nexport const mergeDeep = (base: any, ...sources: any[]): any => {\r\n  if (!sources.length) return base;\r\n  const source = sources.shift();\r\n\r\n  if (isObject(base) && isObject(source)) {\r\n    for (const key in source) {\r\n      if (isObject(source[key])) {\r\n        if (!base[key]) Object.assign(base, { [key]: {} });\r\n        mergeDeep(base[key], source[key]);\r\n      } else {\r\n        Object.assign(base, { [key]: source[key] });\r\n      }\r\n    }\r\n  }\r\n\r\n  return mergeDeep(base, ...sources);\r\n};\r\n","import { PlainObjectOf, StateClass } from '@ngxs/store/internals';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport {\r\n  META_KEY,\r\n  META_OPTIONS_KEY,\r\n  NgxsConfig,\r\n  NgxsSimpleChange,\r\n  SELECTOR_META_KEY,\r\n  StoreOptions\r\n} from '../symbols';\r\nimport { ActionHandlerMetaData } from '../actions/symbols';\r\nimport { getValue } from '../utils/utils';\r\n\r\n// inspired from https://stackoverflow.com/a/43674389\r\nexport interface StateClassInternal<T = any, U = any> extends StateClass<T> {\r\n  [META_KEY]?: MetaDataModel;\r\n  [META_OPTIONS_KEY]?: StoreOptions<U>;\r\n}\r\n\r\nexport type StateKeyGraph = PlainObjectOf<string[]>;\r\nexport type StatesByName = PlainObjectOf<StateClassInternal>;\r\n\r\nexport interface StateOperations<T> {\r\n  getState(): T;\r\n\r\n  setState(val: T): T;\r\n\r\n  dispatch(actionOrActions: any | any[]): Observable<void>;\r\n}\r\n\r\nexport interface MetaDataModel {\r\n  name: string | null;\r\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\r\n  defaults: any;\r\n  path: string | null;\r\n  makeRootSelector: SelectorFactory | null;\r\n  children?: StateClassInternal[];\r\n}\r\n\r\nexport interface RuntimeSelectorContext {\r\n  getStateGetter(key: any): (state: any) => any;\r\n  getSelectorOptions(localOptions?: SharedSelectorOptions): SharedSelectorOptions;\r\n}\r\n\r\nexport type SelectFromRootState = (rootState: any) => any;\r\nexport type SelectorFactory = (runtimeContext: RuntimeSelectorContext) => SelectFromRootState;\r\n\r\nexport interface SharedSelectorOptions {\r\n  injectContainerState?: boolean;\r\n  suppressErrors?: boolean;\r\n}\r\n\r\nexport interface SelectorMetaDataModel {\r\n  makeRootSelector: SelectorFactory | null;\r\n  originalFn: Function | null;\r\n  containerClass: any;\r\n  selectorName: string | null;\r\n  getSelectorOptions: () => SharedSelectorOptions;\r\n}\r\n\r\nexport interface MappedStore {\r\n  name: string;\r\n  isInitialised: boolean;\r\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\r\n  defaults: any;\r\n  instance: any;\r\n  path: string;\r\n}\r\n\r\nexport interface StatesAndDefaults {\r\n  defaults: any;\r\n  states: MappedStore[];\r\n}\r\n\r\nexport type Callback<T = any, V = any> = (...args: V[]) => T;\r\n\r\nexport interface RootStateDiff<T> {\r\n  currentAppState: T;\r\n  newAppState: T;\r\n}\r\n\r\n/**\r\n * Ensures metadata is attached to the class and returns it.\r\n *\r\n * @ignore\r\n */\r\nexport function ensureStoreMetadata(target: StateClassInternal): MetaDataModel {\r\n  if (!target.hasOwnProperty(META_KEY)) {\r\n    const defaultMetadata: MetaDataModel = {\r\n      name: null,\r\n      actions: {},\r\n      defaults: {},\r\n      path: null,\r\n      makeRootSelector(context: RuntimeSelectorContext) {\r\n        return context.getStateGetter(defaultMetadata.name);\r\n      },\r\n      children: []\r\n    };\r\n\r\n    Object.defineProperty(target, META_KEY, { value: defaultMetadata });\r\n  }\r\n  return getStoreMetadata(target);\r\n}\r\n\r\n/**\r\n * Get the metadata attached to the state class if it exists.\r\n *\r\n * @ignore\r\n */\r\nexport function getStoreMetadata(target: StateClassInternal): MetaDataModel {\r\n  return target[META_KEY]!;\r\n}\r\n\r\n/**\r\n * Ensures metadata is attached to the selector and returns it.\r\n *\r\n * @ignore\r\n */\r\nexport function ensureSelectorMetadata(target: Function): SelectorMetaDataModel {\r\n  if (!target.hasOwnProperty(SELECTOR_META_KEY)) {\r\n    const defaultMetadata: SelectorMetaDataModel = {\r\n      makeRootSelector: null,\r\n      originalFn: null,\r\n      containerClass: null,\r\n      selectorName: null,\r\n      getSelectorOptions: () => ({})\r\n    };\r\n\r\n    Object.defineProperty(target, SELECTOR_META_KEY, { value: defaultMetadata });\r\n  }\r\n\r\n  return getSelectorMetadata(target);\r\n}\r\n\r\n/**\r\n * Get the metadata attached to the selector if it exists.\r\n *\r\n * @ignore\r\n */\r\nexport function getSelectorMetadata(target: any): SelectorMetaDataModel {\r\n  return target[SELECTOR_META_KEY];\r\n}\r\n\r\n/**\r\n * Get a deeply nested value. Example:\r\n *\r\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\r\n *\r\n * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.\r\n * See perf hit: https://jsperf.com/fast-value-getter-given-path/1\r\n *\r\n * @ignore\r\n */\r\nfunction compliantPropGetter(paths: string[]): (x: any) => any {\r\n  const copyOfPaths = paths.slice();\r\n  return obj => copyOfPaths.reduce((acc: any, part: string) => acc && acc[part], obj);\r\n}\r\n\r\n/**\r\n * The generated function is faster than:\r\n * - pluck (Observable operator)\r\n * - memoize\r\n *\r\n * @ignore\r\n */\r\nfunction fastPropGetter(paths: string[]): (x: any) => any {\r\n  const segments = paths;\r\n  let seg = 'store.' + segments[0];\r\n  let i = 0;\r\n  const l = segments.length;\r\n\r\n  let expr = seg;\r\n  while (++i < l) {\r\n    expr = expr + ' && ' + (seg = seg + '.' + segments[i]);\r\n  }\r\n\r\n  const fn = new Function('store', 'return ' + expr + ';');\r\n\r\n  return <(x: any) => any>fn;\r\n}\r\n\r\n/**\r\n * Get a deeply nested value. Example:\r\n *\r\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\r\n *\r\n * @ignore\r\n */\r\nexport function propGetter(paths: string[], config: NgxsConfig) {\r\n  if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {\r\n    return compliantPropGetter(paths);\r\n  } else {\r\n    return fastPropGetter(paths);\r\n  }\r\n}\r\n\r\n/**\r\n * Given an array of states, it will return a object graph. Example:\r\n *    const states = [\r\n *      Cart,\r\n *      CartSaved,\r\n *      CartSavedItems\r\n *    ]\r\n *\r\n * would return:\r\n *\r\n *  const graph = {\r\n *    cart: ['saved'],\r\n *    saved: ['items'],\r\n *    items: []\r\n *  };\r\n *\r\n * @ignore\r\n */\r\nexport function buildGraph(stateClasses: StateClassInternal[]): StateKeyGraph {\r\n  const findName = (stateClass: StateClassInternal) => {\r\n    const meta = stateClasses.find(g => g === stateClass);\r\n    if (!meta) {\r\n      throw new Error(\r\n        `Child state not found: ${stateClass}. \\r\\nYou may have forgotten to add states to module`\r\n      );\r\n    }\r\n\r\n    return meta[META_KEY]!.name!;\r\n  };\r\n\r\n  return stateClasses.reduce<StateKeyGraph>(\r\n    (result: StateKeyGraph, stateClass: StateClassInternal) => {\r\n      const { name, children } = stateClass[META_KEY]!;\r\n      result[name!] = (children || []).map(findName);\r\n      return result;\r\n    },\r\n    {}\r\n  );\r\n}\r\n\r\n/**\r\n * Given a states array, returns object graph\r\n * returning the name and state metadata. Example:\r\n *\r\n *  const graph = {\r\n *    cart: { metadata }\r\n *  };\r\n *\r\n * @ignore\r\n */\r\nexport function nameToState(states: StateClassInternal[]): PlainObjectOf<StateClassInternal> {\r\n  return states.reduce<PlainObjectOf<StateClassInternal>>(\r\n    (result: PlainObjectOf<StateClassInternal>, stateClass: StateClassInternal) => {\r\n      const meta = stateClass[META_KEY]!;\r\n      result[meta.name!] = stateClass;\r\n      return result;\r\n    },\r\n    {}\r\n  );\r\n}\r\n\r\n/**\r\n * Given a object relationship graph will return the full path\r\n * for the child items. Example:\r\n *\r\n *  const graph = {\r\n *    cart: ['saved'],\r\n *    saved: ['items'],\r\n *    items: []\r\n *  };\r\n *\r\n * would return:\r\n *\r\n *  const r = {\r\n *    cart: 'cart',\r\n *    saved: 'cart.saved',\r\n *    items: 'cart.saved.items'\r\n *  };\r\n *\r\n * @ignore\r\n */\r\nexport function findFullParentPath(\r\n  obj: StateKeyGraph,\r\n  newObj: PlainObjectOf<string> = {}\r\n): PlainObjectOf<string> {\r\n  const visit = (child: StateKeyGraph, keyToFind: string): string | null => {\r\n    for (const key in child) {\r\n      if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {\r\n        const parent = visit(child, key);\r\n        return parent !== null ? `${parent}.${key}` : key;\r\n      }\r\n    }\r\n    return null;\r\n  };\r\n\r\n  for (const key in obj) {\r\n    if (obj.hasOwnProperty(key)) {\r\n      const parent = visit(obj, key);\r\n      newObj[key] = parent ? `${parent}.${key}` : key;\r\n    }\r\n  }\r\n\r\n  return newObj;\r\n}\r\n\r\n/**\r\n * Given a object graph, it will return the items topologically sorted Example:\r\n *\r\n *  const graph = {\r\n *    cart: ['saved'],\r\n *    saved: ['items'],\r\n *    items: []\r\n *  };\r\n *\r\n * would return:\r\n *\r\n *  const results = [\r\n *    'items',\r\n *    'saved',\r\n *    'cart'\r\n *  ];\r\n *\r\n * @ignore\r\n */\r\nexport function topologicalSort(graph: StateKeyGraph): string[] {\r\n  const sorted: string[] = [];\r\n  const visited: PlainObjectOf<boolean> = {};\r\n\r\n  const visit = (name: string, ancestors: string[] = []) => {\r\n    if (!Array.isArray(ancestors)) {\r\n      ancestors = [];\r\n    }\r\n\r\n    ancestors.push(name);\r\n    visited[name] = true;\r\n\r\n    graph[name].forEach((dep: string) => {\r\n      if (ancestors.indexOf(dep) >= 0) {\r\n        throw new Error(\r\n          `Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`\r\n        );\r\n      }\r\n\r\n      if (visited[dep]) {\r\n        return;\r\n      }\r\n\r\n      visit(dep, ancestors.slice(0));\r\n    });\r\n\r\n    if (sorted.indexOf(name) < 0) {\r\n      sorted.push(name);\r\n    }\r\n  };\r\n\r\n  Object.keys(graph).forEach(k => visit(k));\r\n\r\n  return sorted.reverse();\r\n}\r\n\r\n/**\r\n * Returns if the parameter is a object or not.\r\n *\r\n * @ignore\r\n */\r\nexport function isObject(obj: any) {\r\n  return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';\r\n}\r\n\r\nexport function getStateDiffChanges<T>(\r\n  mappedStore: MappedStore,\r\n  diff: RootStateDiff<T>\r\n): NgxsSimpleChange {\r\n  const previousValue: T = getValue(diff.currentAppState, mappedStore.path);\r\n  const currentValue: T = getValue(diff.newAppState, mappedStore.path);\r\n  return new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);\r\n}\r\n","import { OperatorFunction, Observable } from 'rxjs';\r\nimport { map, filter } from 'rxjs/operators';\r\n\r\nimport { ActionType } from '../actions/symbols';\r\nimport { getActionTypeFromInstance } from '../utils/utils';\r\nimport { ActionContext, ActionStatus } from '../actions-stream';\r\n\r\nexport interface ActionCompletion<T = any, E = Error> {\r\n  action: T;\r\n  result: {\r\n    successful: boolean;\r\n    canceled: boolean;\r\n    error?: E;\r\n  };\r\n}\r\n\r\nexport function ofAction<T = any>(allowedType: ActionType): OperatorFunction<ActionContext, T>;\r\nexport function ofAction<T = any>(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, T>;\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will grab actions that have just been dispatched as well as actions that have completed\r\n */\r\nexport function ofAction(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been dispatched\r\n */\r\nexport function ofActionDispatched(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Dispatched]);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been successfully completed\r\n */\r\nexport function ofActionSuccessful(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Successful]);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been canceled\r\n */\r\nexport function ofActionCanceled(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Canceled]);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been completed\r\n */\r\nexport function ofActionCompleted(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, ActionCompletion> {\r\n  const allowedStatuses = [\r\n    ActionStatus.Successful,\r\n    ActionStatus.Canceled,\r\n    ActionStatus.Errored\r\n  ];\r\n  return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just thrown an error\r\n */\r\nexport function ofActionErrored(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Errored]);\r\n}\r\n\r\nfunction ofActionOperator(\r\n  allowedTypes: ActionType[],\r\n  statuses?: ActionStatus[],\r\n  // This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,\r\n  // since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`\r\n  // defaults to `any`, thus there is no sense from union type.\r\n  mapOperator: () => OperatorFunction<ActionContext, any> = mapAction\r\n): OperatorFunction<ActionContext, any> {\r\n  const allowedMap = createAllowedActionTypesMap(allowedTypes);\r\n  const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);\r\n  return function(o: Observable<ActionContext>) {\r\n    return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());\r\n  };\r\n}\r\n\r\nfunction filterStatus(allowedTypes: FilterMap, allowedStatuses?: FilterMap) {\r\n  return filter((ctx: ActionContext) => {\r\n    const actionType = getActionTypeFromInstance(ctx.action)!;\r\n    const typeMatch = allowedTypes[actionType];\r\n    const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;\r\n    return typeMatch && statusMatch;\r\n  });\r\n}\r\n\r\nfunction mapActionResult(): OperatorFunction<ActionContext, ActionCompletion> {\r\n  return map(({ action, status, error }: ActionContext) => {\r\n    return <ActionCompletion>{\r\n      action,\r\n      result: {\r\n        successful: ActionStatus.Successful === status,\r\n        canceled: ActionStatus.Canceled === status,\r\n        error\r\n      }\r\n    };\r\n  });\r\n}\r\n\r\nfunction mapAction<T = any>(): OperatorFunction<ActionContext, T> {\r\n  return map((ctx: ActionContext) => <T>ctx.action);\r\n}\r\n\r\ninterface FilterMap {\r\n  [key: string]: boolean;\r\n}\r\n\r\nfunction createAllowedActionTypesMap(types: ActionType[]): FilterMap {\r\n  return types.reduce((filterMap: FilterMap, klass: any) => {\r\n    filterMap[getActionTypeFromInstance(klass)!] = true;\r\n    return filterMap;\r\n  }, <FilterMap>{});\r\n}\r\n\r\nfunction createAllowedStatusesMap(statuses: ActionStatus[]): FilterMap {\r\n  return statuses.reduce((filterMap: FilterMap, status: ActionStatus) => {\r\n    filterMap[status] = true;\r\n    return filterMap;\r\n  }, <FilterMap>{});\r\n}\r\n","import { MonoTypeOperatorFunction, Observable, Observer } from 'rxjs';\r\nimport { NgxsExecutionStrategy } from '../execution/symbols';\r\n\r\n/**\r\n * Returns operator that will run\r\n * `subscribe` outside of the ngxs execution context\r\n */\r\nexport function leaveNgxs<T>(\r\n  ngxsExecutionStrategy: NgxsExecutionStrategy\r\n): MonoTypeOperatorFunction<T> {\r\n  return (source: Observable<T>) => {\r\n    return new Observable((sink: Observer<T>) => {\r\n      return source.subscribe({\r\n        next(value) {\r\n          ngxsExecutionStrategy.leave(() => sink.next(value));\r\n        },\r\n        error(error) {\r\n          ngxsExecutionStrategy.leave(() => sink.error(error));\r\n        },\r\n        complete() {\r\n          ngxsExecutionStrategy.leave(() => sink.complete());\r\n        }\r\n      });\r\n    });\r\n  };\r\n}\r\n","import { Injectable, Inject } from '@angular/core';\r\n\r\nimport { NgxsExecutionStrategy, NGXS_EXECUTION_STRATEGY } from './symbols';\r\n\r\n@Injectable()\r\nexport class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {\r\n  constructor(\r\n    @Inject(NGXS_EXECUTION_STRATEGY) private _executionStrategy: NgxsExecutionStrategy\r\n  ) {}\r\n\r\n  enter<T>(func: () => T): T {\r\n    return this._executionStrategy.enter(func);\r\n  }\r\n\r\n  leave<T>(func: () => T): T {\r\n    return this._executionStrategy.leave(func);\r\n  }\r\n}\r\n","import { Injectable } from '@angular/core';\r\nimport { Subject, Observable } from 'rxjs';\r\n\r\nimport { leaveNgxs } from './operators/leave-ngxs';\r\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\r\n\r\n/**\r\n * Status of a dispatched action\r\n */\r\nexport const enum ActionStatus {\r\n  Dispatched = 'DISPATCHED',\r\n  Successful = 'SUCCESSFUL',\r\n  Canceled = 'CANCELED',\r\n  Errored = 'ERRORED'\r\n}\r\n\r\nexport interface ActionContext<T = any> {\r\n  status: ActionStatus;\r\n  action: T;\r\n  error?: Error;\r\n}\r\n\r\n/**\r\n * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.\r\n * A standard Subject does not have this guarantee.\r\n * For example, given the following code:\r\n * ```typescript\r\n *   const subject = new Subject<string>();\r\n     subject.subscribe(value => {\r\n       if (value === 'start') subject.next('end');\r\n     });\r\n     subject.subscribe(value => { });\r\n     subject.next('start');\r\n * ```\r\n * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.\r\n * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.\r\n */\r\nexport class OrderedSubject<T> extends Subject<T> {\r\n  private _itemQueue: T[] = [];\r\n  private _busyPushingNext = false;\r\n\r\n  next(value?: T): void {\r\n    if (this._busyPushingNext) {\r\n      this._itemQueue.unshift(value!);\r\n      return;\r\n    }\r\n    this._busyPushingNext = true;\r\n    super.next(value);\r\n    while (this._itemQueue.length > 0) {\r\n      const nextValue = this._itemQueue.pop();\r\n      super.next(nextValue);\r\n    }\r\n    this._busyPushingNext = false;\r\n  }\r\n}\r\n\r\n/**\r\n * Internal Action stream that is emitted anytime an action is dispatched.\r\n */\r\n@Injectable()\r\nexport class InternalActions extends OrderedSubject<ActionContext> {}\r\n\r\n/**\r\n * Action stream that is emitted anytime an action is dispatched.\r\n *\r\n * You can listen to this in services to react without stores.\r\n */\r\n@Injectable()\r\nexport class Actions extends Observable<any> {\r\n  // This has to be `Observable<ActionContext>` in the v4. Because `InternalActions`\r\n  // is a `Subject<ActionContext>`. Leave it as `any` to avoid breaking changes\r\n  constructor(\r\n    internalActions$: InternalActions,\r\n    internalExecutionStrategy: InternalNgxsExecutionStrategy\r\n  ) {\r\n    super(observer => {\r\n      const childSubscription = internalActions$\r\n        .pipe(leaveNgxs(internalExecutionStrategy))\r\n        .subscribe({\r\n          next: ctx => observer.next(ctx),\r\n          error: error => observer.error(error),\r\n          complete: () => observer.complete()\r\n        });\r\n\r\n      observer.add(childSubscription);\r\n    });\r\n  }\r\n}\r\n","export type StateFn = (...args: any[]) => any;\r\n\r\n/**\r\n * Composes a array of functions from left to right. Example:\r\n *\r\n *      compose([fn, final])(state, action);\r\n *\r\n * then the funcs have a signature like:\r\n *\r\n *      function fn (state, action, next) {\r\n *          console.log('here', state, action, next);\r\n *          return next(state, action);\r\n *      }\r\n *\r\n *      function final (state, action) {\r\n *          console.log('here', state, action);\r\n *          return state;\r\n *      }\r\n *\r\n * the last function should not call `next`.\r\n *\r\n * @ignore\r\n */\r\nexport const compose = (funcs: StateFn[]) => (...args: any[]) => {\r\n  const curr = funcs.shift()!;\r\n  return curr(...args, (...nextArgs: any[]) => compose(funcs)(...nextArgs));\r\n};\r\n","import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject } from 'rxjs';\r\n\r\nimport { PlainObject } from '@ngxs/store/internals';\r\n\r\n/**\r\n * BehaviorSubject of the entire state.\r\n * @ignore\r\n */\r\n@Injectable()\r\nexport class StateStream extends BehaviorSubject<PlainObject> {\r\n  constructor() {\r\n    super({});\r\n  }\r\n}\r\n","import { Inject, Injectable, Optional, SkipSelf } from '@angular/core';\r\nimport { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn } from './symbols';\r\n\r\n@Injectable()\r\nexport class PluginManager {\r\n  public plugins: NgxsPluginFn[] = [];\r\n\r\n  constructor(\r\n    @Optional()\r\n    @SkipSelf()\r\n    private _parentManager: PluginManager,\r\n    @Inject(NGXS_PLUGINS)\r\n    @Optional()\r\n    private _pluginHandlers: NgxsPlugin[]\r\n  ) {\r\n    this.registerHandlers();\r\n  }\r\n\r\n  private get rootPlugins(): NgxsPluginFn[] {\r\n    return (this._parentManager && this._parentManager.plugins) || this.plugins;\r\n  }\r\n\r\n  private registerHandlers(): void {\r\n    const pluginHandlers: NgxsPluginFn[] = this.getPluginHandlers();\r\n    this.rootPlugins.push(...pluginHandlers);\r\n  }\r\n\r\n  private getPluginHandlers(): NgxsPluginFn[] {\r\n    const handlers: NgxsPlugin[] = this._pluginHandlers || [];\r\n    return handlers.map(\r\n      (plugin: NgxsPlugin) =>\r\n        (plugin.handle ? plugin.handle.bind(plugin) : plugin) as NgxsPluginFn\r\n    );\r\n  }\r\n}\r\n","import { ErrorHandler, Injectable } from '@angular/core';\r\nimport { EMPTY, forkJoin, Observable, of, Subject, throwError } from 'rxjs';\r\nimport { exhaustMap, filter, shareReplay, take } from 'rxjs/operators';\r\n\r\nimport { compose } from '../utils/compose';\r\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\r\nimport { StateStream } from './state-stream';\r\nimport { PluginManager } from '../plugin-manager';\r\nimport { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';\r\nimport { leaveNgxs } from '../operators/leave-ngxs';\r\nimport { getActionTypeFromInstance } from '../utils/utils';\r\n\r\n/**\r\n * Internal Action result stream that is emitted when an action is completed.\r\n * This is used as a method of returning the action result to the dispatcher\r\n * for the observable returned by the dispatch(...) call.\r\n * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.\r\n */\r\n@Injectable()\r\nexport class InternalDispatchedActionResults extends Subject<ActionContext> {}\r\n\r\n@Injectable()\r\nexport class InternalDispatcher {\r\n  constructor(\r\n    private _errorHandler: ErrorHandler,\r\n    private _actions: InternalActions,\r\n    private _actionResults: InternalDispatchedActionResults,\r\n    private _pluginManager: PluginManager,\r\n    private _stateStream: StateStream,\r\n    private _ngxsExecutionStrategy: InternalNgxsExecutionStrategy\r\n  ) {}\r\n\r\n  /**\r\n   * Dispatches event(s).\r\n   */\r\n  dispatch(actionOrActions: any | any[]): Observable<any> {\r\n    const result = this._ngxsExecutionStrategy.enter(() =>\r\n      this.dispatchByEvents(actionOrActions)\r\n    );\r\n\r\n    result.subscribe({\r\n      error: error =>\r\n        this._ngxsExecutionStrategy.leave(() => {\r\n          try {\r\n            this._errorHandler.handleError(error);\r\n          } catch {}\r\n        })\r\n    });\r\n\r\n    return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));\r\n  }\r\n\r\n  private dispatchByEvents(actionOrActions: any | any[]): Obse