@ngxs/store 3.7.5-dev.master-056a44f → 3.7.6

package/bundles/ngxs-store.umd.min.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../node_modules/tslib/tslib.es6.js","ng://@ngxs/store/src/execution/dispatch-outside-zone-ngxs-execution-strategy.ts","ng://@ngxs/store/src/configs/messages.config.ts","ng://@ngxs/store/src/symbols.ts","ng://@ngxs/store/src/execution/noop-ngxs-execution-strategy.ts","ng://@ngxs/store/src/execution/symbols.ts","ng://@ngxs/store/src/internal/internals.ts","ng://@ngxs/store/src/utils/utils.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/error-handler.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/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/ivy/ivy-enabled-in-dev-mode.ts","ng://@ngxs/store/src/internal/state-factory.ts","ng://@ngxs/store/src/utils/selector-utils.ts","ng://@ngxs/store/src/store.ts","ng://@ngxs/store/src/internal/lifecycle-state-manager.ts","ng://@ngxs/store/src/decorators/select/select-factory.ts","ng://@ngxs/store/src/actions/actions.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/select/symbols.ts","ng://@ngxs/store/src/state-token/state-token.ts","ng://@ngxs/store/src/decorators/action.ts","ng://@ngxs/store/src/decorators/select/select.ts","ng://@ngxs/store/src/decorators/selector/selector.ts","ng://@ngxs/store/src/decorators/selector-options.ts","ng://@ngxs/store/src/decorators/state.ts","ng://@ngxs/store/src/public_to_deprecate.ts"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__extends","__","this","constructor","prototype","create","__assign","assign","t","s","i","n","arguments","length","call","apply","__values","o","Symbol","iterator","m","next","value","done","TypeError","__read","r","e","ar","push","error","__spread","concat","DispatchOutsideZoneNgxsExecutionStrategy","_ngZone","_platformId","ngDevMode","ngZone","NgZone","console","warn","verifyZoneIsNotNooped","enter","func","isPlatformServer","runInsideAngular","runOutsideAngular","leave","isInAngularZone","run","Injectable","args","providedIn","Inject","PLATFORM_ID","ROOT_STATE_TOKEN","InjectionToken","FEATURE_STATE_TOKEN","NGXS_PLUGINS","META_KEY","META_OPTIONS_KEY","SELECTOR_META_KEY","NgxsConfig","defaultsState","selectorOptions","injectContainerState","suppressErrors","compatibility","strictContentSecurityPolicy","executionStrategy","previousValue","currentValue","firstChange","NoopNgxsExecutionStrategy","USER_PROVIDED_NGXS_EXECUTION_STRATEGY","NGXS_EXECUTION_STRATEGY","factory","injector","inject","INJECTOR","get","ɵglobal","Zone","ensureStoreMetadata","target","defaultMetadata_1","name","actions","defaults","path","makeRootSelector","context","getStateGetter","children","defineProperty","getStoreMetadata","ensureSelectorMetadata","originalFn","containerClass","selectorName","getSelectorOptions","getSelectorMetadata","propGetter","paths","config","copyOfPaths","slice","obj","reduce","acc","part","compliantPropGetter","segments","seg","l","expr","Function","fastPropGetter","getActionTypeFromInstance","action","type","setValue","prop","val","split","lastIndex","index","isArray","getValue","isObject","item","mergeDeep","base","sources","_i","source","shift","key","_a","_b","ofActionDispatched","allowedTypes","ofActionOperator","statuses","mapOperator","mapAction","allowedMap","filterMap","klass","allowedStatusMap","status","createAllowedStatusesMap","pipe","allowedStatuses","filter","ctx","actionType","typeMatch","statusMatch","filterStatus","mapActionResult","map","result","successful","canceled","leaveNgxs","ngxsExecutionStrategy","Observable","sink","subscribe","complete","InternalNgxsExecutionStrategy","_executionStrategy","OrderedSubject","_this","_super","_itemQueue","_busyPushingNext","tslib_1.__extends","unshift","nextValue","pop","Subject","InternalActions","ngOnDestroy","Actions","internalActions$","internalExecutionStrategy","sharedInternalActions$","share","observer","childSubscription","add","compose","funcs","curr","nextArgs","InternalErrorReporter","_injector","_errorHandler","reportErrorSafely","ErrorHandler","handleError","Injector","StateStream","BehaviorSubject","PluginManager","_parentManager","_pluginHandlers","plugins","registerHandlers","pluginHandlers","getPluginHandlers","rootPlugins","plugin","handle","bind","decorators","Optional","SkipSelf","InternalDispatchedActionResults","InternalDispatcher","_actions","_actionResults","_pluginManager","_stateStream","_ngxsExecutionStrategy","_internalErrorReporter","dispatch","actionOrActions","internalErrorReporter","dispatchByEvents","subscribed","Promise","resolve","then","subscriber","of","forkJoin","dispatchSingle","Error","throwError","prevState","nextState","nextAction","actionResult$","getActionResultStream","createDispatchObservable","shareReplay","take","exhaustMap","EMPTY","deepFreeze","freeze","oIsFunction","hasOwnProp","getOwnPropertyNames","forEach","isFrozen","InternalStateOperations","_dispatcher","_config","getRootStateOperations","root","rootStateOperations","getState","setState","newState","developmentMode","frozenValue","setStateToTheCurrentWithNew","results","stateOperations","currentState","simplePatch","existingState","throwPatchingArrayError","throwPatchingPrimitiveError","StateContextFactory","_internalStateOperations","createStateContext","mappedStore","currentAppState","setStateValue","newValue","newAppState","setStateFromOperator","stateOperator","patchState","StoreValidators","checkThatStateIsNamedCorrectly","stateNameRegex","test","throwStateNameError","throwStateNamePropertyError","checkThatStateNameIsUnique","stateName","state","statesByName","current","newName","oldName","throwStateUniqueError","checkThatStateClassesHaveBeenDecorated","stateClasses","stateClass","throwStateDecoratorError","RegExp","ensureStateClassIsInjectable","ɵivyEnabled","ɵprov","StateFactory","_parentFactory","_stateContextFactory","_initialState","_actionsSubscription","_states","_statesByName","_statePaths","getRuntimeSelectorContext","memoize","stateFactory","resolveGetter","statePaths","getter","undefined","localOptions","globalSelectorOptions","states","cloneDefaults","unsubscribe","newStates","addToStatesMap","graph","sorted","visited","visit","stateGraph","findName","meta","find","g","buildGraph","sortedStates","ancestors","dep","indexOf","join","keys","k","reverse","newObj","child","keyToFind","parent_1","parent_2","findFullParentPath","nameGraph","bootstrappedStores","sortedStates_1","tslib_1.__values","sortedStates_1_1","name_1","addRuntimeInfoToMeta","stateMap","isInitialised","instance","hasBeenMountedAndBootstrapped","addAndReturnDefaults","classes","mappedStores","connectActionHandlers","dispatched$","mergeMap","invokeActions","defaultIfEmpty","catchError","_c","_d","metadata","actionMetas","actionMetas_1","actionMetas_1_1","actionMeta","stateContext","fn","from","isObservable","options","cancelUncompleted","takeUntil","statesMap","stateClasses_1","stateClasses_1_1","valueIsBootstrappedInInitialState","INITIAL_STATE_TOKEN","selectorOptionsMetaAccessor","getOptions","defineOptions","createSelector","selectors","creationMetadata","memoizedFn","returnValue","innerMemoizedFn","selectorMetaData","getExplicitSelectorOptions","selectorMetaDataClone","explicitOptions","getLocalSelectorOptions","setupSelectorMetadata","localSelectorOptions","argumentSelectorFunctions","selectorsToApply","canInjectContainerState","getSelectorsToApply","selector","getRootSelectorFactory","getRuntimeSelectorInfo","rootState","argFn","ex","Store","_internalExecutionStrategy","_stateFactory","initialStateValue","_selectableStateStream","observeOn","queueScheduler","bufferSize","refCount","initStateStream","select","selectorFn","getStoreBoundSelectorFn","err","distinctUntilChanged","selectOnce","selectSnapshot","snapshot","reset","makeSelectorFn","storeValues","LifecycleStateManager","_store","_bootstrapper","_destroy$","ngxsBootstrap","tap","_invokeInitOnStates","appBootstrapped$","appBootstrapped","_invokeBootstrapOnStates","ngxsOnChanges","this_1","startWith","pairwise","change","NgxsSimpleChange","ngxsOnInit","_getStateContext","mappedStores_1","mappedStores_1_1","mappedStores_2","mappedStores_2_1","ngxsAfterBootstrap","NgxsBootstrapper","SelectFactory","store","InitState","UpdateState","addedStates","NgxsRootModule","internalStateOperations","_select","lifecycleStateManager","NgModule","NgxsFeatureModule","flattenedStates","flattenStates","total","values","NgxsModule","forRoot","ngModule","providers","ngxsTokenProviders","forFeature","provide","multi","useValue","ROOT_OPTIONS","useFactory","ngxsConfigFactory","deps","APP_BOOTSTRAP_LISTENER","appBootstrapListenerFactory","getInitialState","NGXS_STATE_CONTEXT_FACTORY","useExisting","NGXS_STATE_FACTORY","bootstrapper","bootstrap","InitialState","DOLLAR_CHAR_CODE","createSelectObservable","throwSelectFactoryNotConnectedError","createSelectorFn","rawSelector","lastCharIndex","charCodeAt","removeDollarAtTheEnd","StateToken","runtimeContext","getName","toString","throwActionDecoratorError","actions_1","actions_1_1","selectorId","defineProperties","writable","enumerable","configurable","descriptor","throwSelectorDecoratorError","newDescriptor","methodName","inheritedStateClass","getPrototypeOf","optionsWithInheritance","inheritanceOptions","getStateOptions","params","inheritedMeta","mutateMetaData","action1","type1","action2","ensureSelectorMetadataInternal","ensureStoreMetadataInternal","getSelectorMetadataInternal","getStoreMetadataInternal"],"mappings":"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","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","import { Inject, Injectable, NgZone, PLATFORM_ID } from '@angular/core';\nimport { isPlatformServer } from '@angular/common';\n\nimport { NgxsExecutionStrategy } from './symbols';\nimport { getZoneWarningMessage } from '../configs/messages.config';\n\n@Injectable({ providedIn: 'root' })\nexport class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {\n  constructor(private _ngZone: NgZone, @Inject(PLATFORM_ID) private _platformId: string) {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      verifyZoneIsNotNooped(_ngZone);\n    }\n  }\n\n  enter<T>(func: () => T): T {\n    if (isPlatformServer(this._platformId)) {\n      return this.runInsideAngular(func);\n    }\n    return this.runOutsideAngular(func);\n  }\n\n  leave<T>(func: () => T): T {\n    return this.runInsideAngular(func);\n  }\n\n  private runInsideAngular<T>(func: () => T): T {\n    if (NgZone.isInAngularZone()) {\n      return func();\n    }\n    return this._ngZone.run(func);\n  }\n\n  private runOutsideAngular<T>(func: () => T): T {\n    if (NgZone.isInAngularZone()) {\n      return this._ngZone.runOutsideAngular(func);\n    }\n    return func();\n  }\n}\n\n// Caretaker note: this should exist as a separate function and not a class method,\n// since class methods are not tree-shakable.\nfunction verifyZoneIsNotNooped(ngZone: NgZone): void {\n  // `NoopNgZone` is not exposed publicly as it doesn't expect\n  // to be used outside of the core Angular code, thus we just have\n  // to check if the zone doesn't extend or instanceof `NgZone`.\n  if (ngZone instanceof NgZone) {\n    return;\n  }\n\n  console.warn(getZoneWarningMessage());\n}\n","export function throwStateNameError(name: string): never {\n  throw new Error(\n    `${name} is not a valid state name. It needs to be a valid object property name.`\n  );\n}\n\nexport function throwStateNamePropertyError(): never {\n  throw new Error(`States must register a 'name' property.`);\n}\n\nexport function throwStateUniqueError(\n  current: string,\n  newName: string,\n  oldName: string\n): never {\n  throw new Error(`State name '${current}' from ${newName} already exists in ${oldName}.`);\n}\n\nexport function throwStateDecoratorError(name: string): never {\n  throw new Error(`States must be decorated with @State() decorator, but \"${name}\" isn't.`);\n}\n\nexport function throwActionDecoratorError(): never {\n  throw new Error('@Action() decorator cannot be used with static methods.');\n}\n\nexport function throwSelectorDecoratorError(): never {\n  throw new Error('Selectors only work on methods.');\n}\n\nexport function getZoneWarningMessage(): string {\n  return (\n    'Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\\n' +\n    'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\\n' +\n    'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })'\n  );\n}\n\nexport function getUndecoratedStateInIvyWarningMessage(name: string): string {\n  return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;\n}\n\nexport function throwSelectFactoryNotConnectedError(): never {\n  throw new Error('You have forgotten to import the NGXS module!');\n}\n\nexport function throwPatchingArrayError(): never {\n  throw new Error('Patching arrays is not supported.');\n}\n\nexport function throwPatchingPrimitiveError(): never {\n  throw new Error('Patching primitives is not supported.');\n}\n","import { Injectable, InjectionToken, Type } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { PlainObject, StateClass } from '@ngxs/store/internals';\nimport { SharedSelectorOptions } from './internal/internals';\nimport { NgxsExecutionStrategy } from './execution/symbols';\nimport { DispatchOutsideZoneNgxsExecutionStrategy } from './execution/dispatch-outside-zone-ngxs-execution-strategy';\nimport { StateToken } from './state-token/state-token';\n\nexport const ROOT_STATE_TOKEN = new InjectionToken<any>('ROOT_STATE_TOKEN');\nexport const FEATURE_STATE_TOKEN = new InjectionToken<any>('FEATURE_STATE_TOKEN');\nexport const NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');\n\nexport const META_KEY = 'NGXS_META';\nexport const META_OPTIONS_KEY = 'NGXS_OPTIONS_META';\nexport const SELECTOR_META_KEY = 'NGXS_SELECTOR_META';\n\nexport type NgxsLifeCycle = Partial<NgxsOnChanges> &\n  Partial<NgxsOnInit> &\n  Partial<NgxsAfterBootstrap>;\n\nexport type NgxsPluginFn = (state: any, mutation: any, next: NgxsNextPluginFn) => any;\n\n/**\n * The NGXS config settings.\n */\n@Injectable()\nexport class NgxsConfig {\n  /**\n   * Run in development mode. This will add additional debugging features:\n   * - Object.freeze on the state and actions to guarantee immutability\n   * (default: false)\n   *\n   * Note: this property will be accounted only in development mode when using the Ivy compiler.\n   * It makes sense to use it only during development to ensure there're no state mutations.\n   * When building for production, the Object.freeze will be tree-shaken away.\n   */\n  developmentMode: boolean;\n  compatibility: {\n    /**\n     * Support a strict Content Security Policy.\n     * This will circumvent some optimisations that violate a strict CSP through the use of `new Function(...)`.\n     * (default: false)\n     */\n    strictContentSecurityPolicy: boolean;\n  };\n  /**\n   * Determines the execution context to perform async operations inside. An implementation can be\n   * provided to override the default behaviour where the async operations are run\n   * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.\n   * These observable behaviours are from:\n   *   `@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`\n   * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your\n   * application doesn't rely on zone.js running change detection then you can switch to the\n   * `NoopNgxsExecutionStrategy` that doesn't interact with zones.\n   * (default: null)\n   */\n  executionStrategy: Type<NgxsExecutionStrategy>;\n  /**\n   * Defining the default state before module initialization\n   * This is convenient if we need to create a define our own set of states.\n   * @deprecated will be removed after v4\n   * (default: {})\n   */\n  defaultsState: PlainObject = {};\n  /**\n   * Defining shared selector options\n   */\n  selectorOptions: SharedSelectorOptions = {\n    injectContainerState: true, // TODO: default is true in v3, will change in v4\n    suppressErrors: true // TODO: default is true in v3, will change in v4\n  };\n\n  constructor() {\n    this.compatibility = {\n      strictContentSecurityPolicy: false\n    };\n    this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;\n  }\n}\n\nexport type StateOperator<T> = (existing: Readonly<T>) => T;\n\n/**\n * State context provided to the actions in the state.\n */\nexport interface StateContext<T> {\n  /**\n   * Get the current state.\n   */\n  getState(): T;\n\n  /**\n   * Reset the state to a new value.\n   */\n  setState(val: T | StateOperator<T>): T;\n\n  /**\n   * Patch the existing state with the provided value.\n   */\n  patchState(val: Partial<T>): T;\n\n  /**\n   * Dispatch a new action and return the dispatched observable.\n   */\n  dispatch(actions: any | any[]): Observable<void>;\n}\n\nexport type NgxsNextPluginFn = (state: any, mutation: any) => any;\n\n/**\n * Plugin interface\n */\nexport interface NgxsPlugin {\n  /**\n   * Handle the state/action before its submitted to the state handlers.\n   */\n  handle(state: any, action: any, next: NgxsNextPluginFn): any;\n}\n\n/**\n * Options that can be provided to the store.\n */\nexport interface StoreOptions<T> {\n  /**\n   * Name of the state. Required.\n   */\n  name: string | StateToken<T>;\n\n  /**\n   * Default values for the state. If not provided, uses empty object.\n   */\n  defaults?: T;\n\n  /**\n   * Sub states for the given state.\n   */\n  children?: StateClass[];\n}\n\n/**\n * Represents a basic change from a previous to a new value for a single state instance.\n * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.\n */\nexport class NgxsSimpleChange<T = any> {\n  constructor(\n    public readonly previousValue: T,\n    public readonly currentValue: T,\n    public readonly firstChange: boolean\n  ) {}\n}\n\n/**\n * On init interface\n */\nexport interface NgxsOnInit {\n  ngxsOnInit(ctx: StateContext<any>): void;\n}\n\n/**\n * On change interface\n */\nexport interface NgxsOnChanges {\n  ngxsOnChanges(change: NgxsSimpleChange): void;\n}\n\n/**\n * After bootstrap interface\n */\nexport interface NgxsAfterBootstrap {\n  ngxsAfterBootstrap(ctx: StateContext<any>): void;\n}\n\nexport type NgxsModuleOptions = Partial<NgxsConfig>;\n\n/** @internal */\ndeclare global {\n  const ngDevMode: boolean;\n}\n","import { Injectable } from '@angular/core';\n\nimport { NgxsExecutionStrategy } from './symbols';\n\n@Injectable({ providedIn: 'root' })\nexport class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {\n  enter<T>(func: () => T): T {\n    return func();\n  }\n\n  leave<T>(func: () => T): T {\n    return func();\n  }\n}\n","import { InjectionToken, inject, INJECTOR, Type, ɵglobal } from '@angular/core';\n\nimport { NoopNgxsExecutionStrategy } from './noop-ngxs-execution-strategy';\nimport { DispatchOutsideZoneNgxsExecutionStrategy } from './dispatch-outside-zone-ngxs-execution-strategy';\n\n/**\n * The strategy that might be provided by users through `options.executionStrategy`.\n */\nexport const USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken<\n  Type<NgxsExecutionStrategy> | undefined\n>('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');\n\n/*\n * Internal execution strategy injection token\n */\nexport const NGXS_EXECUTION_STRATEGY = new InjectionToken<NgxsExecutionStrategy>(\n  'NGXS_EXECUTION_STRATEGY',\n  {\n    providedIn: 'root',\n    factory: () => {\n      const injector = inject(INJECTOR);\n      const executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);\n      return executionStrategy\n        ? injector.get(executionStrategy)\n        : injector.get(\n            typeof ɵglobal.Zone !== 'undefined'\n              ? DispatchOutsideZoneNgxsExecutionStrategy\n              : NoopNgxsExecutionStrategy\n          );\n    }\n  }\n);\n\n/*\n * Execution strategy interface\n */\nexport interface NgxsExecutionStrategy {\n  enter<T>(func: () => T): T;\n  leave<T>(func: () => T): T;\n}\n","import { PlainObjectOf, StateClass } from '@ngxs/store/internals';\nimport { Observable } from 'rxjs';\n\nimport {\n  META_KEY,\n  META_OPTIONS_KEY,\n  NgxsConfig,\n  SELECTOR_META_KEY,\n  StoreOptions\n} from '../symbols';\nimport { ActionHandlerMetaData } from '../actions/symbols';\n\n// inspired from https://stackoverflow.com/a/43674389\nexport interface StateClassInternal<T = any, U = any> extends StateClass<T> {\n  [META_KEY]?: MetaDataModel;\n  [META_OPTIONS_KEY]?: StoreOptions<U>;\n}\n\nexport type StateKeyGraph = PlainObjectOf<string[]>;\nexport type StatesByName = PlainObjectOf<StateClassInternal>;\n\nexport interface StateOperations<T> {\n  getState(): T;\n\n  setState(val: T): T;\n\n  dispatch(actionOrActions: any | any[]): Observable<void>;\n}\n\nexport interface MetaDataModel {\n  name: string | null;\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\n  defaults: any;\n  path: string | null;\n  makeRootSelector: SelectorFactory | null;\n  children?: StateClassInternal[];\n}\n\nexport interface RuntimeSelectorContext {\n  getStateGetter(key: any): (state: any) => any;\n  getSelectorOptions(localOptions?: SharedSelectorOptions): SharedSelectorOptions;\n}\n\nexport type SelectFromRootState = (rootState: any) => any;\nexport type SelectorFactory = (runtimeContext: RuntimeSelectorContext) => SelectFromRootState;\n\nexport interface SharedSelectorOptions {\n  injectContainerState?: boolean;\n  suppressErrors?: boolean;\n}\n\nexport interface SelectorMetaDataModel {\n  makeRootSelector: SelectorFactory | null;\n  originalFn: Function | null;\n  containerClass: any;\n  selectorName: string | null;\n  getSelectorOptions: () => SharedSelectorOptions;\n}\n\nexport interface MappedStore {\n  name: string;\n  isInitialised: boolean;\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\n  defaults: any;\n  instance: any;\n  path: string;\n}\n\nexport interface StatesAndDefaults {\n  defaults: any;\n  states: MappedStore[];\n}\n\n/**\n * Ensures metadata is attached to the class and returns it.\n *\n * @ignore\n */\nexport function ensureStoreMetadata(target: StateClassInternal): MetaDataModel {\n  if (!target.hasOwnProperty(META_KEY)) {\n    const defaultMetadata: MetaDataModel = {\n      name: null,\n      actions: {},\n      defaults: {},\n      path: null,\n      makeRootSelector(context: RuntimeSelectorContext) {\n        return context.getStateGetter(defaultMetadata.name);\n      },\n      children: []\n    };\n\n    Object.defineProperty(target, META_KEY, { value: defaultMetadata });\n  }\n  return getStoreMetadata(target);\n}\n\n/**\n * Get the metadata attached to the state class if it exists.\n *\n * @ignore\n */\nexport function getStoreMetadata(target: StateClassInternal): MetaDataModel {\n  return target[META_KEY]!;\n}\n\n/**\n * Ensures metadata is attached to the selector and returns it.\n *\n * @ignore\n */\nexport function ensureSelectorMetadata(target: Function): SelectorMetaDataModel {\n  if (!target.hasOwnProperty(SELECTOR_META_KEY)) {\n    const defaultMetadata: SelectorMetaDataModel = {\n      makeRootSelector: null,\n      originalFn: null,\n      containerClass: null,\n      selectorName: null,\n      getSelectorOptions: () => ({})\n    };\n\n    Object.defineProperty(target, SELECTOR_META_KEY, { value: defaultMetadata });\n  }\n\n  return getSelectorMetadata(target);\n}\n\n/**\n * Get the metadata attached to the selector if it exists.\n *\n * @ignore\n */\nexport function getSelectorMetadata(target: any): SelectorMetaDataModel {\n  return target[SELECTOR_META_KEY];\n}\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.\n * See perf hit: https://jsperf.com/fast-value-getter-given-path/1\n *\n * @ignore\n */\nfunction compliantPropGetter(paths: string[]): (x: any) => any {\n  const copyOfPaths = paths.slice();\n  return obj => copyOfPaths.reduce((acc: any, part: string) => acc && acc[part], obj);\n}\n\n/**\n * The generated function is faster than:\n * - pluck (Observable operator)\n * - memoize\n *\n * @ignore\n */\nfunction fastPropGetter(paths: string[]): (x: any) => any {\n  const segments = paths;\n  let seg = 'store.' + segments[0];\n  let i = 0;\n  const l = segments.length;\n\n  let expr = seg;\n  while (++i < l) {\n    expr = expr + ' && ' + (seg = seg + '.' + segments[i]);\n  }\n\n  const fn = new Function('store', 'return ' + expr + ';');\n\n  return <(x: any) => any>fn;\n}\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * @ignore\n */\nexport function propGetter(paths: string[], config: NgxsConfig) {\n  if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {\n    return compliantPropGetter(paths);\n  } else {\n    return fastPropGetter(paths);\n  }\n}\n\n/**\n * Given an array of states, it will return a object graph. Example:\n *    const states = [\n *      Cart,\n *      CartSaved,\n *      CartSavedItems\n *    ]\n *\n * would return:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * @ignore\n */\nexport function buildGraph(stateClasses: StateClassInternal[]): StateKeyGraph {\n  const findName = (stateClass: StateClassInternal) => {\n    const meta = stateClasses.find(g => g === stateClass);\n\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && !meta) {\n      throw new Error(\n        `Child state not found: ${stateClass}. \\r\\nYou may have forgotten to add states to module`\n      );\n    }\n\n    return meta![META_KEY]!.name!;\n  };\n\n  return stateClasses.reduce<StateKeyGraph>(\n    (result: StateKeyGraph, stateClass: StateClassInternal) => {\n      const { name, children } = stateClass[META_KEY]!;\n      result[name!] = (children || []).map(findName);\n      return result;\n    },\n    {}\n  );\n}\n\n/**\n * Given a states array, returns object graph\n * returning the name and state metadata. Example:\n *\n *  const graph = {\n *    cart: { metadata }\n *  };\n *\n * @ignore\n */\nexport function nameToState(states: StateClassInternal[]): PlainObjectOf<StateClassInternal> {\n  return states.reduce<PlainObjectOf<StateClassInternal>>(\n    (result: PlainObjectOf<StateClassInternal>, stateClass: StateClassInternal) => {\n      const meta = stateClass[META_KEY]!;\n      result[meta.name!] = stateClass;\n      return result;\n    },\n    {}\n  );\n}\n\n/**\n * Given a object relationship graph will return the full path\n * for the child items. Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const r = {\n *    cart: 'cart',\n *    saved: 'cart.saved',\n *    items: 'cart.saved.items'\n *  };\n *\n * @ignore\n */\nexport function findFullParentPath(\n  obj: StateKeyGraph,\n  newObj: PlainObjectOf<string> = {}\n): PlainObjectOf<string> {\n  const visit = (child: StateKeyGraph, keyToFind: string): string | null => {\n    for (const key in child) {\n      if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {\n        const parent = visit(child, key);\n        return parent !== null ? `${parent}.${key}` : key;\n      }\n    }\n    return null;\n  };\n\n  for (const key in obj) {\n    if (obj.hasOwnProperty(key)) {\n      const parent = visit(obj, key);\n      newObj[key] = parent ? `${parent}.${key}` : key;\n    }\n  }\n\n  return newObj;\n}\n\n/**\n * Given a object graph, it will return the items topologically sorted Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const results = [\n *    'items',\n *    'saved',\n *    'cart'\n *  ];\n *\n * @ignore\n */\nexport function topologicalSort(graph: StateKeyGraph): string[] {\n  const sorted: string[] = [];\n  const visited: PlainObjectOf<boolean> = {};\n\n  const visit = (name: string, ancestors: string[] = []) => {\n    if (!Array.isArray(ancestors)) {\n      ancestors = [];\n    }\n\n    ancestors.push(name);\n    visited[name] = true;\n\n    graph[name].forEach((dep: string) => {\n      // Caretaker note: we have still left the `typeof` condition in order to avoid\n      // creating a breaking change for projects that still use the View Engine.\n      if ((typeof ngDevMode === 'undefined' || ngDevMode) && ancestors.indexOf(dep) >= 0) {\n        throw new Error(\n          `Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`\n        );\n      }\n\n      if (visited[dep]) {\n        return;\n      }\n\n      visit(dep, ancestors.slice(0));\n    });\n\n    if (sorted.indexOf(name) < 0) {\n      sorted.push(name);\n    }\n  };\n\n  Object.keys(graph).forEach(k => visit(k));\n\n  return sorted.reverse();\n}\n\n/**\n * Returns if the parameter is a object or not.\n *\n * @ignore\n */\nexport function isObject(obj: any) {\n  return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';\n}\n","/**\n * Returns the type from an action instance/class.\n * @ignore\n */\nexport function getActionTypeFromInstance(action: any): string | undefined {\n  if (action.constructor && action.constructor.type) {\n    return action.constructor.type;\n  } else {\n    return action.type;\n  }\n}\n\n/**\n * Matches a action\n * @ignore\n */\nexport function actionMatcher(action1: any) {\n  const type1 = getActionTypeFromInstance(action1);\n\n  return function(action2: any) {\n    return type1 === getActionTypeFromInstance(action2);\n  };\n}\n\n/**\n * Set a deeply nested value. Example:\n *\n *   setValue({ foo: { bar: { eat: false } } },\n *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }\n *\n * While it traverses it also creates new objects from top down.\n *\n * @ignore\n */\nexport const setValue = (obj: any, prop: string, val: any) => {\n  obj = { ...obj };\n\n  const split = prop.split('.');\n  const lastIndex = split.length - 1;\n\n  split.reduce((acc, part, index) => {\n    if (index === lastIndex) {\n      acc[part] = val;\n    } else {\n      acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : { ...acc[part] };\n    }\n\n    return acc && acc[part];\n  }, obj);\n\n  return obj;\n};\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * @ignore\n */\nexport const getValue = (obj: any, prop: string): any =>\n  prop.split('.').reduce((acc: any, part: string) => acc && acc[part], obj);\n\n/**\n * Simple object check.\n *\n *    isObject({a:1}) //=> true\n *    isObject(1) //=> false\n *\n * @ignore\n */\nexport const isObject = (item: any) => {\n  return item && typeof item === 'object' && !Array.isArray(item);\n};\n\n/**\n * Deep merge two objects.\n *\n *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}\n *\n * @param base base object onto which `sources` will be applied\n */\nexport const mergeDeep = (base: any, ...sources: any[]): any => {\n  if (!sources.length) return base;\n  const source = sources.shift();\n\n  if (isObject(base) && isObject(source)) {\n    for (const key in source) {\n      if (isObject(source[key])) {\n        if (!base[key]) Object.assign(base, { [key]: {} });\n        mergeDeep(base[key], source[key]);\n      } else {\n        Object.assign(base, { [key]: source[key] });\n      }\n    }\n  }\n\n  return mergeDeep(base, ...sources);\n};\n","import { OperatorFunction, Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ActionType } from '../actions/symbols';\nimport { getActionTypeFromInstance } from '../utils/utils';\nimport { ActionContext, ActionStatus } from '../actions-stream';\n\ntype TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>;\n\n/**\n * Given a POJO, returns the POJO type, given a class constructor object, returns the type of the class.\n *\n * This utility type exists due to the complexity of ActionType being either an ActionDef class or the plain\n * `{ type: string }` type (or similar compatible POJO types).\n */\ntype Constructed<T> = T extends new (...args: any[]) => infer U ? U : T;\n\nexport interface ActionCompletion<T = any, E = Error> {\n  action: T;\n  result: {\n    successful: boolean;\n    canceled: boolean;\n    error?: E;\n  };\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will grab actions that have just been dispatched as well as actions that have completed\n */\nexport function ofAction<T extends ActionType[]>(\n  ...allowedTypes: T\n): OperatorFunction<\n  ActionContext<Constructed<T[TupleKeys<T>]>>,\n  Constructed<T[TupleKeys<T>]>\n> {\n  return ofActionOperator(allowedTypes);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been dispatched\n */\nexport function ofActionDispatched<T extends ActionType[]>(\n  ...allowedTypes: T\n): OperatorFunction<\n  ActionContext<Constructed<T[TupleKeys<T>]>>,\n  Constructed<T[TupleKeys<T>]>\n> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Dispatched]);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been successfully completed\n */\nexport function ofActionSuccessful<T extends ActionType[]>(\n  ...allowedTypes: T\n): OperatorFunction<\n  ActionContext<Constructed<T[TupleKeys<T>]>>,\n  Constructed<T[TupleKeys<T>]>\n> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Successful]);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been canceled\n */\nexport function ofActionCanceled<T extends ActionType[]>(\n  ...allowedTypes: T\n): OperatorFunction<\n  ActionContext<Constructed<T[TupleKeys<T>]>>,\n  Constructed<T[TupleKeys<T>]>\n> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Canceled]);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been completed\n */\nexport function ofActionCompleted<T extends ActionType[]>(\n  ...allowedTypes: T\n): OperatorFunction<\n  ActionContext<Constructed<T[TupleKeys<T>]>>,\n  ActionCompletion<Constructed<T[TupleKeys<T>]>>\n> {\n  const allowedStatuses = [\n    ActionStatus.Successful,\n    ActionStatus.Canceled,\n    ActionStatus.Errored\n  ];\n  return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just thrown an error\n */\nexport function ofActionErrored<T extends ActionType[]>(\n  ...allowedTypes: T\n): OperatorFunction<\n  ActionContext<Constructed<T[TupleKeys<T>]>>,\n  Constructed<T[TupleKeys<T>]>\n> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Errored]);\n}\n\nfunction ofActionOperator(\n  allowedTypes: ActionType[],\n  statuses?: ActionStatus[],\n  // This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,\n  // since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`\n  // defaults to `any`, thus there is no sense from union type.\n  mapOperator: () => OperatorFunction<ActionContext, any> = mapAction\n): OperatorFunction<ActionContext, any> {\n  const allowedMap = createAllowedActionTypesMap(allowedTypes);\n  const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);\n  return function(o: Observable<ActionContext>) {\n    return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());\n  };\n}\n\nfunction filterStatus(allowedTypes: FilterMap, allowedStatuses?: FilterMap) {\n  return filter((ctx: ActionContext) => {\n    const actionType = getActionTypeFromInstance(ctx.action)!;\n    const typeMatch = allowedTypes[actionType];\n    const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;\n    return typeMatch && statusMatch;\n  });\n}\n\nfunction mapActionResult(): OperatorFunction<ActionContext, ActionCompletion> {\n  return map(({ action, status, error }: ActionContext) => {\n    return <ActionCompletion>{\n      action,\n      result: {\n        successful: ActionStatus.Successful === status,\n        canceled: ActionStatus.Canceled === status,\n        error\n      }\n    };\n  });\n}\n\nfunction mapAction<T = any>(): OperatorFunction<ActionContext, T> {\n  return map((ctx: ActionContext) => <T>ctx.action);\n}\n\ninterface FilterMap {\n  [key: string]: boolean;\n}\n\nfunction createAllowedActionTypesMap(types: ActionType[]): FilterMap {\n  return types.reduce((filterMap: FilterMap, klass: any) => {\n    filterMap[getActionTypeFromInstance(klass)!] = true;\n    return filterMap;\n  }, <FilterMap>{});\n}\n\nfunction createAllowedStatusesMap(statuses: ActionStatus[]): FilterMap {\n  return statuses.reduce((filterMap: FilterMap, status: ActionStatus) => {\n    filterMap[status] = true;\n    return filterMap;\n  }, <FilterMap>{});\n}\n","import { MonoTypeOperatorFunction, Observable, Observer } from 'rxjs';\nimport { NgxsExecutionStrategy } from '../execution/symbols';\n\n/**\n * Returns operator that will run\n * `subscribe` outside of the ngxs execution context\n */\nexport function leaveNgxs<T>(\n  ngxsExecutionStrategy: NgxsExecutionStrategy\n): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => {\n    return new Observable((sink: Observer<T>) => {\n      return source.subscribe({\n        next(value) {\n          ngxsExecutionStrategy.leave(() => sink.next(value));\n        },\n        error(error) {\n          ngxsExecutionStrategy.leave(() => sink.error(error));\n        },\n        complete() {\n          ngxsExecutionStrategy.leave(() => sink.complete());\n        }\n      });\n    });\n  };\n}\n","import { Injectable, Inject } from '@angular/core';\n\nimport { NgxsExecutionStrategy, NGXS_EXECUTION_STRATEGY } from './symbols';\n\n@Injectable()\nexport class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {\n  constructor(\n    @Inject(NGXS_EXECUTION_STRATEGY) private _executionStrategy: NgxsExecutionStrategy\n  ) {}\n\n  enter<T>(func: () => T): T {\n    return this._executionStrategy.enter(func);\n  }\n\n  leave<T>(func: () => T): T {\n    return this._executionStrategy.leave(func);\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\nimport { Subject, Observable } from 'rxjs';\nimport { share } from 'rxjs/operators';\n\nimport { leaveNgxs } from './operators/leave-ngxs';\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\n\n/**\n * Status of a dispatched action\n */\nexport const enum ActionStatus {\n  Dispatched = 'DISPATCHED',\n  Successful = 'SUCCESSFUL',\n  Canceled = 'CANCELED',\n  Errored = 'ERRORED'\n}\n\nexport interface ActionContext<T = any> {\n  status: ActionStatus;\n  action: T;\n  error?: Error;\n}\n\n/**\n * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.\n * A standard Subject does not have this guarantee.\n * For example, given the following code:\n * ```typescript\n *   const subject = new Subject<string>();\n     subject.subscribe(value => {\n       if (value === 'start') subject.next('end');\n     });\n     subject.subscribe(value => { });\n     subject.next('start');\n * ```\n * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.\n * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.\n */\nexport class OrderedSubject<T> extends Subject<T> {\n  private _itemQueue: T[] = [];\n  private _busyPushingNext = false;\n\n  next(value?: T): void {\n    if (this._busyPushingNext) {\n      this._itemQueue.unshift(value!);\n      return;\n    }\n    this._busyPushingNext = true;\n    super.next(value);\n    while (this._itemQueue.length > 0) {\n      const nextValue = this._itemQueue.pop();\n      super.next(nextValue);\n    }\n    this._busyPushingNext = false;\n  }\n}\n\n/**\n * Internal Action stream that is emitted anytime an action is dispatched.\n */\n@Injectable()\nexport class InternalActions extends OrderedSubject<ActionContext> implements OnDestroy {\n  ngOnDestroy(): void {\n    this.complete();\n  }\n}\n\n/**\n * Action stream that is emitted anytime an action is dispatched.\n *\n * You can listen to this in services to react without stores.\n */\n@Injectable()\nexport class Actions extends Observable<ActionContext> {\n  constructor(\n    internalActions$: InternalActions,\n    internalExecutionStrategy: InternalNgxsExecutionStrategy\n  ) {\n    const sharedInternalActions$ = internalActions$.pipe(\n      leaveNgxs(internalExecutionStrategy),\n      // The `InternalActions` subject emits outside of the Angular zone.\n      // We have to re-enter the Angular zone for any incoming consumer.\n      // The `share()` operator reduces the number of change detections.\n      // This would call leave only once for any stream emission across all active subscribers.\n      share()\n    );\n\n    super(observer => {\n      const childSubscription = sharedInternalActions$.subscribe({\n        next: ctx => observer.next(ctx),\n        error: error => observer.error(error),\n        complete: () => observer.complete()\n      });\n\n      observer.add(childSubscription);\n    });\n  }\n}\n","export type StateFn = (...args: any[]) => any;\n\n/**\n * Composes a array of functions from left to right. Example:\n *\n *      compose([fn, final])(state, action);\n *\n * then the funcs have a signature like:\n *\n *      function fn (state, action, next) {\n *          console.log('here', state, action, next);\n *          return next(state, action);\n *      }\n *\n *      function final (state, action) {\n *          console.log('here', state, action);\n *          return state;\n *      }\n *\n * the last function should not call `next`.\n *\n * @ignore\n */\nexport const compose = (funcs: StateFn[]) => (...args: any[]) => {\n  const curr = funcs.shift()!;\n  return curr(...args, (...nextArgs: any[]) => compose(funcs)(...nextArgs));\n};\n","import { ErrorHandler, Injectable, Injector } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { leaveNgxs } from '../operators/leave-ngxs';\nimport { NgxsExecutionStrategy } from '../execution/symbols';\n\n/**\n * This operator is used for piping the observable result\n * from the `dispatch()`. It has a \"smart\" error handling\n * strategy that allows us to decide whether we propagate\n * errors to Angular's `ErrorHandler` or enable users to\n * handle them manually. We consider following cases:\n * 1) `store.dispatch()` (no subscribe) -> call `handleError()`\n * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`\n * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`\n * 4) `toPromise()` without `catch` -> do `handleError()`\n * 5) `toPromise()` with `catch` -> don't `handleError()`\n */\nexport function ngxsErrorHandler<T>(\n  internalErrorReporter: InternalErrorReporter,\n  ngxsExecutionStrategy: NgxsExecutionStrategy\n) {\n  return (source: Observable<T>) => {\n    let subscribed = false;\n\n    source.subscribe({\n      error: error => {\n        // Do not trigger change detection for a microtask. This depends on the execution\n        // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`\n        // leaves the Angular zone.\n        ngxsExecutionStrategy.enter(() =>\n          Promise.resolve().then(() => {\n            if (!subscribed) {\n              ngxsExecutionStrategy.leave(() =>\n                internalErrorReporter.reportErrorSafely(error)\n              );\n            }\n          })\n        );\n      }\n    });\n\n    return new Observable(subscriber => {\n      subscribed = true;\n      return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);\n    });\n  };\n}\n\n@Injectable({ providedIn: 'root' })\nexport class InternalErrorReporter {\n  /** Will be set lazily to be backward compatible. */\n  private _errorHandler: ErrorHandler = null!;\n\n  constructor(private _injector: Injector) {}\n\n  reportErrorSafely(error: any): void {\n    if (this._errorHandler === null) {\n      this._errorHandler = this._injector.get(ErrorHandler);\n    }\n    // The `try-catch` is used to avoid handling the error twice. Suppose we call\n    // `handleError` which re-throws the error internally. The re-thrown error will\n    // be caught by zone.js which will then get to the `zone.onError.emit()` and the\n    // `onError` subscriber will call `handleError` again.\n    try {\n      this._errorHandler.handleError(error);\n    } catch {}\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { PlainObject } from '@ngxs/store/internals';\n\n/**\n * BehaviorSubject of the entire state.\n * @ignore\n */\n@Injectable()\nexport class StateStream extends BehaviorSubject<PlainObject> implements OnDestroy {\n  constructor() {\n    super({});\n  }\n\n  ngOnDestroy(): void {\n    // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.\n    // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users\n    // might forget to unsubscribe from `store.select` or `store.subscribe`, thus this will lead to huge memory leaks in SSR apps.\n    this.complete();\n  }\n}\n","import { Inject, Injectable, Optional, SkipSelf } from '@angular/core';\nimport { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn } from './symbols';\n\n@Injectable()\nexport class PluginManager {\n  public plugins: NgxsPluginFn[] = [];\n\n  constructor(\n    @Optional()\n    @SkipSelf()\n    private _parentManager: PluginManager,\n    @Inject(NGXS_PLUGINS)\n    @Optional()\n    private _pluginHandlers: NgxsPlugin[]\n  ) {\n    this.registerHandlers();\n  }\n\n  private get rootPlugins(): NgxsPluginFn[] {\n    return (this._parentManager && this._parentManager.plugins) || this.plugins;\n  }\n\n  private registerHandlers(): void {\n    const pluginHandlers: NgxsPluginFn[] = this.getPluginHandlers();\n    this.rootPlugins.push(...pluginHandlers);\n  }\n\n  private getPluginHandlers(): NgxsPluginFn[] {\n    const handlers: NgxsPlugin[] = this._pluginHandlers || [];\n    return handlers.map(\n      (plugin: NgxsPlugin) =>\n        (plugin.handle ? plugin.handle.bind(plugin) : plugin) as NgxsPluginFn\n    );\n  }\n}\n","import { Injectable } from '@angular/core';\nimport { EMPTY, forkJoin, Observable, of, Subject, throwError } from 'rxjs';\nimport { exhaustMap, filter, shareReplay, take } from 'rxjs/operators';\n\nimport { compose } from '../utils/compose';\nimport { InternalErrorReporter, ngxsErrorHandler } from './error-handler';\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\nimport { StateStream } from './state-stream';\nimport { PluginManager } from '../plugin-manager';\nimport { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';\nimport { getActionTypeFromInstance } from '../utils/utils';\n\n/**\n * Internal Action result stream that is emitted when an action is completed.\n * This is used as a method of returning the action result to the dispatcher\n * for the observable returned by the dispatch(...) call.\n * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.\n */\n@Injectable()\nexport class InternalDispatchedActionResults extends Subject<ActionContext> {}\n\n@Injectable()\nexport class InternalDispatcher {\n  constructor(\n    private _actions: InternalActions,\n    private _actionResults: InternalDispatchedActionResults,\n    private _pluginManager: PluginManager,\n    private _stateStream: StateStream,\n    private _ngxsExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _internalErrorReporter: InternalErrorReporter\n  ) {}\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    const result = this._ngxsExecutionStrategy.enter(() =>\n      this.dispatchByEvents(actionOrActions)\n    );\n\n    return result.pipe(\n      ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy)\n    );\n  }\n\n  private dispatchByEvents(actionOrActions: any | any[]): Observable<any> {\n    if (Array.isArray(actionOrActions)) {\n      if (actionOrActions.length === 0) return of(this._stateStream.getValue());\n      return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));\n    } else {\n      return this.dispatchSingle(actionOrActions);\n    }\n  }\n\n  private dispatchSingle(action: any): Observable<any> {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const type: string | undefined = getActionTypeFromInstance(action);\n      if (!type) {\n        const error = new Error(\n          `This action doesn't have a type property: ${action.constructor.name}`\n        );\n        return throwError(error);\n      }\n    }\n\n    const prevState = this._stateStream.getValue();\n    const plugins = this._pluginManager.plugins;\n\n    return (compose([\n      ...plugins,\n      (nextState: any, nextAction: any) => {\n        if (nextState !== prevState) {\n          this._stateStream.next(nextState);\n        }\n        const actionResult$ = this.getActionResultStream(nextAction);\n        actionResult$.subscribe(ctx => this._actions.next(ctx));\n        this._actions.next({ action: nextAction, status: ActionStatus.Dispatched });\n        return this.createDispatchObservable(actionResult$);\n      }\n    ])(prevState, action) as Observable<any>).pipe(shareReplay());\n  }\n\n  private getActionResultStream(action: any): Observable<ActionContext> {\n    return this._actionResults.pipe(\n      filter(\n        (ctx: ActionContext) => ctx.action === action && ctx.status !== ActionStatus.Dispatched\n      ),\n      take(1),\n      shareReplay()\n    );\n  }\n\n  private createDispatchObservable(actionResult$: Observable<ActionContext>): Observable<any> {\n    return actionResult$\n      .pipe(\n        exhaustMap((ctx: ActionContext) => {\n          switch (ctx.status) {\n            case ActionStatus.Successful:\n              return of(this._stateStream.getValue());\n            case ActionStatus.Errored:\n              return throwError(ctx.error);\n            default:\n              return EMPTY;\n          }\n        })\n      )\n      .pipe(shareReplay());\n  }\n}\n","/**\n * Object freeze code\n * https://github.com/jsdf/deep-freeze\n */\nexport const deepFreeze = (o: any) => {\n  Object.freeze(o);\n\n  const oIsFunction = typeof o === 'function';\n  const hasOwnProp = Object.prototype.hasOwnProperty;\n\n  Object.getOwnPropertyNames(o).forEach(function(prop) {\n    if (\n      hasOwnProp.call(o, prop) &&\n      (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&\n      o[prop] !== null &&\n      (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\n      !Object.isFrozen(o[prop])\n    ) {\n      deepFreeze(o[prop]);\n    }\n  });\n\n  return o;\n};\n","import { Injectable } from '@angular/core';\n\nimport { StateOperations, StatesAndDefaults } from '../internal/internals';\nimport { InternalDispatcher } from '../internal/dispatcher';\nimport { StateStream } from './state-stream';\nimport { NgxsConfig } from '../symbols';\nimport { deepFreeze } from '../utils/freeze';\n\n/**\n * State Context factory class\n * @ignore\n */\n@Injectable()\nexport class InternalStateOperations {\n  constructor(\n    private _stateStream: StateStream,\n    private _dispatcher: InternalDispatcher,\n    private _config: NgxsConfig\n  ) {}\n\n  /**\n   * Returns the root state operators.\n   */\n  getRootStateOperations(): StateOperations<any> {\n    const rootStateOperations = {\n      getState: () => this._stateStream.getValue(),\n      setState: (newState: any) => this._stateStream.next(newState),\n      dispatch: (actionOrActions: any | any[]) => this._dispatcher.dispatch(actionOrActions)\n    };\n\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      return this._config.developmentMode\n        ? ensureStateAndActionsAreImmutable(rootStateOperations)\n        : rootStateOperations;\n    } else {\n      return rootStateOperations;\n    }\n  }\n\n  setStateToTheCurrentWithNew(results: StatesAndDefaults): void {\n    const stateOperations: StateOperations<any> = this.getRootStateOperations();\n\n    // Get our current stream\n    const currentState = stateOperations.getState();\n    // Set the state to the current + new\n    stateOperations.setState({ ...currentState, ...results.defaults });\n  }\n}\n\nfunction ensureStateAndActionsAreImmutable(root: StateOperations<any>): StateOperations<any> {\n  return {\n    getState: () => root.getState(),\n    setState: value => {\n      const frozenValue = deepFreeze(value);\n      return root.setState(frozenValue);\n    },\n    dispatch: actions => {\n      return root.dispatch(actions);\n    }\n  };\n}\n","import {\n  throwPatchingArrayError,\n  throwPatchingPrimitiveError\n} from '../configs/messages.config';\nimport { StateOperator } from '../symbols';\n\nexport function simplePatch<T>(val: Partial<T>): StateOperator<T> {\n  return (existingState: Readonly<T>) => {\n    if (Array.isArray(val)) {\n      throwPatchingArrayError();\n    } else if (typeof val !== 'object') {\n      throwPatchingPrimitiveError();\n    }\n\n    const newState: any = { ...(existingState as any) };\n    for (const key in val) {\n      // deep clone for patch compatibility\n      // noinspection JSUnfilteredForInLoop (IDE)\n      newState[key] = (val as any)[key];\n    }\n\n    return newState as T;\n  };\n}\n","import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { StateContext, StateOperator } from '../symbols';\nimport { MappedStore } from '../internal/internals';\nimport { setValue, getValue } from '../utils/utils';\nimport { InternalStateOperations } from '../internal/state-operations';\nimport { simplePatch } from './state-operators';\n\n/**\n * State Context factory class\n * @ignore\n */\n@Injectable()\nexport class StateContextFactory {\n  constructor(private _internalStateOperations: InternalStateOperations) {}\n\n  /**\n   * Create the state context\n   */\n  createStateContext<T>(mappedStore: MappedStore): StateContext<T> {\n    const root = this._internalStateOperations.getRootStateOperations();\n\n    function getState(currentAppState: any): T {\n      return getValue(currentAppState, mappedStore.path);\n    }\n\n    function setStateValue(currentAppState: any, newValue: T): any {\n      const newAppState = setValue(currentAppState, mappedStore.path, newValue);\n      root.setState(newAppState);\n      return newAppState;\n      // In doing this refactoring I noticed that there is a 'bug' where the\n      // application state is returned instead of this state slice.\n      // This has worked this way since the beginning see:\n      // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts\n      // This needs to be fixed, but is a 'breaking' change.\n      // I will do this fix in a subsequent PR and we can decide how to handle it.\n    }\n\n    function setStateFromOperator(currentAppState: any, stateOperator: StateOperator<T>) {\n      const local = getState(currentAppState);\n      const newValue = stateOperator(local);\n      return setStateValue(currentAppState, newValue);\n    }\n\n    function isStateOperator(value: T | StateOperator<T>): value is StateOperator<T> {\n      return typeof value === 'function';\n    }\n\n    return {\n      getState(): T {\n        const currentAppState = root.getState();\n        return getState(currentAppState);\n      },\n      patchState(val: Partial<T>): T {\n        const currentAppState = root.getState();\n        const patchOperator = simplePatch<T>(val);\n        return setStateFromOperator(currentAppState, patchOperator);\n      },\n      setState(val: T | StateOperator<T>): T {\n        const currentAppState = root.getState();\n        return isStateOperator(val)\n          ? setStateFromOperator(currentAppState, val)\n          : setStateValue(currentAppState, val);\n      },\n      dispatch(actions: any | any[]): Observable<void> {\n        return root.dispatch(actions);\n      }\n    };\n  }\n}\n","import { getStoreMetadata, StateClassInternal, StatesByName } from '../internal/internals';\nimport {\n  throwStateDecoratorError,\n  throwStateNameError,\n  throwStateNamePropertyError,\n  throwStateUniqueError\n} from '../configs/messages.config';\n\nexport abstract class StoreValidators {\n  private static stateNameRegex: RegExp = new RegExp('^[a-zA-Z0-9_]+$');\n\n  static checkThatStateIsNamedCorrectly(name: string | null): void | never {\n    if (!name) {\n      throwStateNamePropertyError();\n    } else if (!this.stateNameRegex.test(name)) {\n      throwStateNameError(name);\n    }\n  }\n\n  static checkThatStateNameIsUnique(\n    stateName: string,\n    state: StateClassInternal,\n    statesByName: StatesByName\n  ): void | never {\n    const existingState = statesByName[stateName];\n    if (existingState && existingState !== state) {\n      throwStateUniqueError(stateName, state.name, existingState.name);\n    }\n  }\n\n  static checkThatStateClassesHaveBeenDecorated(\n    stateClasses: StateClassInternal[]\n  ): void | never {\n    stateClasses.forEach((stateClass: StateClassInternal) => {\n      if (!getStoreMetadata(stateClass)) {\n        throwStateDecoratorError(stateClass.name);\n      }\n    });\n  }\n}\n","import { ɵivyEnabled } from '@angular/core';\n\nimport { getUndecoratedStateInIvyWarningMessage } from '../configs/messages.config';\n\n/**\n * All provided or injected tokens must have `@Injectable` decorator\n * (previously, injected tokens without `@Injectable` were allowed\n * if another decorator was used, e.g. pipes).\n */\nexport function ensureStateClassIsInjectable(stateClass: any): void {\n  // `ɵprov` is a static property added by the NGCC compiler. It always exists in\n  // AOT mode because this property is added before runtime. If an application is running in\n  // JIT mode then this property can be added by the `@Injectable()` decorator. The `@Injectable()`\n  // decorator has to go after the `@State()` decorator, thus we prevent users from unwanted DI errors.\n  if (ɵivyEnabled) {\n    const ngInjectableDef = stateClass.ɵprov;\n    if (!ngInjectableDef) {\n      // Don't warn if Ivy is disabled or `ɵprov` exists on the class\n      console.warn(getUndecoratedStateInIvyWarningMessage(stateClass.name));\n    }\n  }\n}\n","import { Injectable, Injector, Optional, SkipSelf, Inject, OnDestroy } from '@angular/core';\nimport {\n  forkJoin,\n  from,\n  Observable,\n  of,\n  throwError,\n  Subscription,\n  Subject,\n  isObservable\n} from 'rxjs';\nimport {\n  catchError,\n  defaultIfEmpty,\n  filter,\n  map,\n  mergeMap,\n  shareReplay,\n  takeUntil\n} from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObjectOf, memoize } from '@ngxs/store/internals';\n\nimport { META_KEY, NgxsConfig } from '../symbols';\nimport {\n  buildGraph,\n  findFullParentPath,\n  isObject,\n  MappedStore,\n  MetaDataModel,\n  nameToState,\n  propGetter,\n  StateClassInternal,\n  StateKeyGraph,\n  StatesAndDefaults,\n  StatesByName,\n  topologicalSort,\n  RuntimeSelectorContext,\n  SharedSelectorOptions,\n  getStoreMetadata\n} from './internals';\nimport { getActionTypeFromInstance, getValue, setValue } from '../utils/utils';\nimport { ofActionDispatched } from '../operators/of-action';\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\nimport { InternalDispatchedActionResults } from '../internal/dispatcher';\nimport { StateContextFactory } from '../internal/state-context-factory';\nimport { StoreValidators } from '../utils/store-validators';\nimport { ensureStateClassIsInjectable } from '../ivy/ivy-enabled-in-dev-mode';\n\n/**\n * State factory class\n * @ignore\n */\n@Injectable()\nexport class StateFactory implements OnDestroy {\n  private _actionsSubscription: Subscription | null = null;\n\n  constructor(\n    private _injector: Injector,\n    private _config: NgxsConfig,\n    @Optional()\n    @SkipSelf()\n    private _parentFactory: StateFactory,\n    private _actions: InternalActions,\n    private _actionResults: InternalDispatchedActionResults,\n    private _stateContextFactory: StateContextFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    private _initialState: any\n  ) {}\n\n  private _states: MappedStore[] = [];\n\n  get states(): MappedStore[] {\n    return this._parentFactory ? this._parentFactory.states : this._states;\n  }\n\n  private _statesByName: StatesByName = {};\n\n  get statesByName(): StatesByName {\n    return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;\n  }\n\n  private _statePaths: PlainObjectOf<string> = {};\n\n  private get statePaths(): PlainObjectOf<string> {\n    return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;\n  }\n\n  getRuntimeSelectorContext = memoize(() => {\n    const stateFactory = this;\n\n    function resolveGetter(key: string) {\n      const path = stateFactory.statePaths[key];\n      return path ? propGetter(path.split('.'), stateFactory._config) : null;\n    }\n\n    const context: RuntimeSelectorContext = this._parentFactory\n      ? this._parentFactory.getRuntimeSelectorContext()\n      : {\n          getStateGetter(key: string) {\n            let getter = resolveGetter(key);\n            if (getter) {\n              return getter;\n            }\n            return (...args) => {\n              // Late loaded getter\n              if (!getter) {\n                getter = resolveGetter(key);\n              }\n              return getter ? getter(...args) : undefined;\n            };\n          },\n          getSelectorOptions(localOptions?: SharedSelectorOptions) {\n            const globalSelectorOptions = stateFactory._config.selectorOptions;\n            return {\n              ...globalSelectorOptions,\n              ...(localOptions || {})\n            };\n          }\n        };\n    return context;\n  });\n\n  private static cloneDefaults(defaults: any): any {\n    let value = {};\n\n    if (Array.isArray(defaults)) {\n      value = defaults.slice();\n    } else if (isObject(defaults)) {\n      value = { ...defaults };\n    } else if (defaults === undefined) {\n      value = {};\n    } else {\n      value = defaults;\n    }\n\n    return value;\n  }\n\n  ngOnDestroy(): void {\n    // I'm using non-null assertion here since `_actionsSubscrition` will\n    // be 100% defined. This is because `ngOnDestroy()` cannot be invoked\n    // on the `StateFactory` until its initialized :) An it's initialized\n    // for the first time along with the `NgxsRootModule`.\n    this._actionsSubscription!.unsubscribe();\n  }\n\n  /**\n   * Add a new state to the global defs.\n   */\n  add(stateClasses: StateClassInternal[]): MappedStore[] {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      StoreValidators.checkThatStateClassesHaveBeenDecorated(stateClasses);\n    }\n\n    const { newStates } = this.addToStatesMap(stateClasses);\n    if (!newStates.length) return [];\n\n    const stateGraph: StateKeyGraph = buildGraph(newStates);\n    const sortedStates: string[] = topologicalSort(stateGraph);\n    const paths: PlainObjectOf<string> = findFullParentPath(stateGraph);\n    const nameGraph: PlainObjectOf<StateClassInternal> = nameToState(newStates);\n    const bootstrappedStores: MappedStore[] = [];\n\n    for (const name of sortedStates) {\n      const stateClass: StateClassInternal = nameGraph[name];\n      const path: string = paths[name];\n      const meta: MetaDataModel = stateClass[META_KEY]!;\n\n      this.addRuntimeInfoToMeta(meta, path);\n\n      // Note: previously we called `ensureStateClassIsInjectable` within the\n      // `State` decorator. This check is moved here because the `ɵprov` property\n      // will not exist on the class in JIT mode (because it's set asynchronously\n      // during JIT compilation through `Object.defineProperty`).\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        ensureStateClassIsInjectable(stateClass);\n      }\n\n      const stateMap: MappedStore = {\n        name,\n        path,\n        isInitialised: false,\n        actions: meta.actions,\n        instance: this._injector.get(stateClass),\n        defaults: StateFactory.cloneDefaults(meta.defaults)\n      };\n\n      // ensure our store hasn't already been added\n      // but don't throw since it could be lazy\n      // loaded from different paths\n      if (!this.hasBeenMountedAndBootstrapped(name, path)) {\n        bootstrappedStores.push(stateMap);\n      }\n\n      this.states.push(stateMap);\n    }\n\n    return bootstrappedStores;\n  }\n\n  /**\n   * Add a set of states to the store and return the defaults\n   */\n  addAndReturnDefaults(stateClasses: StateClassInternal[]): StatesAndDefaults {\n    const classes: StateClassInternal[] = stateClasses || [];\n\n    const mappedStores: MappedStore[] = this.add(classes);\n    const defaults = mappedStores.reduce(\n      (result: any, mappedStore: MappedStore) =>\n        setValue(result, mappedStore.path, mappedStore.defaults),\n      {}\n    );\n    return { defaults, states: mappedStores };\n  }\n\n  /**\n   * Bind the actions to the handlers\n   */\n  connectActionHandlers() {\n    if (this._actionsSubscription !== null) return;\n    const dispatched$ = new Subject<ActionContext>();\n    this._actionsSubscription = this._actions\n      .pipe(\n        filter((ctx: ActionContext) => ctx.status === ActionStatus.Dispatched),\n        mergeMap(ctx => {\n          dispatched$.next(ctx);\n          const action = ctx.action;\n          return this.invokeActions(dispatched$, action!).pipe(\n            map(() => <ActionContext>{ action, status: ActionStatus.Successful }),\n            defaultIfEmpty(<ActionContext>{ action, status: ActionStatus.Canceled }),\n            catchError(error =>\n              of(<ActionContext>{ action, status: ActionStatus.Errored, error })\n            )\n          );\n        })\n      )\n      .subscribe(ctx => this._actionResults.next(ctx));\n  }\n\n  /**\n   * Invoke actions on the states.\n   */\n  invokeActions(dispatched$: Observable<ActionContext>, action: any) {\n    const type = getActionTypeFromInstance(action)!;\n    const results = [];\n\n    for (const metadata of this.states) {\n      const actionMetas = metadata.actions[type];\n\n      if (actionMetas) {\n        for (const actionMeta of actionMetas) {\n          const stateContext = this._stateContextFactory.createStateContext(metadata);\n          try {\n            let result = metadata.instance[actionMeta.fn](stateContext, action);\n\n            if (result instanceof Promise) {\n              result = from(result);\n            }\n\n            if (isObservable(result)) {\n              // If this observable has been completed w/o emitting\n              // any value then we wouldn't want to complete the whole chain\n              // of actions. Since if any observable completes then\n              // action will be canceled.\n              // For instance if any action handler would've had such statement:\n              // `handler(ctx) { return EMPTY; }`\n              // then the action will be canceled.\n              // See https://github.com/ngxs/store/issues/1568\n              result = result.pipe(\n                mergeMap((value: any) => {\n                  if (value instanceof Promise) {\n                    return from(value);\n                  }\n                  if (isObservable(value)) {\n                    return value;\n                  }\n                  return of(value);\n                }),\n                defaultIfEmpty({})\n              );\n\n              if (actionMeta.options.cancelUncompleted) {\n                // todo: ofActionDispatched should be used with action class\n                result = result.pipe(\n                  takeUntil(dispatched$.pipe(ofActionDispatched(action as any)))\n                );\n              }\n            } else {\n              result = of({}).pipe(shareReplay());\n            }\n\n            results.push(result);\n          } catch (e) {\n            results.push(throwError(e));\n          }\n        }\n      }\n    }\n\n    if (!results.length) {\n      results.push(of({}));\n    }\n\n    return forkJoin(results);\n  }\n\n  private addToStatesMap(\n    stateClasses: StateClassInternal[]\n  ): { newStates: StateClassInternal[] } {\n    const newStates: StateClassInternal[] = [];\n    const statesMap: StatesByName = this.statesByName;\n\n    for (const stateClass of stateClasses) {\n      const stateName = getStoreMetadata(stateClass).name!;\n      // Caretaker note: we have still left the `typeof` condition in order to avoid\n      // creating a breaking change for projects that still use the View Engine.\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        StoreValidators.checkThatStateNameIsUnique(stateName, stateClass, statesMap);\n      }\n      const unmountedState = !statesMap[stateName];\n      if (unmountedState) {\n        newStates.push(stateClass);\n        statesMap[stateName] = stateClass;\n      }\n    }\n\n    return { newStates };\n  }\n\n  private addRuntimeInfoToMeta(meta: MetaDataModel, path: string): void {\n    this.statePaths[meta.name!] = path;\n    // TODO: v4 - we plan to get rid of the path property because it is non-deterministic\n    // we can do this when we get rid of the incorrectly exposed getStoreMetadata\n    // We will need to come up with an alternative in v4 because this is used by many plugins\n    meta.path = path;\n  }\n\n  /**\n   * @description\n   * the method checks if the state has already been added to the tree\n   * and completed the life cycle\n   * @param name\n   * @param path\n   */\n  private hasBeenMountedAndBootstrapped(name: string, path: string): boolean {\n    const valueIsBootstrappedInInitialState: boolean =\n      getValue(this._initialState, path) !== undefined;\n    return this.statesByName[name] && valueIsBootstrappedInInitialState;\n  }\n}\n","import { memoize } from '@ngxs/store/internals';\n\nimport {\n  ensureSelectorMetadata,\n  getSelectorMetadata,\n  getStoreMetadata,\n  SelectorMetaDataModel,\n  SharedSelectorOptions,\n  RuntimeSelectorContext,\n  SelectorFactory,\n  SelectFromRootState\n} from '../internal/internals';\n\nconst SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';\n\nexport const selectorOptionsMetaAccessor = {\n  getOptions: (target: any): SharedSelectorOptions => {\n    return (target && (<any>target)[SELECTOR_OPTIONS_META_KEY]) || {};\n  },\n  defineOptions: (target: any, options: SharedSelectorOptions) => {\n    if (!target) return;\n    (<any>target)[SELECTOR_OPTIONS_META_KEY] = options;\n  }\n};\n\ninterface CreationMetadata {\n  containerClass: any;\n  selectorName: string;\n  getSelectorOptions?: () => SharedSelectorOptions;\n}\n\ninterface RuntimeSelectorInfo {\n  selectorOptions: SharedSelectorOptions;\n  argumentSelectorFunctions: SelectFromRootState[];\n}\n\n/**\n * Function for creating a selector\n * @param selectors The selectors to use to create the arguments of this function\n * @param originalFn The original function being made into a selector\n * @param creationMetadata\n */\nexport function createSelector<T extends (...args: any[]) => any>(\n  selectors: any[] | undefined,\n  originalFn: T,\n  creationMetadata?: CreationMetadata\n) {\n  const containerClass = creationMetadata && creationMetadata.containerClass;\n  const wrappedFn = function wrappedSelectorFn(...args: any[]) {\n    const returnValue = originalFn.apply(containerClass, args);\n    if (returnValue instanceof Function) {\n      const innerMemoizedFn = memoize.apply(null, [returnValue]);\n      return innerMemoizedFn;\n    }\n    return returnValue;\n  } as T;\n  const memoizedFn = memoize(wrappedFn);\n  Object.setPrototypeOf(memoizedFn, originalFn);\n\n  const selectorMetaData = setupSelectorMetadata<T>(originalFn, creationMetadata);\n\n  const makeRootSelector: SelectorFactory = (context: RuntimeSelectorContext) => {\n    const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(\n      context,\n      selectorMetaData,\n      selectors\n    );\n\n    return function selectFromRoot(rootState: any) {\n      // Determine arguments from the app state using the selectors\n      const results = argumentSelectorFunctions.map(argFn => argFn(rootState));\n\n      // if the lambda tries to access a something on the\n      // state that doesn't exist, it will throw a TypeError.\n      // since this is quite usual behaviour, we simply return undefined if so.\n      try {\n        return memoizedFn(...results);\n      } catch (ex) {\n        if (ex instanceof TypeError && selectorOptions.suppressErrors) {\n          return undefined;\n        }\n\n        throw ex;\n      }\n    };\n  };\n\n  selectorMetaData.makeRootSelector = makeRootSelector;\n\n  return memoizedFn;\n}\n\nfunction setupSelectorMetadata<T extends (...args: any[]) => any>(\n  originalFn: T,\n  creationMetadata: CreationMetadata | undefined\n) {\n  const selectorMetaData = ensureSelectorMetadata(originalFn);\n  selectorMetaData.originalFn = originalFn;\n  let getExplicitSelectorOptions = () => ({});\n  if (creationMetadata) {\n    selectorMetaData.containerClass = creationMetadata.containerClass;\n    selectorMetaData.selectorName = creationMetadata.selectorName;\n    getExplicitSelectorOptions =\n      creationMetadata.getSelectorOptions || getExplicitSelectorOptions;\n  }\n  const selectorMetaDataClone = { ...selectorMetaData };\n  selectorMetaData.getSelectorOptions = () =>\n    getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions());\n  return selectorMetaData;\n}\n\nfunction getRuntimeSelectorInfo(\n  context: RuntimeSelectorContext,\n  selectorMetaData: SelectorMetaDataModel,\n  selectors: any[] | undefined = []\n): RuntimeSelectorInfo {\n  const localSelectorOptions = selectorMetaData.getSelectorOptions();\n  const selectorOptions = context.getSelectorOptions(localSelectorOptions);\n  const selectorsToApply = getSelectorsToApply(\n    selectors,\n    selectorOptions,\n    selectorMetaData.containerClass\n  );\n\n  const argumentSelectorFunctions = selectorsToApply.map(selector => {\n    const factory = getRootSelectorFactory(selector);\n    return factory(context);\n  });\n  return {\n    selectorOptions,\n    argumentSelectorFunctions\n  };\n}\n\nfunction getLocalSelectorOptions(\n  selectorMetaData: SelectorMetaDataModel,\n  explicitOptions: SharedSelectorOptions\n): SharedSelectorOptions {\n  return {\n    ...(selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {}),\n    ...(selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {}),\n    ...(selectorMetaData.getSelectorOptions() || {}),\n    ...explicitOptions\n  };\n}\n\nfunction getSelectorsToApply(\n  selectors: any[] | undefined = [],\n  selectorOptions: SharedSelectorOptions,\n  containerClass: any\n) {\n  const selectorsToApply = [];\n  const canInjectContainerState =\n    selectors.length === 0 || selectorOptions.injectContainerState;\n  if (containerClass && canInjectContainerState) {\n    // If we are on a state class, add it as the first selector parameter\n    const metadata = getStoreMetadata(containerClass);\n    if (metadata) {\n      selectorsToApply.push(containerClass);\n    }\n  }\n  if (selectors) {\n    selectorsToApply.push(...selectors);\n  }\n  return selectorsToApply;\n}\n\n/**\n * This function gets the factory function to create the selector to get the selected slice from the app state\n * @ignore\n */\nexport function getRootSelectorFactory(selector: any): SelectorFactory {\n  const metadata = getSelectorMetadata(selector) || getStoreMetadata(selector);\n  return (metadata && metadata.makeRootSelector) || (() => selector);\n}\n","// tslint:disable:unified-signatures\nimport { Inject, Injectable, Optional, Type } from '@angular/core';\nimport { Observable, of, Subscription, throwError, queueScheduler } from 'rxjs';\nimport {\n  catchError,\n  distinctUntilChanged,\n  map,\n  shareReplay,\n  take,\n  observeOn\n} from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObject } from '@ngxs/store/internals';\n\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\nimport { InternalStateOperations } from './internal/state-operations';\nimport { getRootSelectorFactory } from './utils/selector-utils';\nimport { StateStream } from './internal/state-stream';\nimport { leaveNgxs } from './operators/leave-ngxs';\nimport { NgxsConfig } from './symbols';\nimport { StateToken } from './state-token/state-token';\nimport { StateFactory } from './internal/state-factory';\n\n@Injectable()\nexport class Store {\n  /**\n   * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,\n   * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.\n   * All selects would use this stream, and it would call leave only once for any state change across all active selectors.\n   */\n  private _selectableStateStream = this._stateStream.pipe(\n    observeOn(queueScheduler),\n    leaveNgxs(this._internalExecutionStrategy),\n    shareReplay({ bufferSize: 1, refCount: true })\n  );\n\n  constructor(\n    private _stateStream: StateStream,\n    private _internalStateOperations: InternalStateOperations,\n    private _config: NgxsConfig,\n    private _internalExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _stateFactory: StateFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    initialStateValue: any\n  ) {\n    this.initStateStream(initialStateValue);\n  }\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);\n  }\n\n  /**\n   * Selects a slice of data from the store.\n   */\n  select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  select<T = any>(selector: string | Type<any>): Observable<T>;\n  select<T>(selector: StateToken<T>): Observable<T>;\n  select(selector: any): Observable<any> {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return this._selectableStateStream.pipe(\n      map(selectorFn),\n      catchError((err: Error): Observable<never> | Observable<undefined> => {\n        // if error is TypeError we swallow it to prevent usual errors with property access\n        const { suppressErrors } = this._config.selectorOptions;\n\n        if (err instanceof TypeError && suppressErrors) {\n          return of(undefined);\n        }\n\n        // rethrow other errors\n        return throwError(err);\n      }),\n      distinctUntilChanged(),\n      leaveNgxs(this._internalExecutionStrategy)\n    );\n  }\n\n  /**\n   * Select one slice of data from the store.\n   */\n\n  selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  selectOnce<T = any>(selector: string | Type<any>): Observable<T>;\n  selectOnce<T>(selector: StateToken<T>): Observable<T>;\n  selectOnce(selector: any): Observable<any> {\n    return this.select(selector).pipe(take(1));\n  }\n\n  /**\n   * Select a snapshot from the state.\n   */\n  selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;\n  selectSnapshot<T = any>(selector: string | Type<any>): T;\n  selectSnapshot<T>(selector: StateToken<T>): T;\n  selectSnapshot(selector: any): any {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return selectorFn(this._stateStream.getValue());\n  }\n\n  /**\n   * Allow the user to subscribe to the root of the state\n   */\n  subscribe(fn?: (value: any) => void): Subscription {\n    return this._selectableStateStream\n      .pipe(leaveNgxs(this._internalExecutionStrategy))\n      .subscribe(fn);\n  }\n\n  /**\n   * Return the raw value of the state.\n   */\n  snapshot(): any {\n    return this._internalStateOperations.getRootStateOperations().getState();\n  }\n\n  /**\n   * Reset the state to a specific point in time. This method is useful\n   * for plugin's who need to modify the state directly or unit testing.\n   */\n  reset(state: any) {\n    return this._internalStateOperations.getRootStateOperations().setState(state);\n  }\n\n  private getStoreBoundSelectorFn(selector: any) {\n    const makeSelectorFn = getRootSelectorFactory(selector);\n    const runtimeContext = this._stateFactory.getRuntimeSelectorContext();\n    return makeSelectorFn(runtimeContext);\n  }\n\n  private initStateStream(initialStateValue: any): void {\n    const value: PlainObject = this._stateStream.value;\n    const storeIsEmpty: boolean = !value || Object.keys(value).length === 0;\n    if (storeIsEmpty) {\n      const defaultStateNotEmpty: boolean = Object.keys(this._config.defaultsState).length > 0;\n      const storeValues: PlainObject = defaultStateNotEmpty\n        ? { ...this._config.defaultsState, ...initialStateValue }\n        : initialStateValue;\n\n      this._stateStream.next(storeValues);\n    }\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\nimport { NgxsBootstrapper } from '@ngxs/store/internals';\nimport { EMPTY, Subject } from 'rxjs';\nimport {\n  catchError,\n  filter,\n  mergeMap,\n  pairwise,\n  startWith,\n  takeUntil,\n  tap\n} from 'rxjs/operators';\n\nimport { Store } from '../store';\nimport { getValue } from '../utils/utils';\nimport { InternalErrorReporter } from './error-handler';\nimport { StateContextFactory } from './state-context-factory';\nimport { InternalStateOperations } from './state-operations';\nimport { MappedStore, StatesAndDefaults } from './internals';\nimport { NgxsLifeCycle, NgxsSimpleChange, StateContext } from '../symbols';\n\n@Injectable()\nexport class LifecycleStateManager implements OnDestroy {\n  private readonly _destroy$ = new Subject<void>();\n\n  constructor(\n    private _store: Store,\n    private _internalErrorReporter: InternalErrorReporter,\n    private _internalStateOperations: InternalStateOperations,\n    private _stateContextFactory: StateContextFactory,\n    private _bootstrapper: NgxsBootstrapper\n  ) {}\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n  }\n\n  ngxsBootstrap<T>(action: T, results: StatesAndDefaults | undefined): void {\n    this._internalStateOperations\n      .getRootStateOperations()\n      .dispatch(action)\n      .pipe(\n        filter(() => !!results),\n        tap(() => this._invokeInitOnStates(results!.states)),\n        mergeMap(() => this._bootstrapper.appBootstrapped$),\n        filter(appBootstrapped => !!appBootstrapped),\n        catchError(error => {\n          // The `SafeSubscriber` (which is used by most RxJS operators) re-throws\n          // errors asynchronously (`setTimeout(() => { throw error })`). This might\n          // break existing user's code or unit tests. We catch the error manually to\n          // be backward compatible with the old behavior.\n          this._internalErrorReporter.reportErrorSafely(error);\n          return EMPTY;\n        }),\n        takeUntil(this._destroy$)\n      )\n      .subscribe(() => this._invokeBootstrapOnStates(results!.states));\n  }\n\n  private _invokeInitOnStates(mappedStores: MappedStore[]): void {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n\n      if (instance.ngxsOnChanges) {\n        this._store\n          .select(state => getValue(state, mappedStore.path))\n          .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))\n          .subscribe(([previousValue, currentValue]) => {\n            const change = new NgxsSimpleChange(\n              previousValue,\n              currentValue,\n              !mappedStore.isInitialised\n            );\n            instance.ngxsOnChanges!(change);\n          });\n      }\n\n      if (instance.ngxsOnInit) {\n        instance.ngxsOnInit(this._getStateContext(mappedStore));\n      }\n\n      mappedStore.isInitialised = true;\n    }\n  }\n\n  private _invokeBootstrapOnStates(mappedStores: MappedStore[]) {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n      if (instance.ngxsAfterBootstrap) {\n        instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));\n      }\n    }\n  }\n\n  private _getStateContext(mappedStore: MappedStore): StateContext<any> {\n    return this._stateContextFactory.createStateContext(mappedStore);\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\n\nimport { Store } from '../../store';\nimport { NgxsConfig } from '../../symbols';\n\n/**\n * Allows the select decorator to get access to the DI store, this is used internally\n * in `@Select` decorator.\n */\n@Injectable()\nexport class SelectFactory implements OnDestroy {\n  public static store: Store | null = null;\n  public static config: NgxsConfig | null = null;\n\n  constructor(store: Store, config: NgxsConfig) {\n    SelectFactory.store = store;\n    SelectFactory.config = config;\n  }\n\n  ngOnDestroy(): void {\n    SelectFactory.store = null;\n    SelectFactory.config = null;\n  }\n}\n","import { PlainObject } from '@ngxs/store/internals';\n\n/**\n * Init action\n */\nexport class InitState {\n  static get type() {\n    // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138\n    return '@@INIT';\n  }\n}\n\n/**\n * Update action\n */\nexport class UpdateState {\n  static get type() {\n    // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138\n    return '@@UPDATE_STATE';\n  }\n\n  constructor(public addedStates?: PlainObject) {}\n}\n","import { Inject, NgModule, Optional } from '@angular/core';\n\nimport { StateFactory } from '../internal/state-factory';\nimport { InternalStateOperations } from '../internal/state-operations';\nimport { Store } from '../store';\nimport { SelectFactory } from '../decorators/select/select-factory';\nimport { ROOT_STATE_TOKEN } from '../symbols';\nimport { StateClassInternal, StatesAndDefaults } from '../internal/internals';\nimport { LifecycleStateManager } from '../internal/lifecycle-state-manager';\nimport { InitState } from '../actions/actions';\n\n/**\n * Root module\n * @ignore\n */\n@NgModule()\nexport class NgxsRootModule {\n  constructor(\n    factory: StateFactory,\n    internalStateOperations: InternalStateOperations,\n    _store: Store,\n    _select: SelectFactory,\n    @Optional()\n    @Inject(ROOT_STATE_TOKEN)\n    states: StateClassInternal[] = [],\n    lifecycleStateManager: LifecycleStateManager\n  ) {\n    // Add stores to the state graph and return their defaults\n    const results: StatesAndDefaults = factory.addAndReturnDefaults(states);\n\n    internalStateOperations.setStateToTheCurrentWithNew(results);\n\n    // Connect our actions stream\n    factory.connectActionHandlers();\n\n    // Dispatch the init action and invoke init and bootstrap functions after\n    lifecycleStateManager.ngxsBootstrap(new InitState(), results);\n  }\n}\n","import { Inject, NgModule, Optional } from '@angular/core';\n\nimport { Store } from '../store';\nimport { InternalStateOperations } from '../internal/state-operations';\nimport { StateFactory } from '../internal/state-factory';\nimport { FEATURE_STATE_TOKEN } from '../symbols';\nimport { LifecycleStateManager } from '../internal/lifecycle-state-manager';\nimport { StateClassInternal, StatesAndDefaults } from '../internal/internals';\nimport { UpdateState } from '../actions/actions';\n\n/**\n * Feature module\n * @ignore\n */\n@NgModule()\nexport class NgxsFeatureModule {\n  constructor(\n    _store: Store,\n    internalStateOperations: InternalStateOperations,\n    factory: StateFactory,\n    @Optional()\n    @Inject(FEATURE_STATE_TOKEN)\n    states: StateClassInternal[][] = [],\n    lifecycleStateManager: LifecycleStateManager\n  ) {\n    // Since FEATURE_STATE_TOKEN is a multi token, we need to\n    // flatten it [[Feature1State, Feature2State], [Feature3State]]\n    const flattenedStates: StateClassInternal[] = NgxsFeatureModule.flattenStates(states);\n\n    // add stores to the state graph and return their defaults\n    const results: StatesAndDefaults = factory.addAndReturnDefaults(flattenedStates);\n\n    if (results.states.length) {\n      internalStateOperations.setStateToTheCurrentWithNew(results);\n\n      // dispatch the update action and invoke init and bootstrap functions after\n      lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);\n    }\n  }\n\n  private static flattenStates(states: StateClassInternal[][] = []): StateClassInternal[] {\n    return states.reduce(\n      (total: StateClassInternal[], values: StateClassInternal[]) => total.concat(values),\n      []\n    );\n  }\n}\n","import {\n  APP_BOOTSTRAP_LISTENER,\n  InjectionToken,\n  ModuleWithProviders,\n  NgModule,\n  Provider\n} from '@angular/core';\nimport {\n  INITIAL_STATE_TOKEN,\n  InitialState,\n  NGXS_STATE_CONTEXT_FACTORY,\n  NGXS_STATE_FACTORY,\n  NgxsBootstrapper,\n  StateClass\n} from '@ngxs/store/internals';\n\nimport {\n  FEATURE_STATE_TOKEN,\n  NgxsConfig,\n  NgxsModuleOptions,\n  ROOT_STATE_TOKEN\n} from './symbols';\nimport { USER_PROVIDED_NGXS_EXECUTION_STRATEGY } from './execution/symbols';\nimport { StateFactory } from './internal/state-factory';\nimport { StateContextFactory } from './internal/state-context-factory';\nimport { Actions, InternalActions } from './actions-stream';\nimport { LifecycleStateManager } from './internal/lifecycle-state-manager';\nimport { InternalDispatchedActionResults, InternalDispatcher } from './internal/dispatcher';\nimport { InternalStateOperations } from './internal/state-operations';\nimport { Store } from './store';\nimport { SelectFactory } from './decorators/select/select-factory';\nimport { StateStream } from './internal/state-stream';\nimport { PluginManager } from './plugin-manager';\nimport { NgxsRootModule } from './modules/ngxs-root.module';\nimport { NgxsFeatureModule } from './modules/ngxs-feature.module';\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\nimport { mergeDeep } from './utils/utils';\n\n/**\n * Ngxs Module\n */\n@NgModule()\nexport class NgxsModule {\n  private static readonly ROOT_OPTIONS = new InjectionToken<NgxsModuleOptions>('ROOT_OPTIONS');\n\n  /**\n   * Root module factory\n   */\n  public static forRoot(\n    states: StateClass[] = [],\n    options: NgxsModuleOptions = {}\n  ): ModuleWithProviders<NgxsRootModule> {\n    return {\n      ngModule: NgxsRootModule,\n      providers: [\n        StateFactory,\n        StateContextFactory,\n        Actions,\n        InternalActions,\n        NgxsBootstrapper,\n        LifecycleStateManager,\n        InternalDispatcher,\n        InternalDispatchedActionResults,\n        InternalStateOperations,\n        InternalNgxsExecutionStrategy,\n        Store,\n        StateStream,\n        SelectFactory,\n        PluginManager,\n        ...states,\n        ...NgxsModule.ngxsTokenProviders(states, options)\n      ]\n    };\n  }\n\n  /**\n   * Feature module factory\n   */\n  public static forFeature(states: StateClass[] = []): ModuleWithProviders<NgxsFeatureModule> {\n    return {\n      ngModule: NgxsFeatureModule,\n      providers: [\n        StateFactory,\n        PluginManager,\n        ...states,\n        {\n          provide: FEATURE_STATE_TOKEN,\n          multi: true,\n          useValue: states\n        }\n      ]\n    };\n  }\n\n  private static ngxsTokenProviders(\n    states: StateClass[],\n    options: NgxsModuleOptions\n  ): Provider[] {\n    return [\n      {\n        provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,\n        useValue: options.executionStrategy\n      },\n      {\n        provide: ROOT_STATE_TOKEN,\n        useValue: states\n      },\n      {\n        provide: NgxsModule.ROOT_OPTIONS,\n        useValue: options\n      },\n      {\n        provide: NgxsConfig,\n        useFactory: NgxsModule.ngxsConfigFactory,\n        deps: [NgxsModule.ROOT_OPTIONS]\n      },\n      {\n        provide: APP_BOOTSTRAP_LISTENER,\n        useFactory: NgxsModule.appBootstrapListenerFactory,\n        multi: true,\n        deps: [NgxsBootstrapper]\n      },\n      {\n        provide: INITIAL_STATE_TOKEN,\n        useFactory: NgxsModule.getInitialState\n      },\n      {\n        provide: NGXS_STATE_CONTEXT_FACTORY,\n        useExisting: StateContextFactory\n      },\n      {\n        provide: NGXS_STATE_FACTORY,\n        useExisting: StateFactory\n      }\n    ];\n  }\n\n  private static ngxsConfigFactory(options: NgxsModuleOptions): NgxsConfig {\n    return mergeDeep(new NgxsConfig(), options);\n  }\n\n  private static appBootstrapListenerFactory(bootstrapper: NgxsBootstrapper): Function {\n    return () => bootstrapper.bootstrap();\n  }\n\n  private static getInitialState() {\n    return InitialState.pop();\n  }\n}\n","import { Observable } from 'rxjs';\n\nimport { propGetter } from '../../internal/internals';\nimport { SelectFactory } from './select-factory';\nimport { StateToken } from '../../state-token/state-token';\nimport { ExtractTokenType } from '../../state-token/symbols';\nimport { throwSelectFactoryNotConnectedError } from '../../configs/messages.config';\n\nconst DOLLAR_CHAR_CODE = 36;\n\nexport function createSelectObservable<T = any>(selector: any): Observable<T> {\n  if (!SelectFactory.store) {\n    throwSelectFactoryNotConnectedError();\n  }\n  return SelectFactory.store!.select(selector);\n}\n\nexport function createSelectorFn(name: string, rawSelector?: any, paths: string[] = []): any {\n  rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;\n\n  if (typeof rawSelector === 'string') {\n    const propsArray: string[] = paths.length\n      ? [rawSelector, ...paths]\n      : rawSelector.split('.');\n    return propGetter(propsArray, SelectFactory.config!);\n  }\n\n  return rawSelector;\n}\n\n/**\n * @example If `foo$` => make it just `foo`\n */\nexport function removeDollarAtTheEnd(name: string): string {\n  const lastCharIndex: number = name.length - 1;\n  const dollarAtTheEnd: boolean = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;\n  return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;\n}\n\nexport type PropertyType<T> = T extends StateToken<any>\n  ? Observable<ExtractTokenType<T>>\n  : T extends (...args: any[]) => any\n  ? Observable<ReturnType<T>>\n  : any;\n","import { TokenName } from './symbols';\nimport {\n  ensureSelectorMetadata,\n  RuntimeSelectorContext,\n  SelectFromRootState\n} from '../internal/internals';\n\nexport class StateToken<T = void> {\n  constructor(private readonly name: TokenName<T>) {\n    const selectorMetadata = ensureSelectorMetadata(<any>this);\n    selectorMetadata.makeRootSelector = (\n      runtimeContext: RuntimeSelectorContext\n    ): SelectFromRootState => {\n      return runtimeContext.getStateGetter(this.name);\n    };\n  }\n\n  getName(): string {\n    return this.name;\n  }\n\n  toString(): string {\n    return `StateToken[${this.name}]`;\n  }\n}\n","import { ensureStoreMetadata } from '../internal/internals';\nimport { ActionType, ActionOptions } from '../actions/symbols';\nimport { throwActionDecoratorError } from '../configs/messages.config';\n\n/**\n * Decorates a method with a action information.\n */\nexport function Action(\n  actions: ActionType | ActionType[],\n  options?: ActionOptions\n): MethodDecorator {\n  return (target: any, name: string | symbol): void => {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const isStaticMethod = target.hasOwnProperty('prototype');\n\n      if (isStaticMethod) {\n        throwActionDecoratorError();\n      }\n    }\n\n    const meta = ensureStoreMetadata(target.constructor);\n\n    if (!Array.isArray(actions)) {\n      actions = [actions];\n    }\n\n    for (const action of actions) {\n      const type = action.type;\n\n      if (!meta.actions[type]) {\n        meta.actions[type] = [];\n      }\n\n      meta.actions[type].push({\n        fn: name,\n        options: options || {},\n        type\n      });\n    }\n  };\n}\n","import { createSelectObservable, createSelectorFn, PropertyType } from './symbols';\n\n/**\n * Decorator for selecting a slice of state from the store.\n */\nexport function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator {\n  return function(target, key): void {\n    const name: string = key.toString();\n    const selectorId = `__${name}__selector`;\n    const selector = createSelectorFn(name, rawSelector, paths);\n\n    Object.defineProperties(target, {\n      [selectorId]: {\n        writable: true,\n        enumerable: false,\n        configurable: true\n      },\n      [name]: {\n        enumerable: true,\n        configurable: true,\n        get(): PropertyType<T> {\n          return this[selectorId] || (this[selectorId] = createSelectObservable(selector));\n        }\n      }\n    });\n  };\n}\n","import { throwSelectorDecoratorError } from '../../configs/messages.config';\nimport { createSelector } from '../../utils/selector-utils';\nimport { SelectorSpec, SelectorType } from './symbols';\n\n/**\n * Decorator for memoizing a state selector.\n */\nexport function Selector<T>(selectors?: T[]): SelectorType<T> {\n  return <U>(\n    target: any,\n    key: string | symbol,\n    descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>\n  ): TypedPropertyDescriptor<SelectorSpec<T, U>> | void => {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const isNotMethod = !(descriptor && descriptor.value !== null);\n\n      if (isNotMethod) {\n        throwSelectorDecoratorError();\n      }\n    }\n\n    const originalFn = descriptor.value;\n    const memoizedFn = createSelector(selectors, originalFn as any, {\n      containerClass: target,\n      selectorName: key.toString(),\n      getSelectorOptions() {\n        return {};\n      }\n    });\n    const newDescriptor = {\n      configurable: true,\n      get() {\n        return memoizedFn;\n      }\n    };\n    // Add hidden property to descriptor\n    (<any>newDescriptor)['originalFn'] = originalFn;\n    return newDescriptor;\n  };\n}\n","import { SharedSelectorOptions } from '../internal/internals';\nimport { selectorOptionsMetaAccessor } from '../utils/selector-utils';\n\n/**\n * Decorator for setting selector options at a method or class level.\n */\nexport function SelectorOptions(options: SharedSelectorOptions) {\n  return <ClassDecorator & MethodDecorator>(\n    function decorate<T>(\n      target: any,\n      methodName: string,\n      descriptor: TypedPropertyDescriptor<T>\n    ) {\n      if (methodName) {\n        // Method Decorator\n        const originalFn = descriptor.value || (<any>descriptor).originalFn;\n        if (originalFn) {\n          selectorOptionsMetaAccessor.defineOptions(originalFn, options);\n        }\n      } else {\n        // Class Decorator\n        selectorOptionsMetaAccessor.defineOptions(target, options);\n      }\n    }\n  );\n}\n","import { StateClass } from '@ngxs/store/internals';\n\nimport { ensureStoreMetadata, MetaDataModel, StateClassInternal } from '../internal/internals';\nimport { META_KEY, META_OPTIONS_KEY, StoreOptions } from '../symbols';\nimport { StoreValidators } from '../utils/store-validators';\n\ninterface MutateMetaOptions<T> {\n  meta: MetaDataModel;\n  inheritedStateClass: StateClassInternal;\n  optionsWithInheritance: StoreOptions<T>;\n}\n\n/**\n * Decorates a class with ngxs state information.\n */\nexport function State<T>(options: StoreOptions<T>) {\n  function getStateOptions(inheritedStateClass: StateClassInternal): StoreOptions<T> {\n    const inheritanceOptions: Partial<StoreOptions<T>> =\n      inheritedStateClass[META_OPTIONS_KEY] || {};\n    return { ...inheritanceOptions, ...options } as StoreOptions<T>;\n  }\n\n  function mutateMetaData(params: MutateMetaOptions<T>): void {\n    const { meta, inheritedStateClass, optionsWithInheritance } = params;\n    const { children, defaults, name } = optionsWithInheritance;\n    const stateName: string | null =\n      typeof name === 'string' ? name : (name && name.getName()) || null;\n\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      StoreValidators.checkThatStateIsNamedCorrectly(stateName);\n    }\n\n    if (inheritedStateClass.hasOwnProperty(META_KEY)) {\n      const inheritedMeta: Partial<MetaDataModel> = inheritedStateClass[META_KEY] || {};\n      meta.actions = { ...meta.actions, ...inheritedMeta.actions };\n    }\n\n    meta.children = children;\n    meta.defaults = defaults;\n    meta.name = stateName;\n  }\n\n  return (target: StateClass): void => {\n    const stateClass: StateClassInternal = target;\n    const meta: MetaDataModel = ensureStoreMetadata(stateClass);\n    const inheritedStateClass: StateClassInternal = Object.getPrototypeOf(stateClass);\n    const optionsWithInheritance: StoreOptions<T> = getStateOptions(inheritedStateClass);\n    mutateMetaData({ meta, inheritedStateClass, optionsWithInheritance });\n    stateClass[META_OPTIONS_KEY] = optionsWithInheritance;\n  };\n}\n","import {\n  getSelectorMetadata as getSelectorMetadataInternal,\n  getStoreMetadata as getStoreMetadataInternal,\n  ensureStoreMetadata as ensureStoreMetadataInternal,\n  ensureSelectorMetadata as ensureSelectorMetadataInternal,\n  StateClassInternal,\n  SharedSelectorOptions\n} from './internal/internals';\nimport { PlainObjectOf } from '../internals/src/symbols';\nimport { ActionHandlerMetaData } from './actions/symbols';\n\ninterface MetaDataModel {\n  name: string | null;\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\n  defaults: any;\n  path: string | null;\n  // selectFromAppState: SelectFromState | null;\n  // makeRootSelector: SelectorFactory | null; // Don't expose new stuff\n  children?: StateClassInternal[];\n}\n\ninterface SelectorMetaDataModel {\n  // selectFromAppState: SelectFromState | null;\n  // makeRootSelector: SelectorFactory | null; // Don't expose new stuff\n  originalFn: Function | null;\n  containerClass: any;\n  selectorName: string | null;\n  getSelectorOptions: () => SharedSelectorOptions;\n}\n\nexport function ensureStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel {\n  return ensureStoreMetadataInternal(target);\n}\n\nexport function getStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel {\n  return getStoreMetadataInternal(target);\n}\n\nexport function ensureSelectorMetadata(target: Function): SelectorMetaDataModel {\n  return ensureSelectorMetadataInternal(target);\n}\n\nexport function getSelectorMetadata(target: any): SelectorMetaDataModel {\n  return getSelectorMetadataInternal(target);\n}\n"]}
+{"version":3,"sources":["../../../node_modules/tslib/tslib.es6.js","ng://@ngxs/store/src/execution/dispatch-outside-zone-ngxs-execution-strategy.ts","ng://@ngxs/store/src/configs/messages.config.ts","ng://@ngxs/store/src/symbols.ts","ng://@ngxs/store/src/execution/noop-ngxs-execution-strategy.ts","ng://@ngxs/store/src/execution/symbols.ts","ng://@ngxs/store/src/internal/internals.ts","ng://@ngxs/store/src/utils/utils.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/error-handler.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/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/ivy/ivy-enabled-in-dev-mode.ts","ng://@ngxs/store/src/internal/state-factory.ts","ng://@ngxs/store/src/utils/selector-utils.ts","ng://@ngxs/store/src/store.ts","ng://@ngxs/store/src/internal/lifecycle-state-manager.ts","ng://@ngxs/store/src/decorators/select/select-factory.ts","ng://@ngxs/store/src/actions/actions.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/select/symbols.ts","ng://@ngxs/store/src/state-token/state-token.ts","ng://@ngxs/store/src/decorators/action.ts","ng://@ngxs/store/src/decorators/select/select.ts","ng://@ngxs/store/src/decorators/selector/selector.ts","ng://@ngxs/store/src/decorators/selector-options.ts","ng://@ngxs/store/src/decorators/state.ts","ng://@ngxs/store/src/public_to_deprecate.ts"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","hasOwnProperty","__extends","__","this","constructor","prototype","create","__assign","assign","t","s","i","n","arguments","length","call","apply","__values","o","Symbol","iterator","m","next","value","done","TypeError","__read","r","e","ar","push","error","__spread","concat","DispatchOutsideZoneNgxsExecutionStrategy","_ngZone","_platformId","ngDevMode","ngZone","NgZone","console","warn","verifyZoneIsNotNooped","enter","func","isPlatformServer","runInsideAngular","runOutsideAngular","leave","isInAngularZone","run","Injectable","args","providedIn","Inject","PLATFORM_ID","ROOT_STATE_TOKEN","InjectionToken","FEATURE_STATE_TOKEN","NGXS_PLUGINS","META_KEY","META_OPTIONS_KEY","SELECTOR_META_KEY","NgxsConfig","defaultsState","selectorOptions","injectContainerState","suppressErrors","compatibility","strictContentSecurityPolicy","executionStrategy","previousValue","currentValue","firstChange","NoopNgxsExecutionStrategy","USER_PROVIDED_NGXS_EXECUTION_STRATEGY","NGXS_EXECUTION_STRATEGY","factory","injector","inject","INJECTOR","get","ɵglobal","Zone","ensureStoreMetadata","target","defaultMetadata_1","name","actions","defaults","path","makeRootSelector","context","getStateGetter","children","defineProperty","getStoreMetadata","ensureSelectorMetadata","originalFn","containerClass","selectorName","getSelectorOptions","getSelectorMetadata","propGetter","paths","config","copyOfPaths","slice","obj","reduce","acc","part","compliantPropGetter","segments","seg","l","expr","Function","fastPropGetter","getActionTypeFromInstance","action","type","setValue","prop","val","split","lastIndex","index","isArray","getValue","isObject","item","mergeDeep","base","sources","_i","source","shift","key","_a","_b","ofActionDispatched","allowedTypes","ofActionOperator","statuses","mapOperator","mapAction","allowedMap","filterMap","klass","allowedStatusMap","status","createAllowedStatusesMap","pipe","allowedStatuses","filter","ctx","actionType","typeMatch","statusMatch","filterStatus","mapActionResult","map","result","successful","canceled","leaveNgxs","ngxsExecutionStrategy","Observable","sink","subscribe","complete","InternalNgxsExecutionStrategy","_executionStrategy","OrderedSubject","_this","_super","_itemQueue","_busyPushingNext","tslib_1.__extends","unshift","nextValue","pop","Subject","InternalActions","ngOnDestroy","Actions","internalActions$","internalExecutionStrategy","sharedInternalActions$","share","observer","childSubscription","add","compose","funcs","curr","nextArgs","InternalErrorReporter","_injector","_errorHandler","reportErrorSafely","ErrorHandler","handleError","Injector","StateStream","BehaviorSubject","PluginManager","_parentManager","_pluginHandlers","plugins","registerHandlers","pluginHandlers","getPluginHandlers","rootPlugins","plugin","handle","bind","decorators","Optional","SkipSelf","InternalDispatchedActionResults","InternalDispatcher","_actions","_actionResults","_pluginManager","_stateStream","_ngxsExecutionStrategy","_internalErrorReporter","dispatch","actionOrActions","internalErrorReporter","dispatchByEvents","subscribed","Promise","resolve","then","subscriber","of","forkJoin","dispatchSingle","Error","throwError","prevState","nextState","nextAction","actionResult$","getActionResultStream","createDispatchObservable","shareReplay","take","exhaustMap","EMPTY","deepFreeze","freeze","oIsFunction","hasOwnProp","getOwnPropertyNames","forEach","isFrozen","InternalStateOperations","_dispatcher","_config","getRootStateOperations","root","rootStateOperations","getState","setState","newState","developmentMode","frozenValue","setStateToTheCurrentWithNew","results","stateOperations","currentState","simplePatch","existingState","throwPatchingArrayError","throwPatchingPrimitiveError","StateContextFactory","_internalStateOperations","createStateContext","mappedStore","currentAppState","setStateValue","newValue","newAppState","setStateFromOperator","stateOperator","patchState","StoreValidators","checkThatStateIsNamedCorrectly","stateNameRegex","test","throwStateNameError","throwStateNamePropertyError","checkThatStateNameIsUnique","stateName","state","statesByName","current","newName","oldName","throwStateUniqueError","checkThatStateClassesHaveBeenDecorated","stateClasses","stateClass","throwStateDecoratorError","RegExp","ensureStateClassIsInjectable","ɵivyEnabled","ɵprov","StateFactory","_parentFactory","_stateContextFactory","_initialState","_actionsSubscription","_states","_statesByName","_statePaths","getRuntimeSelectorContext","memoize","stateFactory","resolveGetter","statePaths","getter","undefined","localOptions","globalSelectorOptions","states","cloneDefaults","unsubscribe","newStates","addToStatesMap","graph","sorted","visited","visit","stateGraph","findName","meta","find","g","buildGraph","sortedStates","ancestors","dep","indexOf","join","keys","k","reverse","newObj","child","keyToFind","parent_1","parent_2","findFullParentPath","nameGraph","bootstrappedStores","sortedStates_1","tslib_1.__values","sortedStates_1_1","name_1","addRuntimeInfoToMeta","stateMap","isInitialised","instance","hasBeenMountedAndBootstrapped","addAndReturnDefaults","classes","mappedStores","connectActionHandlers","dispatched$","mergeMap","invokeActions","defaultIfEmpty","catchError","_c","_d","metadata","actionMetas","actionMetas_1","actionMetas_1_1","actionMeta","stateContext","fn","from","isObservable","options","cancelUncompleted","takeUntil","statesMap","stateClasses_1","stateClasses_1_1","valueIsBootstrappedInInitialState","INITIAL_STATE_TOKEN","selectorOptionsMetaAccessor","getOptions","defineOptions","createSelector","selectors","creationMetadata","memoizedFn","returnValue","innerMemoizedFn","selectorMetaData","getExplicitSelectorOptions","selectorMetaDataClone","explicitOptions","getLocalSelectorOptions","setupSelectorMetadata","localSelectorOptions","argumentSelectorFunctions","selectorsToApply","canInjectContainerState","getSelectorsToApply","selector","getRootSelectorFactory","getRuntimeSelectorInfo","rootState","argFn","ex","Store","_internalExecutionStrategy","_stateFactory","initialStateValue","_selectableStateStream","observeOn","queueScheduler","bufferSize","refCount","initStateStream","select","selectorFn","getStoreBoundSelectorFn","err","distinctUntilChanged","selectOnce","selectSnapshot","snapshot","reset","makeSelectorFn","storeValues","LifecycleStateManager","_store","_bootstrapper","_destroy$","ngxsBootstrap","tap","_invokeInitOnStates","appBootstrapped$","appBootstrapped","_invokeBootstrapOnStates","ngxsOnChanges","this_1","startWith","pairwise","change","NgxsSimpleChange","ngxsOnInit","_getStateContext","mappedStores_1","mappedStores_1_1","mappedStores_2","mappedStores_2_1","ngxsAfterBootstrap","NgxsBootstrapper","SelectFactory","store","InitState","UpdateState","addedStates","NgxsRootModule","internalStateOperations","_select","lifecycleStateManager","NgModule","NgxsFeatureModule","flattenedStates","flattenStates","total","values","NgxsModule","forRoot","ngModule","providers","ngxsTokenProviders","forFeature","provide","multi","useValue","ROOT_OPTIONS","useFactory","ngxsConfigFactory","deps","APP_BOOTSTRAP_LISTENER","appBootstrapListenerFactory","getInitialState","NGXS_STATE_CONTEXT_FACTORY","useExisting","NGXS_STATE_FACTORY","bootstrapper","bootstrap","InitialState","DOLLAR_CHAR_CODE","createSelectObservable","throwSelectFactoryNotConnectedError","createSelectorFn","rawSelector","lastCharIndex","charCodeAt","removeDollarAtTheEnd","StateToken","runtimeContext","getName","toString","throwActionDecoratorError","actions_1","actions_1_1","selectorId","defineProperties","writable","enumerable","configurable","descriptor","throwSelectorDecoratorError","newDescriptor","methodName","inheritedStateClass","getPrototypeOf","optionsWithInheritance","inheritanceOptions","getStateOptions","params","inheritedMeta","mutateMetaData","action1","type1","action2","ensureSelectorMetadataInternal","ensureStoreMetadataInternal","getSelectorMetadataInternal","getStoreMetadataInternal"],"mappings":"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","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","import { Inject, Injectable, NgZone, PLATFORM_ID } from '@angular/core';\nimport { isPlatformServer } from '@angular/common';\n\nimport { NgxsExecutionStrategy } from './symbols';\nimport { getZoneWarningMessage } from '../configs/messages.config';\n\n@Injectable({ providedIn: 'root' })\nexport class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {\n  constructor(private _ngZone: NgZone, @Inject(PLATFORM_ID) private _platformId: string) {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      verifyZoneIsNotNooped(_ngZone);\n    }\n  }\n\n  enter<T>(func: () => T): T {\n    if (isPlatformServer(this._platformId)) {\n      return this.runInsideAngular(func);\n    }\n    return this.runOutsideAngular(func);\n  }\n\n  leave<T>(func: () => T): T {\n    return this.runInsideAngular(func);\n  }\n\n  private runInsideAngular<T>(func: () => T): T {\n    if (NgZone.isInAngularZone()) {\n      return func();\n    }\n    return this._ngZone.run(func);\n  }\n\n  private runOutsideAngular<T>(func: () => T): T {\n    if (NgZone.isInAngularZone()) {\n      return this._ngZone.runOutsideAngular(func);\n    }\n    return func();\n  }\n}\n\n// Caretaker note: this should exist as a separate function and not a class method,\n// since class methods are not tree-shakable.\nfunction verifyZoneIsNotNooped(ngZone: NgZone): void {\n  // `NoopNgZone` is not exposed publicly as it doesn't expect\n  // to be used outside of the core Angular code, thus we just have\n  // to check if the zone doesn't extend or instanceof `NgZone`.\n  if (ngZone instanceof NgZone) {\n    return;\n  }\n\n  console.warn(getZoneWarningMessage());\n}\n","export function throwStateNameError(name: string): never {\n  throw new Error(\n    `${name} is not a valid state name. It needs to be a valid object property name.`\n  );\n}\n\nexport function throwStateNamePropertyError(): never {\n  throw new Error(`States must register a 'name' property.`);\n}\n\nexport function throwStateUniqueError(\n  current: string,\n  newName: string,\n  oldName: string\n): never {\n  throw new Error(`State name '${current}' from ${newName} already exists in ${oldName}.`);\n}\n\nexport function throwStateDecoratorError(name: string): never {\n  throw new Error(`States must be decorated with @State() decorator, but \"${name}\" isn't.`);\n}\n\nexport function throwActionDecoratorError(): never {\n  throw new Error('@Action() decorator cannot be used with static methods.');\n}\n\nexport function throwSelectorDecoratorError(): never {\n  throw new Error('Selectors only work on methods.');\n}\n\nexport function getZoneWarningMessage(): string {\n  return (\n    'Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\\n' +\n    'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\\n' +\n    'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })'\n  );\n}\n\nexport function getUndecoratedStateInIvyWarningMessage(name: string): string {\n  return `'${name}' class should be decorated with @Injectable() right after the @State() decorator`;\n}\n\nexport function throwSelectFactoryNotConnectedError(): never {\n  throw new Error('You have forgotten to import the NGXS module!');\n}\n\nexport function throwPatchingArrayError(): never {\n  throw new Error('Patching arrays is not supported.');\n}\n\nexport function throwPatchingPrimitiveError(): never {\n  throw new Error('Patching primitives is not supported.');\n}\n","import { Injectable, InjectionToken, Type } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { PlainObject, StateClass } from '@ngxs/store/internals';\nimport { SharedSelectorOptions } from './internal/internals';\nimport { NgxsExecutionStrategy } from './execution/symbols';\nimport { DispatchOutsideZoneNgxsExecutionStrategy } from './execution/dispatch-outside-zone-ngxs-execution-strategy';\nimport { StateToken } from './state-token/state-token';\n\nexport const ROOT_STATE_TOKEN = new InjectionToken<any>('ROOT_STATE_TOKEN');\nexport const FEATURE_STATE_TOKEN = new InjectionToken<any>('FEATURE_STATE_TOKEN');\nexport const NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');\n\nexport const META_KEY = 'NGXS_META';\nexport const META_OPTIONS_KEY = 'NGXS_OPTIONS_META';\nexport const SELECTOR_META_KEY = 'NGXS_SELECTOR_META';\n\nexport type NgxsLifeCycle = Partial<NgxsOnChanges> &\n  Partial<NgxsOnInit> &\n  Partial<NgxsAfterBootstrap>;\n\nexport type NgxsPluginFn = (state: any, mutation: any, next: NgxsNextPluginFn) => any;\n\n/**\n * The NGXS config settings.\n */\n@Injectable()\nexport class NgxsConfig {\n  /**\n   * Run in development mode. This will add additional debugging features:\n   * - Object.freeze on the state and actions to guarantee immutability\n   * (default: false)\n   *\n   * Note: this property will be accounted only in development mode when using the Ivy compiler.\n   * It makes sense to use it only during development to ensure there're no state mutations.\n   * When building for production, the Object.freeze will be tree-shaken away.\n   */\n  developmentMode: boolean;\n  compatibility: {\n    /**\n     * Support a strict Content Security Policy.\n     * This will circumvent some optimisations that violate a strict CSP through the use of `new Function(...)`.\n     * (default: false)\n     */\n    strictContentSecurityPolicy: boolean;\n  };\n  /**\n   * Determines the execution context to perform async operations inside. An implementation can be\n   * provided to override the default behaviour where the async operations are run\n   * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.\n   * These observable behaviours are from:\n   *   `@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`\n   * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your\n   * application doesn't rely on zone.js running change detection then you can switch to the\n   * `NoopNgxsExecutionStrategy` that doesn't interact with zones.\n   * (default: null)\n   */\n  executionStrategy: Type<NgxsExecutionStrategy>;\n  /**\n   * Defining the default state before module initialization\n   * This is convenient if we need to create a define our own set of states.\n   * @deprecated will be removed after v4\n   * (default: {})\n   */\n  defaultsState: PlainObject = {};\n  /**\n   * Defining shared selector options\n   */\n  selectorOptions: SharedSelectorOptions = {\n    injectContainerState: true, // TODO: default is true in v3, will change in v4\n    suppressErrors: true // TODO: default is true in v3, will change in v4\n  };\n\n  constructor() {\n    this.compatibility = {\n      strictContentSecurityPolicy: false\n    };\n    this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;\n  }\n}\n\nexport type StateOperator<T> = (existing: Readonly<T>) => T;\n\n/**\n * State context provided to the actions in the state.\n */\nexport interface StateContext<T> {\n  /**\n   * Get the current state.\n   */\n  getState(): T;\n\n  /**\n   * Reset the state to a new value.\n   */\n  setState(val: T | StateOperator<T>): T;\n\n  /**\n   * Patch the existing state with the provided value.\n   */\n  patchState(val: Partial<T>): T;\n\n  /**\n   * Dispatch a new action and return the dispatched observable.\n   */\n  dispatch(actions: any | any[]): Observable<void>;\n}\n\nexport type NgxsNextPluginFn = (state: any, mutation: any) => any;\n\n/**\n * Plugin interface\n */\nexport interface NgxsPlugin {\n  /**\n   * Handle the state/action before its submitted to the state handlers.\n   */\n  handle(state: any, action: any, next: NgxsNextPluginFn): any;\n}\n\n/**\n * Options that can be provided to the store.\n */\nexport interface StoreOptions<T> {\n  /**\n   * Name of the state. Required.\n   */\n  name: string | StateToken<T>;\n\n  /**\n   * Default values for the state. If not provided, uses empty object.\n   */\n  defaults?: T;\n\n  /**\n   * Sub states for the given state.\n   */\n  children?: StateClass[];\n}\n\n/**\n * Represents a basic change from a previous to a new value for a single state instance.\n * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.\n */\nexport class NgxsSimpleChange<T = any> {\n  constructor(\n    public readonly previousValue: T,\n    public readonly currentValue: T,\n    public readonly firstChange: boolean\n  ) {}\n}\n\n/**\n * On init interface\n */\nexport interface NgxsOnInit {\n  ngxsOnInit(ctx: StateContext<any>): void;\n}\n\n/**\n * On change interface\n */\nexport interface NgxsOnChanges {\n  ngxsOnChanges(change: NgxsSimpleChange): void;\n}\n\n/**\n * After bootstrap interface\n */\nexport interface NgxsAfterBootstrap {\n  ngxsAfterBootstrap(ctx: StateContext<any>): void;\n}\n\nexport type NgxsModuleOptions = Partial<NgxsConfig>;\n\n/** @internal */\ndeclare global {\n  const ngDevMode: boolean;\n}\n","import { Injectable } from '@angular/core';\n\nimport { NgxsExecutionStrategy } from './symbols';\n\n@Injectable({ providedIn: 'root' })\nexport class NoopNgxsExecutionStrategy implements NgxsExecutionStrategy {\n  enter<T>(func: () => T): T {\n    return func();\n  }\n\n  leave<T>(func: () => T): T {\n    return func();\n  }\n}\n","import { InjectionToken, inject, INJECTOR, Type, ɵglobal } from '@angular/core';\n\nimport { NoopNgxsExecutionStrategy } from './noop-ngxs-execution-strategy';\nimport { DispatchOutsideZoneNgxsExecutionStrategy } from './dispatch-outside-zone-ngxs-execution-strategy';\n\n/**\n * The strategy that might be provided by users through `options.executionStrategy`.\n */\nexport const USER_PROVIDED_NGXS_EXECUTION_STRATEGY = new InjectionToken<\n  Type<NgxsExecutionStrategy> | undefined\n>('USER_PROVIDED_NGXS_EXECUTION_STRATEGY');\n\n/*\n * Internal execution strategy injection token\n */\nexport const NGXS_EXECUTION_STRATEGY = new InjectionToken<NgxsExecutionStrategy>(\n  'NGXS_EXECUTION_STRATEGY',\n  {\n    providedIn: 'root',\n    factory: () => {\n      const injector = inject(INJECTOR);\n      const executionStrategy = injector.get(USER_PROVIDED_NGXS_EXECUTION_STRATEGY);\n      return executionStrategy\n        ? injector.get(executionStrategy)\n        : injector.get(\n            typeof ɵglobal.Zone !== 'undefined'\n              ? DispatchOutsideZoneNgxsExecutionStrategy\n              : NoopNgxsExecutionStrategy\n          );\n    }\n  }\n);\n\n/*\n * Execution strategy interface\n */\nexport interface NgxsExecutionStrategy {\n  enter<T>(func: () => T): T;\n  leave<T>(func: () => T): T;\n}\n","import { PlainObjectOf, StateClass } from '@ngxs/store/internals';\nimport { Observable } from 'rxjs';\n\nimport {\n  META_KEY,\n  META_OPTIONS_KEY,\n  NgxsConfig,\n  SELECTOR_META_KEY,\n  StoreOptions\n} from '../symbols';\nimport { ActionHandlerMetaData } from '../actions/symbols';\n\n// inspired from https://stackoverflow.com/a/43674389\nexport interface StateClassInternal<T = any, U = any> extends StateClass<T> {\n  [META_KEY]?: MetaDataModel;\n  [META_OPTIONS_KEY]?: StoreOptions<U>;\n}\n\nexport type StateKeyGraph = PlainObjectOf<string[]>;\nexport type StatesByName = PlainObjectOf<StateClassInternal>;\n\nexport interface StateOperations<T> {\n  getState(): T;\n\n  setState(val: T): T;\n\n  dispatch(actionOrActions: any | any[]): Observable<void>;\n}\n\nexport interface MetaDataModel {\n  name: string | null;\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\n  defaults: any;\n  path: string | null;\n  makeRootSelector: SelectorFactory | null;\n  children?: StateClassInternal[];\n}\n\nexport interface RuntimeSelectorContext {\n  getStateGetter(key: any): (state: any) => any;\n  getSelectorOptions(localOptions?: SharedSelectorOptions): SharedSelectorOptions;\n}\n\nexport type SelectFromRootState = (rootState: any) => any;\nexport type SelectorFactory = (runtimeContext: RuntimeSelectorContext) => SelectFromRootState;\n\nexport interface SharedSelectorOptions {\n  injectContainerState?: boolean;\n  suppressErrors?: boolean;\n}\n\nexport interface SelectorMetaDataModel {\n  makeRootSelector: SelectorFactory | null;\n  originalFn: Function | null;\n  containerClass: any;\n  selectorName: string | null;\n  getSelectorOptions: () => SharedSelectorOptions;\n}\n\nexport interface MappedStore {\n  name: string;\n  isInitialised: boolean;\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\n  defaults: any;\n  instance: any;\n  path: string;\n}\n\nexport interface StatesAndDefaults {\n  defaults: any;\n  states: MappedStore[];\n}\n\n/**\n * Ensures metadata is attached to the class and returns it.\n *\n * @ignore\n */\nexport function ensureStoreMetadata(target: StateClassInternal): MetaDataModel {\n  if (!target.hasOwnProperty(META_KEY)) {\n    const defaultMetadata: MetaDataModel = {\n      name: null,\n      actions: {},\n      defaults: {},\n      path: null,\n      makeRootSelector(context: RuntimeSelectorContext) {\n        return context.getStateGetter(defaultMetadata.name);\n      },\n      children: []\n    };\n\n    Object.defineProperty(target, META_KEY, { value: defaultMetadata });\n  }\n  return getStoreMetadata(target);\n}\n\n/**\n * Get the metadata attached to the state class if it exists.\n *\n * @ignore\n */\nexport function getStoreMetadata(target: StateClassInternal): MetaDataModel {\n  return target[META_KEY]!;\n}\n\n/**\n * Ensures metadata is attached to the selector and returns it.\n *\n * @ignore\n */\nexport function ensureSelectorMetadata(target: Function): SelectorMetaDataModel {\n  if (!target.hasOwnProperty(SELECTOR_META_KEY)) {\n    const defaultMetadata: SelectorMetaDataModel = {\n      makeRootSelector: null,\n      originalFn: null,\n      containerClass: null,\n      selectorName: null,\n      getSelectorOptions: () => ({})\n    };\n\n    Object.defineProperty(target, SELECTOR_META_KEY, { value: defaultMetadata });\n  }\n\n  return getSelectorMetadata(target);\n}\n\n/**\n * Get the metadata attached to the selector if it exists.\n *\n * @ignore\n */\nexport function getSelectorMetadata(target: any): SelectorMetaDataModel {\n  return target[SELECTOR_META_KEY];\n}\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.\n * See perf hit: https://jsperf.com/fast-value-getter-given-path/1\n *\n * @ignore\n */\nfunction compliantPropGetter(paths: string[]): (x: any) => any {\n  const copyOfPaths = paths.slice();\n  return obj => copyOfPaths.reduce((acc: any, part: string) => acc && acc[part], obj);\n}\n\n/**\n * The generated function is faster than:\n * - pluck (Observable operator)\n * - memoize\n *\n * @ignore\n */\nfunction fastPropGetter(paths: string[]): (x: any) => any {\n  const segments = paths;\n  let seg = 'store.' + segments[0];\n  let i = 0;\n  const l = segments.length;\n\n  let expr = seg;\n  while (++i < l) {\n    expr = expr + ' && ' + (seg = seg + '.' + segments[i]);\n  }\n\n  const fn = new Function('store', 'return ' + expr + ';');\n\n  return <(x: any) => any>fn;\n}\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * @ignore\n */\nexport function propGetter(paths: string[], config: NgxsConfig) {\n  if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {\n    return compliantPropGetter(paths);\n  } else {\n    return fastPropGetter(paths);\n  }\n}\n\n/**\n * Given an array of states, it will return a object graph. Example:\n *    const states = [\n *      Cart,\n *      CartSaved,\n *      CartSavedItems\n *    ]\n *\n * would return:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * @ignore\n */\nexport function buildGraph(stateClasses: StateClassInternal[]): StateKeyGraph {\n  const findName = (stateClass: StateClassInternal) => {\n    const meta = stateClasses.find(g => g === stateClass);\n\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if ((typeof ngDevMode === 'undefined' || ngDevMode) && !meta) {\n      throw new Error(\n        `Child state not found: ${stateClass}. \\r\\nYou may have forgotten to add states to module`\n      );\n    }\n\n    return meta![META_KEY]!.name!;\n  };\n\n  return stateClasses.reduce<StateKeyGraph>(\n    (result: StateKeyGraph, stateClass: StateClassInternal) => {\n      const { name, children } = stateClass[META_KEY]!;\n      result[name!] = (children || []).map(findName);\n      return result;\n    },\n    {}\n  );\n}\n\n/**\n * Given a states array, returns object graph\n * returning the name and state metadata. Example:\n *\n *  const graph = {\n *    cart: { metadata }\n *  };\n *\n * @ignore\n */\nexport function nameToState(states: StateClassInternal[]): PlainObjectOf<StateClassInternal> {\n  return states.reduce<PlainObjectOf<StateClassInternal>>(\n    (result: PlainObjectOf<StateClassInternal>, stateClass: StateClassInternal) => {\n      const meta = stateClass[META_KEY]!;\n      result[meta.name!] = stateClass;\n      return result;\n    },\n    {}\n  );\n}\n\n/**\n * Given a object relationship graph will return the full path\n * for the child items. Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const r = {\n *    cart: 'cart',\n *    saved: 'cart.saved',\n *    items: 'cart.saved.items'\n *  };\n *\n * @ignore\n */\nexport function findFullParentPath(\n  obj: StateKeyGraph,\n  newObj: PlainObjectOf<string> = {}\n): PlainObjectOf<string> {\n  const visit = (child: StateKeyGraph, keyToFind: string): string | null => {\n    for (const key in child) {\n      if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {\n        const parent = visit(child, key);\n        return parent !== null ? `${parent}.${key}` : key;\n      }\n    }\n    return null;\n  };\n\n  for (const key in obj) {\n    if (obj.hasOwnProperty(key)) {\n      const parent = visit(obj, key);\n      newObj[key] = parent ? `${parent}.${key}` : key;\n    }\n  }\n\n  return newObj;\n}\n\n/**\n * Given a object graph, it will return the items topologically sorted Example:\n *\n *  const graph = {\n *    cart: ['saved'],\n *    saved: ['items'],\n *    items: []\n *  };\n *\n * would return:\n *\n *  const results = [\n *    'items',\n *    'saved',\n *    'cart'\n *  ];\n *\n * @ignore\n */\nexport function topologicalSort(graph: StateKeyGraph): string[] {\n  const sorted: string[] = [];\n  const visited: PlainObjectOf<boolean> = {};\n\n  const visit = (name: string, ancestors: string[] = []) => {\n    if (!Array.isArray(ancestors)) {\n      ancestors = [];\n    }\n\n    ancestors.push(name);\n    visited[name] = true;\n\n    graph[name].forEach((dep: string) => {\n      // Caretaker note: we have still left the `typeof` condition in order to avoid\n      // creating a breaking change for projects that still use the View Engine.\n      if ((typeof ngDevMode === 'undefined' || ngDevMode) && ancestors.indexOf(dep) >= 0) {\n        throw new Error(\n          `Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`\n        );\n      }\n\n      if (visited[dep]) {\n        return;\n      }\n\n      visit(dep, ancestors.slice(0));\n    });\n\n    if (sorted.indexOf(name) < 0) {\n      sorted.push(name);\n    }\n  };\n\n  Object.keys(graph).forEach(k => visit(k));\n\n  return sorted.reverse();\n}\n\n/**\n * Returns if the parameter is a object or not.\n *\n * @ignore\n */\nexport function isObject(obj: any) {\n  return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';\n}\n","/**\n * Returns the type from an action instance/class.\n * @ignore\n */\nexport function getActionTypeFromInstance(action: any): string | undefined {\n  if (action.constructor && action.constructor.type) {\n    return action.constructor.type;\n  } else {\n    return action.type;\n  }\n}\n\n/**\n * Matches a action\n * @ignore\n */\nexport function actionMatcher(action1: any) {\n  const type1 = getActionTypeFromInstance(action1);\n\n  return function(action2: any) {\n    return type1 === getActionTypeFromInstance(action2);\n  };\n}\n\n/**\n * Set a deeply nested value. Example:\n *\n *   setValue({ foo: { bar: { eat: false } } },\n *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }\n *\n * While it traverses it also creates new objects from top down.\n *\n * @ignore\n */\nexport const setValue = (obj: any, prop: string, val: any) => {\n  obj = { ...obj };\n\n  const split = prop.split('.');\n  const lastIndex = split.length - 1;\n\n  split.reduce((acc, part, index) => {\n    if (index === lastIndex) {\n      acc[part] = val;\n    } else {\n      acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : { ...acc[part] };\n    }\n\n    return acc && acc[part];\n  }, obj);\n\n  return obj;\n};\n\n/**\n * Get a deeply nested value. Example:\n *\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\n *\n * @ignore\n */\nexport const getValue = (obj: any, prop: string): any =>\n  prop.split('.').reduce((acc: any, part: string) => acc && acc[part], obj);\n\n/**\n * Simple object check.\n *\n *    isObject({a:1}) //=> true\n *    isObject(1) //=> false\n *\n * @ignore\n */\nexport const isObject = (item: any) => {\n  return item && typeof item === 'object' && !Array.isArray(item);\n};\n\n/**\n * Deep merge two objects.\n *\n *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}\n *\n * @param base base object onto which `sources` will be applied\n */\nexport const mergeDeep = (base: any, ...sources: any[]): any => {\n  if (!sources.length) return base;\n  const source = sources.shift();\n\n  if (isObject(base) && isObject(source)) {\n    for (const key in source) {\n      if (isObject(source[key])) {\n        if (!base[key]) Object.assign(base, { [key]: {} });\n        mergeDeep(base[key], source[key]);\n      } else {\n        Object.assign(base, { [key]: source[key] });\n      }\n    }\n  }\n\n  return mergeDeep(base, ...sources);\n};\n","import { OperatorFunction, Observable } from 'rxjs';\nimport { map, filter } from 'rxjs/operators';\n\nimport { ActionType } from '../actions/symbols';\nimport { getActionTypeFromInstance } from '../utils/utils';\nimport { ActionContext, ActionStatus } from '../actions-stream';\n\nexport interface ActionCompletion<T = any, E = Error> {\n  action: T;\n  result: {\n    successful: boolean;\n    canceled: boolean;\n    error?: E;\n  };\n}\n\nexport function ofAction<T = any>(allowedType: ActionType): OperatorFunction<ActionContext, T>;\nexport function ofAction<T = any>(\n  ...allowedTypes: ActionType[]\n): OperatorFunction<ActionContext, T>;\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will grab actions that have just been dispatched as well as actions that have completed\n */\nexport function ofAction(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, any> {\n  return ofActionOperator(allowedTypes);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been dispatched\n */\nexport function ofActionDispatched(\n  ...allowedTypes: ActionType[]\n): OperatorFunction<ActionContext, any> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Dispatched]);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been successfully completed\n */\nexport function ofActionSuccessful(\n  ...allowedTypes: ActionType[]\n): OperatorFunction<ActionContext, any> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Successful]);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been canceled\n */\nexport function ofActionCanceled(\n  ...allowedTypes: ActionType[]\n): OperatorFunction<ActionContext, any> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Canceled]);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just been completed\n */\nexport function ofActionCompleted(\n  ...allowedTypes: ActionType[]\n): OperatorFunction<ActionContext, ActionCompletion> {\n  const allowedStatuses = [\n    ActionStatus.Successful,\n    ActionStatus.Canceled,\n    ActionStatus.Errored\n  ];\n  return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);\n}\n\n/**\n * RxJS operator for selecting out specific actions.\n *\n * This will ONLY grab actions that have just thrown an error\n */\nexport function ofActionErrored(\n  ...allowedTypes: ActionType[]\n): OperatorFunction<ActionContext, any> {\n  return ofActionOperator(allowedTypes, [ActionStatus.Errored]);\n}\n\nfunction ofActionOperator(\n  allowedTypes: ActionType[],\n  statuses?: ActionStatus[],\n  // This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,\n  // since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`\n  // defaults to `any`, thus there is no sense from union type.\n  mapOperator: () => OperatorFunction<ActionContext, any> = mapAction\n): OperatorFunction<ActionContext, any> {\n  const allowedMap = createAllowedActionTypesMap(allowedTypes);\n  const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);\n  return function(o: Observable<ActionContext>) {\n    return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());\n  };\n}\n\nfunction filterStatus(allowedTypes: FilterMap, allowedStatuses?: FilterMap) {\n  return filter((ctx: ActionContext) => {\n    const actionType = getActionTypeFromInstance(ctx.action)!;\n    const typeMatch = allowedTypes[actionType];\n    const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;\n    return typeMatch && statusMatch;\n  });\n}\n\nfunction mapActionResult(): OperatorFunction<ActionContext, ActionCompletion> {\n  return map(({ action, status, error }: ActionContext) => {\n    return <ActionCompletion>{\n      action,\n      result: {\n        successful: ActionStatus.Successful === status,\n        canceled: ActionStatus.Canceled === status,\n        error\n      }\n    };\n  });\n}\n\nfunction mapAction<T = any>(): OperatorFunction<ActionContext, T> {\n  return map((ctx: ActionContext) => <T>ctx.action);\n}\n\ninterface FilterMap {\n  [key: string]: boolean;\n}\n\nfunction createAllowedActionTypesMap(types: ActionType[]): FilterMap {\n  return types.reduce((filterMap: FilterMap, klass: any) => {\n    filterMap[getActionTypeFromInstance(klass)!] = true;\n    return filterMap;\n  }, <FilterMap>{});\n}\n\nfunction createAllowedStatusesMap(statuses: ActionStatus[]): FilterMap {\n  return statuses.reduce((filterMap: FilterMap, status: ActionStatus) => {\n    filterMap[status] = true;\n    return filterMap;\n  }, <FilterMap>{});\n}\n","import { MonoTypeOperatorFunction, Observable, Observer } from 'rxjs';\nimport { NgxsExecutionStrategy } from '../execution/symbols';\n\n/**\n * Returns operator that will run\n * `subscribe` outside of the ngxs execution context\n */\nexport function leaveNgxs<T>(\n  ngxsExecutionStrategy: NgxsExecutionStrategy\n): MonoTypeOperatorFunction<T> {\n  return (source: Observable<T>) => {\n    return new Observable((sink: Observer<T>) => {\n      return source.subscribe({\n        next(value) {\n          ngxsExecutionStrategy.leave(() => sink.next(value));\n        },\n        error(error) {\n          ngxsExecutionStrategy.leave(() => sink.error(error));\n        },\n        complete() {\n          ngxsExecutionStrategy.leave(() => sink.complete());\n        }\n      });\n    });\n  };\n}\n","import { Injectable, Inject } from '@angular/core';\n\nimport { NgxsExecutionStrategy, NGXS_EXECUTION_STRATEGY } from './symbols';\n\n@Injectable()\nexport class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {\n  constructor(\n    @Inject(NGXS_EXECUTION_STRATEGY) private _executionStrategy: NgxsExecutionStrategy\n  ) {}\n\n  enter<T>(func: () => T): T {\n    return this._executionStrategy.enter(func);\n  }\n\n  leave<T>(func: () => T): T {\n    return this._executionStrategy.leave(func);\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\nimport { Subject, Observable } from 'rxjs';\nimport { share } from 'rxjs/operators';\n\nimport { leaveNgxs } from './operators/leave-ngxs';\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\n\n/**\n * Status of a dispatched action\n */\nexport const enum ActionStatus {\n  Dispatched = 'DISPATCHED',\n  Successful = 'SUCCESSFUL',\n  Canceled = 'CANCELED',\n  Errored = 'ERRORED'\n}\n\nexport interface ActionContext<T = any> {\n  status: ActionStatus;\n  action: T;\n  error?: Error;\n}\n\n/**\n * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.\n * A standard Subject does not have this guarantee.\n * For example, given the following code:\n * ```typescript\n *   const subject = new Subject<string>();\n     subject.subscribe(value => {\n       if (value === 'start') subject.next('end');\n     });\n     subject.subscribe(value => { });\n     subject.next('start');\n * ```\n * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.\n * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.\n */\nexport class OrderedSubject<T> extends Subject<T> {\n  private _itemQueue: T[] = [];\n  private _busyPushingNext = false;\n\n  next(value?: T): void {\n    if (this._busyPushingNext) {\n      this._itemQueue.unshift(value!);\n      return;\n    }\n    this._busyPushingNext = true;\n    super.next(value);\n    while (this._itemQueue.length > 0) {\n      const nextValue = this._itemQueue.pop();\n      super.next(nextValue);\n    }\n    this._busyPushingNext = false;\n  }\n}\n\n/**\n * Internal Action stream that is emitted anytime an action is dispatched.\n */\n@Injectable()\nexport class InternalActions extends OrderedSubject<ActionContext> implements OnDestroy {\n  ngOnDestroy(): void {\n    this.complete();\n  }\n}\n\n/**\n * Action stream that is emitted anytime an action is dispatched.\n *\n * You can listen to this in services to react without stores.\n */\n@Injectable()\nexport class Actions extends Observable<any> {\n  // This has to be `Observable<ActionContext>` in the v4. Because `InternalActions`\n  // is a `Subject<ActionContext>`. Leave it as `any` to avoid breaking changes\n  constructor(\n    internalActions$: InternalActions,\n    internalExecutionStrategy: InternalNgxsExecutionStrategy\n  ) {\n    const sharedInternalActions$ = internalActions$.pipe(\n      leaveNgxs(internalExecutionStrategy),\n      // The `InternalActions` subject emits outside of the Angular zone.\n      // We have to re-enter the Angular zone for any incoming consumer.\n      // The `share()` operator reduces the number of change detections.\n      // This would call leave only once for any stream emission across all active subscribers.\n      share()\n    );\n\n    super(observer => {\n      const childSubscription = sharedInternalActions$.subscribe({\n        next: ctx => observer.next(ctx),\n        error: error => observer.error(error),\n        complete: () => observer.complete()\n      });\n\n      observer.add(childSubscription);\n    });\n  }\n}\n","export type StateFn = (...args: any[]) => any;\n\n/**\n * Composes a array of functions from left to right. Example:\n *\n *      compose([fn, final])(state, action);\n *\n * then the funcs have a signature like:\n *\n *      function fn (state, action, next) {\n *          console.log('here', state, action, next);\n *          return next(state, action);\n *      }\n *\n *      function final (state, action) {\n *          console.log('here', state, action);\n *          return state;\n *      }\n *\n * the last function should not call `next`.\n *\n * @ignore\n */\nexport const compose = (funcs: StateFn[]) => (...args: any[]) => {\n  const curr = funcs.shift()!;\n  return curr(...args, (...nextArgs: any[]) => compose(funcs)(...nextArgs));\n};\n","import { ErrorHandler, Injectable, Injector } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { leaveNgxs } from '../operators/leave-ngxs';\nimport { NgxsExecutionStrategy } from '../execution/symbols';\n\n/**\n * This operator is used for piping the observable result\n * from the `dispatch()`. It has a \"smart\" error handling\n * strategy that allows us to decide whether we propagate\n * errors to Angular's `ErrorHandler` or enable users to\n * handle them manually. We consider following cases:\n * 1) `store.dispatch()` (no subscribe) -> call `handleError()`\n * 2) `store.dispatch().subscribe()` (no error callback) -> call `handleError()`\n * 3) `store.dispatch().subscribe({ error: ... })` -> don't call `handleError()`\n * 4) `toPromise()` without `catch` -> do `handleError()`\n * 5) `toPromise()` with `catch` -> don't `handleError()`\n */\nexport function ngxsErrorHandler<T>(\n  internalErrorReporter: InternalErrorReporter,\n  ngxsExecutionStrategy: NgxsExecutionStrategy\n) {\n  return (source: Observable<T>) => {\n    let subscribed = false;\n\n    source.subscribe({\n      error: error => {\n        // Do not trigger change detection for a microtask. This depends on the execution\n        // strategy being used, but the default `DispatchOutsideZoneNgxsExecutionStrategy`\n        // leaves the Angular zone.\n        ngxsExecutionStrategy.enter(() =>\n          Promise.resolve().then(() => {\n            if (!subscribed) {\n              ngxsExecutionStrategy.leave(() =>\n                internalErrorReporter.reportErrorSafely(error)\n              );\n            }\n          })\n        );\n      }\n    });\n\n    return new Observable(subscriber => {\n      subscribed = true;\n      return source.pipe(leaveNgxs(ngxsExecutionStrategy)).subscribe(subscriber);\n    });\n  };\n}\n\n@Injectable({ providedIn: 'root' })\nexport class InternalErrorReporter {\n  /** Will be set lazily to be backward compatible. */\n  private _errorHandler: ErrorHandler = null!;\n\n  constructor(private _injector: Injector) {}\n\n  reportErrorSafely(error: any): void {\n    if (this._errorHandler === null) {\n      this._errorHandler = this._injector.get(ErrorHandler);\n    }\n    // The `try-catch` is used to avoid handling the error twice. Suppose we call\n    // `handleError` which re-throws the error internally. The re-thrown error will\n    // be caught by zone.js which will then get to the `zone.onError.emit()` and the\n    // `onError` subscriber will call `handleError` again.\n    try {\n      this._errorHandler.handleError(error);\n    } catch {}\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\nimport { BehaviorSubject } from 'rxjs';\n\nimport { PlainObject } from '@ngxs/store/internals';\n\n/**\n * BehaviorSubject of the entire state.\n * @ignore\n */\n@Injectable()\nexport class StateStream extends BehaviorSubject<PlainObject> implements OnDestroy {\n  constructor() {\n    super({});\n  }\n\n  ngOnDestroy(): void {\n    // The `StateStream` should never emit values once the root view is removed, e.g. when the `NgModuleRef.destroy()` is called.\n    // This will eliminate memory leaks in server-side rendered apps where the `StateStream` is created per each HTTP request, users\n    // might forget to unsubscribe from `store.select` or `store.subscribe`, thus this will lead to huge memory leaks in SSR apps.\n    this.complete();\n  }\n}\n","import { Inject, Injectable, Optional, SkipSelf } from '@angular/core';\nimport { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn } from './symbols';\n\n@Injectable()\nexport class PluginManager {\n  public plugins: NgxsPluginFn[] = [];\n\n  constructor(\n    @Optional()\n    @SkipSelf()\n    private _parentManager: PluginManager,\n    @Inject(NGXS_PLUGINS)\n    @Optional()\n    private _pluginHandlers: NgxsPlugin[]\n  ) {\n    this.registerHandlers();\n  }\n\n  private get rootPlugins(): NgxsPluginFn[] {\n    return (this._parentManager && this._parentManager.plugins) || this.plugins;\n  }\n\n  private registerHandlers(): void {\n    const pluginHandlers: NgxsPluginFn[] = this.getPluginHandlers();\n    this.rootPlugins.push(...pluginHandlers);\n  }\n\n  private getPluginHandlers(): NgxsPluginFn[] {\n    const handlers: NgxsPlugin[] = this._pluginHandlers || [];\n    return handlers.map(\n      (plugin: NgxsPlugin) =>\n        (plugin.handle ? plugin.handle.bind(plugin) : plugin) as NgxsPluginFn\n    );\n  }\n}\n","import { Injectable } from '@angular/core';\nimport { EMPTY, forkJoin, Observable, of, Subject, throwError } from 'rxjs';\nimport { exhaustMap, filter, shareReplay, take } from 'rxjs/operators';\n\nimport { compose } from '../utils/compose';\nimport { InternalErrorReporter, ngxsErrorHandler } from './error-handler';\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\nimport { StateStream } from './state-stream';\nimport { PluginManager } from '../plugin-manager';\nimport { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';\nimport { getActionTypeFromInstance } from '../utils/utils';\n\n/**\n * Internal Action result stream that is emitted when an action is completed.\n * This is used as a method of returning the action result to the dispatcher\n * for the observable returned by the dispatch(...) call.\n * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.\n */\n@Injectable()\nexport class InternalDispatchedActionResults extends Subject<ActionContext> {}\n\n@Injectable()\nexport class InternalDispatcher {\n  constructor(\n    private _actions: InternalActions,\n    private _actionResults: InternalDispatchedActionResults,\n    private _pluginManager: PluginManager,\n    private _stateStream: StateStream,\n    private _ngxsExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _internalErrorReporter: InternalErrorReporter\n  ) {}\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    const result = this._ngxsExecutionStrategy.enter(() =>\n      this.dispatchByEvents(actionOrActions)\n    );\n\n    return result.pipe(\n      ngxsErrorHandler(this._internalErrorReporter, this._ngxsExecutionStrategy)\n    );\n  }\n\n  private dispatchByEvents(actionOrActions: any | any[]): Observable<any> {\n    if (Array.isArray(actionOrActions)) {\n      if (actionOrActions.length === 0) return of(this._stateStream.getValue());\n      return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));\n    } else {\n      return this.dispatchSingle(actionOrActions);\n    }\n  }\n\n  private dispatchSingle(action: any): Observable<any> {\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const type: string | undefined = getActionTypeFromInstance(action);\n      if (!type) {\n        const error = new Error(\n          `This action doesn't have a type property: ${action.constructor.name}`\n        );\n        return throwError(error);\n      }\n    }\n\n    const prevState = this._stateStream.getValue();\n    const plugins = this._pluginManager.plugins;\n\n    return (compose([\n      ...plugins,\n      (nextState: any, nextAction: any) => {\n        if (nextState !== prevState) {\n          this._stateStream.next(nextState);\n        }\n        const actionResult$ = this.getActionResultStream(nextAction);\n        actionResult$.subscribe(ctx => this._actions.next(ctx));\n        this._actions.next({ action: nextAction, status: ActionStatus.Dispatched });\n        return this.createDispatchObservable(actionResult$);\n      }\n    ])(prevState, action) as Observable<any>).pipe(shareReplay());\n  }\n\n  private getActionResultStream(action: any): Observable<ActionContext> {\n    return this._actionResults.pipe(\n      filter(\n        (ctx: ActionContext) => ctx.action === action && ctx.status !== ActionStatus.Dispatched\n      ),\n      take(1),\n      shareReplay()\n    );\n  }\n\n  private createDispatchObservable(actionResult$: Observable<ActionContext>): Observable<any> {\n    return actionResult$\n      .pipe(\n        exhaustMap((ctx: ActionContext) => {\n          switch (ctx.status) {\n            case ActionStatus.Successful:\n              return of(this._stateStream.getValue());\n            case ActionStatus.Errored:\n              return throwError(ctx.error);\n            default:\n              return EMPTY;\n          }\n        })\n      )\n      .pipe(shareReplay());\n  }\n}\n","/**\n * Object freeze code\n * https://github.com/jsdf/deep-freeze\n */\nexport const deepFreeze = (o: any) => {\n  Object.freeze(o);\n\n  const oIsFunction = typeof o === 'function';\n  const hasOwnProp = Object.prototype.hasOwnProperty;\n\n  Object.getOwnPropertyNames(o).forEach(function(prop) {\n    if (\n      hasOwnProp.call(o, prop) &&\n      (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&\n      o[prop] !== null &&\n      (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\n      !Object.isFrozen(o[prop])\n    ) {\n      deepFreeze(o[prop]);\n    }\n  });\n\n  return o;\n};\n","import { Injectable } from '@angular/core';\n\nimport { StateOperations, StatesAndDefaults } from '../internal/internals';\nimport { InternalDispatcher } from '../internal/dispatcher';\nimport { StateStream } from './state-stream';\nimport { NgxsConfig } from '../symbols';\nimport { deepFreeze } from '../utils/freeze';\n\n/**\n * State Context factory class\n * @ignore\n */\n@Injectable()\nexport class InternalStateOperations {\n  constructor(\n    private _stateStream: StateStream,\n    private _dispatcher: InternalDispatcher,\n    private _config: NgxsConfig\n  ) {}\n\n  /**\n   * Returns the root state operators.\n   */\n  getRootStateOperations(): StateOperations<any> {\n    const rootStateOperations = {\n      getState: () => this._stateStream.getValue(),\n      setState: (newState: any) => this._stateStream.next(newState),\n      dispatch: (actionOrActions: any | any[]) => this._dispatcher.dispatch(actionOrActions)\n    };\n\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      return this._config.developmentMode\n        ? ensureStateAndActionsAreImmutable(rootStateOperations)\n        : rootStateOperations;\n    } else {\n      return rootStateOperations;\n    }\n  }\n\n  setStateToTheCurrentWithNew(results: StatesAndDefaults): void {\n    const stateOperations: StateOperations<any> = this.getRootStateOperations();\n\n    // Get our current stream\n    const currentState = stateOperations.getState();\n    // Set the state to the current + new\n    stateOperations.setState({ ...currentState, ...results.defaults });\n  }\n}\n\nfunction ensureStateAndActionsAreImmutable(root: StateOperations<any>): StateOperations<any> {\n  return {\n    getState: () => root.getState(),\n    setState: value => {\n      const frozenValue = deepFreeze(value);\n      return root.setState(frozenValue);\n    },\n    dispatch: actions => {\n      return root.dispatch(actions);\n    }\n  };\n}\n","import {\n  throwPatchingArrayError,\n  throwPatchingPrimitiveError\n} from '../configs/messages.config';\nimport { StateOperator } from '../symbols';\n\nexport function simplePatch<T>(val: Partial<T>): StateOperator<T> {\n  return (existingState: Readonly<T>) => {\n    if (Array.isArray(val)) {\n      throwPatchingArrayError();\n    } else if (typeof val !== 'object') {\n      throwPatchingPrimitiveError();\n    }\n\n    const newState: any = { ...(existingState as any) };\n    for (const key in val) {\n      // deep clone for patch compatibility\n      // noinspection JSUnfilteredForInLoop (IDE)\n      newState[key] = (val as any)[key];\n    }\n\n    return newState as T;\n  };\n}\n","import { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { StateContext, StateOperator } from '../symbols';\nimport { MappedStore } from '../internal/internals';\nimport { setValue, getValue } from '../utils/utils';\nimport { InternalStateOperations } from '../internal/state-operations';\nimport { simplePatch } from './state-operators';\n\n/**\n * State Context factory class\n * @ignore\n */\n@Injectable()\nexport class StateContextFactory {\n  constructor(private _internalStateOperations: InternalStateOperations) {}\n\n  /**\n   * Create the state context\n   */\n  createStateContext<T>(mappedStore: MappedStore): StateContext<T> {\n    const root = this._internalStateOperations.getRootStateOperations();\n\n    function getState(currentAppState: any): T {\n      return getValue(currentAppState, mappedStore.path);\n    }\n\n    function setStateValue(currentAppState: any, newValue: T): any {\n      const newAppState = setValue(currentAppState, mappedStore.path, newValue);\n      root.setState(newAppState);\n      return newAppState;\n      // In doing this refactoring I noticed that there is a 'bug' where the\n      // application state is returned instead of this state slice.\n      // This has worked this way since the beginning see:\n      // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts\n      // This needs to be fixed, but is a 'breaking' change.\n      // I will do this fix in a subsequent PR and we can decide how to handle it.\n    }\n\n    function setStateFromOperator(currentAppState: any, stateOperator: StateOperator<T>) {\n      const local = getState(currentAppState);\n      const newValue = stateOperator(local);\n      return setStateValue(currentAppState, newValue);\n    }\n\n    function isStateOperator(value: T | StateOperator<T>): value is StateOperator<T> {\n      return typeof value === 'function';\n    }\n\n    return {\n      getState(): T {\n        const currentAppState = root.getState();\n        return getState(currentAppState);\n      },\n      patchState(val: Partial<T>): T {\n        const currentAppState = root.getState();\n        const patchOperator = simplePatch<T>(val);\n        return setStateFromOperator(currentAppState, patchOperator);\n      },\n      setState(val: T | StateOperator<T>): T {\n        const currentAppState = root.getState();\n        return isStateOperator(val)\n          ? setStateFromOperator(currentAppState, val)\n          : setStateValue(currentAppState, val);\n      },\n      dispatch(actions: any | any[]): Observable<void> {\n        return root.dispatch(actions);\n      }\n    };\n  }\n}\n","import { getStoreMetadata, StateClassInternal, StatesByName } from '../internal/internals';\nimport {\n  throwStateDecoratorError,\n  throwStateNameError,\n  throwStateNamePropertyError,\n  throwStateUniqueError\n} from '../configs/messages.config';\n\nexport abstract class StoreValidators {\n  private static stateNameRegex: RegExp = new RegExp('^[a-zA-Z0-9_]+$');\n\n  static checkThatStateIsNamedCorrectly(name: string | null): void | never {\n    if (!name) {\n      throwStateNamePropertyError();\n    } else if (!this.stateNameRegex.test(name)) {\n      throwStateNameError(name);\n    }\n  }\n\n  static checkThatStateNameIsUnique(\n    stateName: string,\n    state: StateClassInternal,\n    statesByName: StatesByName\n  ): void | never {\n    const existingState = statesByName[stateName];\n    if (existingState && existingState !== state) {\n      throwStateUniqueError(stateName, state.name, existingState.name);\n    }\n  }\n\n  static checkThatStateClassesHaveBeenDecorated(\n    stateClasses: StateClassInternal[]\n  ): void | never {\n    stateClasses.forEach((stateClass: StateClassInternal) => {\n      if (!getStoreMetadata(stateClass)) {\n        throwStateDecoratorError(stateClass.name);\n      }\n    });\n  }\n}\n","import { ɵivyEnabled } from '@angular/core';\n\nimport { getUndecoratedStateInIvyWarningMessage } from '../configs/messages.config';\n\n/**\n * All provided or injected tokens must have `@Injectable` decorator\n * (previously, injected tokens without `@Injectable` were allowed\n * if another decorator was used, e.g. pipes).\n */\nexport function ensureStateClassIsInjectable(stateClass: any): void {\n  // `ɵprov` is a static property added by the NGCC compiler. It always exists in\n  // AOT mode because this property is added before runtime. If an application is running in\n  // JIT mode then this property can be added by the `@Injectable()` decorator. The `@Injectable()`\n  // decorator has to go after the `@State()` decorator, thus we prevent users from unwanted DI errors.\n  if (ɵivyEnabled) {\n    const ngInjectableDef = stateClass.ɵprov;\n    if (!ngInjectableDef) {\n      // Don't warn if Ivy is disabled or `ɵprov` exists on the class\n      console.warn(getUndecoratedStateInIvyWarningMessage(stateClass.name));\n    }\n  }\n}\n","import { Injectable, Injector, Optional, SkipSelf, Inject, OnDestroy } from '@angular/core';\nimport {\n  forkJoin,\n  from,\n  Observable,\n  of,\n  throwError,\n  Subscription,\n  Subject,\n  isObservable\n} from 'rxjs';\nimport {\n  catchError,\n  defaultIfEmpty,\n  filter,\n  map,\n  mergeMap,\n  shareReplay,\n  takeUntil\n} from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObjectOf, memoize } from '@ngxs/store/internals';\n\nimport { META_KEY, NgxsConfig } from '../symbols';\nimport {\n  buildGraph,\n  findFullParentPath,\n  isObject,\n  MappedStore,\n  MetaDataModel,\n  nameToState,\n  propGetter,\n  StateClassInternal,\n  StateKeyGraph,\n  StatesAndDefaults,\n  StatesByName,\n  topologicalSort,\n  RuntimeSelectorContext,\n  SharedSelectorOptions,\n  getStoreMetadata\n} from './internals';\nimport { getActionTypeFromInstance, getValue, setValue } from '../utils/utils';\nimport { ofActionDispatched } from '../operators/of-action';\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\nimport { InternalDispatchedActionResults } from '../internal/dispatcher';\nimport { StateContextFactory } from '../internal/state-context-factory';\nimport { StoreValidators } from '../utils/store-validators';\nimport { ensureStateClassIsInjectable } from '../ivy/ivy-enabled-in-dev-mode';\n\n/**\n * State factory class\n * @ignore\n */\n@Injectable()\nexport class StateFactory implements OnDestroy {\n  private _actionsSubscription: Subscription | null = null;\n\n  constructor(\n    private _injector: Injector,\n    private _config: NgxsConfig,\n    @Optional()\n    @SkipSelf()\n    private _parentFactory: StateFactory,\n    private _actions: InternalActions,\n    private _actionResults: InternalDispatchedActionResults,\n    private _stateContextFactory: StateContextFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    private _initialState: any\n  ) {}\n\n  private _states: MappedStore[] = [];\n\n  get states(): MappedStore[] {\n    return this._parentFactory ? this._parentFactory.states : this._states;\n  }\n\n  private _statesByName: StatesByName = {};\n\n  get statesByName(): StatesByName {\n    return this._parentFactory ? this._parentFactory.statesByName : this._statesByName;\n  }\n\n  private _statePaths: PlainObjectOf<string> = {};\n\n  private get statePaths(): PlainObjectOf<string> {\n    return this._parentFactory ? this._parentFactory.statePaths : this._statePaths;\n  }\n\n  getRuntimeSelectorContext = memoize(() => {\n    const stateFactory = this;\n\n    function resolveGetter(key: string) {\n      const path = stateFactory.statePaths[key];\n      return path ? propGetter(path.split('.'), stateFactory._config) : null;\n    }\n\n    const context: RuntimeSelectorContext = this._parentFactory\n      ? this._parentFactory.getRuntimeSelectorContext()\n      : {\n          getStateGetter(key: string) {\n            let getter = resolveGetter(key);\n            if (getter) {\n              return getter;\n            }\n            return (...args) => {\n              // Late loaded getter\n              if (!getter) {\n                getter = resolveGetter(key);\n              }\n              return getter ? getter(...args) : undefined;\n            };\n          },\n          getSelectorOptions(localOptions?: SharedSelectorOptions) {\n            const globalSelectorOptions = stateFactory._config.selectorOptions;\n            return {\n              ...globalSelectorOptions,\n              ...(localOptions || {})\n            };\n          }\n        };\n    return context;\n  });\n\n  private static cloneDefaults(defaults: any): any {\n    let value = {};\n\n    if (Array.isArray(defaults)) {\n      value = defaults.slice();\n    } else if (isObject(defaults)) {\n      value = { ...defaults };\n    } else if (defaults === undefined) {\n      value = {};\n    } else {\n      value = defaults;\n    }\n\n    return value;\n  }\n\n  ngOnDestroy(): void {\n    // I'm using non-null assertion here since `_actionsSubscrition` will\n    // be 100% defined. This is because `ngOnDestroy()` cannot be invoked\n    // on the `StateFactory` until its initialized :) An it's initialized\n    // for the first time along with the `NgxsRootModule`.\n    this._actionsSubscription!.unsubscribe();\n  }\n\n  /**\n   * Add a new state to the global defs.\n   */\n  add(stateClasses: StateClassInternal[]): MappedStore[] {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      StoreValidators.checkThatStateClassesHaveBeenDecorated(stateClasses);\n    }\n\n    const { newStates } = this.addToStatesMap(stateClasses);\n    if (!newStates.length) return [];\n\n    const stateGraph: StateKeyGraph = buildGraph(newStates);\n    const sortedStates: string[] = topologicalSort(stateGraph);\n    const paths: PlainObjectOf<string> = findFullParentPath(stateGraph);\n    const nameGraph: PlainObjectOf<StateClassInternal> = nameToState(newStates);\n    const bootstrappedStores: MappedStore[] = [];\n\n    for (const name of sortedStates) {\n      const stateClass: StateClassInternal = nameGraph[name];\n      const path: string = paths[name];\n      const meta: MetaDataModel = stateClass[META_KEY]!;\n\n      this.addRuntimeInfoToMeta(meta, path);\n\n      // Note: previously we called `ensureStateClassIsInjectable` within the\n      // `State` decorator. This check is moved here because the `ɵprov` property\n      // will not exist on the class in JIT mode (because it's set asynchronously\n      // during JIT compilation through `Object.defineProperty`).\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        ensureStateClassIsInjectable(stateClass);\n      }\n\n      const stateMap: MappedStore = {\n        name,\n        path,\n        isInitialised: false,\n        actions: meta.actions,\n        instance: this._injector.get(stateClass),\n        defaults: StateFactory.cloneDefaults(meta.defaults)\n      };\n\n      // ensure our store hasn't already been added\n      // but don't throw since it could be lazy\n      // loaded from different paths\n      if (!this.hasBeenMountedAndBootstrapped(name, path)) {\n        bootstrappedStores.push(stateMap);\n      }\n\n      this.states.push(stateMap);\n    }\n\n    return bootstrappedStores;\n  }\n\n  /**\n   * Add a set of states to the store and return the defaults\n   */\n  addAndReturnDefaults(stateClasses: StateClassInternal[]): StatesAndDefaults {\n    const classes: StateClassInternal[] = stateClasses || [];\n\n    const mappedStores: MappedStore[] = this.add(classes);\n    const defaults = mappedStores.reduce(\n      (result: any, mappedStore: MappedStore) =>\n        setValue(result, mappedStore.path, mappedStore.defaults),\n      {}\n    );\n    return { defaults, states: mappedStores };\n  }\n\n  /**\n   * Bind the actions to the handlers\n   */\n  connectActionHandlers() {\n    if (this._actionsSubscription !== null) return;\n    const dispatched$ = new Subject<ActionContext>();\n    this._actionsSubscription = this._actions\n      .pipe(\n        filter((ctx: ActionContext) => ctx.status === ActionStatus.Dispatched),\n        mergeMap(ctx => {\n          dispatched$.next(ctx);\n          const action = ctx.action;\n          return this.invokeActions(dispatched$, action!).pipe(\n            map(() => <ActionContext>{ action, status: ActionStatus.Successful }),\n            defaultIfEmpty(<ActionContext>{ action, status: ActionStatus.Canceled }),\n            catchError(error =>\n              of(<ActionContext>{ action, status: ActionStatus.Errored, error })\n            )\n          );\n        })\n      )\n      .subscribe(ctx => this._actionResults.next(ctx));\n  }\n\n  /**\n   * Invoke actions on the states.\n   */\n  invokeActions(dispatched$: Observable<ActionContext>, action: any) {\n    const type = getActionTypeFromInstance(action)!;\n    const results = [];\n\n    for (const metadata of this.states) {\n      const actionMetas = metadata.actions[type];\n\n      if (actionMetas) {\n        for (const actionMeta of actionMetas) {\n          const stateContext = this._stateContextFactory.createStateContext(metadata);\n          try {\n            let result = metadata.instance[actionMeta.fn](stateContext, action);\n\n            if (result instanceof Promise) {\n              result = from(result);\n            }\n\n            if (isObservable(result)) {\n              // If this observable has been completed w/o emitting\n              // any value then we wouldn't want to complete the whole chain\n              // of actions. Since if any observable completes then\n              // action will be canceled.\n              // For instance if any action handler would've had such statement:\n              // `handler(ctx) { return EMPTY; }`\n              // then the action will be canceled.\n              // See https://github.com/ngxs/store/issues/1568\n              result = result.pipe(\n                mergeMap((value: any) => {\n                  if (value instanceof Promise) {\n                    return from(value);\n                  }\n                  if (isObservable(value)) {\n                    return value;\n                  }\n                  return of(value);\n                }),\n                defaultIfEmpty({})\n              );\n\n              if (actionMeta.options.cancelUncompleted) {\n                // todo: ofActionDispatched should be used with action class\n                result = result.pipe(\n                  takeUntil(dispatched$.pipe(ofActionDispatched(action as any)))\n                );\n              }\n            } else {\n              result = of({}).pipe(shareReplay());\n            }\n\n            results.push(result);\n          } catch (e) {\n            results.push(throwError(e));\n          }\n        }\n      }\n    }\n\n    if (!results.length) {\n      results.push(of({}));\n    }\n\n    return forkJoin(results);\n  }\n\n  private addToStatesMap(\n    stateClasses: StateClassInternal[]\n  ): { newStates: StateClassInternal[] } {\n    const newStates: StateClassInternal[] = [];\n    const statesMap: StatesByName = this.statesByName;\n\n    for (const stateClass of stateClasses) {\n      const stateName = getStoreMetadata(stateClass).name!;\n      // Caretaker note: we have still left the `typeof` condition in order to avoid\n      // creating a breaking change for projects that still use the View Engine.\n      if (typeof ngDevMode === 'undefined' || ngDevMode) {\n        StoreValidators.checkThatStateNameIsUnique(stateName, stateClass, statesMap);\n      }\n      const unmountedState = !statesMap[stateName];\n      if (unmountedState) {\n        newStates.push(stateClass);\n        statesMap[stateName] = stateClass;\n      }\n    }\n\n    return { newStates };\n  }\n\n  private addRuntimeInfoToMeta(meta: MetaDataModel, path: string): void {\n    this.statePaths[meta.name!] = path;\n    // TODO: v4 - we plan to get rid of the path property because it is non-deterministic\n    // we can do this when we get rid of the incorrectly exposed getStoreMetadata\n    // We will need to come up with an alternative in v4 because this is used by many plugins\n    meta.path = path;\n  }\n\n  /**\n   * @description\n   * the method checks if the state has already been added to the tree\n   * and completed the life cycle\n   * @param name\n   * @param path\n   */\n  private hasBeenMountedAndBootstrapped(name: string, path: string): boolean {\n    const valueIsBootstrappedInInitialState: boolean =\n      getValue(this._initialState, path) !== undefined;\n    return this.statesByName[name] && valueIsBootstrappedInInitialState;\n  }\n}\n","import { memoize } from '@ngxs/store/internals';\n\nimport {\n  ensureSelectorMetadata,\n  getSelectorMetadata,\n  getStoreMetadata,\n  SelectorMetaDataModel,\n  SharedSelectorOptions,\n  RuntimeSelectorContext,\n  SelectorFactory,\n  SelectFromRootState\n} from '../internal/internals';\n\nconst SELECTOR_OPTIONS_META_KEY = 'NGXS_SELECTOR_OPTIONS_META';\n\nexport const selectorOptionsMetaAccessor = {\n  getOptions: (target: any): SharedSelectorOptions => {\n    return (target && (<any>target)[SELECTOR_OPTIONS_META_KEY]) || {};\n  },\n  defineOptions: (target: any, options: SharedSelectorOptions) => {\n    if (!target) return;\n    (<any>target)[SELECTOR_OPTIONS_META_KEY] = options;\n  }\n};\n\ninterface CreationMetadata {\n  containerClass: any;\n  selectorName: string;\n  getSelectorOptions?: () => SharedSelectorOptions;\n}\n\ninterface RuntimeSelectorInfo {\n  selectorOptions: SharedSelectorOptions;\n  argumentSelectorFunctions: SelectFromRootState[];\n}\n\n/**\n * Function for creating a selector\n * @param selectors The selectors to use to create the arguments of this function\n * @param originalFn The original function being made into a selector\n * @param creationMetadata\n */\nexport function createSelector<T extends (...args: any[]) => any>(\n  selectors: any[] | undefined,\n  originalFn: T,\n  creationMetadata?: CreationMetadata\n) {\n  const containerClass = creationMetadata && creationMetadata.containerClass;\n  const wrappedFn = function wrappedSelectorFn(...args: any[]) {\n    const returnValue = originalFn.apply(containerClass, args);\n    if (returnValue instanceof Function) {\n      const innerMemoizedFn = memoize.apply(null, [returnValue]);\n      return innerMemoizedFn;\n    }\n    return returnValue;\n  } as T;\n  const memoizedFn = memoize(wrappedFn);\n  Object.setPrototypeOf(memoizedFn, originalFn);\n\n  const selectorMetaData = setupSelectorMetadata<T>(originalFn, creationMetadata);\n\n  const makeRootSelector: SelectorFactory = (context: RuntimeSelectorContext) => {\n    const { argumentSelectorFunctions, selectorOptions } = getRuntimeSelectorInfo(\n      context,\n      selectorMetaData,\n      selectors\n    );\n\n    return function selectFromRoot(rootState: any) {\n      // Determine arguments from the app state using the selectors\n      const results = argumentSelectorFunctions.map(argFn => argFn(rootState));\n\n      // if the lambda tries to access a something on the\n      // state that doesn't exist, it will throw a TypeError.\n      // since this is quite usual behaviour, we simply return undefined if so.\n      try {\n        return memoizedFn(...results);\n      } catch (ex) {\n        if (ex instanceof TypeError && selectorOptions.suppressErrors) {\n          return undefined;\n        }\n\n        throw ex;\n      }\n    };\n  };\n\n  selectorMetaData.makeRootSelector = makeRootSelector;\n\n  return memoizedFn;\n}\n\nfunction setupSelectorMetadata<T extends (...args: any[]) => any>(\n  originalFn: T,\n  creationMetadata: CreationMetadata | undefined\n) {\n  const selectorMetaData = ensureSelectorMetadata(originalFn);\n  selectorMetaData.originalFn = originalFn;\n  let getExplicitSelectorOptions = () => ({});\n  if (creationMetadata) {\n    selectorMetaData.containerClass = creationMetadata.containerClass;\n    selectorMetaData.selectorName = creationMetadata.selectorName;\n    getExplicitSelectorOptions =\n      creationMetadata.getSelectorOptions || getExplicitSelectorOptions;\n  }\n  const selectorMetaDataClone = { ...selectorMetaData };\n  selectorMetaData.getSelectorOptions = () =>\n    getLocalSelectorOptions(selectorMetaDataClone, getExplicitSelectorOptions());\n  return selectorMetaData;\n}\n\nfunction getRuntimeSelectorInfo(\n  context: RuntimeSelectorContext,\n  selectorMetaData: SelectorMetaDataModel,\n  selectors: any[] | undefined = []\n): RuntimeSelectorInfo {\n  const localSelectorOptions = selectorMetaData.getSelectorOptions();\n  const selectorOptions = context.getSelectorOptions(localSelectorOptions);\n  const selectorsToApply = getSelectorsToApply(\n    selectors,\n    selectorOptions,\n    selectorMetaData.containerClass\n  );\n\n  const argumentSelectorFunctions = selectorsToApply.map(selector => {\n    const factory = getRootSelectorFactory(selector);\n    return factory(context);\n  });\n  return {\n    selectorOptions,\n    argumentSelectorFunctions\n  };\n}\n\nfunction getLocalSelectorOptions(\n  selectorMetaData: SelectorMetaDataModel,\n  explicitOptions: SharedSelectorOptions\n): SharedSelectorOptions {\n  return {\n    ...(selectorOptionsMetaAccessor.getOptions(selectorMetaData.containerClass) || {}),\n    ...(selectorOptionsMetaAccessor.getOptions(selectorMetaData.originalFn) || {}),\n    ...(selectorMetaData.getSelectorOptions() || {}),\n    ...explicitOptions\n  };\n}\n\nfunction getSelectorsToApply(\n  selectors: any[] | undefined = [],\n  selectorOptions: SharedSelectorOptions,\n  containerClass: any\n) {\n  const selectorsToApply = [];\n  const canInjectContainerState =\n    selectors.length === 0 || selectorOptions.injectContainerState;\n  if (containerClass && canInjectContainerState) {\n    // If we are on a state class, add it as the first selector parameter\n    const metadata = getStoreMetadata(containerClass);\n    if (metadata) {\n      selectorsToApply.push(containerClass);\n    }\n  }\n  if (selectors) {\n    selectorsToApply.push(...selectors);\n  }\n  return selectorsToApply;\n}\n\n/**\n * This function gets the factory function to create the selector to get the selected slice from the app state\n * @ignore\n */\nexport function getRootSelectorFactory(selector: any): SelectorFactory {\n  const metadata = getSelectorMetadata(selector) || getStoreMetadata(selector);\n  return (metadata && metadata.makeRootSelector) || (() => selector);\n}\n","// tslint:disable:unified-signatures\nimport { Inject, Injectable, Optional, Type } from '@angular/core';\nimport { Observable, of, Subscription, throwError, queueScheduler } from 'rxjs';\nimport {\n  catchError,\n  distinctUntilChanged,\n  map,\n  shareReplay,\n  take,\n  observeOn\n} from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObject } from '@ngxs/store/internals';\n\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\nimport { InternalStateOperations } from './internal/state-operations';\nimport { getRootSelectorFactory } from './utils/selector-utils';\nimport { StateStream } from './internal/state-stream';\nimport { leaveNgxs } from './operators/leave-ngxs';\nimport { NgxsConfig } from './symbols';\nimport { StateToken } from './state-token/state-token';\nimport { StateFactory } from './internal/state-factory';\n\n@Injectable()\nexport class Store {\n  /**\n   * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,\n   * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.\n   * All selects would use this stream, and it would call leave only once for any state change across all active selectors.\n   */\n  private _selectableStateStream = this._stateStream.pipe(\n    observeOn(queueScheduler),\n    leaveNgxs(this._internalExecutionStrategy),\n    shareReplay({ bufferSize: 1, refCount: true })\n  );\n\n  constructor(\n    private _stateStream: StateStream,\n    private _internalStateOperations: InternalStateOperations,\n    private _config: NgxsConfig,\n    private _internalExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _stateFactory: StateFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    initialStateValue: any\n  ) {\n    this.initStateStream(initialStateValue);\n  }\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);\n  }\n\n  /**\n   * Selects a slice of data from the store.\n   */\n  select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  select<T = any>(selector: string | Type<any>): Observable<T>;\n  select<T>(selector: StateToken<T>): Observable<T>;\n  select(selector: any): Observable<any> {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return this._selectableStateStream.pipe(\n      map(selectorFn),\n      catchError((err: Error): Observable<never> | Observable<undefined> => {\n        // if error is TypeError we swallow it to prevent usual errors with property access\n        const { suppressErrors } = this._config.selectorOptions;\n\n        if (err instanceof TypeError && suppressErrors) {\n          return of(undefined);\n        }\n\n        // rethrow other errors\n        return throwError(err);\n      }),\n      distinctUntilChanged(),\n      leaveNgxs(this._internalExecutionStrategy)\n    );\n  }\n\n  /**\n   * Select one slice of data from the store.\n   */\n\n  selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  selectOnce<T = any>(selector: string | Type<any>): Observable<T>;\n  selectOnce<T>(selector: StateToken<T>): Observable<T>;\n  selectOnce(selector: any): Observable<any> {\n    return this.select(selector).pipe(take(1));\n  }\n\n  /**\n   * Select a snapshot from the state.\n   */\n  selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;\n  selectSnapshot<T = any>(selector: string | Type<any>): T;\n  selectSnapshot<T>(selector: StateToken<T>): T;\n  selectSnapshot(selector: any): any {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return selectorFn(this._stateStream.getValue());\n  }\n\n  /**\n   * Allow the user to subscribe to the root of the state\n   */\n  subscribe(fn?: (value: any) => void): Subscription {\n    return this._selectableStateStream\n      .pipe(leaveNgxs(this._internalExecutionStrategy))\n      .subscribe(fn);\n  }\n\n  /**\n   * Return the raw value of the state.\n   */\n  snapshot(): any {\n    return this._internalStateOperations.getRootStateOperations().getState();\n  }\n\n  /**\n   * Reset the state to a specific point in time. This method is useful\n   * for plugin's who need to modify the state directly or unit testing.\n   */\n  reset(state: any) {\n    return this._internalStateOperations.getRootStateOperations().setState(state);\n  }\n\n  private getStoreBoundSelectorFn(selector: any) {\n    const makeSelectorFn = getRootSelectorFactory(selector);\n    const runtimeContext = this._stateFactory.getRuntimeSelectorContext();\n    return makeSelectorFn(runtimeContext);\n  }\n\n  private initStateStream(initialStateValue: any): void {\n    const value: PlainObject = this._stateStream.value;\n    const storeIsEmpty: boolean = !value || Object.keys(value).length === 0;\n    if (storeIsEmpty) {\n      const defaultStateNotEmpty: boolean = Object.keys(this._config.defaultsState).length > 0;\n      const storeValues: PlainObject = defaultStateNotEmpty\n        ? { ...this._config.defaultsState, ...initialStateValue }\n        : initialStateValue;\n\n      this._stateStream.next(storeValues);\n    }\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\nimport { NgxsBootstrapper } from '@ngxs/store/internals';\nimport { EMPTY, Subject } from 'rxjs';\nimport {\n  catchError,\n  filter,\n  mergeMap,\n  pairwise,\n  startWith,\n  takeUntil,\n  tap\n} from 'rxjs/operators';\n\nimport { Store } from '../store';\nimport { getValue } from '../utils/utils';\nimport { InternalErrorReporter } from './error-handler';\nimport { StateContextFactory } from './state-context-factory';\nimport { InternalStateOperations } from './state-operations';\nimport { MappedStore, StatesAndDefaults } from './internals';\nimport { NgxsLifeCycle, NgxsSimpleChange, StateContext } from '../symbols';\n\n@Injectable()\nexport class LifecycleStateManager implements OnDestroy {\n  private readonly _destroy$ = new Subject<void>();\n\n  constructor(\n    private _store: Store,\n    private _internalErrorReporter: InternalErrorReporter,\n    private _internalStateOperations: InternalStateOperations,\n    private _stateContextFactory: StateContextFactory,\n    private _bootstrapper: NgxsBootstrapper\n  ) {}\n\n  ngOnDestroy(): void {\n    this._destroy$.next();\n  }\n\n  ngxsBootstrap<T>(action: T, results: StatesAndDefaults | undefined): void {\n    this._internalStateOperations\n      .getRootStateOperations()\n      .dispatch(action)\n      .pipe(\n        filter(() => !!results),\n        tap(() => this._invokeInitOnStates(results!.states)),\n        mergeMap(() => this._bootstrapper.appBootstrapped$),\n        filter(appBootstrapped => !!appBootstrapped),\n        catchError(error => {\n          // The `SafeSubscriber` (which is used by most RxJS operators) re-throws\n          // errors asynchronously (`setTimeout(() => { throw error })`). This might\n          // break existing user's code or unit tests. We catch the error manually to\n          // be backward compatible with the old behavior.\n          this._internalErrorReporter.reportErrorSafely(error);\n          return EMPTY;\n        }),\n        takeUntil(this._destroy$)\n      )\n      .subscribe(() => this._invokeBootstrapOnStates(results!.states));\n  }\n\n  private _invokeInitOnStates(mappedStores: MappedStore[]): void {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n\n      if (instance.ngxsOnChanges) {\n        this._store\n          .select(state => getValue(state, mappedStore.path))\n          .pipe(startWith(undefined), pairwise(), takeUntil(this._destroy$))\n          .subscribe(([previousValue, currentValue]) => {\n            const change = new NgxsSimpleChange(\n              previousValue,\n              currentValue,\n              !mappedStore.isInitialised\n            );\n            instance.ngxsOnChanges!(change);\n          });\n      }\n\n      if (instance.ngxsOnInit) {\n        instance.ngxsOnInit(this._getStateContext(mappedStore));\n      }\n\n      mappedStore.isInitialised = true;\n    }\n  }\n\n  private _invokeBootstrapOnStates(mappedStores: MappedStore[]) {\n    for (const mappedStore of mappedStores) {\n      const instance: NgxsLifeCycle = mappedStore.instance;\n      if (instance.ngxsAfterBootstrap) {\n        instance.ngxsAfterBootstrap(this._getStateContext(mappedStore));\n      }\n    }\n  }\n\n  private _getStateContext(mappedStore: MappedStore): StateContext<any> {\n    return this._stateContextFactory.createStateContext(mappedStore);\n  }\n}\n","import { Injectable, OnDestroy } from '@angular/core';\n\nimport { Store } from '../../store';\nimport { NgxsConfig } from '../../symbols';\n\n/**\n * Allows the select decorator to get access to the DI store, this is used internally\n * in `@Select` decorator.\n */\n@Injectable()\nexport class SelectFactory implements OnDestroy {\n  public static store: Store | null = null;\n  public static config: NgxsConfig | null = null;\n\n  constructor(store: Store, config: NgxsConfig) {\n    SelectFactory.store = store;\n    SelectFactory.config = config;\n  }\n\n  ngOnDestroy(): void {\n    SelectFactory.store = null;\n    SelectFactory.config = null;\n  }\n}\n","import { PlainObject } from '@ngxs/store/internals';\n\n/**\n * Init action\n */\nexport class InitState {\n  static get type() {\n    // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138\n    return '@@INIT';\n  }\n}\n\n/**\n * Update action\n */\nexport class UpdateState {\n  static get type() {\n    // NOTE: Not necessary to declare the type in this way in your code. See https://github.com/ngxs/store/pull/644#issuecomment-436003138\n    return '@@UPDATE_STATE';\n  }\n\n  constructor(public addedStates?: PlainObject) {}\n}\n","import { Inject, NgModule, Optional } from '@angular/core';\n\nimport { StateFactory } from '../internal/state-factory';\nimport { InternalStateOperations } from '../internal/state-operations';\nimport { Store } from '../store';\nimport { SelectFactory } from '../decorators/select/select-factory';\nimport { ROOT_STATE_TOKEN } from '../symbols';\nimport { StateClassInternal, StatesAndDefaults } from '../internal/internals';\nimport { LifecycleStateManager } from '../internal/lifecycle-state-manager';\nimport { InitState } from '../actions/actions';\n\n/**\n * Root module\n * @ignore\n */\n@NgModule()\nexport class NgxsRootModule {\n  constructor(\n    factory: StateFactory,\n    internalStateOperations: InternalStateOperations,\n    _store: Store,\n    _select: SelectFactory,\n    @Optional()\n    @Inject(ROOT_STATE_TOKEN)\n    states: StateClassInternal[] = [],\n    lifecycleStateManager: LifecycleStateManager\n  ) {\n    // Add stores to the state graph and return their defaults\n    const results: StatesAndDefaults = factory.addAndReturnDefaults(states);\n\n    internalStateOperations.setStateToTheCurrentWithNew(results);\n\n    // Connect our actions stream\n    factory.connectActionHandlers();\n\n    // Dispatch the init action and invoke init and bootstrap functions after\n    lifecycleStateManager.ngxsBootstrap(new InitState(), results);\n  }\n}\n","import { Inject, NgModule, Optional } from '@angular/core';\n\nimport { Store } from '../store';\nimport { InternalStateOperations } from '../internal/state-operations';\nimport { StateFactory } from '../internal/state-factory';\nimport { FEATURE_STATE_TOKEN } from '../symbols';\nimport { LifecycleStateManager } from '../internal/lifecycle-state-manager';\nimport { StateClassInternal, StatesAndDefaults } from '../internal/internals';\nimport { UpdateState } from '../actions/actions';\n\n/**\n * Feature module\n * @ignore\n */\n@NgModule()\nexport class NgxsFeatureModule {\n  constructor(\n    _store: Store,\n    internalStateOperations: InternalStateOperations,\n    factory: StateFactory,\n    @Optional()\n    @Inject(FEATURE_STATE_TOKEN)\n    states: StateClassInternal[][] = [],\n    lifecycleStateManager: LifecycleStateManager\n  ) {\n    // Since FEATURE_STATE_TOKEN is a multi token, we need to\n    // flatten it [[Feature1State, Feature2State], [Feature3State]]\n    const flattenedStates: StateClassInternal[] = NgxsFeatureModule.flattenStates(states);\n\n    // add stores to the state graph and return their defaults\n    const results: StatesAndDefaults = factory.addAndReturnDefaults(flattenedStates);\n\n    if (results.states.length) {\n      internalStateOperations.setStateToTheCurrentWithNew(results);\n\n      // dispatch the update action and invoke init and bootstrap functions after\n      lifecycleStateManager.ngxsBootstrap(new UpdateState(results.defaults), results);\n    }\n  }\n\n  private static flattenStates(states: StateClassInternal[][] = []): StateClassInternal[] {\n    return states.reduce(\n      (total: StateClassInternal[], values: StateClassInternal[]) => total.concat(values),\n      []\n    );\n  }\n}\n","import {\n  APP_BOOTSTRAP_LISTENER,\n  InjectionToken,\n  ModuleWithProviders,\n  NgModule,\n  Provider\n} from '@angular/core';\nimport {\n  INITIAL_STATE_TOKEN,\n  InitialState,\n  NGXS_STATE_CONTEXT_FACTORY,\n  NGXS_STATE_FACTORY,\n  NgxsBootstrapper,\n  StateClass\n} from '@ngxs/store/internals';\n\nimport {\n  FEATURE_STATE_TOKEN,\n  NgxsConfig,\n  NgxsModuleOptions,\n  ROOT_STATE_TOKEN\n} from './symbols';\nimport { USER_PROVIDED_NGXS_EXECUTION_STRATEGY } from './execution/symbols';\nimport { StateFactory } from './internal/state-factory';\nimport { StateContextFactory } from './internal/state-context-factory';\nimport { Actions, InternalActions } from './actions-stream';\nimport { LifecycleStateManager } from './internal/lifecycle-state-manager';\nimport { InternalDispatchedActionResults, InternalDispatcher } from './internal/dispatcher';\nimport { InternalStateOperations } from './internal/state-operations';\nimport { Store } from './store';\nimport { SelectFactory } from './decorators/select/select-factory';\nimport { StateStream } from './internal/state-stream';\nimport { PluginManager } from './plugin-manager';\nimport { NgxsRootModule } from './modules/ngxs-root.module';\nimport { NgxsFeatureModule } from './modules/ngxs-feature.module';\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\nimport { mergeDeep } from './utils/utils';\n\n/**\n * Ngxs Module\n */\n@NgModule()\nexport class NgxsModule {\n  private static readonly ROOT_OPTIONS = new InjectionToken<NgxsModuleOptions>('ROOT_OPTIONS');\n\n  /**\n   * Root module factory\n   */\n  public static forRoot(\n    states: StateClass[] = [],\n    options: NgxsModuleOptions = {}\n  ): ModuleWithProviders<NgxsRootModule> {\n    return {\n      ngModule: NgxsRootModule,\n      providers: [\n        StateFactory,\n        StateContextFactory,\n        Actions,\n        InternalActions,\n        NgxsBootstrapper,\n        LifecycleStateManager,\n        InternalDispatcher,\n        InternalDispatchedActionResults,\n        InternalStateOperations,\n        InternalNgxsExecutionStrategy,\n        Store,\n        StateStream,\n        SelectFactory,\n        PluginManager,\n        ...states,\n        ...NgxsModule.ngxsTokenProviders(states, options)\n      ]\n    };\n  }\n\n  /**\n   * Feature module factory\n   */\n  public static forFeature(states: StateClass[] = []): ModuleWithProviders<NgxsFeatureModule> {\n    return {\n      ngModule: NgxsFeatureModule,\n      providers: [\n        StateFactory,\n        PluginManager,\n        ...states,\n        {\n          provide: FEATURE_STATE_TOKEN,\n          multi: true,\n          useValue: states\n        }\n      ]\n    };\n  }\n\n  private static ngxsTokenProviders(\n    states: StateClass[],\n    options: NgxsModuleOptions\n  ): Provider[] {\n    return [\n      {\n        provide: USER_PROVIDED_NGXS_EXECUTION_STRATEGY,\n        useValue: options.executionStrategy\n      },\n      {\n        provide: ROOT_STATE_TOKEN,\n        useValue: states\n      },\n      {\n        provide: NgxsModule.ROOT_OPTIONS,\n        useValue: options\n      },\n      {\n        provide: NgxsConfig,\n        useFactory: NgxsModule.ngxsConfigFactory,\n        deps: [NgxsModule.ROOT_OPTIONS]\n      },\n      {\n        provide: APP_BOOTSTRAP_LISTENER,\n        useFactory: NgxsModule.appBootstrapListenerFactory,\n        multi: true,\n        deps: [NgxsBootstrapper]\n      },\n      {\n        provide: INITIAL_STATE_TOKEN,\n        useFactory: NgxsModule.getInitialState\n      },\n      {\n        provide: NGXS_STATE_CONTEXT_FACTORY,\n        useExisting: StateContextFactory\n      },\n      {\n        provide: NGXS_STATE_FACTORY,\n        useExisting: StateFactory\n      }\n    ];\n  }\n\n  private static ngxsConfigFactory(options: NgxsModuleOptions): NgxsConfig {\n    return mergeDeep(new NgxsConfig(), options);\n  }\n\n  private static appBootstrapListenerFactory(bootstrapper: NgxsBootstrapper): Function {\n    return () => bootstrapper.bootstrap();\n  }\n\n  private static getInitialState() {\n    return InitialState.pop();\n  }\n}\n","import { Observable } from 'rxjs';\n\nimport { propGetter } from '../../internal/internals';\nimport { SelectFactory } from './select-factory';\nimport { StateToken } from '../../state-token/state-token';\nimport { ExtractTokenType } from '../../state-token/symbols';\nimport { throwSelectFactoryNotConnectedError } from '../../configs/messages.config';\n\nconst DOLLAR_CHAR_CODE = 36;\n\nexport function createSelectObservable<T = any>(selector: any): Observable<T> {\n  if (!SelectFactory.store) {\n    throwSelectFactoryNotConnectedError();\n  }\n  return SelectFactory.store!.select(selector);\n}\n\nexport function createSelectorFn(name: string, rawSelector?: any, paths: string[] = []): any {\n  rawSelector = !rawSelector ? removeDollarAtTheEnd(name) : rawSelector;\n\n  if (typeof rawSelector === 'string') {\n    const propsArray: string[] = paths.length\n      ? [rawSelector, ...paths]\n      : rawSelector.split('.');\n    return propGetter(propsArray, SelectFactory.config!);\n  }\n\n  return rawSelector;\n}\n\n/**\n * @example If `foo$` => make it just `foo`\n */\nexport function removeDollarAtTheEnd(name: string): string {\n  const lastCharIndex: number = name.length - 1;\n  const dollarAtTheEnd: boolean = name.charCodeAt(lastCharIndex) === DOLLAR_CHAR_CODE;\n  return dollarAtTheEnd ? name.slice(0, lastCharIndex) : name;\n}\n\nexport type PropertyType<T> = T extends StateToken<any>\n  ? Observable<ExtractTokenType<T>>\n  : T extends (...args: any[]) => any\n  ? Observable<ReturnType<T>>\n  : any;\n","import { TokenName } from './symbols';\nimport {\n  ensureSelectorMetadata,\n  RuntimeSelectorContext,\n  SelectFromRootState\n} from '../internal/internals';\n\nexport class StateToken<T = void> {\n  constructor(private readonly name: TokenName<T>) {\n    const selectorMetadata = ensureSelectorMetadata(<any>this);\n    selectorMetadata.makeRootSelector = (\n      runtimeContext: RuntimeSelectorContext\n    ): SelectFromRootState => {\n      return runtimeContext.getStateGetter(this.name);\n    };\n  }\n\n  getName(): string {\n    return this.name;\n  }\n\n  toString(): string {\n    return `StateToken[${this.name}]`;\n  }\n}\n","import { ensureStoreMetadata } from '../internal/internals';\nimport { ActionType, ActionOptions } from '../actions/symbols';\nimport { throwActionDecoratorError } from '../configs/messages.config';\n\n/**\n * Decorates a method with a action information.\n */\nexport function Action(\n  actions: ActionType | ActionType[],\n  options?: ActionOptions\n): MethodDecorator {\n  return (target: any, name: string | symbol): void => {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const isStaticMethod = target.hasOwnProperty('prototype');\n\n      if (isStaticMethod) {\n        throwActionDecoratorError();\n      }\n    }\n\n    const meta = ensureStoreMetadata(target.constructor);\n\n    if (!Array.isArray(actions)) {\n      actions = [actions];\n    }\n\n    for (const action of actions) {\n      const type = action.type;\n\n      if (!meta.actions[type]) {\n        meta.actions[type] = [];\n      }\n\n      meta.actions[type].push({\n        fn: name,\n        options: options || {},\n        type\n      });\n    }\n  };\n}\n","import { createSelectObservable, createSelectorFn, PropertyType } from './symbols';\n\n/**\n * Decorator for selecting a slice of state from the store.\n */\nexport function Select<T>(rawSelector?: T, ...paths: string[]): PropertyDecorator {\n  return function(target, key): void {\n    const name: string = key.toString();\n    const selectorId = `__${name}__selector`;\n    const selector = createSelectorFn(name, rawSelector, paths);\n\n    Object.defineProperties(target, {\n      [selectorId]: {\n        writable: true,\n        enumerable: false,\n        configurable: true\n      },\n      [name]: {\n        enumerable: true,\n        configurable: true,\n        get(): PropertyType<T> {\n          return this[selectorId] || (this[selectorId] = createSelectObservable(selector));\n        }\n      }\n    });\n  };\n}\n","import { throwSelectorDecoratorError } from '../../configs/messages.config';\nimport { createSelector } from '../../utils/selector-utils';\nimport { SelectorSpec, SelectorType } from './symbols';\n\n/**\n * Decorator for memoizing a state selector.\n */\nexport function Selector<T>(selectors?: T[]): SelectorType<T> {\n  return <U>(\n    target: any,\n    key: string | symbol,\n    descriptor: TypedPropertyDescriptor<SelectorSpec<T, U>>\n  ): TypedPropertyDescriptor<SelectorSpec<T, U>> | void => {\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      const isNotMethod = !(descriptor && descriptor.value !== null);\n\n      if (isNotMethod) {\n        throwSelectorDecoratorError();\n      }\n    }\n\n    const originalFn = descriptor.value;\n    const memoizedFn = createSelector(selectors, originalFn as any, {\n      containerClass: target,\n      selectorName: key.toString(),\n      getSelectorOptions() {\n        return {};\n      }\n    });\n    const newDescriptor = {\n      configurable: true,\n      get() {\n        return memoizedFn;\n      }\n    };\n    // Add hidden property to descriptor\n    (<any>newDescriptor)['originalFn'] = originalFn;\n    return newDescriptor;\n  };\n}\n","import { SharedSelectorOptions } from '../internal/internals';\nimport { selectorOptionsMetaAccessor } from '../utils/selector-utils';\n\n/**\n * Decorator for setting selector options at a method or class level.\n */\nexport function SelectorOptions(options: SharedSelectorOptions) {\n  return <ClassDecorator & MethodDecorator>(\n    function decorate<T>(\n      target: any,\n      methodName: string,\n      descriptor: TypedPropertyDescriptor<T>\n    ) {\n      if (methodName) {\n        // Method Decorator\n        const originalFn = descriptor.value || (<any>descriptor).originalFn;\n        if (originalFn) {\n          selectorOptionsMetaAccessor.defineOptions(originalFn, options);\n        }\n      } else {\n        // Class Decorator\n        selectorOptionsMetaAccessor.defineOptions(target, options);\n      }\n    }\n  );\n}\n","import { StateClass } from '@ngxs/store/internals';\n\nimport { ensureStoreMetadata, MetaDataModel, StateClassInternal } from '../internal/internals';\nimport { META_KEY, META_OPTIONS_KEY, StoreOptions } from '../symbols';\nimport { StoreValidators } from '../utils/store-validators';\n\ninterface MutateMetaOptions<T> {\n  meta: MetaDataModel;\n  inheritedStateClass: StateClassInternal;\n  optionsWithInheritance: StoreOptions<T>;\n}\n\n/**\n * Decorates a class with ngxs state information.\n */\nexport function State<T>(options: StoreOptions<T>) {\n  function getStateOptions(inheritedStateClass: StateClassInternal): StoreOptions<T> {\n    const inheritanceOptions: Partial<StoreOptions<T>> =\n      inheritedStateClass[META_OPTIONS_KEY] || {};\n    return { ...inheritanceOptions, ...options } as StoreOptions<T>;\n  }\n\n  function mutateMetaData(params: MutateMetaOptions<T>): void {\n    const { meta, inheritedStateClass, optionsWithInheritance } = params;\n    const { children, defaults, name } = optionsWithInheritance;\n    const stateName: string | null =\n      typeof name === 'string' ? name : (name && name.getName()) || null;\n\n    // Caretaker note: we have still left the `typeof` condition in order to avoid\n    // creating a breaking change for projects that still use the View Engine.\n    if (typeof ngDevMode === 'undefined' || ngDevMode) {\n      StoreValidators.checkThatStateIsNamedCorrectly(stateName);\n    }\n\n    if (inheritedStateClass.hasOwnProperty(META_KEY)) {\n      const inheritedMeta: Partial<MetaDataModel> = inheritedStateClass[META_KEY] || {};\n      meta.actions = { ...meta.actions, ...inheritedMeta.actions };\n    }\n\n    meta.children = children;\n    meta.defaults = defaults;\n    meta.name = stateName;\n  }\n\n  return (target: StateClass): void => {\n    const stateClass: StateClassInternal = target;\n    const meta: MetaDataModel = ensureStoreMetadata(stateClass);\n    const inheritedStateClass: StateClassInternal = Object.getPrototypeOf(stateClass);\n    const optionsWithInheritance: StoreOptions<T> = getStateOptions(inheritedStateClass);\n    mutateMetaData({ meta, inheritedStateClass, optionsWithInheritance });\n    stateClass[META_OPTIONS_KEY] = optionsWithInheritance;\n  };\n}\n","import {\n  getSelectorMetadata as getSelectorMetadataInternal,\n  getStoreMetadata as getStoreMetadataInternal,\n  ensureStoreMetadata as ensureStoreMetadataInternal,\n  ensureSelectorMetadata as ensureSelectorMetadataInternal,\n  StateClassInternal,\n  SharedSelectorOptions\n} from './internal/internals';\nimport { PlainObjectOf } from '../internals/src/symbols';\nimport { ActionHandlerMetaData } from './actions/symbols';\n\ninterface MetaDataModel {\n  name: string | null;\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\n  defaults: any;\n  path: string | null;\n  // selectFromAppState: SelectFromState | null;\n  // makeRootSelector: SelectorFactory | null; // Don't expose new stuff\n  children?: StateClassInternal[];\n}\n\ninterface SelectorMetaDataModel {\n  // selectFromAppState: SelectFromState | null;\n  // makeRootSelector: SelectorFactory | null; // Don't expose new stuff\n  originalFn: Function | null;\n  containerClass: any;\n  selectorName: string | null;\n  getSelectorOptions: () => SharedSelectorOptions;\n}\n\nexport function ensureStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel {\n  return ensureStoreMetadataInternal(target);\n}\n\nexport function getStoreMetadata(target: StateClassInternal<any, any>): MetaDataModel {\n  return getStoreMetadataInternal(target);\n}\n\nexport function ensureSelectorMetadata(target: Function): SelectorMetaDataModel {\n  return ensureSelectorMetadataInternal(target);\n}\n\nexport function getSelectorMetadata(target: any): SelectorMetaDataModel {\n  return getSelectorMetadataInternal(target);\n}\n"]}