@ngxs/store 3.7.4 → 3.7.5

package/esm2015/src/store.js

@@ -1,190 +1,190 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-// tslint:disable:unified-signatures
-import { Inject, Injectable, Optional } from '@angular/core';
-import { of, throwError } from 'rxjs';
-import { catchError, distinctUntilChanged, map, publishReplay, refCount, take } from 'rxjs/operators';
-import { INITIAL_STATE_TOKEN } from '@ngxs/store/internals';
-import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
-import { InternalStateOperations } from './internal/state-operations';
-import { getRootSelectorFactory } from './utils/selector-utils';
-import { StateStream } from './internal/state-stream';
-import { leaveNgxs } from './operators/leave-ngxs';
-import { NgxsConfig } from './symbols';
-import { StateFactory } from './internal/state-factory';
-export class Store {
-    /**
-     * @param {?} _stateStream
-     * @param {?} _internalStateOperations
-     * @param {?} _config
-     * @param {?} _internalExecutionStrategy
-     * @param {?} _stateFactory
-     * @param {?} initialStateValue
-     */
-    constructor(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {
-        this._stateStream = _stateStream;
-        this._internalStateOperations = _internalStateOperations;
-        this._config = _config;
-        this._internalExecutionStrategy = _internalExecutionStrategy;
-        this._stateFactory = _stateFactory;
-        /**
-         * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
-         * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
-         * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
-         */
-        this._selectableStateStream = this._stateStream.pipe(leaveNgxs(this._internalExecutionStrategy), publishReplay(1), refCount());
-        this.initStateStream(initialStateValue);
-    }
-    /**
-     * Dispatches event(s).
-     * @param {?} actionOrActions
-     * @return {?}
-     */
-    dispatch(actionOrActions) {
-        return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);
-    }
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
-    select(selector) {
-        /** @type {?} */
-        const selectorFn = this.getStoreBoundSelectorFn(selector);
-        return this._selectableStateStream.pipe(map(selectorFn), catchError((/**
-         * @param {?} err
-         * @return {?}
-         */
-        (err) => {
-            // if error is TypeError we swallow it to prevent usual errors with property access
-            const { suppressErrors } = this._config.selectorOptions;
-            if (err instanceof TypeError && suppressErrors) {
-                return of(undefined);
-            }
-            // rethrow other errors
-            return throwError(err);
-        })), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));
-    }
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
-    selectOnce(selector) {
-        return this.select(selector).pipe(take(1));
-    }
-    /**
-     * @param {?} selector
-     * @return {?}
-     */
-    selectSnapshot(selector) {
-        /** @type {?} */
-        const selectorFn = this.getStoreBoundSelectorFn(selector);
-        return selectorFn(this._stateStream.getValue());
-    }
-    /**
-     * Allow the user to subscribe to the root of the state
-     * @param {?=} fn
-     * @return {?}
-     */
-    subscribe(fn) {
-        return this._selectableStateStream
-            .pipe(leaveNgxs(this._internalExecutionStrategy))
-            .subscribe(fn);
-    }
-    /**
-     * Return the raw value of the state.
-     * @return {?}
-     */
-    snapshot() {
-        return this._internalStateOperations.getRootStateOperations().getState();
-    }
-    /**
-     * Reset the state to a specific point in time. This method is useful
-     * for plugin's who need to modify the state directly or unit testing.
-     * @param {?} state
-     * @return {?}
-     */
-    reset(state) {
-        return this._internalStateOperations.getRootStateOperations().setState(state);
-    }
-    /**
-     * @private
-     * @param {?} selector
-     * @return {?}
-     */
-    getStoreBoundSelectorFn(selector) {
-        /** @type {?} */
-        const makeSelectorFn = getRootSelectorFactory(selector);
-        /** @type {?} */
-        const runtimeContext = this._stateFactory.getRuntimeSelectorContext();
-        return makeSelectorFn(runtimeContext);
-    }
-    /**
-     * @private
-     * @param {?} initialStateValue
-     * @return {?}
-     */
-    initStateStream(initialStateValue) {
-        /** @type {?} */
-        const value = this._stateStream.value;
-        /** @type {?} */
-        const storeIsEmpty = !value || Object.keys(value).length === 0;
-        if (storeIsEmpty) {
-            /** @type {?} */
-            const defaultStateNotEmpty = Object.keys(this._config.defaultsState).length > 0;
-            /** @type {?} */
-            const storeValues = defaultStateNotEmpty
-                ? Object.assign({}, this._config.defaultsState, initialStateValue) : initialStateValue;
-            this._stateStream.next(storeValues);
-        }
-    }
-}
-Store.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-Store.ctorParameters = () => [
-    { type: StateStream },
-    { type: InternalStateOperations },
-    { type: NgxsConfig },
-    { type: InternalNgxsExecutionStrategy },
-    { type: StateFactory },
-    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
-];
-if (false) {
-    /**
-     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
-     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
-     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
-     * @type {?}
-     * @private
-     */
-    Store.prototype._selectableStateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._stateStream;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._internalStateOperations;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._config;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._internalExecutionStrategy;
-    /**
-     * @type {?}
-     * @private
-     */
-    Store.prototype._stateFactory;
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"ng://@ngxs/store/","sources":["src/store.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:unified-signatures\r\nimport { Inject, Injectable, Optional, Type } from '@angular/core';\r\nimport { Observable, of, Subscription, throwError } from 'rxjs';\r\nimport {\r\n  catchError,\r\n  distinctUntilChanged,\r\n  map,\r\n  publishReplay,\r\n  refCount,\r\n  take\r\n} from 'rxjs/operators';\r\nimport { INITIAL_STATE_TOKEN, PlainObject } from '@ngxs/store/internals';\r\n\r\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\r\nimport { InternalStateOperations } from './internal/state-operations';\r\nimport { getRootSelectorFactory } from './utils/selector-utils';\r\nimport { StateStream } from './internal/state-stream';\r\nimport { leaveNgxs } from './operators/leave-ngxs';\r\nimport { NgxsConfig } from './symbols';\r\nimport { StateToken } from './state-token/state-token';\r\nimport { StateFactory } from './internal/state-factory';\r\n\r\n@Injectable()\r\nexport class Store {\r\n  /**\r\n   * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,\r\n   * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.\r\n   * All selects would use this stream, and it would call leave only once for any state change across all active selectors.\r\n   */\r\n  private _selectableStateStream = this._stateStream.pipe(\r\n    leaveNgxs(this._internalExecutionStrategy),\r\n    publishReplay(1),\r\n    refCount()\r\n  );\r\n\r\n  constructor(\r\n    private _stateStream: StateStream,\r\n    private _internalStateOperations: InternalStateOperations,\r\n    private _config: NgxsConfig,\r\n    private _internalExecutionStrategy: InternalNgxsExecutionStrategy,\r\n    private _stateFactory: StateFactory,\r\n    @Optional()\r\n    @Inject(INITIAL_STATE_TOKEN)\r\n    initialStateValue: any\r\n  ) {\r\n    this.initStateStream(initialStateValue);\r\n  }\r\n\r\n  /**\r\n   * Dispatches event(s).\r\n   */\r\n  dispatch(actionOrActions: any | any[]): Observable<any> {\r\n    return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);\r\n  }\r\n\r\n  /**\r\n   * Selects a slice of data from the store.\r\n   */\r\n  select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\r\n  select<T = any>(selector: string | Type<any>): Observable<T>;\r\n  select<T>(selector: StateToken<T>): Observable<T>;\r\n  select(selector: any): Observable<any> {\r\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\r\n    return this._selectableStateStream.pipe(\r\n      map(selectorFn),\r\n      catchError((err: Error): Observable<never> | Observable<undefined> => {\r\n        // if error is TypeError we swallow it to prevent usual errors with property access\r\n        const { suppressErrors } = this._config.selectorOptions;\r\n\r\n        if (err instanceof TypeError && suppressErrors) {\r\n          return of(undefined);\r\n        }\r\n\r\n        // rethrow other errors\r\n        return throwError(err);\r\n      }),\r\n      distinctUntilChanged(),\r\n      leaveNgxs(this._internalExecutionStrategy)\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Select one slice of data from the store.\r\n   */\r\n\r\n  selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\r\n  selectOnce<T = any>(selector: string | Type<any>): Observable<T>;\r\n  selectOnce<T>(selector: StateToken<T>): Observable<T>;\r\n  selectOnce(selector: any): Observable<any> {\r\n    return this.select(selector).pipe(take(1));\r\n  }\r\n\r\n  /**\r\n   * Select a snapshot from the state.\r\n   */\r\n  selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;\r\n  selectSnapshot<T = any>(selector: string | Type<any>): T;\r\n  selectSnapshot<T>(selector: StateToken<T>): T;\r\n  selectSnapshot(selector: any): any {\r\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\r\n    return selectorFn(this._stateStream.getValue());\r\n  }\r\n\r\n  /**\r\n   * Allow the user to subscribe to the root of the state\r\n   */\r\n  subscribe(fn?: (value: any) => void): Subscription {\r\n    return this._selectableStateStream\r\n      .pipe(leaveNgxs(this._internalExecutionStrategy))\r\n      .subscribe(fn);\r\n  }\r\n\r\n  /**\r\n   * Return the raw value of the state.\r\n   */\r\n  snapshot(): any {\r\n    return this._internalStateOperations.getRootStateOperations().getState();\r\n  }\r\n\r\n  /**\r\n   * Reset the state to a specific point in time. This method is useful\r\n   * for plugin's who need to modify the state directly or unit testing.\r\n   */\r\n  reset(state: any) {\r\n    return this._internalStateOperations.getRootStateOperations().setState(state);\r\n  }\r\n\r\n  private getStoreBoundSelectorFn(selector: any) {\r\n    const makeSelectorFn = getRootSelectorFactory(selector);\r\n    const runtimeContext = this._stateFactory.getRuntimeSelectorContext();\r\n    return makeSelectorFn(runtimeContext);\r\n  }\r\n\r\n  private initStateStream(initialStateValue: any): void {\r\n    const value: PlainObject = this._stateStream.value;\r\n    const storeIsEmpty: boolean = !value || Object.keys(value).length === 0;\r\n    if (storeIsEmpty) {\r\n      const defaultStateNotEmpty: boolean = Object.keys(this._config.defaultsState).length > 0;\r\n      const storeValues: PlainObject = defaultStateNotEmpty\r\n        ? { ...this._config.defaultsState, ...initialStateValue }\r\n        : initialStateValue;\r\n\r\n      this._stateStream.next(storeValues);\r\n    }\r\n  }\r\n}\r\n"]}
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+// tslint:disable:unified-signatures
+import { Inject, Injectable, Optional } from '@angular/core';
+import { of, throwError, queueScheduler } from 'rxjs';
+import { catchError, distinctUntilChanged, map, shareReplay, take, observeOn } from 'rxjs/operators';
+import { INITIAL_STATE_TOKEN } from '@ngxs/store/internals';
+import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+import { InternalStateOperations } from './internal/state-operations';
+import { getRootSelectorFactory } from './utils/selector-utils';
+import { StateStream } from './internal/state-stream';
+import { leaveNgxs } from './operators/leave-ngxs';
+import { NgxsConfig } from './symbols';
+import { StateFactory } from './internal/state-factory';
+export class Store {
+    /**
+     * @param {?} _stateStream
+     * @param {?} _internalStateOperations
+     * @param {?} _config
+     * @param {?} _internalExecutionStrategy
+     * @param {?} _stateFactory
+     * @param {?} initialStateValue
+     */
+    constructor(_stateStream, _internalStateOperations, _config, _internalExecutionStrategy, _stateFactory, initialStateValue) {
+        this._stateStream = _stateStream;
+        this._internalStateOperations = _internalStateOperations;
+        this._config = _config;
+        this._internalExecutionStrategy = _internalExecutionStrategy;
+        this._stateFactory = _stateFactory;
+        /**
+         * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+         * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+         * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+         */
+        this._selectableStateStream = this._stateStream.pipe(observeOn(queueScheduler), leaveNgxs(this._internalExecutionStrategy), shareReplay({ bufferSize: 1, refCount: true }));
+        this.initStateStream(initialStateValue);
+    }
+    /**
+     * Dispatches event(s).
+     * @param {?} actionOrActions
+     * @return {?}
+     */
+    dispatch(actionOrActions) {
+        return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);
+    }
+    /**
+     * @param {?} selector
+     * @return {?}
+     */
+    select(selector) {
+        /** @type {?} */
+        const selectorFn = this.getStoreBoundSelectorFn(selector);
+        return this._selectableStateStream.pipe(map(selectorFn), catchError((/**
+         * @param {?} err
+         * @return {?}
+         */
+        (err) => {
+            // if error is TypeError we swallow it to prevent usual errors with property access
+            const { suppressErrors } = this._config.selectorOptions;
+            if (err instanceof TypeError && suppressErrors) {
+                return of(undefined);
+            }
+            // rethrow other errors
+            return throwError(err);
+        })), distinctUntilChanged(), leaveNgxs(this._internalExecutionStrategy));
+    }
+    /**
+     * @param {?} selector
+     * @return {?}
+     */
+    selectOnce(selector) {
+        return this.select(selector).pipe(take(1));
+    }
+    /**
+     * @param {?} selector
+     * @return {?}
+     */
+    selectSnapshot(selector) {
+        /** @type {?} */
+        const selectorFn = this.getStoreBoundSelectorFn(selector);
+        return selectorFn(this._stateStream.getValue());
+    }
+    /**
+     * Allow the user to subscribe to the root of the state
+     * @param {?=} fn
+     * @return {?}
+     */
+    subscribe(fn) {
+        return this._selectableStateStream
+            .pipe(leaveNgxs(this._internalExecutionStrategy))
+            .subscribe(fn);
+    }
+    /**
+     * Return the raw value of the state.
+     * @return {?}
+     */
+    snapshot() {
+        return this._internalStateOperations.getRootStateOperations().getState();
+    }
+    /**
+     * Reset the state to a specific point in time. This method is useful
+     * for plugin's who need to modify the state directly or unit testing.
+     * @param {?} state
+     * @return {?}
+     */
+    reset(state) {
+        return this._internalStateOperations.getRootStateOperations().setState(state);
+    }
+    /**
+     * @private
+     * @param {?} selector
+     * @return {?}
+     */
+    getStoreBoundSelectorFn(selector) {
+        /** @type {?} */
+        const makeSelectorFn = getRootSelectorFactory(selector);
+        /** @type {?} */
+        const runtimeContext = this._stateFactory.getRuntimeSelectorContext();
+        return makeSelectorFn(runtimeContext);
+    }
+    /**
+     * @private
+     * @param {?} initialStateValue
+     * @return {?}
+     */
+    initStateStream(initialStateValue) {
+        /** @type {?} */
+        const value = this._stateStream.value;
+        /** @type {?} */
+        const storeIsEmpty = !value || Object.keys(value).length === 0;
+        if (storeIsEmpty) {
+            /** @type {?} */
+            const defaultStateNotEmpty = Object.keys(this._config.defaultsState).length > 0;
+            /** @type {?} */
+            const storeValues = defaultStateNotEmpty
+                ? Object.assign({}, this._config.defaultsState, initialStateValue) : initialStateValue;
+            this._stateStream.next(storeValues);
+        }
+    }
+}
+Store.decorators = [
+    { type: Injectable }
+];
+/** @nocollapse */
+Store.ctorParameters = () => [
+    { type: StateStream },
+    { type: InternalStateOperations },
+    { type: NgxsConfig },
+    { type: InternalNgxsExecutionStrategy },
+    { type: StateFactory },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [INITIAL_STATE_TOKEN,] }] }
+];
+if (false) {
+    /**
+     * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,
+     * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.
+     * All selects would use this stream, and it would call leave only once for any state change across all active selectors.
+     * @type {?}
+     * @private
+     */
+    Store.prototype._selectableStateStream;
+    /**
+     * @type {?}
+     * @private
+     */
+    Store.prototype._stateStream;
+    /**
+     * @type {?}
+     * @private
+     */
+    Store.prototype._internalStateOperations;
+    /**
+     * @type {?}
+     * @private
+     */
+    Store.prototype._config;
+    /**
+     * @type {?}
+     * @private
+     */
+    Store.prototype._internalExecutionStrategy;
+    /**
+     * @type {?}
+     * @private
+     */
+    Store.prototype._stateFactory;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store.js","sourceRoot":"ng://@ngxs/store/","sources":["src/store.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:unified-signatures\nimport { Inject, Injectable, Optional, Type } from '@angular/core';\nimport { Observable, of, Subscription, throwError, queueScheduler } from 'rxjs';\nimport {\n  catchError,\n  distinctUntilChanged,\n  map,\n  shareReplay,\n  take,\n  observeOn\n} from 'rxjs/operators';\nimport { INITIAL_STATE_TOKEN, PlainObject } from '@ngxs/store/internals';\n\nimport { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';\nimport { InternalStateOperations } from './internal/state-operations';\nimport { getRootSelectorFactory } from './utils/selector-utils';\nimport { StateStream } from './internal/state-stream';\nimport { leaveNgxs } from './operators/leave-ngxs';\nimport { NgxsConfig } from './symbols';\nimport { StateToken } from './state-token/state-token';\nimport { StateFactory } from './internal/state-factory';\n\n@Injectable()\nexport class Store {\n  /**\n   * This is a derived state stream that leaves NGXS execution strategy to emit state changes within the Angular zone,\n   * because state is being changed actually within the `<root>` zone, see `InternalDispatcher#dispatchSingle`.\n   * All selects would use this stream, and it would call leave only once for any state change across all active selectors.\n   */\n  private _selectableStateStream = this._stateStream.pipe(\n    observeOn(queueScheduler),\n    leaveNgxs(this._internalExecutionStrategy),\n    shareReplay({ bufferSize: 1, refCount: true })\n  );\n\n  constructor(\n    private _stateStream: StateStream,\n    private _internalStateOperations: InternalStateOperations,\n    private _config: NgxsConfig,\n    private _internalExecutionStrategy: InternalNgxsExecutionStrategy,\n    private _stateFactory: StateFactory,\n    @Optional()\n    @Inject(INITIAL_STATE_TOKEN)\n    initialStateValue: any\n  ) {\n    this.initStateStream(initialStateValue);\n  }\n\n  /**\n   * Dispatches event(s).\n   */\n  dispatch(actionOrActions: any | any[]): Observable<any> {\n    return this._internalStateOperations.getRootStateOperations().dispatch(actionOrActions);\n  }\n\n  /**\n   * Selects a slice of data from the store.\n   */\n  select<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  select<T = any>(selector: string | Type<any>): Observable<T>;\n  select<T>(selector: StateToken<T>): Observable<T>;\n  select(selector: any): Observable<any> {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return this._selectableStateStream.pipe(\n      map(selectorFn),\n      catchError((err: Error): Observable<never> | Observable<undefined> => {\n        // if error is TypeError we swallow it to prevent usual errors with property access\n        const { suppressErrors } = this._config.selectorOptions;\n\n        if (err instanceof TypeError && suppressErrors) {\n          return of(undefined);\n        }\n\n        // rethrow other errors\n        return throwError(err);\n      }),\n      distinctUntilChanged(),\n      leaveNgxs(this._internalExecutionStrategy)\n    );\n  }\n\n  /**\n   * Select one slice of data from the store.\n   */\n\n  selectOnce<T>(selector: (state: any, ...states: any[]) => T): Observable<T>;\n  selectOnce<T = any>(selector: string | Type<any>): Observable<T>;\n  selectOnce<T>(selector: StateToken<T>): Observable<T>;\n  selectOnce(selector: any): Observable<any> {\n    return this.select(selector).pipe(take(1));\n  }\n\n  /**\n   * Select a snapshot from the state.\n   */\n  selectSnapshot<T>(selector: (state: any, ...states: any[]) => T): T;\n  selectSnapshot<T = any>(selector: string | Type<any>): T;\n  selectSnapshot<T>(selector: StateToken<T>): T;\n  selectSnapshot(selector: any): any {\n    const selectorFn = this.getStoreBoundSelectorFn(selector);\n    return selectorFn(this._stateStream.getValue());\n  }\n\n  /**\n   * Allow the user to subscribe to the root of the state\n   */\n  subscribe(fn?: (value: any) => void): Subscription {\n    return this._selectableStateStream\n      .pipe(leaveNgxs(this._internalExecutionStrategy))\n      .subscribe(fn);\n  }\n\n  /**\n   * Return the raw value of the state.\n   */\n  snapshot(): any {\n    return this._internalStateOperations.getRootStateOperations().getState();\n  }\n\n  /**\n   * Reset the state to a specific point in time. This method is useful\n   * for plugin's who need to modify the state directly or unit testing.\n   */\n  reset(state: any) {\n    return this._internalStateOperations.getRootStateOperations().setState(state);\n  }\n\n  private getStoreBoundSelectorFn(selector: any) {\n    const makeSelectorFn = getRootSelectorFactory(selector);\n    const runtimeContext = this._stateFactory.getRuntimeSelectorContext();\n    return makeSelectorFn(runtimeContext);\n  }\n\n  private initStateStream(initialStateValue: any): void {\n    const value: PlainObject = this._stateStream.value;\n    const storeIsEmpty: boolean = !value || Object.keys(value).length === 0;\n    if (storeIsEmpty) {\n      const defaultStateNotEmpty: boolean = Object.keys(this._config.defaultsState).length > 0;\n      const storeValues: PlainObject = defaultStateNotEmpty\n        ? { ...this._config.defaultsState, ...initialStateValue }\n        : initialStateValue;\n\n      this._stateStream.next(storeValues);\n    }\n  }\n}\n"]}