@ngxs/store/fesm2015/ngxs-store.js.map

{"version":3,"file":"ngxs-store.js","sources":["ng://@ngxs/store/src/configs/messages.config.ts","ng://@ngxs/store/src/execution/dispatch-outside-zone-ngxs-execution-strategy.ts","ng://@ngxs/store/src/symbols.ts","ng://@ngxs/store/src/execution/symbols.ts","ng://@ngxs/store/src/utils/utils.ts","ng://@ngxs/store/src/internal/internals.ts","ng://@ngxs/store/src/operators/of-action.ts","ng://@ngxs/store/src/operators/leave-ngxs.ts","ng://@ngxs/store/src/execution/internal-ngxs-execution-strategy.ts","ng://@ngxs/store/src/actions-stream.ts","ng://@ngxs/store/src/utils/compose.ts","ng://@ngxs/store/src/internal/state-stream.ts","ng://@ngxs/store/src/plugin-manager.ts","ng://@ngxs/store/src/internal/dispatcher.ts","ng://@ngxs/store/src/utils/freeze.ts","ng://@ngxs/store/src/host-environment/host-environment.ts","ng://@ngxs/store/src/internal/config-validator.ts","ng://@ngxs/store/src/internal/state-operations.ts","ng://@ngxs/store/src/internal/state-operators.ts","ng://@ngxs/store/src/internal/state-context-factory.ts","ng://@ngxs/store/src/utils/store-validators.ts","ng://@ngxs/store/src/internal/state-factory.ts","ng://@ngxs/store/src/internal/lifecycle-state-manager.ts","ng://@ngxs/store/src/utils/selector-utils.ts","ng://@ngxs/store/src/store.ts","ng://@ngxs/store/src/decorators/select/select-factory.ts","ng://@ngxs/store/src/actions/actions.ts","ng://@ngxs/store/src/ivy/ivy-enabled-in-dev-mode.ts","ng://@ngxs/store/src/modules/ngxs-root.module.ts","ng://@ngxs/store/src/modules/ngxs-feature.module.ts","ng://@ngxs/store/src/module.ts","ng://@ngxs/store/src/decorators/action.ts","ng://@ngxs/store/src/ivy/ensure-state-class-is-injectable.ts","ng://@ngxs/store/src/decorators/state.ts","ng://@ngxs/store/src/decorators/select/symbols.ts","ng://@ngxs/store/src/decorators/select/select.ts","ng://@ngxs/store/src/decorators/selector-options.ts","ng://@ngxs/store/src/public_to_deprecate.ts","ng://@ngxs/store/src/decorators/selector/selector.ts","ng://@ngxs/store/src/execution/noop-ngxs-execution-strategy.ts","ng://@ngxs/store/src/state-token/state-token.ts"],"sourcesContent":["export enum VALIDATION_CODE {\r\n  STATE_NAME = 'STATE_NAME',\r\n  STATE_UNIQUE = 'STATE_UNIQUE',\r\n  STATE_NAME_PROPERTY = 'STATE_NAME_PROPERTY',\r\n  STATE_DECORATOR = 'STATE_DECORATOR',\r\n  INCORRECT_PRODUCTION = 'INCORRECT_PRODUCTION',\r\n  INCORRECT_DEVELOPMENT = 'INCORRECT_DEVELOPMENT',\r\n  SELECT_FACTORY_NOT_CONNECTED = 'SELECT_FACTORY_NOT_CONNECTED',\r\n  ACTION_DECORATOR = 'ACTION_DECORATOR',\r\n  SELECTOR_DECORATOR = 'SELECTOR_DECORATOR',\r\n  ZONE_WARNING = 'ZONE_WARNING',\r\n  PATCHING_ARRAY = 'PATCHING_ARRAY',\r\n  PATCHING_PRIMITIVE = 'PATCHING_PRIMITIVE',\r\n  UNDECORATED_STATE_IN_IVY = 'UNDECORATED_STATE_IN_IVY'\r\n}\r\n\r\nexport const CONFIG_MESSAGES = {\r\n  [VALIDATION_CODE.STATE_NAME]: (name: string) =>\r\n    `${name} is not a valid state name. It needs to be a valid object property name.`,\r\n  [VALIDATION_CODE.STATE_NAME_PROPERTY]: () => `States must register a 'name' property`,\r\n  [VALIDATION_CODE.STATE_UNIQUE]: (current: string, newName: string, oldName: string) =>\r\n    `State name '${current}' from ${newName} already exists in ${oldName}`,\r\n  [VALIDATION_CODE.STATE_DECORATOR]: () => 'States must be decorated with @State() decorator',\r\n  [VALIDATION_CODE.INCORRECT_PRODUCTION]: () =>\r\n    'Angular is running in production mode but NGXS is still running in the development mode!\\n' +\r\n    'Please set developmentMode to false on the NgxsModule options when in production mode.\\n' +\r\n    'NgxsModule.forRoot(states, { developmentMode: !environment.production })',\r\n  [VALIDATION_CODE.INCORRECT_DEVELOPMENT]: () =>\r\n    'RECOMMENDATION: Set developmentMode to true on the NgxsModule when Angular is running in development mode.\\n' +\r\n    'NgxsModule.forRoot(states, { developmentMode: !environment.production })',\r\n  [VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED]: () =>\r\n    'You have forgotten to import the NGXS module!',\r\n  [VALIDATION_CODE.ACTION_DECORATOR]: () =>\r\n    '@Action() decorator cannot be used with static methods',\r\n  [VALIDATION_CODE.SELECTOR_DECORATOR]: () => 'Selectors only work on methods',\r\n  [VALIDATION_CODE.ZONE_WARNING]: () =>\r\n    'Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\\n' +\r\n    'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\\n' +\r\n    'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })',\r\n  [VALIDATION_CODE.PATCHING_ARRAY]: () => 'Patching arrays is not supported.',\r\n  [VALIDATION_CODE.PATCHING_PRIMITIVE]: () => 'Patching primitives is not supported.',\r\n  [VALIDATION_CODE.UNDECORATED_STATE_IN_IVY]: (name: string) =>\r\n    `'${name}' class should be decorated with @Injectable() right after the @State() decorator`\r\n};\r\n","import { Inject, Injectable, NgZone, PLATFORM_ID } from '@angular/core';\r\nimport { isPlatformServer } from '@angular/common';\r\n\r\nimport { NgxsExecutionStrategy } from './symbols';\r\nimport { CONFIG_MESSAGES, VALIDATION_CODE } from '../configs/messages.config';\r\n\r\n@Injectable()\r\nexport class DispatchOutsideZoneNgxsExecutionStrategy implements NgxsExecutionStrategy {\r\n  constructor(private _ngZone: NgZone, @Inject(PLATFORM_ID) private _platformId: string) {\r\n    this.verifyZoneIsNotNooped(this._ngZone);\r\n  }\r\n\r\n  enter<T>(func: () => T): T {\r\n    if (isPlatformServer(this._platformId)) {\r\n      return this.runInsideAngular(func);\r\n    }\r\n    return this.runOutsideAngular(func);\r\n  }\r\n\r\n  leave<T>(func: () => T): T {\r\n    return this.runInsideAngular(func);\r\n  }\r\n\r\n  private runInsideAngular<T>(func: () => T): T {\r\n    if (NgZone.isInAngularZone()) {\r\n      return func();\r\n    }\r\n    return this._ngZone.run(func);\r\n  }\r\n\r\n  private runOutsideAngular<T>(func: () => T): T {\r\n    if (NgZone.isInAngularZone()) {\r\n      return this._ngZone.runOutsideAngular(func);\r\n    }\r\n    return func();\r\n  }\r\n\r\n  private verifyZoneIsNotNooped(ngZone: NgZone): void {\r\n    // `NoopNgZone` is not exposed publicly as it doesn't expect\r\n    // to be used outside of the core Angular code, thus we just have\r\n    // to check if the zone doesn't extend or instanceof `NgZone`\r\n    if (ngZone instanceof NgZone) {\r\n      return;\r\n    }\r\n\r\n    console.warn(CONFIG_MESSAGES[VALIDATION_CODE.ZONE_WARNING]());\r\n  }\r\n}\r\n","import { Injectable, InjectionToken, Type } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { PlainObject, StateClass } from '@ngxs/store/internals';\r\nimport { SharedSelectorOptions, Callback } from './internal/internals';\r\nimport { NgxsExecutionStrategy } from './execution/symbols';\r\nimport { DispatchOutsideZoneNgxsExecutionStrategy } from './execution/dispatch-outside-zone-ngxs-execution-strategy';\r\nimport { StateToken } from './state-token/state-token';\r\n\r\nexport const ROOT_STATE_TOKEN = new InjectionToken<any>('ROOT_STATE_TOKEN');\r\nexport const FEATURE_STATE_TOKEN = new InjectionToken<any>('FEATURE_STATE_TOKEN');\r\nexport const NGXS_PLUGINS = new InjectionToken('NGXS_PLUGINS');\r\nexport const NG_TEST_MODE = new InjectionToken<Callback<boolean>>('NG_TEST_MODE');\r\nexport const NG_DEV_MODE = new InjectionToken<Callback<boolean>>('NG_DEV_MODE');\r\n\r\nexport const META_KEY = 'NGXS_META';\r\nexport const META_OPTIONS_KEY = 'NGXS_OPTIONS_META';\r\nexport const SELECTOR_META_KEY = 'NGXS_SELECTOR_META';\r\n\r\nexport type NgxsLifeCycle = Partial<NgxsOnChanges> &\r\n  Partial<NgxsOnInit> &\r\n  Partial<NgxsAfterBootstrap>;\r\n\r\nexport type NgxsPluginFn = (state: any, mutation: any, next: NgxsNextPluginFn) => any;\r\n\r\n/**\r\n * The NGXS config settings.\r\n */\r\n@Injectable()\r\nexport class NgxsConfig {\r\n  /**\r\n   * Run in development mode. This will add additional debugging features:\r\n   * - Object.freeze on the state and actions to guarantee immutability\r\n   * (default: false)\r\n   */\r\n  developmentMode: boolean;\r\n  compatibility: {\r\n    /**\r\n     * Support a strict Content Security Policy.\r\n     * This will circumvent some optimisations that violate a strict CSP through the use of `new Function(...)`.\r\n     * (default: false)\r\n     */\r\n    strictContentSecurityPolicy: boolean;\r\n  };\r\n  /**\r\n   * Determines the execution context to perform async operations inside. An implementation can be\r\n   * provided to override the default behaviour where the async operations are run\r\n   * outside Angular's zone but all observable behaviours of NGXS are run back inside Angular's zone.\r\n   * These observable behaviours are from:\r\n   *   `@Select(...)`, `store.select(...)`, `actions.subscribe(...)` or `store.dispatch(...).subscribe(...)`\r\n   * Every `zone.run` causes Angular to run change detection on the whole tree (`app.tick()`) so of your\r\n   * application doesn't rely on zone.js running change detection then you can switch to the\r\n   * `NoopNgxsExecutionStrategy` that doesn't interact with zones.\r\n   * (default: null)\r\n   */\r\n  executionStrategy: Type<NgxsExecutionStrategy>;\r\n  /**\r\n   * Defining the default state before module initialization\r\n   * This is convenient if we need to create a define our own set of states.\r\n   * @deprecated will be removed after v4\r\n   * (default: {})\r\n   */\r\n  defaultsState: PlainObject = {};\r\n  /**\r\n   * Defining shared selector options\r\n   */\r\n  selectorOptions: SharedSelectorOptions = {\r\n    injectContainerState: true, // TODO: default is true in v3, will change in v4\r\n    suppressErrors: true // TODO: default is true in v3, will change in v4\r\n  };\r\n\r\n  constructor() {\r\n    this.compatibility = {\r\n      strictContentSecurityPolicy: false\r\n    };\r\n    this.executionStrategy = DispatchOutsideZoneNgxsExecutionStrategy;\r\n  }\r\n}\r\n\r\nexport type StateOperator<T> = (existing: Readonly<T>) => T;\r\n\r\n/**\r\n * State context provided to the actions in the state.\r\n */\r\nexport interface StateContext<T> {\r\n  /**\r\n   * Get the current state.\r\n   */\r\n  getState(): T;\r\n\r\n  /**\r\n   * Reset the state to a new value.\r\n   */\r\n  setState(val: T | StateOperator<T>): T;\r\n\r\n  /**\r\n   * Patch the existing state with the provided value.\r\n   */\r\n  patchState(val: Partial<T>): T;\r\n\r\n  /**\r\n   * Dispatch a new action and return the dispatched observable.\r\n   */\r\n  dispatch(actions: any | any[]): Observable<void>;\r\n}\r\n\r\nexport type NgxsNextPluginFn = (state: any, mutation: any) => any;\r\n\r\n/**\r\n * Plugin interface\r\n */\r\nexport interface NgxsPlugin {\r\n  /**\r\n   * Handle the state/action before its submitted to the state handlers.\r\n   */\r\n  handle(state: any, action: any, next: NgxsNextPluginFn): any;\r\n}\r\n\r\n/**\r\n * Options that can be provided to the store.\r\n */\r\nexport interface StoreOptions<T> {\r\n  /**\r\n   * Name of the state. Required.\r\n   */\r\n  name: string | StateToken<T>;\r\n\r\n  /**\r\n   * Default values for the state. If not provided, uses empty object.\r\n   */\r\n  defaults?: T;\r\n\r\n  /**\r\n   * Sub states for the given state.\r\n   */\r\n  children?: StateClass[];\r\n}\r\n\r\n/**\r\n * Represents a basic change from a previous to a new value for a single state instance.\r\n * Passed as a value in a NgxsSimpleChanges object to the ngxsOnChanges hook.\r\n */\r\nexport class NgxsSimpleChange<T = any> {\r\n  constructor(\r\n    public readonly previousValue: T,\r\n    public readonly currentValue: T,\r\n    public readonly firstChange: boolean\r\n  ) {}\r\n}\r\n\r\n/**\r\n * On init interface\r\n */\r\nexport interface NgxsOnInit {\r\n  ngxsOnInit(ctx?: StateContext<any>): void | any;\r\n}\r\n\r\n/**\r\n * On change interface\r\n */\r\nexport interface NgxsOnChanges {\r\n  ngxsOnChanges(change: NgxsSimpleChange): void;\r\n}\r\n\r\n/**\r\n * After bootstrap interface\r\n */\r\nexport interface NgxsAfterBootstrap {\r\n  ngxsAfterBootstrap(ctx?: StateContext<any>): void;\r\n}\r\n\r\nexport type NgxsModuleOptions = Partial<NgxsConfig>;\r\n","import { InjectionToken } from '@angular/core';\r\n\r\n/*\r\n * Internal execution strategy injection token\r\n */\r\nexport const NGXS_EXECUTION_STRATEGY = new InjectionToken<NgxsExecutionStrategy>(\r\n  'NGXS_EXECUTION_STRATEGY'\r\n);\r\n\r\n/*\r\n * Execution strategy interface\r\n */\r\nexport interface NgxsExecutionStrategy {\r\n  enter<T>(func: () => T): T;\r\n  leave<T>(func: () => T): T;\r\n}\r\n","/**\r\n * Returns the type from an action instance/class.\r\n * @ignore\r\n */\r\nexport function getActionTypeFromInstance(action: any): string | undefined {\r\n  if (action.constructor && action.constructor.type) {\r\n    return action.constructor.type;\r\n  } else {\r\n    return action.type;\r\n  }\r\n}\r\n\r\n/**\r\n * Matches a action\r\n * @ignore\r\n */\r\nexport function actionMatcher(action1: any) {\r\n  const type1 = getActionTypeFromInstance(action1);\r\n\r\n  return function(action2: any) {\r\n    return type1 === getActionTypeFromInstance(action2);\r\n  };\r\n}\r\n\r\n/**\r\n * Set a deeply nested value. Example:\r\n *\r\n *   setValue({ foo: { bar: { eat: false } } },\r\n *      'foo.bar.eat', true) //=> { foo: { bar: { eat: true } } }\r\n *\r\n * While it traverses it also creates new objects from top down.\r\n *\r\n * @ignore\r\n */\r\nexport const setValue = (obj: any, prop: string, val: any) => {\r\n  obj = { ...obj };\r\n\r\n  const split = prop.split('.');\r\n  const lastIndex = split.length - 1;\r\n\r\n  split.reduce((acc, part, index) => {\r\n    if (index === lastIndex) {\r\n      acc[part] = val;\r\n    } else {\r\n      acc[part] = Array.isArray(acc[part]) ? acc[part].slice() : { ...acc[part] };\r\n    }\r\n\r\n    return acc && acc[part];\r\n  }, obj);\r\n\r\n  return obj;\r\n};\r\n\r\n/**\r\n * Get a deeply nested value. Example:\r\n *\r\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\r\n *\r\n * @ignore\r\n */\r\nexport const getValue = (obj: any, prop: string): any =>\r\n  prop.split('.').reduce((acc: any, part: string) => acc && acc[part], obj);\r\n\r\n/**\r\n * Simple object check.\r\n *\r\n *    isObject({a:1}) //=> true\r\n *    isObject(1) //=> false\r\n *\r\n * @ignore\r\n */\r\nexport const isObject = (item: any) => {\r\n  return item && typeof item === 'object' && !Array.isArray(item);\r\n};\r\n\r\n/**\r\n * Deep merge two objects.\r\n *\r\n *    mergeDeep({a:1, b:{x: 1, y:2}}, {b:{x: 3}, c:4}) //=> {a:1, b:{x:3, y:2}, c:4}\r\n *\r\n * @param base base object onto which `sources` will be applied\r\n */\r\nexport const mergeDeep = (base: any, ...sources: any[]): any => {\r\n  if (!sources.length) return base;\r\n  const source = sources.shift();\r\n\r\n  if (isObject(base) && isObject(source)) {\r\n    for (const key in source) {\r\n      if (isObject(source[key])) {\r\n        if (!base[key]) Object.assign(base, { [key]: {} });\r\n        mergeDeep(base[key], source[key]);\r\n      } else {\r\n        Object.assign(base, { [key]: source[key] });\r\n      }\r\n    }\r\n  }\r\n\r\n  return mergeDeep(base, ...sources);\r\n};\r\n","import { PlainObjectOf, StateClass } from '@ngxs/store/internals';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport {\r\n  META_KEY,\r\n  META_OPTIONS_KEY,\r\n  NgxsConfig,\r\n  NgxsSimpleChange,\r\n  SELECTOR_META_KEY,\r\n  StoreOptions\r\n} from '../symbols';\r\nimport { ActionHandlerMetaData } from '../actions/symbols';\r\nimport { getValue } from '../utils/utils';\r\n\r\n// inspired from https://stackoverflow.com/a/43674389\r\nexport interface StateClassInternal<T = any, U = any> extends StateClass<T> {\r\n  [META_KEY]?: MetaDataModel;\r\n  [META_OPTIONS_KEY]?: StoreOptions<U>;\r\n}\r\n\r\nexport type StateKeyGraph = PlainObjectOf<string[]>;\r\nexport type StatesByName = PlainObjectOf<StateClassInternal>;\r\n\r\nexport interface StateOperations<T> {\r\n  getState(): T;\r\n\r\n  setState(val: T): T;\r\n\r\n  dispatch(actionOrActions: any | any[]): Observable<void>;\r\n}\r\n\r\nexport interface MetaDataModel {\r\n  name: string | null;\r\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\r\n  defaults: any;\r\n  path: string | null;\r\n  makeRootSelector: SelectorFactory | null;\r\n  children?: StateClassInternal[];\r\n}\r\n\r\nexport interface RuntimeSelectorContext {\r\n  getStateGetter(key: any): (state: any) => any;\r\n  getSelectorOptions(localOptions?: SharedSelectorOptions): SharedSelectorOptions;\r\n}\r\n\r\nexport type SelectFromRootState = (rootState: any) => any;\r\nexport type SelectorFactory = (runtimeContext: RuntimeSelectorContext) => SelectFromRootState;\r\n\r\nexport interface SharedSelectorOptions {\r\n  injectContainerState?: boolean;\r\n  suppressErrors?: boolean;\r\n}\r\n\r\nexport interface SelectorMetaDataModel {\r\n  makeRootSelector: SelectorFactory | null;\r\n  originalFn: Function | null;\r\n  containerClass: any;\r\n  selectorName: string | null;\r\n  getSelectorOptions: () => SharedSelectorOptions;\r\n}\r\n\r\nexport interface MappedStore {\r\n  name: string;\r\n  isInitialised: boolean;\r\n  actions: PlainObjectOf<ActionHandlerMetaData[]>;\r\n  defaults: any;\r\n  instance: any;\r\n  path: string;\r\n}\r\n\r\nexport interface StatesAndDefaults {\r\n  defaults: any;\r\n  states: MappedStore[];\r\n}\r\n\r\nexport type Callback<T = any, V = any> = (...args: V[]) => T;\r\n\r\nexport interface RootStateDiff<T> {\r\n  currentAppState: T;\r\n  newAppState: T;\r\n}\r\n\r\n/**\r\n * Ensures metadata is attached to the class and returns it.\r\n *\r\n * @ignore\r\n */\r\nexport function ensureStoreMetadata(target: StateClassInternal): MetaDataModel {\r\n  if (!target.hasOwnProperty(META_KEY)) {\r\n    const defaultMetadata: MetaDataModel = {\r\n      name: null,\r\n      actions: {},\r\n      defaults: {},\r\n      path: null,\r\n      makeRootSelector(context: RuntimeSelectorContext) {\r\n        return context.getStateGetter(defaultMetadata.name);\r\n      },\r\n      children: []\r\n    };\r\n\r\n    Object.defineProperty(target, META_KEY, { value: defaultMetadata });\r\n  }\r\n  return getStoreMetadata(target);\r\n}\r\n\r\n/**\r\n * Get the metadata attached to the state class if it exists.\r\n *\r\n * @ignore\r\n */\r\nexport function getStoreMetadata(target: StateClassInternal): MetaDataModel {\r\n  return target[META_KEY]!;\r\n}\r\n\r\n/**\r\n * Ensures metadata is attached to the selector and returns it.\r\n *\r\n * @ignore\r\n */\r\nexport function ensureSelectorMetadata(target: Function): SelectorMetaDataModel {\r\n  if (!target.hasOwnProperty(SELECTOR_META_KEY)) {\r\n    const defaultMetadata: SelectorMetaDataModel = {\r\n      makeRootSelector: null,\r\n      originalFn: null,\r\n      containerClass: null,\r\n      selectorName: null,\r\n      getSelectorOptions: () => ({})\r\n    };\r\n\r\n    Object.defineProperty(target, SELECTOR_META_KEY, { value: defaultMetadata });\r\n  }\r\n\r\n  return getSelectorMetadata(target);\r\n}\r\n\r\n/**\r\n * Get the metadata attached to the selector if it exists.\r\n *\r\n * @ignore\r\n */\r\nexport function getSelectorMetadata(target: any): SelectorMetaDataModel {\r\n  return target[SELECTOR_META_KEY];\r\n}\r\n\r\n/**\r\n * Get a deeply nested value. Example:\r\n *\r\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\r\n *\r\n * Note: This is not as fast as the `fastPropGetter` but is strict Content Security Policy compliant.\r\n * See perf hit: https://jsperf.com/fast-value-getter-given-path/1\r\n *\r\n * @ignore\r\n */\r\nfunction compliantPropGetter(paths: string[]): (x: any) => any {\r\n  const copyOfPaths = paths.slice();\r\n  return obj => copyOfPaths.reduce((acc: any, part: string) => acc && acc[part], obj);\r\n}\r\n\r\n/**\r\n * The generated function is faster than:\r\n * - pluck (Observable operator)\r\n * - memoize\r\n *\r\n * @ignore\r\n */\r\nfunction fastPropGetter(paths: string[]): (x: any) => any {\r\n  const segments = paths;\r\n  let seg = 'store.' + segments[0];\r\n  let i = 0;\r\n  const l = segments.length;\r\n\r\n  let expr = seg;\r\n  while (++i < l) {\r\n    expr = expr + ' && ' + (seg = seg + '.' + segments[i]);\r\n  }\r\n\r\n  const fn = new Function('store', 'return ' + expr + ';');\r\n\r\n  return <(x: any) => any>fn;\r\n}\r\n\r\n/**\r\n * Get a deeply nested value. Example:\r\n *\r\n *    getValue({ foo: bar: [] }, 'foo.bar') //=> []\r\n *\r\n * @ignore\r\n */\r\nexport function propGetter(paths: string[], config: NgxsConfig) {\r\n  if (config && config.compatibility && config.compatibility.strictContentSecurityPolicy) {\r\n    return compliantPropGetter(paths);\r\n  } else {\r\n    return fastPropGetter(paths);\r\n  }\r\n}\r\n\r\n/**\r\n * Given an array of states, it will return a object graph. Example:\r\n *    const states = [\r\n *      Cart,\r\n *      CartSaved,\r\n *      CartSavedItems\r\n *    ]\r\n *\r\n * would return:\r\n *\r\n *  const graph = {\r\n *    cart: ['saved'],\r\n *    saved: ['items'],\r\n *    items: []\r\n *  };\r\n *\r\n * @ignore\r\n */\r\nexport function buildGraph(stateClasses: StateClassInternal[]): StateKeyGraph {\r\n  const findName = (stateClass: StateClassInternal) => {\r\n    const meta = stateClasses.find(g => g === stateClass);\r\n    if (!meta) {\r\n      throw new Error(\r\n        `Child state not found: ${stateClass}. \\r\\nYou may have forgotten to add states to module`\r\n      );\r\n    }\r\n\r\n    return meta[META_KEY]!.name!;\r\n  };\r\n\r\n  return stateClasses.reduce<StateKeyGraph>(\r\n    (result: StateKeyGraph, stateClass: StateClassInternal) => {\r\n      const { name, children } = stateClass[META_KEY]!;\r\n      result[name!] = (children || []).map(findName);\r\n      return result;\r\n    },\r\n    {}\r\n  );\r\n}\r\n\r\n/**\r\n * Given a states array, returns object graph\r\n * returning the name and state metadata. Example:\r\n *\r\n *  const graph = {\r\n *    cart: { metadata }\r\n *  };\r\n *\r\n * @ignore\r\n */\r\nexport function nameToState(states: StateClassInternal[]): PlainObjectOf<StateClassInternal> {\r\n  return states.reduce<PlainObjectOf<StateClassInternal>>(\r\n    (result: PlainObjectOf<StateClassInternal>, stateClass: StateClassInternal) => {\r\n      const meta = stateClass[META_KEY]!;\r\n      result[meta.name!] = stateClass;\r\n      return result;\r\n    },\r\n    {}\r\n  );\r\n}\r\n\r\n/**\r\n * Given a object relationship graph will return the full path\r\n * for the child items. Example:\r\n *\r\n *  const graph = {\r\n *    cart: ['saved'],\r\n *    saved: ['items'],\r\n *    items: []\r\n *  };\r\n *\r\n * would return:\r\n *\r\n *  const r = {\r\n *    cart: 'cart',\r\n *    saved: 'cart.saved',\r\n *    items: 'cart.saved.items'\r\n *  };\r\n *\r\n * @ignore\r\n */\r\nexport function findFullParentPath(\r\n  obj: StateKeyGraph,\r\n  newObj: PlainObjectOf<string> = {}\r\n): PlainObjectOf<string> {\r\n  const visit = (child: StateKeyGraph, keyToFind: string): string | null => {\r\n    for (const key in child) {\r\n      if (child.hasOwnProperty(key) && child[key].indexOf(keyToFind) >= 0) {\r\n        const parent = visit(child, key);\r\n        return parent !== null ? `${parent}.${key}` : key;\r\n      }\r\n    }\r\n    return null;\r\n  };\r\n\r\n  for (const key in obj) {\r\n    if (obj.hasOwnProperty(key)) {\r\n      const parent = visit(obj, key);\r\n      newObj[key] = parent ? `${parent}.${key}` : key;\r\n    }\r\n  }\r\n\r\n  return newObj;\r\n}\r\n\r\n/**\r\n * Given a object graph, it will return the items topologically sorted Example:\r\n *\r\n *  const graph = {\r\n *    cart: ['saved'],\r\n *    saved: ['items'],\r\n *    items: []\r\n *  };\r\n *\r\n * would return:\r\n *\r\n *  const results = [\r\n *    'items',\r\n *    'saved',\r\n *    'cart'\r\n *  ];\r\n *\r\n * @ignore\r\n */\r\nexport function topologicalSort(graph: StateKeyGraph): string[] {\r\n  const sorted: string[] = [];\r\n  const visited: PlainObjectOf<boolean> = {};\r\n\r\n  const visit = (name: string, ancestors: string[] = []) => {\r\n    if (!Array.isArray(ancestors)) {\r\n      ancestors = [];\r\n    }\r\n\r\n    ancestors.push(name);\r\n    visited[name] = true;\r\n\r\n    graph[name].forEach((dep: string) => {\r\n      if (ancestors.indexOf(dep) >= 0) {\r\n        throw new Error(\r\n          `Circular dependency '${dep}' is required by '${name}': ${ancestors.join(' -> ')}`\r\n        );\r\n      }\r\n\r\n      if (visited[dep]) {\r\n        return;\r\n      }\r\n\r\n      visit(dep, ancestors.slice(0));\r\n    });\r\n\r\n    if (sorted.indexOf(name) < 0) {\r\n      sorted.push(name);\r\n    }\r\n  };\r\n\r\n  Object.keys(graph).forEach(k => visit(k));\r\n\r\n  return sorted.reverse();\r\n}\r\n\r\n/**\r\n * Returns if the parameter is a object or not.\r\n *\r\n * @ignore\r\n */\r\nexport function isObject(obj: any) {\r\n  return (typeof obj === 'object' && obj !== null) || typeof obj === 'function';\r\n}\r\n\r\nexport function getStateDiffChanges<T>(\r\n  mappedStore: MappedStore,\r\n  diff: RootStateDiff<T>\r\n): NgxsSimpleChange {\r\n  const previousValue: T = getValue(diff.currentAppState, mappedStore.path);\r\n  const currentValue: T = getValue(diff.newAppState, mappedStore.path);\r\n  return new NgxsSimpleChange(previousValue, currentValue, !mappedStore.isInitialised);\r\n}\r\n","import { OperatorFunction, Observable } from 'rxjs';\r\nimport { map, filter } from 'rxjs/operators';\r\n\r\nimport { ActionType } from '../actions/symbols';\r\nimport { getActionTypeFromInstance } from '../utils/utils';\r\nimport { ActionContext, ActionStatus } from '../actions-stream';\r\n\r\nexport interface ActionCompletion<T = any, E = Error> {\r\n  action: T;\r\n  result: {\r\n    successful: boolean;\r\n    canceled: boolean;\r\n    error?: E;\r\n  };\r\n}\r\n\r\nexport function ofAction<T = any>(allowedType: ActionType): OperatorFunction<ActionContext, T>;\r\nexport function ofAction<T = any>(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, T>;\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will grab actions that have just been dispatched as well as actions that have completed\r\n */\r\nexport function ofAction(...allowedTypes: ActionType[]): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been dispatched\r\n */\r\nexport function ofActionDispatched(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Dispatched]);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been successfully completed\r\n */\r\nexport function ofActionSuccessful(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Successful]);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been canceled\r\n */\r\nexport function ofActionCanceled(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Canceled]);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just been completed\r\n */\r\nexport function ofActionCompleted(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, ActionCompletion> {\r\n  const allowedStatuses = [\r\n    ActionStatus.Successful,\r\n    ActionStatus.Canceled,\r\n    ActionStatus.Errored\r\n  ];\r\n  return ofActionOperator(allowedTypes, allowedStatuses, mapActionResult);\r\n}\r\n\r\n/**\r\n * RxJS operator for selecting out specific actions.\r\n *\r\n * This will ONLY grab actions that have just thrown an error\r\n */\r\nexport function ofActionErrored(\r\n  ...allowedTypes: ActionType[]\r\n): OperatorFunction<ActionContext, any> {\r\n  return ofActionOperator(allowedTypes, [ActionStatus.Errored]);\r\n}\r\n\r\nfunction ofActionOperator(\r\n  allowedTypes: ActionType[],\r\n  statuses?: ActionStatus[],\r\n  // This actually could've been `OperatorFunction<ActionContext, ActionCompletion | any>`,\r\n  // since it maps either to `ctx.action` OR to `ActionCompletion`. But `ActionCompleteion | any`\r\n  // defaults to `any`, thus there is no sense from union type.\r\n  mapOperator: () => OperatorFunction<ActionContext, any> = mapAction\r\n): OperatorFunction<ActionContext, any> {\r\n  const allowedMap = createAllowedActionTypesMap(allowedTypes);\r\n  const allowedStatusMap = statuses && createAllowedStatusesMap(statuses);\r\n  return function(o: Observable<ActionContext>) {\r\n    return o.pipe(filterStatus(allowedMap, allowedStatusMap), mapOperator());\r\n  };\r\n}\r\n\r\nfunction filterStatus(allowedTypes: FilterMap, allowedStatuses?: FilterMap) {\r\n  return filter((ctx: ActionContext) => {\r\n    const actionType = getActionTypeFromInstance(ctx.action)!;\r\n    const typeMatch = allowedTypes[actionType];\r\n    const statusMatch = allowedStatuses ? allowedStatuses[ctx.status] : true;\r\n    return typeMatch && statusMatch;\r\n  });\r\n}\r\n\r\nfunction mapActionResult(): OperatorFunction<ActionContext, ActionCompletion> {\r\n  return map(({ action, status, error }: ActionContext) => {\r\n    return <ActionCompletion>{\r\n      action,\r\n      result: {\r\n        successful: ActionStatus.Successful === status,\r\n        canceled: ActionStatus.Canceled === status,\r\n        error\r\n      }\r\n    };\r\n  });\r\n}\r\n\r\nfunction mapAction<T = any>(): OperatorFunction<ActionContext, T> {\r\n  return map((ctx: ActionContext) => <T>ctx.action);\r\n}\r\n\r\ninterface FilterMap {\r\n  [key: string]: boolean;\r\n}\r\n\r\nfunction createAllowedActionTypesMap(types: ActionType[]): FilterMap {\r\n  return types.reduce((filterMap: FilterMap, klass: any) => {\r\n    filterMap[getActionTypeFromInstance(klass)!] = true;\r\n    return filterMap;\r\n  }, <FilterMap>{});\r\n}\r\n\r\nfunction createAllowedStatusesMap(statuses: ActionStatus[]): FilterMap {\r\n  return statuses.reduce((filterMap: FilterMap, status: ActionStatus) => {\r\n    filterMap[status] = true;\r\n    return filterMap;\r\n  }, <FilterMap>{});\r\n}\r\n","import { MonoTypeOperatorFunction, Observable, Observer } from 'rxjs';\r\nimport { NgxsExecutionStrategy } from '../execution/symbols';\r\n\r\n/**\r\n * Returns operator that will run\r\n * `subscribe` outside of the ngxs execution context\r\n */\r\nexport function leaveNgxs<T>(\r\n  ngxsExecutionStrategy: NgxsExecutionStrategy\r\n): MonoTypeOperatorFunction<T> {\r\n  return (source: Observable<T>) => {\r\n    return new Observable((sink: Observer<T>) => {\r\n      return source.subscribe({\r\n        next(value) {\r\n          ngxsExecutionStrategy.leave(() => sink.next(value));\r\n        },\r\n        error(error) {\r\n          ngxsExecutionStrategy.leave(() => sink.error(error));\r\n        },\r\n        complete() {\r\n          ngxsExecutionStrategy.leave(() => sink.complete());\r\n        }\r\n      });\r\n    });\r\n  };\r\n}\r\n","import { Injectable, Inject } from '@angular/core';\r\n\r\nimport { NgxsExecutionStrategy, NGXS_EXECUTION_STRATEGY } from './symbols';\r\n\r\n@Injectable()\r\nexport class InternalNgxsExecutionStrategy implements NgxsExecutionStrategy {\r\n  constructor(\r\n    @Inject(NGXS_EXECUTION_STRATEGY) private _executionStrategy: NgxsExecutionStrategy\r\n  ) {}\r\n\r\n  enter<T>(func: () => T): T {\r\n    return this._executionStrategy.enter(func);\r\n  }\r\n\r\n  leave<T>(func: () => T): T {\r\n    return this._executionStrategy.leave(func);\r\n  }\r\n}\r\n","import { Injectable } from '@angular/core';\r\nimport { Subject, Observable } from 'rxjs';\r\n\r\nimport { leaveNgxs } from './operators/leave-ngxs';\r\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\r\n\r\n/**\r\n * Status of a dispatched action\r\n */\r\nexport const enum ActionStatus {\r\n  Dispatched = 'DISPATCHED',\r\n  Successful = 'SUCCESSFUL',\r\n  Canceled = 'CANCELED',\r\n  Errored = 'ERRORED'\r\n}\r\n\r\nexport interface ActionContext<T = any> {\r\n  status: ActionStatus;\r\n  action: T;\r\n  error?: Error;\r\n}\r\n\r\n/**\r\n * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.\r\n * A standard Subject does not have this guarantee.\r\n * For example, given the following code:\r\n * ```typescript\r\n *   const subject = new Subject<string>();\r\n     subject.subscribe(value => {\r\n       if (value === 'start') subject.next('end');\r\n     });\r\n     subject.subscribe(value => { });\r\n     subject.next('start');\r\n * ```\r\n * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.\r\n * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.\r\n */\r\nexport class OrderedSubject<T> extends Subject<T> {\r\n  private _itemQueue: T[] = [];\r\n  private _busyPushingNext = false;\r\n\r\n  next(value?: T): void {\r\n    if (this._busyPushingNext) {\r\n      this._itemQueue.unshift(value!);\r\n      return;\r\n    }\r\n    this._busyPushingNext = true;\r\n    super.next(value);\r\n    while (this._itemQueue.length > 0) {\r\n      const nextValue = this._itemQueue.pop();\r\n      super.next(nextValue);\r\n    }\r\n    this._busyPushingNext = false;\r\n  }\r\n}\r\n\r\n/**\r\n * Internal Action stream that is emitted anytime an action is dispatched.\r\n */\r\n@Injectable()\r\nexport class InternalActions extends OrderedSubject<ActionContext> {}\r\n\r\n/**\r\n * Action stream that is emitted anytime an action is dispatched.\r\n *\r\n * You can listen to this in services to react without stores.\r\n */\r\n@Injectable()\r\nexport class Actions extends Observable<any> {\r\n  // This has to be `Observable<ActionContext>` in the v4. Because `InternalActions`\r\n  // is a `Subject<ActionContext>`. Leave it as `any` to avoid breaking changes\r\n  constructor(\r\n    internalActions$: InternalActions,\r\n    internalExecutionStrategy: InternalNgxsExecutionStrategy\r\n  ) {\r\n    super(observer => {\r\n      const childSubscription = internalActions$\r\n        .pipe(leaveNgxs(internalExecutionStrategy))\r\n        .subscribe({\r\n          next: ctx => observer.next(ctx),\r\n          error: error => observer.error(error),\r\n          complete: () => observer.complete()\r\n        });\r\n\r\n      observer.add(childSubscription);\r\n    });\r\n  }\r\n}\r\n","export type StateFn = (...args: any[]) => any;\r\n\r\n/**\r\n * Composes a array of functions from left to right. Example:\r\n *\r\n *      compose([fn, final])(state, action);\r\n *\r\n * then the funcs have a signature like:\r\n *\r\n *      function fn (state, action, next) {\r\n *          console.log('here', state, action, next);\r\n *          return next(state, action);\r\n *      }\r\n *\r\n *      function final (state, action) {\r\n *          console.log('here', state, action);\r\n *          return state;\r\n *      }\r\n *\r\n * the last function should not call `next`.\r\n *\r\n * @ignore\r\n */\r\nexport const compose = (funcs: StateFn[]) => (...args: any[]) => {\r\n  const curr = funcs.shift()!;\r\n  return curr(...args, (...nextArgs: any[]) => compose(funcs)(...nextArgs));\r\n};\r\n","import { Injectable } from '@angular/core';\r\nimport { BehaviorSubject } from 'rxjs';\r\n\r\nimport { PlainObject } from '@ngxs/store/internals';\r\n\r\n/**\r\n * BehaviorSubject of the entire state.\r\n * @ignore\r\n */\r\n@Injectable()\r\nexport class StateStream extends BehaviorSubject<PlainObject> {\r\n  constructor() {\r\n    super({});\r\n  }\r\n}\r\n","import { Inject, Injectable, Optional, SkipSelf } from '@angular/core';\r\nimport { NGXS_PLUGINS, NgxsPlugin, NgxsPluginFn } from './symbols';\r\n\r\n@Injectable()\r\nexport class PluginManager {\r\n  public plugins: NgxsPluginFn[] = [];\r\n\r\n  constructor(\r\n    @Optional()\r\n    @SkipSelf()\r\n    private _parentManager: PluginManager,\r\n    @Inject(NGXS_PLUGINS)\r\n    @Optional()\r\n    private _pluginHandlers: NgxsPlugin[]\r\n  ) {\r\n    this.registerHandlers();\r\n  }\r\n\r\n  private get rootPlugins(): NgxsPluginFn[] {\r\n    return (this._parentManager && this._parentManager.plugins) || this.plugins;\r\n  }\r\n\r\n  private registerHandlers(): void {\r\n    const pluginHandlers: NgxsPluginFn[] = this.getPluginHandlers();\r\n    this.rootPlugins.push(...pluginHandlers);\r\n  }\r\n\r\n  private getPluginHandlers(): NgxsPluginFn[] {\r\n    const handlers: NgxsPlugin[] = this._pluginHandlers || [];\r\n    return handlers.map(\r\n      (plugin: NgxsPlugin) =>\r\n        (plugin.handle ? plugin.handle.bind(plugin) : plugin) as NgxsPluginFn\r\n    );\r\n  }\r\n}\r\n","import { ErrorHandler, Injectable } from '@angular/core';\r\nimport { EMPTY, forkJoin, Observable, of, Subject, throwError } from 'rxjs';\r\nimport { exhaustMap, filter, shareReplay, take } from 'rxjs/operators';\r\n\r\nimport { compose } from '../utils/compose';\r\nimport { ActionContext, ActionStatus, InternalActions } from '../actions-stream';\r\nimport { StateStream } from './state-stream';\r\nimport { PluginManager } from '../plugin-manager';\r\nimport { InternalNgxsExecutionStrategy } from '../execution/internal-ngxs-execution-strategy';\r\nimport { leaveNgxs } from '../operators/leave-ngxs';\r\nimport { getActionTypeFromInstance } from '../utils/utils';\r\n\r\n/**\r\n * Internal Action result stream that is emitted when an action is completed.\r\n * This is used as a method of returning the action result to the dispatcher\r\n * for the observable returned by the dispatch(...) call.\r\n * The dispatcher then asynchronously pushes the result from this stream onto the main action stream as a result.\r\n */\r\n@Injectable()\r\nexport class InternalDispatchedActionResults extends Subject<ActionContext> {}\r\n\r\n@Injectable()\r\nexport class InternalDispatcher {\r\n  constructor(\r\n    private _errorHandler: ErrorHandler,\r\n    private _actions: InternalActions,\r\n    private _actionResults: InternalDispatchedActionResults,\r\n    private _pluginManager: PluginManager,\r\n    private _stateStream: StateStream,\r\n    private _ngxsExecutionStrategy: InternalNgxsExecutionStrategy\r\n  ) {}\r\n\r\n  /**\r\n   * Dispatches event(s).\r\n   */\r\n  dispatch(actionOrActions: any | any[]): Observable<any> {\r\n    const result = this._ngxsExecutionStrategy.enter(() =>\r\n      this.dispatchByEvents(actionOrActions)\r\n    );\r\n\r\n    result.subscribe({\r\n      error: error =>\r\n        this._ngxsExecutionStrategy.leave(() => {\r\n          try {\r\n            this._errorHandler.handleError(error);\r\n          } catch {}\r\n        })\r\n    });\r\n\r\n    return result.pipe(leaveNgxs(this._ngxsExecutionStrategy));\r\n  }\r\n\r\n  private dispatchByEvents(actionOrActions: any | any[]): Observable<any> {\r\n    if (Array.isArray(actionOrActions)) {\r\n      if (actionOrActions.length === 0) return of(this._stateStream.getValue());\r\n      return forkJoin(actionOrActions.map(action => this.dispatchSingle(action)));\r\n    } else {\r\n      return this.dispatchSingle(actionOrActions);\r\n    }\r\n  }\r\n\r\n  private dispatchSingle(action: any): Observable<any> {\r\n    const type: string | undefined = getActionTypeFromInstance(action);\r\n    if (!type) {\r\n      const error = new Error(\r\n        `This action doesn't have a type property: ${action.constructor.name}`\r\n      );\r\n      return throwError(error);\r\n    }\r\n\r\n    const prevState = this._stateStream.getValue();\r\n    const plugins = this._pluginManager.plugins;\r\n\r\n    return (compose([\r\n      ...plugins,\r\n      (nextState: any, nextAction: any) => {\r\n        if (nextState !== prevState) {\r\n          this._stateStream.next(nextState);\r\n        }\r\n        const actionResult$ = this.getActionResultStream(nextAction);\r\n        actionResult$.subscribe(ctx => this._actions.next(ctx));\r\n        this._actions.next({ action: nextAction, status: ActionStatus.Dispatched });\r\n        return this.createDispatchObservable(actionResult$);\r\n      }\r\n    ])(prevState, action) as Observable<any>).pipe(shareReplay());\r\n  }\r\n\r\n  private getActionResultStream(action: any): Observable<ActionContext> {\r\n    return this._actionResults.pipe(\r\n      filter(\r\n        (ctx: ActionContext) => ctx.action === action && ctx.status !== ActionStatus.Dispatched\r\n      ),\r\n      take(1),\r\n      shareReplay()\r\n    );\r\n  }\r\n\r\n  private createDispatchObservable(actionResult$: Observable<ActionContext>): Observable<any> {\r\n    return actionResult$\r\n      .pipe(\r\n        exhaustMap((ctx: ActionContext) => {\r\n          switch (ctx.status) {\r\n            case ActionStatus.Successful:\r\n              return of(this._stateStream.getValue());\r\n            case ActionStatus.Errored:\r\n              return throwError(ctx.error);\r\n            default:\r\n              return EMPTY;\r\n          }\r\n        })\r\n      )\r\n      .pipe(shareReplay());\r\n  }\r\n}\r\n","/**\r\n * Object freeze code\r\n * https://github.com/jsdf/deep-freeze\r\n */\r\nexport const deepFreeze = (o: any) => {\r\n  Object.freeze(o);\r\n\r\n  const oIsFunction = typeof o === 'function';\r\n  const hasOwnProp = Object.prototype.hasOwnProperty;\r\n\r\n  Object.getOwnPropertyNames(o).forEach(function(prop) {\r\n    if (\r\n      hasOwnProp.call(o, prop) &&\r\n      (oIsFunction ? prop !== 'caller' && prop !== 'callee' && prop !== 'arguments' : true) &&\r\n      o[prop] !== null &&\r\n      (typeof o[prop] === 'object' || typeof o[prop] === 'function') &&\r\n      !Object.isFrozen(o[prop])\r\n    ) {\r\n      deepFreeze(o[prop]);\r\n    }\r\n  });\r\n\r\n  return o;\r\n};\r\n","import { Inject, Injectable } from '@angular/core';\r\nimport { NG_DEV_MODE, NG_TEST_MODE } from '../symbols';\r\nimport { Callback } from '../internal/internals';\r\n\r\n@Injectable()\r\nexport class HostEnvironment {\r\n  constructor(\r\n    @Inject(NG_DEV_MODE) public isDevMode: Callback<boolean>,\r\n    @Inject(NG_TEST_MODE) public isTestMode: Callback<boolean>\r\n  ) {}\r\n}\r\n","import { Injectable } from '@angular/core';\r\n\r\nimport {\r\n  CONFIG_MESSAGES as MESSAGES,\r\n  VALIDATION_CODE as CODE\r\n} from '../configs/messages.config';\r\nimport { NgxsConfig } from '../symbols';\r\nimport { HostEnvironment } from '../host-environment/host-environment';\r\n\r\n@Injectable()\r\nexport class ConfigValidator {\r\n  constructor(private _host: HostEnvironment, private _config: NgxsConfig) {}\r\n\r\n  private get isIncorrectProduction(): boolean {\r\n    return !this._host.isDevMode() && this._config.developmentMode;\r\n  }\r\n\r\n  private get isIncorrectDevelopment(): boolean {\r\n    return this._host.isDevMode() && !this._config.developmentMode;\r\n  }\r\n\r\n  public verifyDevMode(): void {\r\n    if (this._host.isTestMode()) {\r\n      return;\r\n    }\r\n\r\n    if (this.isIncorrectProduction) {\r\n      console.warn(MESSAGES[CODE.INCORRECT_PRODUCTION]());\r\n    } else if (this.isIncorrectDevelopment) {\r\n      console.warn(MESSAGES[CODE.INCORRECT_DEVELOPMENT]());\r\n    }\r\n  }\r\n}\r\n","import { Injectable } from '@angular/core';\r\n\r\nimport { StateOperations, StatesAndDefaults } from '../internal/internals';\r\nimport { InternalDispatcher } from '../internal/dispatcher';\r\nimport { StateStream } from './state-stream';\r\nimport { NgxsConfig } from '../symbols';\r\nimport { deepFreeze } from '../utils/freeze';\r\nimport { ConfigValidator } from '../internal/config-validator';\r\n\r\n/**\r\n * State Context factory class\r\n * @ignore\r\n */\r\n@Injectable()\r\nexport class InternalStateOperations {\r\n  constructor(\r\n    private _stateStream: StateStream,\r\n    private _dispatcher: InternalDispatcher,\r\n    private _config: NgxsConfig,\r\n    configValidator: ConfigValidator\r\n  ) {\r\n    configValidator.verifyDevMode();\r\n  }\r\n\r\n  /**\r\n   * Returns the root state operators.\r\n   */\r\n  getRootStateOperations(): StateOperations<any> {\r\n    const rootStateOperations = {\r\n      getState: () => this._stateStream.getValue(),\r\n      setState: (newState: any) => this._stateStream.next(newState),\r\n      dispatch: (actionOrActions: any | any[]) => this._dispatcher.dispatch(actionOrActions)\r\n    };\r\n\r\n    if (this._config.developmentMode) {\r\n      return this.ensureStateAndActionsAreImmutable(rootStateOperations);\r\n    }\r\n\r\n    return rootStateOperations;\r\n  }\r\n\r\n  private ensureStateAndActionsAreImmutable(root: StateOperations<any>): StateOperations<any> {\r\n    return {\r\n      getState: () => root.getState(),\r\n      setState: value => {\r\n        const frozenValue = deepFreeze(value);\r\n        return root.setState(frozenValue);\r\n      },\r\n      dispatch: actions => {\r\n        return root.dispatch(actions);\r\n      }\r\n    };\r\n  }\r\n\r\n  setStateToTheCurrentWithNew(results: StatesAndDefaults): void {\r\n    const stateOperations: StateOperations<any> = this.getRootStateOperations();\r\n\r\n    // Get our current stream\r\n    const currentState = stateOperations.getState();\r\n    // Set the state to the current + new\r\n    stateOperations.setState({ ...currentState, ...results.defaults });\r\n  }\r\n}\r\n","import {\r\n  CONFIG_MESSAGES as MESSAGES,\r\n  VALIDATION_CODE as CODE\r\n} from '../configs/messages.config';\r\nimport { StateOperator } from '../symbols';\r\n\r\nexport function simplePatch<T>(val: Partial<T>): StateOperator<T> {\r\n  return (existingState: Readonly<T>) => {\r\n    if (Array.isArray(val)) {\r\n      throw new Error(MESSAGES[CODE.PATCHING_ARRAY]());\r\n    } else if (typeof val !== 'object') {\r\n      throw new Error(MESSAGES[CODE.PATCHING_PRIMITIVE]());\r\n    }\r\n\r\n    const newState: any = { ...(existingState as any) };\r\n    for (const key in val) {\r\n      // deep clone for patch compatibility\r\n      // noinspection JSUnfilteredForInLoop (IDE)\r\n      newState[key] = (val as any)[key];\r\n    }\r\n\r\n    return newState as T;\r\n  };\r\n}\r\n","import { Injectable } from '@angular/core';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { NgxsLifeCycle, NgxsSimpleChange, StateContext, StateOperator } from '../symbols';\r\nimport { getStateDiffChanges, MappedStore } from '../internal/internals';\r\nimport { setValue, getValue } from '../utils/utils';\r\nimport { InternalStateOperations } from '../internal/state-operations';\r\nimport { simplePatch } from './state-operators';\r\n\r\n/**\r\n * State Context factory class\r\n * @ignore\r\n */\r\n@Injectable()\r\nexport class StateContextFactory {\r\n  constructor(private _internalStateOperations: InternalStateOperations) {}\r\n\r\n  /**\r\n   * Create the state context\r\n   */\r\n  createStateContext<T>(mappedStore: MappedStore): StateContext<T> {\r\n    const root = this._internalStateOperations.getRootStateOperations();\r\n\r\n    function getState(currentAppState: any): T {\r\n      return getValue(currentAppState, mappedStore.path);\r\n    }\r\n\r\n    function setStateValue(currentAppState: any, newValue: T): any {\r\n      const newAppState = setValue(currentAppState, mappedStore.path, newValue);\r\n      const instance: NgxsLifeCycle = mappedStore.instance;\r\n\r\n      if (instance.ngxsOnChanges) {\r\n        const change: NgxsSimpleChange = getStateDiffChanges<T>(mappedStore, {\r\n          currentAppState,\r\n          newAppState\r\n        });\r\n\r\n        instance.ngxsOnChanges(change);\r\n      }\r\n\r\n      root.setState(newAppState);\r\n      return newAppState;\r\n      // In doing this refactoring I noticed that there is a 'bug' where the\r\n      // application state is returned instead of this state slice.\r\n      // This has worked this way since the beginning see:\r\n      // https://github.com/ngxs/store/blame/324c667b4b7debd8eb979006c67ca0ae347d88cd/src/state-factory.ts\r\n      // This needs to be fixed, but is a 'breaking' change.\r\n      // I will do this fix in a subsequent PR and we can decide how to handle it.\r\n    }\r\n\r\n    function setStateFromOperator(currentAppState: any, stateOperator: StateOperator<T>) {\r\n      const local = getState(currentAppState);\r\n      const newValue = stateOperator(local);\r\n      return setStateValue(currentAppState, newValue);\r\n    }\r\n\r\n    function isStateOperator(value: T | StateOperator<T>): value is StateOperator<T> {\r\n      return typeof value === 'function';\r\n    }\r\n\r\n    return {\r\n      getState(): T {\r\n        const currentAppState = root.getState();\r\n        return getState(currentAppState);\r\n      },\r\n      patchState(val: Partial<T>): T {\r\n        const currentAppState = root.getState();\r\n        const patchOperator = simplePatch<T>(val);\r\n        return setStateFromOperator(currentAppState, patchOperator);\r\n      },\r\n      setState(val: T | StateOperator<T>): T {\r\n        const currentAppState = root.getState();\r\n        return isStateOperator(val)\r\n          ? setStateFromOperator(currentAppState, val)\r\n          : setStateValue(currentAppState, val);\r\n      },\r\n      dispatch(actions: any | any[]): Observable<void> {\r\n        return root.dispatch(actions);\r\n      }\r\n    };\r\n  }\r\n}\r\n","import {\r\n  getStoreMetadata,\r\n  MetaDataModel,\r\n  StateClassInternal,\r\n  StatesByName\r\n} from '../internal/internals';\r\nimport {\r\n  CONFIG_MESSAGES as MESSAGES,\r\n  VALIDATION_CODE as CODE\r\n} from '../configs/messages.config';\r\n\r\nexport abstract class StoreValidators {\r\n  public static stateNameRegex: RegExp = new RegExp('^[a-zA-Z0-9_]+$');\r\n\r\n  public static stateN