{"version":3,"sources":["node_modules/@rx-angular/state/fesm2015/state-selections.js","node_modules/@rx-angular/state/fesm2015/state.js"],"sourcesContent":["import { Subject, BehaviorSubject, merge, queueScheduler, EMPTY, noop } from 'rxjs';\nimport { distinctUntilChanged, mergeAll, observeOn, withLatestFrom, scan, tap, catchError, publish, publishReplay, filter, shareReplay, map, pluck } from 'rxjs/operators';\nconst defaultAccumulator = (st, sl) => {\n  return Object.assign(Object.assign({}, st), sl);\n};\nfunction createAccumulationObservable(stateObservables = new Subject(), stateSlices = new Subject(), accumulatorObservable = new BehaviorSubject(defaultAccumulator)) {\n  const signal$ = merge(stateObservables.pipe(distinctUntilChanged(), mergeAll(), observeOn(queueScheduler)), stateSlices.pipe(observeOn(queueScheduler))).pipe(withLatestFrom(accumulatorObservable.pipe(observeOn(queueScheduler))), scan((state, [slice, stateAccumulator]) => stateAccumulator(state, slice), {}), tap(newState => compositionObservable.state = newState, error => console.error(error)),\n  // @Notice We catch the error here as it get lost in between `publish` and `publishReplay`. We return empty to\n  catchError(e => EMPTY), publish());\n  const state$ = signal$.pipe(publishReplay(1));\n  const compositionObservable = {\n    state: {},\n    signal$,\n    state$,\n    nextSlice,\n    nextSliceObservable,\n    nextAccumulator,\n    subscribe\n  };\n  // ======\n  return compositionObservable;\n  // ======\n  function nextAccumulator(accumulatorFn) {\n    accumulatorObservable.next(accumulatorFn);\n  }\n  function nextSlice(stateSlice) {\n    stateSlices.next(stateSlice);\n  }\n  function nextSliceObservable(stateObservable) {\n    stateObservables.next(stateObservable);\n  }\n  function subscribe() {\n    const sub = compositionObservable.signal$.connect();\n    sub.add(compositionObservable.state$.connect());\n    sub.add(() => {\n      accumulatorObservable.complete();\n      stateObservables.complete();\n      stateSlices.complete();\n    });\n    return sub;\n  }\n}\nfunction isPromiseGuard(value) {\n  return value !== null && value !== undefined && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\nfunction isOperateFnArrayGuard(op) {\n  if (!Array.isArray(op)) {\n    return false;\n  }\n  return op.length > 0 && op.every(i => typeof i === 'function');\n}\nfunction isStringArrayGuard(op) {\n  if (!Array.isArray(op)) {\n    return false;\n  }\n  return op.length > 0 && op.every(i => typeof i === 'string');\n}\nfunction isIterableGuard(obj) {\n  if (obj === null || obj === undefined) {\n    return false;\n  }\n  return typeof obj[Symbol.iterator] === 'function';\n}\nfunction isKeyOf(k) {\n  const typeofK = typeof k;\n  return k !== null && k !== undefined && ['string', 'symbol', 'number'].includes(typeofK);\n}\nfunction isObjectGuard(obj) {\n  return obj !== null && obj !== undefined && typeof obj === 'object' && !Array.isArray(obj);\n}\nfunction isDefined(val) {\n  return val !== null && val !== undefined;\n}\nfunction isStringAndFunctionTupleGuard(op) {\n  return typeof op[0] === 'string' && typeof op[1] === 'function';\n}\nfunction isStringArrayFunctionAndOptionalObjectTupleGuard(op) {\n  return isStringArrayGuard(op[0]) && typeof op[1] === 'function' && (op[2] === undefined || typeof op[2] === 'object');\n}\nfunction pipeFromArray(fns) {\n  if (!fns) {\n    return noop;\n  }\n  if (fns.length === 1) {\n    return fns[0];\n  }\n  return function piped(input) {\n    return fns.reduce((prev, fn) => fn(prev), input);\n  };\n}\n\n/**\n * @description\n *\n * As it acts like the Observables `pipe` method, it accepts one or many RxJS operators as params.\n *\n * @example\n * import { Observable } from 'rxjs';\n * import { map } from 'rxjs/operators';\n * import { stateful } from 'rx-angular/state';\n *\n * const state$: Observable<{ name: string; items: string[] }>;\n * const derivation$ = state$.pipe(\n *   stateful(\n *     map(state => state.list.length),\n *     filter(length => length > 3)\n *   )\n * );\n *\n * @param {OperatorFunction<T, A>} op - one or multiple passed operator comma separated\n *\n * @docsPage stateful\n * @docsCategory operators\n */\nfunction stateful(...optionalDerive) {\n  return s => {\n    return s.pipe(\n    // distinct same base-state objects (e.g. a default emission of default switch cases, incorrect mutable handling\n    // of data) @TODO evaluate benefits vs. overhead\n    distinctUntilChanged(),\n    // CUSTOM LOGIC HERE\n    o => {\n      if (isOperateFnArrayGuard(optionalDerive)) {\n        return o.pipe(pipeFromArray(optionalDerive));\n      }\n      return o;\n    },\n    // initial emissions, undefined is no base-state, pollution with skip(1)\n    filter(v => v !== undefined),\n    // distinct same derivation value\n    distinctUntilChanged(),\n    // reuse custom operations result for multiple subscribers and reemit the last calculated value.\n    shareReplay({\n      bufferSize: 1,\n      refCount: true\n    }));\n  };\n}\nfunction safePluck(stateObject, keys) {\n  // needed to match null and undefined conventions of RxAngular core components\n  // safePluck(null) -> return null\n  // safePluck(undefined) -> return undefined\n  // safePluck(obj, ['wrongKey']) -> return undefined\n  // safePluck(obj, ['correctKey']) -> return value of key\n  // safePluck(obj, '') -> return undefined\n  // safePluck(obj, null) -> return undefined\n  if (!isDefined(stateObject)) {\n    return stateObject;\n  }\n  if (!isDefined(keys)) {\n    return undefined;\n  }\n  // sanitize keys -> keep only valid keys (string, number, symbol)\n  const keysArr = (Array.isArray(keys) ? keys : [keys]).filter(k => isKeyOf(k));\n  if (keysArr.length === 0 || !isObjectGuard(stateObject) || Object.keys(stateObject).length === 0) {\n    return undefined;\n  }\n  let prop = stateObject[keysArr.shift()];\n  keysArr.forEach(key => {\n    if (isObjectGuard(prop) && isKeyOf(key)) {\n      prop = prop[key];\n    }\n  });\n  return prop;\n}\n\n/**\n * @internal\n */\nfunction defaultCompare(oldVal, newVal) {\n  return oldVal === newVal;\n}\n/**\n * @description\n *\n * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from\n * the previous item. Comparison will be done for each set key in the `keys` array.\n *\n * You can fine grain your distinct checks by providing a `KeyCompareMap` with those keys you want to compute\n * explicitly different\n *\n * The name `distinctUntilSomeChanged` was picked since it internally iterates over the `keys` and utilizes the\n * [some](https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/Array/some) method in order to\n * compute if values are distinct or not.\n *\n * @example\n *\n * import { of } from 'rxjs';\n * import { distinctUntilSomeChanged } from 'rx-angular/state';\n *\n * interface Person {\n *    age: number;\n *    name: string;\n * }\n *\n * of(\n *   { age: 4, name: 'Hans'},\n *   { age: 7, name: 'Sophie'},\n *   { age: 5, name: 'Han Solo'},\n *   { age: 5, name: 'HanSophie'},\n * ).pipe(\n *   distinctUntilSomeChanged(['age', 'name']),\n * )\n * .subscribe(x => console.log(x));\n *\n * // displays:\n * // { age: 4, name: 'Hans'}\n * // { age: 7, name: 'Sophie'}\n * // { age: 5, name: 'Han Solo'}\n * // { age: 5, name: 'HanSophie'}\n *\n * @example\n * // An example with `KeyCompareMap`\n * import { of } from 'rxjs';\n * import { distinctUntilSomeChanged } from 'rxjs/operators';\n *\n * interface Person {\n *     age: number;\n *     name: string;\n *  }\n * const customComparison: KeyCompareMap<Person> = {\n *   name: (oldName, newName) => oldName.substring(0, 2) === newName.substring(0, 2)\n * };\n *\n * of(\n *     { age: 4, name: 'Hans'},\n *     { age: 7, name: 'Sophie'},\n *     { age: 5, name: 'Han Solo'},\n *     { age: 5, name: 'HanSophie'},\n *   ).pipe(\n *     distinctUntilSomeChanged(['age', 'name'], customComparison),\n *   )\n *   .subscribe(x => console.log(x));\n *\n * // displays:\n * // { age: 4, name: 'Hans' }\n * // { age: 7, name: 'Sophie' }\n * // { age: 5, name: 'Han Solo' }\n *\n * @param {K[]} keys String key for object property lookup on each item.\n * @param {KeyCompareMap<T>} [compare] Optional KeyCompareMap to explicitly define comparisons for some of the keys\n * @docsPage distinctUntilSomeChanged\n * @docsCategory operators\n */\nfunction distinctUntilSomeChanged(keys, keyCompareMap) {\n  // default compare function applying === to every key\n  let distinctCompare = (oldState, newState) => keys.some(key => !defaultCompare(safePluck(oldState, [key]), safePluck(newState, [key])));\n  // generate compare function respecting every case of provided keyCompareMap\n  if (keyCompareMap !== undefined) {\n    const compare = key => {\n      return keyCompareMap.hasOwnProperty(key) && keyCompareMap[key] !== undefined ? keyCompareMap[key] : defaultCompare;\n    };\n    distinctCompare = (oldState, newState) => {\n      return keys.some(key => !compare(key)(safePluck(oldState, [key]), safePluck(newState, [key])));\n    };\n  }\n  return distinctUntilChanged((oldV, newV) => !distinctCompare(oldV, newV));\n}\n\n/**\n * @description\n *\n * Returns an Observable that emits only the provided `keys` emitted by the source Observable. Each key will get\n * filtered to only emit _defined_ values as well as checked for distinct emissions.\n * Comparison will be done for each set key in the `keys` array.\n *\n * `selectSlice` will only emit _valid_ selections. A selection is _valid_ if every\n * selected key exists and is defined in the source Observable. This ensures that the `selectSlice`\n * operator will always return a complete slice with all values defined.\n *\n * You can fine grain your distinct checks by providing a `KeyCompareMap` with those keys you want to compute\n * explicitly different\n *\n * @example\n *\n * // An example with a custom comparison applied to each key\n * import { of } from 'rxjs';\n * import { selectSlice } from 'rx-angular/state';\n *\n *\n * const state$: Observable<MyState> = of(\n *  { title: 'myTitle', panelOpen: true},\n *  { title: 'myTitle2', panelOpen: true},\n *  { title: 'newTitle', panelOpen: true},\n *  { title: 'newTitle', panelOpen: false}\n * )\n * .pipe(\n *     selectSlice(['title', 'panelOpen']),\n *   )\n *   .subscribe(x => console.log(x));\n *\n * // displays:\n * //  { title: 'myTitle', panelOpen: true },\n * //  { title: 'myTitle2', panelOpen: true },\n * //  { title: 'newTitle', panelOpen: true },\n * //  { title: 'newTitle', panelOpen: false }\n *\n * @example\n *\n * import { of, Observable } from 'rxjs';\n * import { tap } from 'rxjs/operators';\n * import { selectSlice } from 'rx-angular/state';\n *\n * interface MyState {\n *    title: string;\n *    items: string[];\n *    panelOpen: boolean;\n * }\n * // Select items and title.\n * // apply custom compare logic for the items array\n * const customComparison: KeyCompareMap<MyState> = {\n *   items: (oldItems, newItems) => compareItems(oldItems, newItems)\n * };\n * const state$: Observable<MyState> = of(\n * { title: 'myTitle', items: ['foo', 'bar'], panelOpen: true },\n * { title: 'myTitle', items: ['foo', 'bar'], panelOpen: false },\n * { title: 'nextTitle', items: ['foo', 'baR'], panelOpen: true },\n * { title: 'nextTitle', items: ['fooRz', 'boo'], panelOpen: false },\n * );\n * const slice$ = state$.pipe(selectSlice(['title', 'items'], customComparison), tap(console.log)).subscribe();\n *\n * // displays:\n * // { title: 'myTitle', items: ['foo', 'bar'] }\n * // { title: 'nextTitle', items: ['foo', 'baR'] }\n * // { title: 'nextTitle', items: ['fooRz', 'boo'] }\n *\n * @param {(K)[]} keys - the array of keys which should be selected\n * @param {KeyCompareMap<{ [P in K]: T[P] }>} [keyCompareMap] Optional KeyCompareMap to provide custom compare logic\n * for some the keys\n * @docsPage selectSlice\n * @docsCategory operators\n */\nfunction selectSlice(keys, keyCompareMap) {\n  return o$ => o$.pipe(filter(state => state !== undefined), map(state => {\n    // forward null\n    if (state === null) {\n      return null;\n    }\n    // an array of all keys which exist and are _defined_ in the state object\n    const definedKeys = keys\n    // filter out undefined properties e. g. {}, { str: undefined }\n    .filter(k => state.hasOwnProperty(k) && state[k] !== undefined);\n    // we want to ensure to only emit _valid_ selections\n    // a selection is _valid_ if every selected key exists and has a value:\n    // {} => selectSlice(['foo']) => no emission\n    // {str: 'test'} => selectSlice([]) => no emission\n    // {str: 'test'} => selectSlice(['notPresent']) => no emission\n    // {str: 'test'} => state.select(selectSlice([])) => no emission\n    // {str: 'test'} => state.select(selectSlice(['notPresent'])) => no emission\n    // {str: undefined} => state.select(selectSlice(['str'])) => no emission\n    // {str: 'test', foo: undefined } => state.select(selectSlice(['foo'])) => no emission\n    if (definedKeys.length < keys.length) {\n      return undefined;\n    }\n    // create the selected slice\n    return definedKeys.reduce((vm, key) => {\n      vm[key] = state[key];\n      return vm;\n    }, {});\n  }), filter(v => v !== undefined), distinctUntilSomeChanged(keys, keyCompareMap));\n}\n\n/**\n * @internal\n */\nfunction select(...opOrMapFn) {\n  return state$ => {\n    if (!opOrMapFn || opOrMapFn.length === 0) {\n      return state$.pipe(stateful());\n    } else if (isStringAndFunctionTupleGuard(opOrMapFn)) {\n      return state$.pipe(stateful(map(s => opOrMapFn[1](s[opOrMapFn[0]]))));\n    } else if (isStringArrayFunctionAndOptionalObjectTupleGuard(opOrMapFn)) {\n      return state$.pipe(selectSlice(opOrMapFn[0], opOrMapFn[2]), stateful(map(opOrMapFn[1])));\n    } else if (isStringArrayGuard(opOrMapFn)) {\n      return state$.pipe(stateful(pluck(...opOrMapFn)));\n    } else if (isOperateFnArrayGuard(opOrMapFn)) {\n      return state$.pipe(stateful(pipeFromArray(opOrMapFn)));\n    } else {\n      throw new Error('wrong params passed to select');\n    }\n  };\n}\nfunction createSideEffectObservable(stateObservables = new Subject()) {\n  const effects$ = merge(stateObservables.pipe(mergeAll(), observeOn(queueScheduler)));\n  function nextEffectObservable(effect$) {\n    stateObservables.next(effect$);\n  }\n  function subscribe() {\n    return effects$.subscribe();\n  }\n  return {\n    effects$,\n    nextEffectObservable,\n    subscribe\n  };\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { createAccumulationObservable, createSideEffectObservable, distinctUntilSomeChanged, isDefined, isKeyOf, isObjectGuard, isOperateFnArrayGuard, isStringAndFunctionTupleGuard, isStringArrayFunctionAndOptionalObjectTupleGuard, isStringArrayGuard, pipeFromArray, safePluck, select, selectSlice, stateful };\n","import * as i0 from '@angular/core';\nimport { Injectable } from '@angular/core';\nimport { createAccumulationObservable, createSideEffectObservable, safePluck, isKeyOf, select, isDefined, isObjectGuard } from '@rx-angular/state/selections';\nexport * from '@rx-angular/state/selections';\nimport { Subscription, isObservable, EMPTY } from 'rxjs';\nimport { map, catchError, tap } from 'rxjs/operators';\n\n/**\n * @description\n * RxState is a light-weight reactive state management service for managing local state in angular.\n *\n * @example\n * Component({\n *   selector: 'app-stateful',\n *   template: `<div>{{ state$ | async | json }}</div>`,\n *   providers: [RxState]\n * })\n * export class StatefulComponent {\n *   readonly state$ = this.state.select();\n *\n *   constructor(private state: RxState<{ foo: string }>) {}\n * }\n *\n * @docsCategory RxState\n * @docsPage RxState\n */\nlet RxState = /*#__PURE__*/(() => {\n  class RxState {\n    /**\n     * @internal\n     */\n    constructor() {\n      this.subscription = new Subscription();\n      this.accumulator = createAccumulationObservable();\n      this.effectObservable = createSideEffectObservable();\n      /**\n       * @description\n       * The unmodified state exposed as `Observable<T>`. It is not shared, distinct or gets replayed.\n       * Use the `$` property if you want to read the state without having applied {@link stateful} to it.\n       */\n      this.$ = this.accumulator.signal$;\n      this.subscription.add(this.subscribe());\n    }\n    /**\n     * @internal\n     */\n    ngOnDestroy() {\n      this.subscription.unsubscribe();\n    }\n    /**\n     * @description\n     *\n     * Allows to customize state accumulation function.\n     * This can be helpful to implement deep updates and tackle other immutability problems in a custom way.\n     * @example\n     *\n     * ```typescript\n     * const myAccumulator = (state: MyState, slice: Partial<MyState>) => deepCopy(state, slice);\n     *\n     * this.state.setAccumulator(myAccumulator);\n     * ```\n     */\n    setAccumulator(accumulatorFn) {\n      this.accumulator.nextAccumulator(accumulatorFn);\n    }\n    /** @internal **/\n    get(...keys) {\n      const hasStateAnyKeys = Object.keys(this.accumulator.state).length > 0;\n      if (!!keys && keys.length) {\n        return safePluck(this.accumulator.state, keys);\n      } else {\n        return hasStateAnyKeys ? this.accumulator.state : undefined;\n      }\n    }\n    /**\n     * @internal\n     */\n    set(keyOrStateOrProjectState, stateOrSliceProjectFn) {\n      if (typeof keyOrStateOrProjectState === 'object' && stateOrSliceProjectFn === undefined) {\n        this.accumulator.nextSlice(keyOrStateOrProjectState);\n        return;\n      }\n      if (typeof keyOrStateOrProjectState === 'function' && stateOrSliceProjectFn === undefined) {\n        this.accumulator.nextSlice(keyOrStateOrProjectState(this.accumulator.state));\n        return;\n      }\n      if (isKeyOf(keyOrStateOrProjectState) && typeof stateOrSliceProjectFn === 'function') {\n        const state = {};\n        state[keyOrStateOrProjectState] = stateOrSliceProjectFn(this.accumulator.state);\n        this.accumulator.nextSlice(state);\n        return;\n      }\n      throw new Error('wrong params passed to set');\n    }\n    /**\n     * @internal\n     */\n    connect(keyOrInputOrSlice$, projectOrSlices$, projectValueFn) {\n      if (projectValueFn === undefined && projectOrSlices$ === undefined && isObservable(keyOrInputOrSlice$)) {\n        this.accumulator.nextSliceObservable(keyOrInputOrSlice$);\n        return;\n      }\n      if (projectValueFn === undefined && typeof projectOrSlices$ === 'function' && isObservable(keyOrInputOrSlice$) && !isObservable(projectOrSlices$)) {\n        const project = projectOrSlices$;\n        const slice$ = keyOrInputOrSlice$.pipe(map(v => project(this.get(), v)));\n        this.accumulator.nextSliceObservable(slice$);\n        return;\n      }\n      if (projectValueFn === undefined && isKeyOf(keyOrInputOrSlice$) && isObservable(projectOrSlices$)) {\n        const key = keyOrInputOrSlice$;\n        const slice$ = projectOrSlices$.pipe(map(value => Object.assign({}, {\n          [key]: value\n        })));\n        this.accumulator.nextSliceObservable(slice$);\n        return;\n      }\n      if (typeof projectValueFn === 'function' && isKeyOf(keyOrInputOrSlice$) && isObservable(projectOrSlices$)) {\n        const key = keyOrInputOrSlice$;\n        const slice$ = projectOrSlices$.pipe(map(value => Object.assign({}, {\n          [key]: projectValueFn(this.get(), value)\n        })));\n        this.accumulator.nextSliceObservable(slice$);\n        return;\n      }\n      throw new Error('wrong params passed to connect');\n    }\n    /**\n     * @internal\n     */\n    select(...args) {\n      return this.accumulator.state$.pipe(select(...args));\n    }\n    /**\n     * @description\n     * Manages side-effects of your state. Provide an `Observable<any>` **side-effect** and an optional\n     * `sideEffectFunction`.\n     * Subscription handling is done automatically.\n     *\n     * @example\n     * // Directly pass an observable side-effect\n     * const localStorageEffect$ = changes$.pipe(\n     *  tap(changes => storeChanges(changes))\n     * );\n     * state.hold(localStorageEffect$);\n     *\n     * // Pass an additional `sideEffectFunction`\n     *\n     * const localStorageEffectFn = changes => storeChanges(changes);\n     * state.hold(changes$, localStorageEffectFn);\n     *\n     * @param {Observable<S>} obsOrObsWithSideEffect\n     * @param {function} [sideEffectFn]\n     */\n    hold(obsOrObsWithSideEffect, sideEffectFn) {\n      const sideEffect = obsOrObsWithSideEffect.pipe(catchError(e => EMPTY));\n      if (typeof sideEffectFn === 'function') {\n        this.effectObservable.nextEffectObservable(sideEffect.pipe(tap(sideEffectFn)));\n        return;\n      }\n      this.effectObservable.nextEffectObservable(sideEffect);\n    }\n    /**\n     * @internal\n     */\n    subscribe() {\n      const subscription = new Subscription();\n      subscription.add(this.accumulator.subscribe());\n      subscription.add(this.effectObservable.subscribe());\n      return subscription;\n    }\n  }\n  /** @nocollapse */\n  /** @nocollapse */RxState.ɵfac = function RxState_Factory(t) {\n    return new (t || RxState)();\n  };\n  RxState.ɵprov = /* @__PURE__ */i0.ɵɵdefineInjectable({\n    token: RxState,\n    factory: RxState.ɵfac\n  });\n  return RxState;\n})();\n(() => {\n  (typeof ngDevMode === \"undefined\" || ngDevMode) && void 0;\n})();\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction insert(source, updates) {\n  const updatesDefined = isDefined(updates);\n  const sourceIsNotArray = !Array.isArray(source);\n  const invalidInput = sourceIsNotArray && !updatesDefined;\n  if (sourceIsNotArray && isDefined(source)) {\n    console.warn(`Insert: Original value (${source}) is not an array.`);\n  }\n  if (invalidInput) {\n    return source;\n  }\n  return (sourceIsNotArray ? [] : source).concat(updatesDefined ? Array.isArray(updates) ? updates : [updates] : []);\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\nconst defaultCompareFn = (a, b) => a === b;\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction valuesComparer(original, incoming, compare) {\n  if (isKeyOf(compare)) {\n    return original[compare] === incoming[compare];\n  }\n  if (Array.isArray(compare)) {\n    const sanitizedKeys = compare.filter(k => isKeyOf(k));\n    return sanitizedKeys.length > 0 ? sanitizedKeys.every(k => original[k] === incoming[k]) : defaultCompareFn(original, incoming);\n  }\n  return (compare || defaultCompareFn)(original, incoming);\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction remove(source, scrap, compare) {\n  const scrapAsArray = isDefined(scrap) ? Array.isArray(scrap) ? scrap : [scrap] : [];\n  const invalidInput = !Array.isArray(source);\n  if (invalidInput) {\n    console.warn(`Remove: original value (${source}) is not an array`);\n    return source;\n  }\n  return source.filter(existingItem => {\n    return !scrapAsArray.some(item => valuesComparer(item, existingItem, compare));\n  });\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction toDictionary(source, key) {\n  if (!isDefined(source)) {\n    return source;\n  }\n  const sourceEmpty = !source.length;\n  if (!Array.isArray(source) || sourceEmpty || !isKeyOf(source[0][key])) {\n    if (!sourceEmpty) {\n      console.warn('ToDictionary: unexpected input params.');\n    }\n    return {};\n  }\n  const dictionary = {};\n  const length = source.length;\n  let i = 0;\n  for (i; i < length; i++) {\n    dictionary[`${source[i][key]}`] = Object.assign({}, source[i]);\n  }\n  return dictionary;\n}\n\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction update(source, updates, compare) {\n  const updatesDefined = updates != null;\n  const updatesAsArray = updatesDefined ? Array.isArray(updates) ? updates : [updates] : [];\n  const sourceDefined = source != null;\n  const sourceIsNotArray = !Array.isArray(source);\n  const invalidInput = sourceIsNotArray || source.length === 0 || updatesAsArray.length === 0;\n  if (sourceDefined && sourceIsNotArray) {\n    console.warn(`Update: Original value (${source}) is not an array.`);\n  }\n  if (invalidInput) {\n    return source;\n  }\n  const x = [];\n  for (const existingItem of source) {\n    const match = customFind(updatesAsArray, item => valuesComparer(item, existingItem, compare));\n    x.push(match ? Object.assign(Object.assign({}, existingItem), match) : existingItem);\n  }\n  return x;\n}\nfunction customFind(array, fn) {\n  for (const item of array) {\n    const x = fn(item);\n    if (x) {\n      return item;\n    }\n  }\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction extract(array, keys) {\n  const arrayIsArray = isDefined(array) && Array.isArray(array);\n  if (!arrayIsArray) {\n    console.warn(`extract: original value (${array}) is not an array.`);\n    return undefined;\n  }\n  const sanitizedKeys = (Array.isArray(keys) ? keys : [keys]).filter(k => isKeyOf(k) && array.some(i => k in i));\n  const length = sanitizedKeys.length;\n  if (!sanitizedKeys.length) {\n    console.warn(`extract: provided keys not found`);\n    return undefined;\n  }\n  return array.map(item => {\n    let i = 0;\n    const result = {};\n    for (i; i < length; i++) {\n      result[sanitizedKeys[i]] = item[sanitizedKeys[i]];\n    }\n    return result;\n  });\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction upsert(source, update, compare) {\n  // check inputs for validity\n  const updatesAsArray = update != null ? Array.isArray(update) ? update : [update] : [];\n  // check inputs for validity\n  const sourceIsNotArray = !Array.isArray(source);\n  const invalidInput = sourceIsNotArray && updatesAsArray.length === 0;\n  // if the source value is not an Array or the input is not defined return the original source\n  // this is the case for any edge case:\n  // '', null, undefined, CustomObjectOfDoomAndDarkness, ...\n  if (invalidInput) {\n    return source;\n  }\n  // if source is empty array or not an array, but the updates are valid:\n  // return a shallow copy of the updates as result\n  if (updatesAsArray.length > 0 && (sourceIsNotArray || source.length === 0)) {\n    return [...updatesAsArray];\n  }\n  const inserts = [];\n  const updates = {};\n  // process updates/inserts\n  for (const item of updatesAsArray) {\n    const match = source.findIndex(sourceItem => valuesComparer(item, sourceItem, compare));\n    // if item already exists, save it as update\n    if (match !== -1) {\n      updates[match] = item;\n    } else {\n      // otherwise consider this as insert\n      if (isObjectGuard(item)) {\n        // create a shallow copy if item is an object\n        inserts.push(Object.assign({}, item));\n      } else {\n        // otherwise just push it\n        inserts.push(item);\n      }\n    }\n  }\n  const updated = source.map((item, i) => {\n    const updatedItem = updates[i];\n    // process the updated\n    if (updatedItem !== null && updatedItem !== undefined) {\n      if (isObjectGuard(item)) {\n        return Object.assign(Object.assign({}, item), updatedItem);\n      } else {\n        return updatedItem;\n      }\n    }\n    return item;\n  });\n  // return the combination of the updated source & the inserts as new array\n  return updated.concat(inserts);\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction deleteProp(object, key) {\n  if (!isDefined(object) || !isObjectGuard(object)) {\n    console.warn(`DeleteProp: original value ${object} is not an object.`);\n    return object;\n  }\n  if (!isKeyOf(key)) {\n    console.warn(`DeleteProp: provided key is not a string, number or symbol.`);\n    return Object.assign({}, object);\n  }\n  const copy = Object.assign({}, object);\n  delete copy[key];\n  return copy;\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction dictionaryToArray(dictionary) {\n  if (!isDefined(dictionary)) {\n    return dictionary;\n  }\n  if (!isObjectGuard(dictionary)) {\n    console.warn(`DictionaryToArray: unexpected input.`);\n    return [];\n  }\n  return Object.values(dictionary);\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction patch(object, upd) {\n  const update = isObjectGuard(upd) ? upd : {};\n  if (!isObjectGuard(object) && isObjectGuard(upd)) {\n    console.warn(`Patch: original value ${object} is not an object.`);\n    return Object.assign({}, update);\n  }\n  if (!isObjectGuard(object) && !isObjectGuard(upd)) {\n    console.warn(`Patch: original value ${object} and updates ${upd} are not objects.`);\n    return object;\n  }\n  return Object.assign(Object.assign({}, object), update);\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction setProp(object, key, value) {\n  const objectIsObject = isObjectGuard(object);\n  const keyIsValid = isKeyOf(key);\n  const initialObject = objectIsObject ? object : {};\n  if (!objectIsObject) {\n    console.warn(`SetProp: original value (${object}) is not an object.`);\n  }\n  if (!keyIsValid) {\n    console.warn(`SetProp: key argument (${key}) is invalid.`);\n  }\n  if (!isDefined(object) && !keyIsValid) {\n    return object;\n  }\n  if (keyIsValid) {\n    return Object.assign(Object.assign({}, initialObject), {\n      [key]: value\n    });\n  }\n  return Object.assign({}, initialObject);\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction toggle(object, key) {\n  const objectIsObject = isObjectGuard(object);\n  const keyIsValid = isKeyOf(key);\n  const initialObject = objectIsObject ? object : {};\n  if (!objectIsObject) {\n    console.warn(`Toggle: original value (${object}) is not an object.`);\n  }\n  if (!keyIsValid) {\n    console.warn(`Toggle: key argument (${key}) is invalid.`);\n  }\n  if (keyIsValid && typeof initialObject[key] !== 'boolean') {\n    console.warn(`Toggle: value of the key (${key}) is not a boolean.`);\n  }\n  if (!isDefined(object) && !keyIsValid) {\n    return object;\n  }\n  if (keyIsValid && (typeof initialObject[key] === 'boolean' || !initialObject.hasOwnProperty(key))) {\n    return Object.assign(Object.assign({}, initialObject), {\n      [key]: !initialObject[key]\n    });\n  }\n  return Object.assign({}, initialObject);\n}\n\n// eslint-disable-next-line @nrwl/nx/enforce-module-boundaries\n/**\n * @deprecated moved to `@rx-angular/cdk/transformations`\n * @see {@link https://www.npmjs.com/package/@rx-angular/cdk}\n */\nfunction slice(object, keys) {\n  const objectIsObject = isDefined(object) && isObjectGuard(object);\n  if (!objectIsObject) {\n    console.warn(`slice: original value (${object}) is not an object.`);\n    return undefined;\n  }\n  const sanitizedKeys = (Array.isArray(keys) ? keys : [keys]).filter(k => isKeyOf(k) && k in object);\n  if (!sanitizedKeys.length) {\n    console.warn(`slice: provided keys not found`);\n    return undefined;\n  }\n  return sanitizedKeys.reduce((acc, k) => Object.assign(Object.assign({}, acc), {\n    [k]: object[k]\n  }), {});\n}\n\n/**\n * Generated bundle index. Do not edit.\n */\n\nexport { RxState, deleteProp, dictionaryToArray, extract, insert, patch, remove, setProp, slice, toDictionary, toggle, update, upsert };\n"],"mappings":"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","names":["defaultAccumulator","st","sl","createAccumulationObservable","stateObservables","Subject","stateSlices","accumulatorObservable","BehaviorSubject","signal$","merge","distinctUntilChanged","mergeAll","observeOn","queueScheduler","withLatestFrom","scan","state","slice","stateAccumulator","tap","newState","compositionObservable","error","catchError","e","EMPTY","publish","state$","publishReplay","nextSlice","nextSliceObservable","nextAccumulator","subscribe","accumulatorFn","stateSlice","stateObservable","sub","isOperateFnArrayGuard","op","i","isStringArrayGuard","isKeyOf","k","typeofK","isObjectGuard","obj","isDefined","val","isStringAndFunctionTupleGuard","op","isStringArrayFunctionAndOptionalObjectTupleGuard","isStringArrayGuard","pipeFromArray","fns","input","prev","fn","noop","stateful","optionalDerive","s","distinctUntilChanged","o","isOperateFnArrayGuard","filter","v","shareReplay","safePluck","stateObject","keys","keysArr","prop","key","defaultCompare","oldVal","newVal","distinctUntilSomeChanged","keyCompareMap","distinctCompare","oldState","newState","compare","oldV","newV","selectSlice","o$","state","map","definedKeys","vm","select","opOrMapFn","state$","pluck","createSideEffectObservable","stateObservables","Subject","effects$","merge","mergeAll","observeOn","queueScheduler","nextEffectObservable","effect$","subscribe","RxState","Subscription","createAccumulationObservable","createSideEffectObservable","accumulatorFn","keys","hasStateAnyKeys","safePluck","keyOrStateOrProjectState","stateOrSliceProjectFn","isKeyOf","state","keyOrInputOrSlice$","projectOrSlices$","projectValueFn","isObservable","project","slice$","map","v","key","value","args","select","obsOrObsWithSideEffect","sideEffectFn","sideEffect","catchError","e","EMPTY","tap","subscription","t","ɵɵdefineInjectable"],"x_google_ignoreList":[0,1]}