ng-simple-state 15.1.3 → 16.0.1

package/README.md

@@ -477,6 +477,85 @@ export class AppComponent {
 }
 ```
 
+
+## NgSimpleStateBaseStore API
+
+```ts
+@Injectable()
+@Directive()
+export abstract class NgSimpleStateBaseStore<S extends object | Array<any>> implements OnDestroy {
+
+    /**
+     * Return the observable of the state
+     * @returns Observable of the state
+     */
+    public get state(): BehaviorSubject<S>;
+
+    constructor(@Inject(Injector) injector: Injector);
+
+    /**
+     * When you override this method, you have to call the `super.ngOnDestroy()` method in your `ngOnDestroy()` method.
+     */
+    ngOnDestroy(): void;
+
+    /**
+     * Reset store to first loaded store state:
+     *  - the last saved state, if `enableLocalStorage` config is `true`
+     *  - otherwise the initial state provided from `initialState()` method.
+     */
+    resetState(): boolean;
+
+    /**
+     * Restart the store to initial state provided from `initialState()` method
+     */
+    restartState(): boolean;
+
+    /**
+     * Override this method for set a specific config for the store
+     * @returns NgSimpleStateStoreConfig
+     */
+    storeConfig(): NgSimpleStateStoreConfig;
+
+    /**
+     * Set into the store the initial state
+     * @param injector current Injector
+     * @returns The state object
+     */
+    initialState(injector?: Injector): S;
+
+    /**
+     * Select a store state
+     * @param selectFn State selector (if not provided return full state)
+     * @param comparator A function used to compare the previous and current state for equality. Defaults to a `===` check.
+     * @returns Observable of the selected state
+     */
+    selectState<K>(selectFn?: (state: Readonly<S>) => K, comparator?: (previous: K, current: K) => boolean): Observable<K>;
+
+    /**
+     * Return the current store state (snapshot)
+     * @returns The current state
+     */
+    getCurrentState(): Readonly<S>;
+
+    /**
+     * Return the first loaded store state:
+     * the last saved state, if `enableLocalStorage` config is `true`;
+     * otherwise the initial state provided from `initialState()` method.
+     * @returns The first state
+     */
+    getFirstState(): Readonly<S> | null;
+
+    /**
+     * Set a new state
+     * @param selectFn State reducer
+     * @param actionName The action label into Redux DevTools (default is parent function name)
+     * @returns True if the state is changed
+     */
+    setState(stateFn: (currentState: Readonly<S>) => Partial<S>, actionName?: string): boolean; 
+}
+```
+
+
 ## Alternatives
 
 Aren't you satisfied? there are some valid alternatives:

package/esm2022/lib/ng-simple-state-base-store.mjs

@@ -0,0 +1,191 @@
+import { Inject, Injectable, Injector, Directive, isDevMode } from '@angular/core';
+import { BehaviorSubject, asyncScheduler } from 'rxjs';
+import { map, distinctUntilChanged, observeOn } from 'rxjs/operators';
+import { NgSimpleStateDevTool } from './ng-simple-state-dev-tool';
+import { NgSimpleStateLocalStorage } from './ng-simple-state-local-storage';
+import { NG_SIMPLE_STORE_CONFIG } from './ng-simple-state-models';
+import { NgSimpleStateSessionStorage } from './ng-simple-state-session-storage';
+import * as i0 from "@angular/core";
+class NgSimpleStateBaseStore {
+    /**
+     * Return the observable of the state
+     * @returns Observable of the state
+     */
+    get state() {
+        return this.state$;
+    }
+    constructor(injector) {
+        this.devMode = isDevMode();
+        const globalConfig = injector.get(NG_SIMPLE_STORE_CONFIG, {});
+        const storeConfig = this.storeConfig() || {};
+        this.localStoreConfig = { ...globalConfig, ...storeConfig };
+        this.localStorageIsEnabled = typeof this.localStoreConfig.enableLocalStorage === 'boolean' ? this.localStoreConfig.enableLocalStorage : false;
+        if (this.localStorageIsEnabled) {
+            if (this.localStoreConfig.persistentStorage === 'local') {
+                this.persistentStorage = injector.get(NgSimpleStateLocalStorage);
+            }
+            else if (this.localStoreConfig.persistentStorage === 'session') {
+                this.persistentStorage = injector.get(NgSimpleStateSessionStorage);
+            }
+        }
+        this.devToolIsEnabled = typeof this.localStoreConfig.enableDevTool === 'boolean' ? this.localStoreConfig.enableDevTool : false;
+        if (this.devToolIsEnabled) {
+            this.devTool = injector.get(NgSimpleStateDevTool);
+        }
+        this.storeName = typeof this.localStoreConfig.storeName === 'string' ? this.localStoreConfig.storeName : this.constructor.name;
+        if (typeof this.localStoreConfig.comparator === 'function') {
+            this.comparator = this.localStoreConfig.comparator;
+        }
+        if (this.localStorageIsEnabled && this.persistentStorage) {
+            const firstState = this.persistentStorage.getItem(this.storeName);
+            if (firstState) {
+                this.firstState = firstState;
+            }
+        }
+        if (!this.firstState) {
+            this.firstState = this.initialState(injector);
+        }
+        this.devToolSend(this.firstState, `initialState`);
+        this.isArray = Array.isArray(this.firstState);
+        this.state$ = new BehaviorSubject(Object.assign(this.isArray ? [] : {}, this.firstState));
+    }
+    /**
+     * When you override this method, you have to call the `super.ngOnDestroy()` method in your `ngOnDestroy()` method.
+     */
+    ngOnDestroy() {
+        this.devToolSend(undefined, 'ngOnDestroy');
+        this.state$.complete();
+    }
+    /**
+     * Reset store to first loaded store state:
+     *  - the last saved state, if `enableLocalStorage` config is `true`
+     *  - otherwise the initial state provided from `initialState()` method.
+     */
+    resetState() {
+        return this.setState(() => this.firstState, 'resetState');
+    }
+    /**
+     * Restart the store to initial state provided from `initialState()` method
+     */
+    restartState() {
+        return this.setState(() => this.initialState(), 'restartState');
+    }
+    /**
+     * Select a store state
+     * @param selectFn State selector (if not provided return full state)
+     * @param comparator A function used to compare the previous and current state for equality. Defaults to a `===` check.
+     * @returns Observable of the selected state
+     */
+    selectState(selectFn, comparator) {
+        if (!selectFn) {
+            selectFn = (tmpState) => Object.assign(this.isArray ? [] : {}, tmpState);
+        }
+        if (!comparator && this.comparator) {
+            comparator = this.comparator;
+        }
+        return this.state$.pipe(map(state => selectFn(state)), distinctUntilChanged(comparator), observeOn(asyncScheduler));
+    }
+    /**
+     * Return the current store state (snapshot)
+     * @returns The current state
+     */
+    getCurrentState() {
+        return this.deepFreeze(this.state$.getValue());
+    }
+    /**
+     * Return the first loaded store state:
+     * the last saved state, if `enableLocalStorage` config is `true`;
+     * otherwise the initial state provided from `initialState()` method.
+     * @returns The first state
+     */
+    getFirstState() {
+        return this.deepFreeze(this.firstState);
+    }
+    /**
+     * Set a new state
+     * @param selectFn State reducer
+     * @param actionName The action label into Redux DevTools (default is parent function name)
+     * @returns True if the state is changed
+     */
+    setState(stateFn, actionName) {
+        const currState = this.getCurrentState();
+        const newState = stateFn(currState);
+        if (currState === newState) {
+            return false;
+        }
+        let state;
+        if (this.isArray) {
+            state = Object.assign([], newState);
+        }
+        else {
+            state = Object.assign({}, currState, newState);
+        }
+        this.state$.next(state);
+        this.devToolSend(state, actionName);
+        if (this.localStorageIsEnabled && this.persistentStorage) {
+            this.persistentStorage.setItem(this.storeName, state);
+        }
+        return true;
+    }
+    /**
+     * Send to dev tool a new state
+     * @param newState new state
+     * @param actionName The action name
+     * @returns True if fìdev tools are enabled
+     */
+    devToolSend(newState, actionName) {
+        if (!this.devToolIsEnabled || !this.devTool) {
+            return false;
+        }
+        if (!actionName) {
+            // retrive the parent (of parent) method into the stack trace
+            actionName = new Error().stack
+                ?.split('\n')[3]
+                .trim()
+                .split(' ')[1]
+                .split('.')[1] || 'unknown';
+        }
+        if (!this.devTool.send(this.storeName, actionName, newState)) {
+            console.log(this.storeName + '.' + actionName, newState);
+        }
+        return true;
+    }
+    /**
+     * Recursively Object.freeze simple Javascript structures consisting of plain objects, arrays, and primitives.
+     * Make the data immutable.
+     * @returns immutable object
+     */
+    deepFreeze(object) {
+        // No freezing in production (for better performance).
+        if (!this.devMode || !object) {
+            return object;
+        }
+        // When already frozen, we assume its children are frozen (for better performance).
+        // This should be true if you always use `deepFreeze` to freeze objects.
+        //
+        // Note that Object.isFrozen will also return `true` for primitives (numbers,
+        // strings, booleans, undefined, null), so there is no need to check for
+        // those explicitly.
+        if (Object.isFrozen(object)) {
+            return object;
+        }
+        // At this point we know that we're dealing with either an array or plain object, so
+        // just freeze it and recurse on its values.
+        Object.freeze(object);
+        Object.keys(object).forEach(key => this.deepFreeze(object[key]));
+        return object;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateBaseStore, deps: [{ token: Injector }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: NgSimpleStateBaseStore, ngImport: i0 }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateBaseStore }); }
+}
+export { NgSimpleStateBaseStore };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateBaseStore, decorators: [{
+            type: Injectable
+        }, {
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [Injector]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ng-simple-state-base-store.js","sourceRoot":"","sources":["../../../../projects/ng-simple-state/src/lib/ng-simple-state-base-store.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Injector, OnDestroy, Directive, isDevMode } from '@angular/core';\r\nimport { BehaviorSubject, Observable, asyncScheduler } from 'rxjs';\r\nimport { map, distinctUntilChanged, observeOn } from 'rxjs/operators';\r\nimport { NgSimpleStateBrowserStorage } from './ng-simple-state-browser-storage';\r\nimport { NgSimpleStateDevTool } from './ng-simple-state-dev-tool';\r\nimport { NgSimpleStateLocalStorage } from './ng-simple-state-local-storage';\r\nimport { NgSimpleStateStoreConfig, NG_SIMPLE_STORE_CONFIG } from './ng-simple-state-models';\r\nimport { NgSimpleStateSessionStorage } from './ng-simple-state-session-storage';\r\n\r\n@Injectable()\r\n@Directive()\r\nexport abstract class NgSimpleStateBaseStore<S extends object | Array<any>> implements OnDestroy {\r\n\r\n    private state$: BehaviorSubject<S>;\r\n    private localStorageIsEnabled: boolean;\r\n    private devToolIsEnabled: boolean;\r\n    private devTool!: NgSimpleStateDevTool;\r\n    private persistentStorage!: NgSimpleStateBrowserStorage;\r\n    private localStoreConfig: NgSimpleStateStoreConfig;\r\n    private storeName: string;\r\n    private firstState!: S;\r\n    private isArray: boolean;\r\n    private devMode: boolean = isDevMode();\r\n    private comparator!: <K>(previous: K, current: K) => boolean;\r\n\r\n    /**\r\n     * Return the observable of the state\r\n     * @returns Observable of the state\r\n     */\r\n    public get state(): BehaviorSubject<S> {\r\n        return this.state$;\r\n    }\r\n\r\n    constructor(@Inject(Injector) injector: Injector) {\r\n\r\n        const globalConfig = injector.get(NG_SIMPLE_STORE_CONFIG, {});\r\n        const storeConfig = this.storeConfig() || {};\r\n        this.localStoreConfig = { ...globalConfig, ...storeConfig };\r\n\r\n        this.localStorageIsEnabled = typeof this.localStoreConfig.enableLocalStorage === 'boolean' ? this.localStoreConfig.enableLocalStorage : false;\r\n\r\n        if (this.localStorageIsEnabled) {\r\n            if (this.localStoreConfig.persistentStorage === 'local') {\r\n                this.persistentStorage = injector.get(NgSimpleStateLocalStorage);\r\n            } else if (this.localStoreConfig.persistentStorage === 'session') {\r\n                this.persistentStorage = injector.get(NgSimpleStateSessionStorage);\r\n            }\r\n        }\r\n\r\n        this.devToolIsEnabled = typeof this.localStoreConfig.enableDevTool === 'boolean' ? this.localStoreConfig.enableDevTool : false;\r\n        if (this.devToolIsEnabled) {\r\n            this.devTool = injector.get(NgSimpleStateDevTool);\r\n        }\r\n\r\n        this.storeName = typeof this.localStoreConfig.storeName === 'string' ? this.localStoreConfig.storeName : this.constructor.name;\r\n        if (typeof this.localStoreConfig.comparator === 'function') {\r\n            this.comparator = this.localStoreConfig.comparator;\r\n        }\r\n\r\n        if (this.localStorageIsEnabled && this.persistentStorage) {\r\n            const firstState = this.persistentStorage.getItem<S>(this.storeName);\r\n            if (firstState) {\r\n                this.firstState = firstState;\r\n            }\r\n        }\r\n        if (!this.firstState) {\r\n            this.firstState = this.initialState(injector);\r\n        }\r\n\r\n        this.devToolSend(this.firstState, `initialState`);\r\n\r\n        this.isArray = Array.isArray(this.firstState);\r\n        this.state$ = new BehaviorSubject<S>(Object.assign(this.isArray ? [] : {}, this.firstState));\r\n    }\r\n\r\n    /**\r\n     * When you override this method, you have to call the `super.ngOnDestroy()` method in your `ngOnDestroy()` method.\r\n     */\r\n    ngOnDestroy(): void {\r\n        this.devToolSend(undefined, 'ngOnDestroy');\r\n        this.state$.complete();\r\n    }\r\n\r\n    /**\r\n     * Reset store to first loaded store state:\r\n     *  - the last saved state, if `enableLocalStorage` config is `true`\r\n     *  - otherwise the initial state provided from `initialState()` method.\r\n     */\r\n    resetState(): boolean {\r\n        return this.setState(() => this.firstState, 'resetState');\r\n    }\r\n\r\n    /**\r\n     * Restart the store to initial state provided from `initialState()` method\r\n     */\r\n    restartState(): boolean {\r\n        return this.setState(() => this.initialState(), 'restartState');\r\n    }\r\n\r\n    /**\r\n     * Override this method for set a specific config for the store\r\n     * @returns NgSimpleStateStoreConfig\r\n     */\r\n    protected abstract storeConfig(): NgSimpleStateStoreConfig;\r\n\r\n    /**\r\n     * Set into the store the initial state\r\n     * @param injector current Injector\r\n     * @returns The state object\r\n     */\r\n    protected abstract initialState(injector?: Injector): S;\r\n\r\n    /**\r\n     * Select a store state\r\n     * @param selectFn State selector (if not provided return full state)\r\n     * @param comparator A function used to compare the previous and current state for equality. Defaults to a `===` check.\r\n     * @returns Observable of the selected state\r\n     */\r\n    selectState<K>(selectFn?: (state: Readonly<S>) => K, comparator?: (previous: K, current: K) => boolean): Observable<K> {\r\n        if (!selectFn) {\r\n            selectFn = (tmpState: Readonly<S>) => Object.assign(this.isArray ? [] : {}, tmpState) as K;\r\n        }\r\n        if (!comparator && this.comparator) {\r\n            comparator = this.comparator;\r\n        }\r\n        return this.state$.pipe(\r\n            map(state => (selectFn as (state: Readonly<S>) => K)(state as Readonly<S>)),\r\n            distinctUntilChanged(comparator),\r\n            observeOn(asyncScheduler)\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Return the current store state (snapshot)\r\n     * @returns The current state\r\n     */\r\n    getCurrentState(): Readonly<S> {\r\n        return this.deepFreeze(this.state$.getValue());\r\n    }\r\n\r\n    /**\r\n     * Return the first loaded store state:\r\n     * the last saved state, if `enableLocalStorage` config is `true`;\r\n     * otherwise the initial state provided from `initialState()` method.\r\n     * @returns The first state\r\n     */\r\n    getFirstState(): Readonly<S> | null {\r\n        return this.deepFreeze(this.firstState);\r\n    }\r\n\r\n    /**\r\n     * Set a new state\r\n     * @param selectFn State reducer\r\n     * @param actionName The action label into Redux DevTools (default is parent function name)\r\n     * @returns True if the state is changed\r\n     */\r\n    setState(stateFn: (currentState: Readonly<S>) => Partial<S>, actionName?: string): boolean {\r\n        const currState = this.getCurrentState();\r\n        const newState = stateFn(currState);\r\n        if (currState === newState) {\r\n            return false;\r\n        }\r\n        let state: S;\r\n        if (this.isArray) {\r\n            state = Object.assign([] as S, newState);\r\n        } else {\r\n            state = Object.assign({}, currState, newState);\r\n        }\r\n        this.state$.next(state);\r\n        this.devToolSend(state, actionName);\r\n        if (this.localStorageIsEnabled && this.persistentStorage) {\r\n            this.persistentStorage.setItem<S>(this.storeName, state);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Send to dev tool a new state\r\n     * @param newState new state\r\n     * @param actionName The action name\r\n     * @returns True if fìdev tools are enabled\r\n     */\r\n    private devToolSend(newState: S | undefined, actionName?: string): boolean {\r\n        if (!this.devToolIsEnabled || !this.devTool) {\r\n            return false;\r\n        }\r\n        if (!actionName) {\r\n            // retrive the parent (of parent) method into the stack trace\r\n            actionName = new Error().stack\r\n                ?.split('\\n')[3]\r\n                .trim()\r\n                .split(' ')[1]\r\n                .split('.')[1] || 'unknown';\r\n        }\r\n        if (!this.devTool.send(this.storeName, actionName, newState)) {\r\n            console.log(this.storeName + '.' + actionName, newState);\r\n        }\r\n        return true;\r\n    }\r\n\r\n    /**\r\n     * Recursively Object.freeze simple Javascript structures consisting of plain objects, arrays, and primitives.\r\n     * Make the data immutable.\r\n     * @returns immutable object\r\n     */\r\n    private deepFreeze(object: S): Readonly<S> {\r\n        // No freezing in production (for better performance).\r\n        if (!this.devMode || !object) {\r\n            return object as Readonly<S>;\r\n        }\r\n\r\n        // When already frozen, we assume its children are frozen (for better performance).\r\n        // This should be true if you always use `deepFreeze` to freeze objects.\r\n        //\r\n        // Note that Object.isFrozen will also return `true` for primitives (numbers,\r\n        // strings, booleans, undefined, null), so there is no need to check for\r\n        // those explicitly.\r\n        if (Object.isFrozen(object)) {\r\n            return object as Readonly<S>;\r\n        }\r\n\r\n        // At this point we know that we're dealing with either an array or plain object, so\r\n        // just freeze it and recurse on its values.\r\n        Object.freeze(object);\r\n        Object.keys(object).forEach(key => this.deepFreeze((object as any)[key]));\r\n\r\n        return object as Readonly<S>;\r\n    }\r\n}\r\n"]}

package/esm2022/lib/ng-simple-state-browser-storage.mjs

@@ -0,0 +1,71 @@
+export const BASE_KEY = 'NgSimpleState::';
+export class NgSimpleStateBrowserStorage {
+    constructor(storage) {
+        this.storage = storage;
+        this.isStorageActive = false;
+        this.isStorageActive = !!storage;
+    }
+    /**
+     * Return true if storage is active
+     * @returns True if storage is active
+     */
+    isActive() {
+        return this.isStorageActive;
+    }
+    /**
+     * Set item into storage
+     * @param key key name
+     * @param state state valie
+     * @returns True if item is stored into storage
+     */
+    setItem(key, state) {
+        if (this.isStorageActive) {
+            this.storage.setItem(BASE_KEY + key, JSON.stringify(state));
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Return item from storage
+     * @param key key name
+     * @returns the item
+     */
+    getItem(key) {
+        if (this.isStorageActive) {
+            const state = this.storage.getItem(BASE_KEY + key);
+            if (state) {
+                return JSON.parse(state);
+            }
+        }
+        return null;
+    }
+    /**
+     * Remove item from storage
+     * @param key key name
+     * @returns True if item is removed
+     */
+    removeItem(key) {
+        if (this.isStorageActive) {
+            this.storage.removeItem(BASE_KEY + key);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Removes all key/value pairs, if there are any.
+     * @returns True if storage is cleared
+     */
+    clear() {
+        if (this.isStorageActive) {
+            for (let i = 0, e = this.storage.length; i < e; i++) {
+                const key = this.storage.key(i);
+                if (key && key.startsWith(BASE_KEY)) {
+                    this.storage.removeItem(key);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ng-simple-state-dev-tool.mjs

@@ -0,0 +1,55 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class NgSimpleStateDevTool {
+    constructor(ngZone) {
+        this.globalDevtools = window.__REDUX_DEVTOOLS_EXTENSION__ || window.devToolsExtension;
+        this.isActiveDevtool = false;
+        this.instanceId = `ng-simple-state-${Date.now()}`;
+        this.baseState = {};
+        if (this.globalDevtools) {
+            // The `connect` method adds `message` event listener since it communicates
+            // with an extension through `window.postMessage` and message events.
+            // We handle only 2 events; thus, we don't want to run many change detections
+            // because the extension sends events that we don't have to handle.
+            ngZone.runOutsideAngular(() => {
+                this.localDevTool = this.globalDevtools.connect({
+                    name: 'NgSimpleState',
+                    instanceId: this.instanceId
+                });
+                this.isActiveDevtool = !!this.localDevTool;
+                if (this.isActiveDevtool) {
+                    this.localDevTool.init(this.baseState);
+                }
+            });
+        }
+    }
+    /**
+     * Return true if dev tool is actvice
+     * @returns True if dev tool is actvice
+     */
+    isActive() {
+        return this.isActiveDevtool;
+    }
+    /**
+     * Send to dev tool a new state
+     * @param storeName The store name
+     * @param actionName The action name
+     * @param state the state
+     * @returns True if dev tool is enabled and action is send
+     */
+    send(storeName, actionName, state) {
+        if (this.isActiveDevtool && this.localDevTool) {
+            this.localDevTool.send(`${storeName}.${actionName}`, Object.assign(this.baseState, { [storeName]: state }), false, this.instanceId);
+            return true;
+        }
+        return false;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateDevTool, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateDevTool, providedIn: 'root' }); }
+}
+export { NgSimpleStateDevTool };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateDevTool, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/ng-simple-state-local-storage.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { NgSimpleStateBrowserStorage } from './ng-simple-state-browser-storage';
+import * as i0 from "@angular/core";
+class NgSimpleStateLocalStorage extends NgSimpleStateBrowserStorage {
+    constructor() {
+        super(localStorage);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateLocalStorage, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateLocalStorage, providedIn: 'root' }); }
+}
+export { NgSimpleStateLocalStorage };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateLocalStorage, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctc2ltcGxlLXN0YXRlLWxvY2FsLXN0b3JhZ2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9uZy1zaW1wbGUtc3RhdGUvc3JjL2xpYi9uZy1zaW1wbGUtc3RhdGUtbG9jYWwtc3RvcmFnZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSwyQkFBMkIsRUFBRSxNQUFNLG1DQUFtQyxDQUFDOztBQUVoRixNQUNhLHlCQUEwQixTQUFRLDJCQUEyQjtJQUN0RTtRQUNJLEtBQUssQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUN4QixDQUFDOzhHQUhRLHlCQUF5QjtrSEFBekIseUJBQXlCLGNBRFosTUFBTTs7U0FDbkIseUJBQXlCOzJGQUF6Qix5QkFBeUI7a0JBRHJDLFVBQVU7bUJBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBOZ1NpbXBsZVN0YXRlQnJvd3NlclN0b3JhZ2UgfSBmcm9tICcuL25nLXNpbXBsZS1zdGF0ZS1icm93c2VyLXN0b3JhZ2UnO1xyXG5cclxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcclxuZXhwb3J0IGNsYXNzIE5nU2ltcGxlU3RhdGVMb2NhbFN0b3JhZ2UgZXh0ZW5kcyBOZ1NpbXBsZVN0YXRlQnJvd3NlclN0b3JhZ2Uge1xyXG4gICAgY29uc3RydWN0b3IoKSB7XHJcbiAgICAgICAgc3VwZXIobG9jYWxTdG9yYWdlKTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2022/lib/ng-simple-state-models.mjs

@@ -0,0 +1,6 @@
+import { InjectionToken } from '@angular/core';
+/**
+ * NgSimpleState config InjectionToken
+ */
+export const NG_SIMPLE_STORE_CONFIG = new InjectionToken('ng-simple-state.config');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctc2ltcGxlLXN0YXRlLW1vZGVscy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXNpbXBsZS1zdGF0ZS9zcmMvbGliL25nLXNpbXBsZS1zdGF0ZS1tb2RlbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQWtDL0M7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxzQkFBc0IsR0FBRyxJQUFJLGNBQWMsQ0FDcEQsd0JBQXdCLENBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuLyoqXHJcbiAqIE5nU2ltcGxlU3RhdGUgY29uZmlnIG9wdGlvblxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBOZ1NpbXBsZVN0YXRlQ29uZmlnIHtcclxuICAgIC8qKlxyXG4gICAgICogaWYgYHRydWVgIGVuYWJsZSBgUmVkdXggRGV2VG9vbHNgIGJyb3dzZXIgZXh0ZW5zaW9uIGZvciBpbnNwZWN0IHRoZSBzdGF0ZSBvZiB0aGUgc3RvcmUuXHJcbiAgICAgKi9cclxuICAgIGVuYWJsZURldlRvb2w/OiBib29sZWFuO1xyXG4gICAgLyoqXHJcbiAgICAgKiBpZiBgdHJ1ZWAgbGF0ZXN0IHN0YXRlIG9mIHN0b3JlIGlzIHNhdmVkIGluIGxvY2FsIHN0b3JhZ2UgYW5kIHJlbG9hZGVkIG9uIHN0b3JlIGluaXRpYWxpemF0aW9uLlxyXG4gICAgICovXHJcbiAgICBlbmFibGVMb2NhbFN0b3JhZ2U/OiBib29sZWFuO1xyXG4gICAgLyoqXHJcbiAgICAgKiBTZXQgdGhlIHBlcnNpc3RlbnQgc3RvcmFnZSBgbG9jYWxgIG9yIGBzZXNzaW9uYC5cclxuICAgICAqL1xyXG4gICAgcGVyc2lzdGVudFN0b3JhZ2U/OiAnc2Vzc2lvbicgfCAnbG9jYWwnO1xyXG4gICAgLyoqXHJcbiAgICAgKiBBIGZ1bmN0aW9uIHVzZWQgdG8gY29tcGFyZSB0aGUgcHJldmlvdXMgYW5kIGN1cnJlbnQgc3RhdGUgZm9yIGVxdWFsaXR5LiBcclxuICAgICAqL1xyXG4gICAgY29tcGFyYXRvcj86IDxLPihwcmV2aW91czogSywgY3VycmVudDogSykgPT4gYm9vbGVhbjtcclxufVxyXG5cclxuLyoqXHJcbiAqIE5nU2ltcGxlU3RhdGUgY29uZmlnIG9wdGlvbiBmb3Igc3RvcmVcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgTmdTaW1wbGVTdGF0ZVN0b3JlQ29uZmlnIGV4dGVuZHMgTmdTaW1wbGVTdGF0ZUNvbmZpZyB7XHJcbiAgICAvKiogXHJcbiAgICAgKiBUaGUgc3RvcmUgbmFtZSBcclxuICAgICAqL1xyXG4gICAgc3RvcmVOYW1lOiBzdHJpbmc7XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBOZ1NpbXBsZVN0YXRlIGNvbmZpZyBJbmplY3Rpb25Ub2tlblxyXG4gKi9cclxuZXhwb3J0IGNvbnN0IE5HX1NJTVBMRV9TVE9SRV9DT05GSUcgPSBuZXcgSW5qZWN0aW9uVG9rZW48TmdTaW1wbGVTdGF0ZUNvbmZpZz4oXHJcbiAgICAnbmctc2ltcGxlLXN0YXRlLmNvbmZpZydcclxuKTtcclxuIl19

package/esm2022/lib/ng-simple-state-session-storage.mjs

@@ -0,0 +1,16 @@
+import { Injectable } from '@angular/core';
+import { NgSimpleStateBrowserStorage } from './ng-simple-state-browser-storage';
+import * as i0 from "@angular/core";
+class NgSimpleStateSessionStorage extends NgSimpleStateBrowserStorage {
+    constructor() {
+        super(sessionStorage);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateSessionStorage, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateSessionStorage, providedIn: 'root' }); }
+}
+export { NgSimpleStateSessionStorage };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateSessionStorage, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctc2ltcGxlLXN0YXRlLXNlc3Npb24tc3RvcmFnZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXNpbXBsZS1zdGF0ZS9zcmMvbGliL25nLXNpbXBsZS1zdGF0ZS1zZXNzaW9uLXN0b3JhZ2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMzQyxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSxtQ0FBbUMsQ0FBQzs7QUFFaEYsTUFDYSwyQkFBNEIsU0FBUSwyQkFBMkI7SUFDeEU7UUFDSSxLQUFLLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDMUIsQ0FBQzs4R0FIUSwyQkFBMkI7a0hBQTNCLDJCQUEyQixjQURkLE1BQU07O1NBQ25CLDJCQUEyQjsyRkFBM0IsMkJBQTJCO2tCQUR2QyxVQUFVO21CQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTmdTaW1wbGVTdGF0ZUJyb3dzZXJTdG9yYWdlIH0gZnJvbSAnLi9uZy1zaW1wbGUtc3RhdGUtYnJvd3Nlci1zdG9yYWdlJztcclxuXHJcbkBJbmplY3RhYmxlKHsgcHJvdmlkZWRJbjogJ3Jvb3QnIH0pXHJcbmV4cG9ydCBjbGFzcyBOZ1NpbXBsZVN0YXRlU2Vzc2lvblN0b3JhZ2UgZXh0ZW5kcyBOZ1NpbXBsZVN0YXRlQnJvd3NlclN0b3JhZ2Uge1xyXG4gICAgY29uc3RydWN0b3IoKSB7XHJcbiAgICAgICAgc3VwZXIoc2Vzc2lvblN0b3JhZ2UpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2022/lib/ng-simple-state.module.mjs

@@ -0,0 +1,24 @@
+import { NgModule } from '@angular/core';
+import { NG_SIMPLE_STORE_CONFIG } from './ng-simple-state-models';
+import * as i0 from "@angular/core";
+class NgSimpleStateModule {
+    static forRoot(ngSimpleStateConfig) {
+        return {
+            ngModule: NgSimpleStateModule,
+            providers: [
+                {
+                    provide: NG_SIMPLE_STORE_CONFIG,
+                    useValue: ngSimpleStateConfig,
+                },
+            ],
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateModule }); }
+}
+export { NgSimpleStateModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: NgSimpleStateModule, decorators: [{
+            type: NgModule
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctc2ltcGxlLXN0YXRlLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL25nLXNpbXBsZS1zdGF0ZS9zcmMvbGliL25nLXNpbXBsZS1zdGF0ZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUF1QixRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDOUQsT0FBTyxFQUF1QixzQkFBc0IsRUFBRSxNQUFNLDBCQUEwQixDQUFDOztBQUV2RixNQUNhLG1CQUFtQjtJQUM1QixNQUFNLENBQUMsT0FBTyxDQUNWLG1CQUF5QztRQUV6QyxPQUFPO1lBQ0gsUUFBUSxFQUFFLG1CQUFtQjtZQUM3QixTQUFTLEVBQUU7Z0JBQ1A7b0JBQ0ksT0FBTyxFQUFFLHNCQUFzQjtvQkFDL0IsUUFBUSxFQUFFLG1CQUFtQjtpQkFDaEM7YUFDSjtTQUNKLENBQUM7SUFDTixDQUFDOzhHQWJRLG1CQUFtQjsrR0FBbkIsbUJBQW1COytHQUFuQixtQkFBbUI7O1NBQW5CLG1CQUFtQjsyRkFBbkIsbUJBQW1CO2tCQUQvQixRQUFRIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTW9kdWxlV2l0aFByb3ZpZGVycywgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgTmdTaW1wbGVTdGF0ZUNvbmZpZywgTkdfU0lNUExFX1NUT1JFX0NPTkZJRyB9IGZyb20gJy4vbmctc2ltcGxlLXN0YXRlLW1vZGVscyc7XHJcblxyXG5ATmdNb2R1bGUoKVxyXG5leHBvcnQgY2xhc3MgTmdTaW1wbGVTdGF0ZU1vZHVsZSB7XHJcbiAgICBzdGF0aWMgZm9yUm9vdChcclxuICAgICAgICBuZ1NpbXBsZVN0YXRlQ29uZmlnPzogTmdTaW1wbGVTdGF0ZUNvbmZpZ1xyXG4gICAgKTogTW9kdWxlV2l0aFByb3ZpZGVyczxOZ1NpbXBsZVN0YXRlTW9kdWxlPiB7XHJcbiAgICAgICAgcmV0dXJuIHtcclxuICAgICAgICAgICAgbmdNb2R1bGU6IE5nU2ltcGxlU3RhdGVNb2R1bGUsXHJcbiAgICAgICAgICAgIHByb3ZpZGVyczogW1xyXG4gICAgICAgICAgICAgICAge1xyXG4gICAgICAgICAgICAgICAgICAgIHByb3ZpZGU6IE5HX1NJTVBMRV9TVE9SRV9DT05GSUcsXHJcbiAgICAgICAgICAgICAgICAgICAgdXNlVmFsdWU6IG5nU2ltcGxlU3RhdGVDb25maWcsXHJcbiAgICAgICAgICAgICAgICB9LFxyXG4gICAgICAgICAgICBdLFxyXG4gICAgICAgIH07XHJcbiAgICB9XHJcbn1cclxuIl19

package/{esm2020 → esm2022}/ng-simple-state.mjs

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmctc2ltcGxlLXN0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvbmctc2ltcGxlLXN0YXRlL3NyYy9uZy1zaW1wbGUtc3RhdGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/{esm2020 → esm2022}/public-api.mjs

@@ -1,10 +1,10 @@
-/*
- * Public API Surface of ng-simple-state
- */
-export * from './lib/ng-simple-state.module';
-export * from './lib/ng-simple-state-base-store';
-export * from './lib/ng-simple-state-dev-tool';
-export * from './lib/ng-simple-state-local-storage';
-export * from './lib/ng-simple-state-session-storage';
-export * from './lib/ng-simple-state-models';
+/*
+ * Public API Surface of ng-simple-state
+ */
+export * from './lib/ng-simple-state.module';
+export * from './lib/ng-simple-state-base-store';
+export * from './lib/ng-simple-state-dev-tool';
+export * from './lib/ng-simple-state-local-storage';
+export * from './lib/ng-simple-state-session-storage';
+export * from './lib/ng-simple-state-models';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25nLXNpbXBsZS1zdGF0ZS9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcclxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5nLXNpbXBsZS1zdGF0ZVxyXG4gKi9cclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmctc2ltcGxlLXN0YXRlLm1vZHVsZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGliL25nLXNpbXBsZS1zdGF0ZS1iYXNlLXN0b3JlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmctc2ltcGxlLXN0YXRlLWRldi10b29sJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmctc2ltcGxlLXN0YXRlLWxvY2FsLXN0b3JhZ2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xpYi9uZy1zaW1wbGUtc3RhdGUtc2Vzc2lvbi1zdG9yYWdlJztcclxuZXhwb3J0ICogZnJvbSAnLi9saWIvbmctc2ltcGxlLXN0YXRlLW1vZGVscyc7XHJcbiJdfQ==