react-global-state-hooks 1.0.14 → 1.0.16

package/lib/GlobalStore.d.ts

@@ -1,53 +1,50 @@
-import * as IGlobalStore from './GlobalStoreTypes';
-export type IValueWithMedaData = {
-    _type_?: 'map' | 'set' | 'date';
-    value?: unknown;
-};
-export declare const debounce: <T extends Function>(callback: T, wait?: number) => T;
-/**
-* This is a class to create global-store objects
-* @template IState
-* @param {IState} state - Initial state,
-* @template IActions
-* @param {IActions} actions - An specific api to restrict the use of the state,
-* this will disable the default return of the state-setter of the hook, and instead will return the API
-* @param {string} persistStoreAs - A name if you want to persist the state of the store in localstorage
-* */
-export declare class GlobalStore<IState, IActions extends IGlobalStore.IActionCollectionConfig<IState> | null = null> implements IGlobalStore.IGlobalState<IState, IActions> {
-    protected state: IState;
-    protected actions: IActions;
-    protected persistStoreAs: string | null;
-    protected subscribers: IGlobalStore.StateSetter<IState>[];
-    get isPersistStore(): boolean;
-    constructor(state: IState, actions?: IActions, persistStoreAs?: string | null);
-    private storedStateItem;
-    protected localStorageGetItem(): string | null;
-    protected getStoreItem(): IState;
-    protected localStorageSetItem(valueToStore: string): void;
-    protected setStoreItem(): void;
-    protected getPersistStoreValue: () => IState;
-    protected getStateCopy: () => IState;
+export * from 'react-native-global-state-hooks';
+import { GlobalStore as GlobalStoreBase } from 'react-native-global-state-hooks';
+import { ActionCollectionConfig, GlobalStoreConfig, StateConfigCallbackParam, StateSetter } from './GlobalStore.types';
+export declare class GlobalStore<TState, TMetadata = null, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> | null = StateSetter<TState>> extends GlobalStoreBase<TState, TMetadata, TStateSetter> {
     /**
-     * Returns a global hook that will share information across components by subscribing them to a specific store.
-     * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>]
+     * additional configuration for the store
+     * @template {TState} TState - The type of the state object
+     * @template {TMetadata} TMetadata - The type of the metadata object (optional) (default: null) no reactive information set to share with the subscribers
+     * @template {TStateSetter} TStateSetter - The type of the setterConfig object (optional) (default: null) if a configuration is passed, the hook will return an object with the actions then all the store manipulation will be done through the actions
+     * @property {GlobalStoreConfig<TState, TMetadata, TStateSetter>} config.metadata - The metadata to pass to the callbacks (optional) (default: null)
+     * @property {GlobalStoreConfig<TState, TMetadata, TStateSetter>} config.onInit - The callback to execute when the store is initialized (optional) (default: null)
+     * @property {GlobalStoreConfig<TState, TMetadata, TStateSetter>} config.onStateChanged - The callback to execute when the state is changed (optional) (default: null)
+     * @property {GlobalStoreConfig<TState, TMetadata, TStateSetter>} config.onSubscribed - The callback to execute when a component is subscribed to the store (optional) (default: null)
+     * @property {GlobalStoreConfig<TState, TMetadata, TStateSetter>} config.computePreventStateChange - The callback to execute when the state is changed to compute if the state change should be prevented (optional) (default: null)
+     * @property {GlobalStoreConfig<TState, TMetadata, TStateSetter>} config.localStorageKey - The key to use to store the state in the localStorage (optional) (default: null) if not null the state will be stored in the localStorage
      */
-    getHook: <IApi extends IGlobalStore.IActionCollectionResult<IState, IActions> | null = IActions extends null ? null : IGlobalStore.IActionCollectionResult<IState, IActions>>() => () => [IState, IGlobalStore.IHookResult<IState, IActions, IApi>];
+    protected config: GlobalStoreConfig<TState, TMetadata, TStateSetter>;
     /**
-     * This is an access to the subscribers queue and to the current state of a specific store...
-     * THIS IS NOT A REACT-HOOK, so you could use it everywhere example other hooks, and services.
-     * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>]
-     */
-    getHookDecoupled: <IApi extends IGlobalStore.IActionCollectionResult<IState, IActions> | null = IActions extends null ? null : IGlobalStore.IActionCollectionResult<IState, IActions>>() => [() => IState, IGlobalStore.IHookResult<IState, IActions, IApi>];
-    private _stateOrchestrator;
-    protected get stateOrchestrator(): IGlobalStore.StateSetter<IState> | IGlobalStore.IActionCollectionResult<IState, IActions>;
+     * Create a new instance of the GlobalStore
+     * @param {TState} state - The initial state
+     * @param {TStateSetter} setterConfig - The actions configuration object (optional) (default: null) if not null the store manipulation will be done through the actions
+     * @param {GlobalStoreConfig<TState, TMetadata>} config - The configuration object (optional) (default: { metadata: null })
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.metadata - The metadata to pass to the callbacks (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.onInit - The callback to execute when the store is initialized (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.onStateChanged - The callback to execute when the state is changed (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.onSubscribed - The callback to execute when a subscriber is added (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.computePreventStateChange - The callback to execute when the state is changed to compute if the state change should be prevented (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.localStorageKey - The key to use to store the state in the localStorage (optional) (default: null) if not null the state will be stored in the localStorage
+     * */
+    constructor(state: TState, { onInit: onInitConfig, ...config }?: GlobalStoreConfig<TState, TMetadata, TStateSetter>, setterConfig?: TStateSetter | null);
+    protected setLocalStorageValue: () => void;
+    protected getLocalStorageValue: () => string;
     /**
-     **  [subscriber-update-callback, hook, newState]
+     * This method will be called once the store is created after the constructor,
+     * this method is different from the onInit of the confg property and it won't be overriden
      */
-    protected static batchedUpdates: [() => void, object, object][];
-    protected globalSetter: (setter: Partial<IState> | ((state: IState) => Partial<IState>)) => void;
-    protected globalSetterToPersistStoreAsync: (setter: Partial<IState> | ((state: IState) => Partial<IState>)) => Promise<void>;
-    static ExecutePendingBatches: () => void;
-    protected getActions: <IApi extends IGlobalStore.IActionCollectionResult<IState, IGlobalStore.IActionCollectionConfig<IState>>>() => IApi;
+    protected onInit: ({ setState, }: StateConfigCallbackParam<TState, TMetadata, TStateSetter>) => Promise<void>;
+    protected onStateChanged: () => void;
+    /**
+     * set the state and update all the subscribers,
+     * In react web ReacDom allows to batch the state updates, this method will use the unstable_batchedUpdates method if it exists
+     * @param {StateSetter<TState>} setter - The setter function or the value to set
+     * @param {React.Dispatch<React.SetStateAction<TState>>} invokerSetState - The setState function of the component that invoked the state change (optional) (default: null) this is used to updated first the component that invoked the state change
+     * */
+    protected setState: ({ invokerSetState, state, }: {
+        state: TState;
+        invokerSetState?: React.Dispatch<React.SetStateAction<TState>>;
+    }) => void;
 }
-export default GlobalStore;
 //# sourceMappingURL=GlobalStore.d.ts.map

package/lib/GlobalStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalStore.d.ts","sourceRoot":"","sources":["../src/GlobalStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAC;AAWnD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,eAAO,MAAM,QAAQ,uDAUpB,CAAC;AAEF;;;;;;;;IAQI;AACJ,qBAAa,WAAW,CACtB,MAAM,EACN,QAAQ,SAAS,YAAY,CAAC,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAC3E,YAAW,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,CAAC;IAQ1C,SAAS,CAAC,KAAK,EAAE,MAAM;IAAE,SAAS,CAAC,OAAO,EAAE,QAAQ;IAAqB,SAAS,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IAN5H,SAAS,CAAC,WAAW,EAAE,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAM;IAE/D,IAAW,cAAc,YAExB;gBAEqB,KAAK,EAAE,MAAM,EAAY,OAAO,GAAE,QAA2B,EAAY,cAAc,GAAE,MAAM,GAAG,IAAW;IAEnI,OAAO,CAAC,eAAe,CAAiC;IAExD,SAAS,CAAC,mBAAmB,IAAI,MAAM,GAAG,IAAI;IAI9C,SAAS,CAAC,YAAY,IAAI,MAAM;IAehC,SAAS,CAAC,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAIzD,SAAS,CAAC,YAAY,IAAI,IAAI;IAU9B,SAAS,CAAC,oBAAoB,QAAO,MAAM,CAAwB;IAEnE,SAAS,CAAC,YAAY,QAAO,MAAM,CAAqC;IAExE;;;OAGG;IACI,OAAO,6OAsBZ;IAEF;;;;OAIG;IACI,gBAAgB,mLAIf,MAAM,oDASZ;IAEF,OAAO,CAAC,kBAAkB,CAA0G;IAEpI,SAAS,KAAK,iBAAiB,IAAI,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAY3H;IAED;;OAEG;IACH,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,MAAM,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAM;IAErE,SAAS,CAAC,YAAY,sCAAuC,MAAM,KAAK,QAAQ,MAAM,CAAC,WAwBrF;IAEF,SAAS,CAAC,+BAA+B,sCAA6C,MAAM,KAAK,QAAQ,MAAM,CAAC,MAAI,QAAQ,IAAI,CAAC,CAG/H;IAGF,MAAM,CAAC,qBAAqB,aAU3B;IAED,SAAS,CAAC,UAAU,sHAwBlB;CAEH;AAED,eAAe,WAAW,CAAC"}
+{"version":3,"file":"GlobalStore.d.ts","sourceRoot":"","sources":["../src/GlobalStore.ts"],"names":[],"mappings":"AAEA,cAAc,iCAAiC,CAAC;AAEhD,OAAO,EAGL,WAAW,IAAI,eAAe,EAC/B,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,WAAW,EACZ,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,WAAW,CACtB,MAAM,EACN,SAAS,GAAG,IAAI,EAChB,YAAY,SACR,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAAC,GACzC,WAAW,CAAC,MAAM,CAAC,GACnB,IAAI,GAAG,WAAW,CAAC,MAAM,CAAC,CAC9B,SAAQ,eAAe,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC;IACxD;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,MAAM,EAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IAErE;;;;;;;;;;;SAWK;gBAEH,KAAK,EAAE,MAAM,EACb,EACE,MAAM,EAAE,YAAY,EACpB,GAAG,MAAM,EACV,GAAE,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAM,EAC1D,YAAY,GAAE,YAAY,GAAG,IAAW;IAwB1C,SAAS,CAAC,oBAAoB,aAqB5B;IAEF,SAAS,CAAC,oBAAoB,eAmB5B;IAEF;;;OAGG;IACH,SAAS,CAAC,MAAM,kBAEb,yBAAyB,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,mBAgB1D;IAEF,SAAS,CAAC,cAAc,aAEtB;IAEF;;;;;SAKK;IACL,SAAS,CAAC,QAAQ;eAIT,MAAM;0BACK,MAAM,QAAQ,CAAC,MAAM,cAAc,CAAC,MAAM,CAAC,CAAC;eAoB9D;CACH"}

package/lib/GlobalStore.js

@@ -1,165 +1,101 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobalStore = exports.debounce = void 0;
+exports.GlobalStore = void 0;
 const tslib_1 = require("tslib");
 const react_dom_1 = tslib_1.__importDefault(require("react-dom"));
-const json_storage_formatter_1 = require("json-storage-formatter");
-const react_1 = require("react");
-const debounce = (callback, wait = 300) => {
-    let timer;
-    return ((...args) => {
-        clearTimeout(timer);
-        timer = setTimeout(() => {
-            callback(...args);
-        }, wait);
-    });
-};
-exports.debounce = debounce;
-/**
-* This is a class to create global-store objects
-* @template IState
-* @param {IState} state - Initial state,
-* @template IActions
-* @param {IActions} actions - An specific api to restrict the use of the state,
-* this will disable the default return of the state-setter of the hook, and instead will return the API
-* @param {string} persistStoreAs - A name if you want to persist the state of the store in localstorage
-* */
-class GlobalStore {
-    get isPersistStore() {
-        return !!this.persistStoreAs;
-    }
-    constructor(state, actions = null, persistStoreAs = null) {
-        this.state = state;
-        this.actions = actions;
-        this.persistStoreAs = persistStoreAs;
-        this.subscribers = [];
-        this.storedStateItem = undefined;
-        this.getPersistStoreValue = () => this.getStoreItem();
-        this.getStateCopy = () => Object.freeze((0, json_storage_formatter_1.clone)(this.state));
-        /**
-         * Returns a global hook that will share information across components by subscribing them to a specific store.
-         * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>]
-         */
-        this.getHook = () => () => {
-            const [value, setter] = (0, react_1.useState)(this.state);
-            const valueWrapper = this.isPersistStore ? this.getPersistStoreValue() : value;
-            (0, react_1.useEffect)(() => {
-                this.subscribers.push(setter);
-                return () => {
-                    this.subscribers = this.subscribers.filter((hook) => setter !== hook);
-                };
-            }, []);
-            return [
-                valueWrapper,
-                this.stateOrchestrator,
-            ];
+tslib_1.__exportStar(require("react-native-global-state-hooks"), exports);
+const react_native_global_state_hooks_1 = require("react-native-global-state-hooks");
+class GlobalStore extends react_native_global_state_hooks_1.GlobalStore {
+    /**
+     * Create a new instance of the GlobalStore
+     * @param {TState} state - The initial state
+     * @param {TStateSetter} setterConfig - The actions configuration object (optional) (default: null) if not null the store manipulation will be done through the actions
+     * @param {GlobalStoreConfig<TState, TMetadata>} config - The configuration object (optional) (default: { metadata: null })
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.metadata - The metadata to pass to the callbacks (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.onInit - The callback to execute when the store is initialized (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.onStateChanged - The callback to execute when the state is changed (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.onSubscribed - The callback to execute when a subscriber is added (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.computePreventStateChange - The callback to execute when the state is changed to compute if the state change should be prevented (optional) (default: null)
+     * @param {StateConfigCallbackParam<TState, TMetadata>} config.localStorageKey - The key to use to store the state in the localStorage (optional) (default: null) if not null the state will be stored in the localStorage
+     * */
+    constructor(state, _a = {}, setterConfig) {
+        var _b;
+        var { onInit: onInitConfig } = _a, config = tslib_1.__rest(_a, ["onInit"]);
+        if (setterConfig === void 0) { setterConfig = null; }
+        debugger;
+        const decrypt = (config === null || config === void 0 ? void 0 : config.decrypt) === undefined ? (_b = config === null || config === void 0 ? void 0 : config.encrypt) !== null && _b !== void 0 ? _b : true : config === null || config === void 0 ? void 0 : config.decrypt;
+        super(state, Object.assign({ metadata: null, encrypt: true, decrypt }, (config !== null && config !== void 0 ? config : {})), setterConfig);
+        this.setLocalStorageValue = () => {
+            const { localStorageKey } = this.config;
+            debugger;
+            let stateToStore = (0, react_native_global_state_hooks_1.formatToStore)(this.getStateClone(), {
+                stringify: true,
+            });
+            const { encrypt } = this.config;
+            if (encrypt) {
+                const isEncryptCallback = typeof encrypt === 'function';
+                const encryptCallback = (isEncryptCallback ? encrypt : (value) => btoa(value));
+                stateToStore = encryptCallback(stateToStore);
+            }
+            localStorage.setItem(localStorageKey, stateToStore);
+        };
+        this.getLocalStorageValue = () => {
+            const { localStorageKey } = this.config;
+            debugger;
+            let storedState = localStorage.getItem(localStorageKey);
+            const { decrypt } = this.config;
+            if (decrypt) {
+                const isDecryptCallback = typeof decrypt === 'function';
+                const decryptCallback = (isDecryptCallback ? decrypt : (value) => atob(value));
+                storedState = decryptCallback(storedState);
+            }
+            return storedState;
         };
         /**
-         * This is an access to the subscribers queue and to the current state of a specific store...
-         * THIS IS NOT A REACT-HOOK, so you could use it everywhere example other hooks, and services.
-         * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>]
+         * This method will be called once the store is created after the constructor,
+         * this method is different from the onInit of the confg property and it won't be overriden
          */
-        this.getHookDecoupled = () => {
-            const valueWrapper = this.isPersistStore ? () => this.getPersistStoreValue() : () => this.state;
-            return [
-                valueWrapper,
-                this.stateOrchestrator,
-            ];
+        this.onInit = ({ setState, }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const { localStorageKey } = this.config;
+            if (!localStorageKey)
+                return;
+            const storedState = this.getLocalStorageValue();
+            if (storedState === null) {
+                this.setLocalStorageValue();
+                return;
+            }
+            const jsonParsed = JSON.parse(storedState);
+            const state = (0, react_native_global_state_hooks_1.formatFromStore)(jsonParsed);
+            setState(state);
+        });
+        this.onStateChanged = () => {
+            this.setLocalStorageValue();
         };
-        this._stateOrchestrator = null;
-        this.globalSetter = (setter) => {
-            const partialState = typeof setter === 'function' ? setter(this.getStateCopy()) : setter;
-            let newState = (0, json_storage_formatter_1.isPrimitive)(partialState) || Array.isArray(partialState)
-                ? partialState : Object.assign(Object.assign({}, this.state), partialState);
-            // avoid perform multiple update batches by accumulating state changes of the same hook
-            GlobalStore.batchedUpdates = GlobalStore.batchedUpdates.filter(([, hook, previousState]) => {
-                const isSameHook = hook === this;
-                if (isSameHook) {
-                    // eslint-disable-next-line no-console
-                    console.warn('You should try avoid call the same state-setter multiple times at one execution line');
-                    newState = (0, json_storage_formatter_1.isPrimitive)(newState) || Array.isArray(partialState)
-                        ? newState : Object.assign(Object.assign({}, previousState), newState);
-                }
-                return !isSameHook;
+        /**
+         * set the state and update all the subscribers,
+         * In react web ReacDom allows to batch the state updates, this method will use the unstable_batchedUpdates method if it exists
+         * @param {StateSetter<TState>} setter - The setter function or the value to set
+         * @param {React.Dispatch<React.SetStateAction<TState>>} invokerSetState - The setState function of the component that invoked the state change (optional) (default: null) this is used to updated first the component that invoked the state change
+         * */
+        this.setState = ({ invokerSetState, state, }) => {
+            // update the state
+            this.state = state;
+            const unstable_batchedUpdates = react_dom_1.default.unstable_batchedUpdates ||
+                ((callback) => callback());
+            unstable_batchedUpdates(() => {
+                // execute first the callback of the component that invoked the state change
+                invokerSetState === null || invokerSetState === void 0 ? void 0 : invokerSetState(state);
+                // update all the subscribers
+                this.subscribers.forEach((setState) => {
+                    if (setState === invokerSetState)
+                        return;
+                    setState(state);
+                });
             });
-            this.state = newState;
-            // batch store updates
-            GlobalStore.batchedUpdates.push([() => this.subscribers.forEach((updateChild) => updateChild(newState)), this, newState]);
-            GlobalStore.ExecutePendingBatches();
         };
-        this.globalSetterToPersistStoreAsync = (setter) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            this.globalSetter(setter);
-            this.setStoreItem();
-        });
-        this.getActions = () => {
-            const actions = this.actions;
-            // Setter is allways async because of the render batch
-            const setter = this.isPersistStore ? this.globalSetterToPersistStoreAsync : this.globalSetter;
-            return Object.keys(actions).reduce((accumulator, key) => (Object.assign(Object.assign({}, accumulator), { [key]: (...parameres) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    let promise;
-                    const setterWrapper = (value) => {
-                        promise = setter(value);
-                        return promise;
-                    };
-                    const result = actions[key](...parameres)(setterWrapper, this.getStateCopy());
-                    const resultPromise = Promise.resolve(result) === result ? result : Promise.resolve();
-                    yield Promise.all([promise, resultPromise]);
-                    return result;
-                }) })), {});
-        };
-    }
-    localStorageGetItem() {
-        return localStorage.getItem(this.persistStoreAs);
-    }
-    getStoreItem() {
-        if (this.storedStateItem !== undefined)
-            return this.storedStateItem;
-        const item = this.localStorageGetItem();
-        if (item) {
-            const value = JSON.parse(item);
-            const newState = (0, json_storage_formatter_1.formatFromStore)(value);
-            this.state = newState;
-        }
-        return this.state;
-    }
-    localStorageSetItem(valueToStore) {
-        localStorage.setItem(this.persistStoreAs, valueToStore);
-    }
-    setStoreItem() {
-        if (this.storedStateItem === this.state)
-            return;
-        this.storedStateItem = this.state;
-        const valueToStore = (0, json_storage_formatter_1.formatToStore)(this.state);
-        this.localStorageSetItem(JSON.stringify(valueToStore));
-    }
-    get stateOrchestrator() {
-        if (this._stateOrchestrator)
-            return this._stateOrchestrator;
-        if (this.actions) {
-            this._stateOrchestrator = this.getActions();
-        }
-        else if (this.persistStoreAs) {
-            this._stateOrchestrator = this.globalSetterToPersistStoreAsync;
-        }
-        else {
-            this._stateOrchestrator = this.globalSetter;
-        }
-        return this._stateOrchestrator;
+        const parameters = this.getConfigCallbackParam({});
+        this.onInit(parameters);
+        onInitConfig === null || onInitConfig === void 0 ? void 0 : onInitConfig(parameters);
     }
 }
 exports.GlobalStore = GlobalStore;
-/**
- **  [subscriber-update-callback, hook, newState]
- */
-GlobalStore.batchedUpdates = [];
-// avoid multiples calls to batchedUpdates
-GlobalStore.ExecutePendingBatches = () => {
-    const reactBatchedUpdates = react_dom_1.default.unstable_batchedUpdates || ((mock) => mock());
-    reactBatchedUpdates(() => {
-        GlobalStore.batchedUpdates.forEach(([execute]) => {
-            execute();
-        });
-        GlobalStore.batchedUpdates = [];
-    });
-};
-exports.default = GlobalStore;

package/lib/GlobalStore.types.d.ts

@@ -0,0 +1,25 @@
+import * as TGlobalStoreBase from 'react-native-global-state-hooks/lib/GlobalStore.types';
+export type StateSetter<TState> = TGlobalStoreBase.StateSetter<TState>;
+export type StateChanges<TState> = TGlobalStoreBase.StateChanges<TState>;
+export type StoreTools<TState, TMetadata = null> = TGlobalStoreBase.StoreTools<TState, TMetadata>;
+export interface ActionCollectionConfig<TState, TMetadata> extends TGlobalStoreBase.ActionCollectionConfig<TState, TMetadata> {
+}
+export type ActionCollectionResult<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> = TGlobalStoreBase.ActionCollectionResult<TState, TMetadata, TStateSetter>;
+export type StateConfigCallbackParam<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> = TGlobalStoreBase.StateConfigCallbackParam<TState, TMetadata, TStateSetter>;
+export type StateChangesParam<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> = TGlobalStoreBase.StateChangesParam<TState, TMetadata, TStateSetter>;
+/**
+ * Configuration of the store (optional) - if you don't need to use the store configuration you don't need to pass this parameter
+ * @param {StateConfigCallbackParam<TState, TMetadata> => void} onInit - callback function called when the store is initialized
+ * @param {StateConfigCallbackParam<TState, TMetadata> => void} onSubscribed - callback function called every time a component is subscribed to the store
+ * @param {StateChangesParam<TState, TMetadata> => boolean} computePreventStateChange - callback function called every time the state is changed and it allows you to prevent the state change
+ * @param {StateChangesParam<TState, TMetadata> => void} onStateChanged - callback function called every time the state is changed
+ * @template TState - the type of the state
+ * @template TMetadata - the type of the metadata (optional) - if you don't pass an metadata as a parameter, you can pass null
+ * @template {ActionCollectionConfig<TState,TMetadata> | null} TStateSetter - the configuration of the API (optional) - if you don't pass an API as a parameter, you can pass null
+ * */
+export type GlobalStoreConfig<TState, TMetadata, TStateSetter extends TGlobalStoreBase.ActionCollectionConfig<TState, TMetadata> | TGlobalStoreBase.StateSetter<TState> = TGlobalStoreBase.StateSetter<TState>> = TGlobalStoreBase.GlobalStoreConfig<TState, TMetadata, TStateSetter> & {
+    localStorageKey?: string;
+    encrypt?: boolean | ((value: string) => string);
+    decrypt?: boolean | ((value: string) => string);
+};
+//# sourceMappingURL=GlobalStore.types.d.ts.map

package/lib/GlobalStore.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalStore.types.d.ts","sourceRoot":"","sources":["../src/GlobalStore.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,gBAAgB,MAAM,uDAAuD,CAAC;AAE1F,MAAM,MAAM,WAAW,CAAC,MAAM,IAAI,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;AAEvE,MAAM,MAAM,YAAY,CAAC,MAAM,IAAI,gBAAgB,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;AAEzE,MAAM,MAAM,UAAU,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,IAAI,gBAAgB,CAAC,UAAU,CAC5E,MAAM,EACN,SAAS,CACV,CAAC;AAEF,MAAM,WAAW,sBAAsB,CAAC,MAAM,EAAE,SAAS,CACvD,SAAQ,gBAAgB,CAAC,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAAC;CAAG;AAEvE,MAAM,MAAM,sBAAsB,CAChC,MAAM,EACN,SAAS,EACT,YAAY,SACR,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAAC,GACzC,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,IAC3C,gBAAgB,CAAC,sBAAsB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;AAE7E,MAAM,MAAM,wBAAwB,CAClC,MAAM,EACN,SAAS,EACT,YAAY,SACR,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAAC,GACzC,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,IAC3C,gBAAgB,CAAC,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;AAE/E,MAAM,MAAM,iBAAiB,CAC3B,MAAM,EACN,SAAS,EACT,YAAY,SACR,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAAC,GACzC,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,CAAC,IAC3C,gBAAgB,CAAC,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;AAExE;;;;;;;;;KASK;AACL,MAAM,MAAM,iBAAiB,CAC3B,MAAM,EACN,SAAS,EACT,YAAY,SACR,gBAAgB,CAAC,sBAAsB,CAAC,MAAM,EAAE,SAAS,CAAC,GAC1D,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,gBAAgB,CAAC,WAAW,CAAC,MAAM,CAAC,IAC7E,gBAAgB,CAAC,iBAAiB,CAAC,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,GAAG;IACxE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;IAChD,OAAO,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAAC;CACjD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-global-state-hooks",
-  "version": "1.0.14",
+  "version": "1.0.16",
   "description": "This is a package to easily handling global-state across your react components No-redux, No-context.",
   "main": "lib/GlobalStore.js",
   "files": [
@@ -60,6 +60,6 @@
     "react-dom": "workspace:*"
   },
   "dependencies": {
-    "json-storage-formatter": "^1.0.2"
+    "react-native-global-state-hooks": "^2.1.9"
   }
 }

package/README.advance.md

@@ -1,123 +0,0 @@
-
-## Creating hooks with reusable actions
-
-Let's say you want to have a STATE with a specific set of actions that you could be reused. With this library is pretty easy to accomplish. Let's create **increase** and **decrease** actions to our count-store. **useCountGlobal.ts**:
-
-```JSX
-import {
-  IActionCollectionConfig,
-  IActionCollectionResult,
-  StateSetter,
-} from 'react-global-state-hooks/lib/GlobalStoreTypes';
-
-/**
- * When using a custom api, the getHook and getHookDecoupled will not longer return directly the setter,
- * intead they will return and api with the specific actions and mutations defined for the store
- * Creating a configuration object for our api
- */
-const countActionsApi: IActionCollectionConfig<number> = {
-  /* Decrease the value of the count */
-  decrease(decrease: number) {
-    /**
-     * We need to return the async function that is gonna take care of the state mutation or actions
-     */
-    return async (setter: StateSetter<number>, state: number) => {
-      /**
-       * Next, we perfom whatever modification we want on top of the store
-       */
-      return setter(state - decrease);
-    };
-  },
-
-  //* Lets add a new action to increase the value of the count */
-  increase(increase: number) {
-
-    return async (setter: StateSetter<number>, state: number) => {
-      return setter(state + increase);
-    };
-  },
-};
-
-/**
- *  Now our getHook and getHookDecoupled are gonna return our custom api instead of the StateSetter,
- *  This will allow us to have more control over our store since the mutations of the same are gonna be limitated 
-*/
-const countStore = new GlobalStore(0, countActionsApi);
-```
-
-If we remove all the explanatory comments the code will look like this:
-
-```TS
-const countStore = new GlobalStore(0, {
-  decrease(decrease: number) {
-    return (setter: StateSetter<number>, state: number) =>
-      setter(state - decrease);
-  },
-
-  increase(increase: number) {
-    return (setter: StateSetter<number>, state: number) =>
-      setter(state + increase);
-  },
-} as IActionCollectionConfig<number>);
-```
-
-Now lets get our new global hook with specific API
-
-```TS
-export interface ICountActions
-  extends IActionCollectionResult<number, IActionCollectionConfig<number>> {
-  decrease: (decrease: number) => Promise<number>;
-  increase: (increase: number) => Promise<number>;
-}
-
-/**
- * The ICountActions interface is optional but it allow you yo get more accurate results for the typescript autocompletes and validations, ignore this if you are not using TS
- */
-export const useCountGlobal = countStore.getHook<ICountActions>();
-```
-
-And that's it! the result of our useCountGlobal will return our actions instead of a simple setter... Let's see how that will look:
-
-```JSX
-import { useCountGlobal } from './useCountGlobal'
-
-const MyComponent: Reac.FC = () => {
-  const [count, countActions] = useCountGlobal();
-
-  // this functions are strongly typed 
-  const increaseClick = () => countActions.increase(1);
-  const decreaseClick = () => countActions.decrease(1);
-
-  return (<>
-      <label>{count}<label/><br/>
-      <button onPress={increaseClick}>increase<button/>
-      <button onPress={decreaseClick}>decrease<button/>
-    </>);
-}
-
-```
-
-## Customize persist storage
-
-Let suppose you don't like **async-storage** or you also want to implement some kind of encrypt-process. You could easily extend the **GlobalStore** Class, and customize your persist store implementation. 
-
-```JSX
-import GlobalState from 'react-global-state-hooks';
-import { IActionCollection } from 'react-global-state-hooks/lib/GlobalStoreTypes';
-
-export class SecureGlobalState<
-  IState,
-  IPersist extends string | null = null,
-  IsPersist extends boolean = IPersist extends null ? false : true,
-  IActions extends IActionCollection<IState> | null = null
-> extends GlobalState<IState, IPersist, IsPersist, IActions> {
-
-  protected getStoreItem = () => secureStorage.getItem(this.persistStoreAs as string);
-
-  /** value is a json string*/
-  protected setStoreItem = (value: string) => secureStorage.setItem(this.persistStoreAs as string, value);
-  
-}
-
-export default SecureGlobalState;
-```

package/lib/GlobalStoreTypes.d.ts

@@ -1,54 +0,0 @@
-/**
-* @param {StateSetter<IState>} setter - add a new value to the state
-* @returns {Promise<void>} result - resolves when update_batches finished
-*/
-export type StateSetter<IState> = (setter: Partial<IState> | ((state: IState) => Partial<IState>)) => void;
-/**
-* This is the structure required by the API actions in order to be able to capture action parameters and inject state setter into actions.
-*/
-export type IAction<IState> = <IResult>(...params: any[]) => (setter: StateSetter<IState>, currentState: IState) => Promise<unknown> | IResult;
-/**
-* Configuration of you API
-*/
-export interface IActionCollectionConfig<IState> {
-    [key: string]: IAction<IState>;
-}
-/**
-* This is the API result of the hook (if you passed an API as a parameter)
-*/
-export type IActionCollectionResult<IState, IActions extends IActionCollectionConfig<IState> | null> = {
-    [key in keyof IActions]: (...params: any[]) => unknown;
-};
-/**
-* Hook result, if you passed an API as a parameter it will be returned in the second position of the hook invoke.
-*/
-export type IHookResult<IState, IActions extends IActionCollectionConfig<IState> | null = null, IApi extends IActionCollectionResult<IState, IActions> | null = IActions extends null ? null : IActionCollectionResult<IState, IActions>> = IApi extends null ? StateSetter<IState> : IActions extends IActionCollectionConfig<IState> ? IApi extends IActionCollectionResult<IState, IActions> ? IApi : StateSetter<IState> : StateSetter<IState>;
-/**
-* This is a class to create global-store objects
-* @template IState
-* @param {IState} state - Initial state,
-* @template IActions
-* @param {IActions} actions - An specific api to restrict the use of the state,
-* this will disable the default return of the state-setter of the hook, and instead will return the API
-* @param {string} persistStoreAs - A name if you want to persist the state of the store in localstorage
-* */
-export interface IGlobalState<IState, IActions extends IActionCollectionConfig<IState> | null = null> {
-    /**
-    * Returns a global hook that will share information across components by subscribing them to a specific store.
-    * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>]
-    */
-    getHook: <IApi extends IActions extends IActionCollectionResult<IState, IActions> ? IActionCollectionResult<IState, IActions> : null>() => () => [
-        IState,
-        IHookResult<IState, IActions, IApi>
-    ];
-    /**
-    * This is an access to the subscribers queue and to the current state of a specific store...
-    * THIS IS NOT A REACT-HOOK, so you could use it everywhere example other hooks, and services.
-    * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>]
-    */
-    getHookDecoupled: <IApi extends IActions extends IActionCollectionResult<IState, IActions> ? IActionCollectionResult<IState, IActions> : null>() => [
-        () => IState,
-        IHookResult<IState, IActions, IApi>
-    ];
-}
-//# sourceMappingURL=GlobalStoreTypes.d.ts.map

package/lib/GlobalStoreTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"GlobalStoreTypes.d.ts","sourceRoot":"","sources":["../src/GlobalStoreTypes.ts"],"names":[],"mappings":"AAAA;;;EAGE;AACF,MAAM,MAAM,WAAW,CAAC,MAAM,IAAI,CAChC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,KAC3D,IAAI,CAAC;AAEV;;EAEE;AAEF,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;AAE/I;;EAEE;AACF,MAAM,WAAW,uBAAuB,CAAC,MAAM;IAC7C,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAChC;AAED;;EAEE;AACF,MAAM,MAAM,uBAAuB,CAAC,MAAM,EAAE,QAAQ,SAAS,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI,IAAI;KAEpG,GAAG,IAAI,MAAM,QAAQ,GAAG,CAAC,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,OAAO;CACvD,CAAC;AAEF;;EAEE;AACF,MAAM,MAAM,WAAW,CACrB,MAAM,EACN,QAAQ,SAAS,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,EAC9D,IAAI,SAAS,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,IAAI,GAAG,QAAQ,SAAS,IAAI,GAAG,IAAI,GAAG,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,IACtI,IAAI,SAAS,IAAI,GACjB,WAAW,CAAC,MAAM,CAAC,GACnB,QAAQ,SAAS,uBAAuB,CAAC,MAAM,CAAC,GAChD,IAAI,SAAS,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,GACpD,IAAI,GACJ,WAAW,CAAC,MAAM,CAAC,GACrB,WAAW,CAAC,MAAM,CAAC,CAAC;AAExB;;;;;;;;IAQI;AACJ,MAAM,WAAW,YAAY,CAC3B,MAAM,EAAE,QAAQ,SAAS,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI;IAEtE;;;MAGE;IACF,OAAO,EAAE,CAAC,IAAI,SAAS,QAAQ,SAAS,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,IAAI,OAAO,MAAM;QAC/I,MAAM;QACN,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC;KACpC,CAAC;IAEF;;;;MAIE;IACF,gBAAgB,EAAE,CAAC,IAAI,SAAS,QAAQ,SAAS,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,uBAAuB,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,IAAI,OAAQ;QACnJ,MAAM,MAAM;QACZ,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC;KACpC,CAAC;CACH"}