@ngrx/store/esm2015/src/store.js

/* eslint-disable @typescript-eslint/naming-convention */
// disabled because we have lowercase generics for `select`
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { distinctUntilChanged, map, pluck } from 'rxjs/operators';
import { ActionsSubject } from './actions_subject';
import { ReducerManager } from './reducer_manager';
import { StateObservable } from './state';
export class Store extends Observable {
    constructor(state$, actionsObserver, reducerManager) {
        super();
        this.actionsObserver = actionsObserver;
        this.reducerManager = reducerManager;
        this.source = state$;
    }
    select(pathOrMapFn, ...paths) {
        return select.call(null, pathOrMapFn, ...paths)(this);
    }
    lift(operator) {
        const store = new Store(this, this.actionsObserver, this.reducerManager);
        store.operator = operator;
        return store;
    }
    dispatch(action) {
        this.actionsObserver.next(action);
    }
    next(action) {
        this.actionsObserver.next(action);
    }
    error(err) {
        this.actionsObserver.error(err);
    }
    complete() {
        this.actionsObserver.complete();
    }
    addReducer(key, reducer) {
        this.reducerManager.addReducer(key, reducer);
    }
    removeReducer(key) {
        this.reducerManager.removeReducer(key);
    }
}
Store.decorators = [
    { type: Injectable }
];
/** @nocollapse */
Store.ctorParameters = () => [
    { type: StateObservable },
    { type: ActionsSubject },
    { type: ReducerManager }
];
export const STORE_PROVIDERS = [Store];
export function select(pathOrMapFn, propsOrPath, ...paths) {
    return function selectOperator(source$) {
        let mapped$;
        if (typeof pathOrMapFn === 'string') {
            const pathSlices = [propsOrPath, ...paths].filter(Boolean);
            mapped$ = source$.pipe(pluck(pathOrMapFn, ...pathSlices));
        }
        else if (typeof pathOrMapFn === 'function') {
            mapped$ = source$.pipe(map((source) => pathOrMapFn(source, propsOrPath)));
        }
        else {
            throw new TypeError(`Unexpected type '${typeof pathOrMapFn}' in select operator,` +
                ` expected 'string' or 'function'`);
        }
        return mapped$.pipe(distinctUntilChanged());
    };
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"","sources":["../../../../../modules/store/src/store.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,2DAA2D;AAC3D,OAAO,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,UAAU,EAAsB,MAAM,MAAM,CAAC;AACtD,OAAO,EAAE,oBAAoB,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAElE,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAG1C,MAAM,OAAO,KACX,SAAQ,UAAa;IAErB,YACE,MAAuB,EACf,eAA+B,EAC/B,cAA8B;QAEtC,KAAK,EAAE,CAAC;QAHA,oBAAe,GAAf,eAAe,CAAgB;QAC/B,mBAAc,GAAd,cAAc,CAAgB;QAItC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAiED,MAAM,CACJ,WAAsD,EACtD,GAAG,KAAe;QAElB,OAAQ,MAAc,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC;IACjE,CAAC;IAED,IAAI,CAAI,QAAwB;QAC9B,MAAM,KAAK,GAAG,IAAI,KAAK,CAAI,IAAI,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;QAC5E,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAAC;QAE1B,OAAO,KAAK,CAAC;IACf,CAAC;IAED,QAAQ,CACN,MAIG;QAEH,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,CAAC,MAAc;QACjB,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,CAAC;IAED,KAAK,CAAC,GAAQ;QACZ,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAClC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,CAAC;IAClC,CAAC;IAED,UAAU,CACR,GAAW,EACX,OAAsC;QAEtC,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED,aAAa,CAAuC,GAAQ;QAC1D,IAAI,CAAC,cAAc,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IACzC,CAAC;;;YA1HF,UAAU;;;;YAFF,eAAe;YAHf,cAAc;YAEd,cAAc;;AAgIvB,MAAM,CAAC,MAAM,eAAe,GAAe,CAAC,KAAK,CAAC,CAAC;AAyFnD,MAAM,UAAU,MAAM,CACpB,WAAwD,EACxD,WAA4B,EAC5B,GAAG,KAAe;IAElB,OAAO,SAAS,cAAc,CAAC,OAAsB;QACnD,IAAI,OAAwB,CAAC;QAE7B,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE;YACnC,MAAM,UAAU,GAAG,CAAS,WAAW,EAAE,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACnE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,GAAG,UAAU,CAAC,CAAC,CAAC;SAC3D;aAAM,IAAI,OAAO,WAAW,KAAK,UAAU,EAAE;YAC5C,OAAO,GAAG,OAAO,CAAC,IAAI,CACpB,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,WAAW,CAAC,MAAM,EAAS,WAAW,CAAC,CAAC,CACzD,CAAC;SACH;aAAM;YACL,MAAM,IAAI,SAAS,CACjB,oBAAoB,OAAO,WAAW,uBAAuB;gBAC3D,kCAAkC,CACrC,CAAC;SACH;QAED,OAAO,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC,CAAC;IAC9C,CAAC,CAAC;AACJ,CAAC","sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention */\n// disabled because we have lowercase generics for `select`\nimport { Injectable, Provider } from '@angular/core';\nimport { Observable, Observer, Operator } from 'rxjs';\nimport { distinctUntilChanged, map, pluck } from 'rxjs/operators';\n\nimport { ActionsSubject } from './actions_subject';\nimport { Action, ActionReducer, FunctionIsNotAllowed } from './models';\nimport { ReducerManager } from './reducer_manager';\nimport { StateObservable } from './state';\n\n@Injectable()\nexport class Store<T = object>\n  extends Observable<T>\n  implements Observer<Action> {\n  constructor(\n    state$: StateObservable,\n    private actionsObserver: ActionsSubject,\n    private reducerManager: ReducerManager\n  ) {\n    super();\n\n    this.source = state$;\n  }\n\n  select<K>(mapFn: (state: T) => K): Observable<K>;\n  /**\n   * @deprecated Selectors with props are deprecated, for more info see {@link https://github.com/ngrx/platform/issues/2980 Github Issue}\n   */\n  select<K, Props = any>(\n    mapFn: (state: T, props: Props) => K,\n    props: Props\n  ): Observable<K>;\n  select<a extends keyof T>(key: a): Observable<T[a]>;\n  select<a extends keyof T, b extends keyof T[a]>(\n    key1: a,\n    key2: b\n  ): Observable<T[a][b]>;\n  select<a extends keyof T, b extends keyof T[a], c extends keyof T[a][b]>(\n    key1: a,\n    key2: b,\n    key3: c\n  ): Observable<T[a][b][c]>;\n  select<\n    a extends keyof T,\n    b extends keyof T[a],\n    c extends keyof T[a][b],\n    d extends keyof T[a][b][c]\n  >(key1: a, key2: b, key3: c, key4: d): Observable<T[a][b][c][d]>;\n  select<\n    a extends keyof T,\n    b extends keyof T[a],\n    c extends keyof T[a][b],\n    d extends keyof T[a][b][c],\n    e extends keyof T[a][b][c][d]\n  >(key1: a, key2: b, key3: c, key4: d, key5: e): Observable<T[a][b][c][d][e]>;\n  select<\n    a extends keyof T,\n    b extends keyof T[a],\n    c extends keyof T[a][b],\n    d extends keyof T[a][b][c],\n    e extends keyof T[a][b][c][d],\n    f extends keyof T[a][b][c][d][e]\n  >(\n    key1: a,\n    key2: b,\n    key3: c,\n    key4: d,\n    key5: e,\n    key6: f\n  ): Observable<T[a][b][c][d][e][f]>;\n  select<\n    a extends keyof T,\n    b extends keyof T[a],\n    c extends keyof T[a][b],\n    d extends keyof T[a][b][c],\n    e extends keyof T[a][b][c][d],\n    f extends keyof T[a][b][c][d][e],\n    K = any\n  >(\n    key1: a,\n    key2: b,\n    key3: c,\n    key4: d,\n    key5: e,\n    key6: f,\n    ...paths: string[]\n  ): Observable<K>;\n  select<Props = any, K = any>(\n    pathOrMapFn: ((state: T, props?: Props) => K) | string,\n    ...paths: string[]\n  ): Observable<any> {\n    return (select as any).call(null, pathOrMapFn, ...paths)(this);\n  }\n\n  lift<R>(operator: Operator<T, R>): Store<R> {\n    const store = new Store<R>(this, this.actionsObserver, this.reducerManager);\n    store.operator = operator;\n\n    return store;\n  }\n\n  dispatch<V extends Action = Action>(\n    action: V &\n      FunctionIsNotAllowed<\n        V,\n        'Functions are not allowed to be dispatched. Did you forget to call the action creator function?'\n      >\n  ) {\n    this.actionsObserver.next(action);\n  }\n\n  next(action: Action) {\n    this.actionsObserver.next(action);\n  }\n\n  error(err: any) {\n    this.actionsObserver.error(err);\n  }\n\n  complete() {\n    this.actionsObserver.complete();\n  }\n\n  addReducer<State, Actions extends Action = Action>(\n    key: string,\n    reducer: ActionReducer<State, Actions>\n  ) {\n    this.reducerManager.addReducer(key, reducer);\n  }\n\n  removeReducer<Key extends Extract<keyof T, string>>(key: Key) {\n    this.reducerManager.removeReducer(key);\n  }\n}\n\nexport const STORE_PROVIDERS: Provider[] = [Store];\n\nexport function select<T, K>(\n  mapFn: (state: T) => K\n): (source$: Observable<T>) => Observable<K>;\n/**\n * @deprecated Selectors with props are deprecated, for more info see {@link https://github.com/ngrx/platform/issues/2980 Github Issue}\n */\nexport function select<T, Props, K>(\n  mapFn: (state: T, props: Props) => K,\n  props: Props\n): (source$: Observable<T>) => Observable<K>;\nexport function select<T, a extends keyof T>(\n  key: a\n): (source$: Observable<T>) => Observable<T[a]>;\nexport function select<T, a extends keyof T, b extends keyof T[a]>(\n  key1: a,\n  key2: b\n): (source$: Observable<T>) => Observable<T[a][b]>;\nexport function select<\n  T,\n  a extends keyof T,\n  b extends keyof T[a],\n  c extends keyof T[a][b]\n>(\n  key1: a,\n  key2: b,\n  key3: c\n): (source$: Observable<T>) => Observable<T[a][b][c]>;\nexport function select<\n  T,\n  a extends keyof T,\n  b extends keyof T[a],\n  c extends keyof T[a][b],\n  d extends keyof T[a][b][c]\n>(\n  key1: a,\n  key2: b,\n  key3: c,\n  key4: d\n): (source$: Observable<T>) => Observable<T[a][b][c][d]>;\nexport function select<\n  T,\n  a extends keyof T,\n  b extends keyof T[a],\n  c extends keyof T[a][b],\n  d extends keyof T[a][b][c],\n  e extends keyof T[a][b][c][d]\n>(\n  key1: a,\n  key2: b,\n  key3: c,\n  key4: d,\n  key5: e\n): (source$: Observable<T>) => Observable<T[a][b][c][d][e]>;\nexport function select<\n  T,\n  a extends keyof T,\n  b extends keyof T[a],\n  c extends keyof T[a][b],\n  d extends keyof T[a][b][c],\n  e extends keyof T[a][b][c][d],\n  f extends keyof T[a][b][c][d][e]\n>(\n  key1: a,\n  key2: b,\n  key3: c,\n  key4: d,\n  key5: e,\n  key6: f\n): (source$: Observable<T>) => Observable<T[a][b][c][d][e][f]>;\nexport function select<\n  T,\n  a extends keyof T,\n  b extends keyof T[a],\n  c extends keyof T[a][b],\n  d extends keyof T[a][b][c],\n  e extends keyof T[a][b][c][d],\n  f extends keyof T[a][b][c][d][e],\n  K = any\n>(\n  key1: a,\n  key2: b,\n  key3: c,\n  key4: d,\n  key5: e,\n  key6: f,\n  ...paths: string[]\n): (source$: Observable<T>) => Observable<K>;\nexport function select<T, Props, K>(\n  pathOrMapFn: ((state: T, props?: Props) => any) | string,\n  propsOrPath?: Props | string,\n  ...paths: string[]\n) {\n  return function selectOperator(source$: Observable<T>): Observable<K> {\n    let mapped$: Observable<any>;\n\n    if (typeof pathOrMapFn === 'string') {\n      const pathSlices = [<string>propsOrPath, ...paths].filter(Boolean);\n      mapped$ = source$.pipe(pluck(pathOrMapFn, ...pathSlices));\n    } else if (typeof pathOrMapFn === 'function') {\n      mapped$ = source$.pipe(\n        map((source) => pathOrMapFn(source, <Props>propsOrPath))\n      );\n    } else {\n      throw new TypeError(\n        `Unexpected type '${typeof pathOrMapFn}' in select operator,` +\n          ` expected 'string' or 'function'`\n      );\n    }\n\n    return mapped$.pipe(distinctUntilChanged());\n  };\n}\n"]}