react-native-global-state-hooks 2.0.7 → 2.1.1

package/lib/GlobalStore.js

@@ -1,167 +1,308 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GlobalStore = exports.debounce = void 0;
-const tslib_1 = require("tslib");
+exports.GlobalStore = void 0;
 const react_1 = require("react");
-const json_storage_formatter_1 = require("json-storage-formatter");
-const async_storage_1 = tslib_1.__importDefault(require("@react-native-async-storage/async-storage"));
-const debounce = (callback, wait = 300) => {
-    let timer;
-    return ((...args) => {
-        clearTimeout(timer);
-        timer = setTimeout(() => {
-            callback(...args);
-        }, wait);
-    });
+const GlobalStore_utils_1 = require("./GlobalStore.utils");
+const throwWrongKeyOnActionCollectionConfig = (action_key) => {
+    throw new Error(`[WRONG CONFIGURATION!]: Every key inside the storeActionsConfig must be a higher order function that returns a function \n[${action_key}]: key is not a valid function, try something like this: \n{\n
+    ${action_key}: (param) => ({ setState, getState, setMetadata, getMetadata }) => {\n
+      setState((state) => ({ ...state, ...param }))\n
+    }\n
+}\n`);
 };
-exports.debounce = debounce;
+/**
+ * The GlobalStore class is the main class of the library and it is used to create a GlobalStore instances
+ * @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
+ * */
 class GlobalStore {
-    get isPersistStore() {
-        return !!this.persistStoreAs;
-    }
-    constructor(state, actions = null, persistStoreAs = null, 
     /**
-     * This function can be used to format the data after it is loaded from the asyncStorage
-    */
-    onPersistStorageLoad = () => null) {
+     * Create a new instance of the GlobalStore
+     * @param {TState} state - The initial state
+     * @param {TMetadata} metadata - The metadata object (optional) (default: null) no reactive information set to share with the subscribers
+     * @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.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)
+     * */
+    constructor(state, metadata = null, setterConfig = null, config = {}) {
         this.state = state;
-        this.actions = actions;
-        this.persistStoreAs = persistStoreAs;
-        this.onPersistStorageLoad = onPersistStorageLoad;
-        this.subscribers = [];
-        this.storedStateItem = undefined;
-        this.getAsyncStoreItemPromise = null;
-        this.getStateCopy = () => Object.freeze((0, json_storage_formatter_1.clone)(this.state));
+        this.metadata = metadata;
+        this.setterConfig = setterConfig;
+        this.config = config;
+        /**
+         * list of all the subscribers setState functions
+         * @template {TState} TState - The type of the state object
+         * */
+        this.subscribers = new Set();
+        /**
+         * execute once the store is created
+         * @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
+         * @param {StateConfigCallbackParam<TState, TMetadata, TStateSetter>} parameters - The parameters object brings the following properties: setState, getState, setMetadata, getMetadata
+         * @param {Dispatch<SetStateAction<TState>>} parameters.setState - The setState function to update the state
+         * @param {() => TState} parameters.getState - The getState function to get the state
+         * @param {Dispatch<SetStateAction<TMetadata>>} parameters.setMetadata - The setMetadata function to update the metadata
+         * @param {() => TMetadata} parameters.getMetadata - The getMetadata function to get the metadata
+         * */
+        this.onInit = null;
+        /**
+         * execute every time the state is changed
+         * @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
+         * @param {StateConfigCallbackParam<TState, TMetadata, TStateSetter>} parameters - The parameters object brings the following properties: setState, getState, setMetadata, getMetadata
+         * @param {Dispatch<SetStateAction<TState>>} parameters.setState - The setState function to update the state
+         * @param {() => TState} parameters.getState - The getState function to get the state
+         * @param {Dispatch<SetStateAction<TMetadata>>} parameters.setMetadata - The setMetadata function to update the metadata
+         * @param {() => TMetadata} parameters.getMetadata - The getMetadata function to get the metadata
+         * */
+        this.onStateChanged = null;
+        /**
+         * Execute each time a new component gets subscribed to 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
+         * @param {StateConfigCallbackParam<TState, TMetadata, TStateSetter>} parameters - The parameters object brings the following properties: setState, getState, setMetadata, getMetadata
+         * @param {Dispatch<SetStateAction<TState>>} parameters.setState - The setState function to update the state
+         * @param {() => TState} parameters.getState - The getState function to get the state
+         * @param {Dispatch<SetStateAction<TMetadata>>} parameters.setMetadata - The setMetadata function to update the metadata
+         * @param {() => TMetadata} parameters.getMetadata - The getMetadata function to get the metadata
+         * */
+        this.onSubscribed = null;
+        /**
+         * Execute everytime a state change is triggered and before the state is updated, it allows to prevent the state change by returning true
+         * @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
+         * @param {StateConfigCallbackParam<TState, TMetadata, TStateSetter>} parameters - The parameters object brings the following properties: setState, getState, setMetadata, getMetadata
+         * @param {Dispatch<SetStateAction<TState>>} parameters.setState - The setState function to update the state
+         * @param {() => TState} parameters.getState - The getState function to get the state
+         * @param {Dispatch<SetStateAction<TMetadata>>} parameters.setMetadata - The setMetadata function to update the metadata
+         * @param {() => TMetadata} parameters.getMetadata - The getMetadata function to get the metadata
+         * @returns {boolean} - true to prevent the state change, false to allow the state change
+         * */
+        this.computePreventStateChange = null;
+        this.onInitializeStore = () => {
+            const { onInit } = this;
+            const { onInit: onInitFromConfig } = this.config;
+            if (!onInit && !onInitFromConfig)
+                return;
+            const parameters = this.getConfigCallbackParam({});
+            onInit === null || onInit === void 0 ? void 0 : onInit(parameters);
+            onInitFromConfig === null || onInitFromConfig === void 0 ? void 0 : onInitFromConfig(parameters);
+        };
+        /**
+         * gets a clone of the state
+         * @returns {TState} - The state clone
+         * */
+        this.getStateClone = () => (0, GlobalStore_utils_1.clone)(this.state);
+        /**
+         * gets a clone of the metadata
+         * @returns {TMetadata} - The metadata clone
+         * */
+        this.getMetadataClone = () => (0, GlobalStore_utils_1.clone)(this.metadata);
+        /**
+         * set the state and update all the subscribers
+         * @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;
+            // 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);
+            });
+        };
+        /**
+         * Set the value of the metadata property, this is no reactive and will not trigger a re-render
+         * @param {StateSetter<TMetadata>} setter - The setter function or the value to set
+         * */
+        this.setMetadata = (setter) => {
+            const isSetterFunction = typeof setter === 'function';
+            const metadata = isSetterFunction
+                ? setter(this.getMetadataClone())
+                : setter;
+            this.metadata = metadata;
+        };
+        /**
+         * get the parameters object to pass to the callback functions (onInit, onStateChanged, onSubscribed, computePreventStateChange)
+         * this parameters object brings the following properties: setState, getState, setMetadata, getMetadata
+         * this parameter object allows to update the state, get the state, update the metadata, get the metadata
+         * @param {{ invokerSetState?: React.Dispatch<React.SetStateAction<TState>> }} parameters - 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
+         * @returns {StateConfigCallbackParam<TState, TMetadata>} - The parameters object
+         * */
+        this.getConfigCallbackParam = ({ invokerSetState, }) => {
+            const { setMetadata, getMetadataClone: getMetadata, getStateClone: getState, } = this;
+            const setState = this.getSetStateWrapper({ invokerSetState });
+            const actions = this.getStoreActionsMap({});
+            return {
+                setMetadata,
+                getMetadata,
+                getState,
+                setState,
+                actions,
+            };
+        };
+        /**
+         * Returns a custom hook that allows to handle a global state
+         * @returns {[TState, TStateSetter, TMetadata]} - The state, the state setter or the actions map, the metadata
+         * */
         this.getHook = () => () => {
             const [value, invokerSetState] = (0, react_1.useState)(() => this.state);
             (0, react_1.useEffect)(() => {
-                this.subscribers.push(invokerSetState);
-                if (this.isPersistStore) {
-                    this.getAsyncStoreItem({ invokerSetState });
+                this.subscribers.add(invokerSetState);
+                const { onSubscribed } = this;
+                const { onSubscribed: onSubscribedFromConfig } = this.config;
+                if (onSubscribed || onSubscribedFromConfig) {
+                    const parameters = this.getConfigCallbackParam({ invokerSetState });
+                    onSubscribed === null || onSubscribed === void 0 ? void 0 : onSubscribed(parameters);
+                    onSubscribedFromConfig === null || onSubscribedFromConfig === void 0 ? void 0 : onSubscribedFromConfig(parameters);
                 }
                 return () => {
-                    this.subscribers = this.subscribers.filter((hook) => invokerSetState !== hook);
+                    this.subscribers.delete(invokerSetState);
                 };
             }, []);
-            return [
-                value,
-                this.getStateOrchestrator(invokerSetState),
-                this.isStoredStateItemUpdated,
-            ];
+            const stateOrchestrator = this.getStateOrchestrator(invokerSetState);
+            return [value, stateOrchestrator, this.getMetadataClone()];
         };
+        /**
+         * Returns an array with the a function to get the state, the state setter or the actions map, and a function to get the metadata
+         * @returns {[() => TState, TStateSetter, () => TMetadata]} - The state getter, the state setter or the actions map, the metadata getter
+         * */
         this.getHookDecoupled = () => {
-            const getState = () => {
-                if (this.isPersistStore) {
-                    return this.getAsyncStoreItem({});
-                }
-                return this.state;
-            };
-            return [
-                getState,
-                this.getStateOrchestrator(),
-            ];
+            const { getStateClone: getState, getMetadataClone: getMetadata } = this;
+            const stateOrchestrator = this.getStateOrchestrator();
+            return [getState, stateOrchestrator, getMetadata];
         };
-        this.getInternalSetter = ({ invokerSetState } = {}) => {
-            let stateOrchestrator;
-            if (this.persistStoreAs) {
-                stateOrchestrator = this.globalSetterToPersistStoreAsync;
-            }
-            else {
-                stateOrchestrator = this.globalSetter;
-            }
-            return (setter) => {
-                stateOrchestrator({ invokerSetState, setter });
+        /**
+         * returns a wrapper for the setState function that will update the state and all the subscribers
+         * @param {{ invokerSetState?: React.Dispatch<React.SetStateAction<TState>> }} parameters - 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
+         * @returns {StateSetter<TState>} - The state setter
+         * */
+        this.getSetStateWrapper = ({ invokerSetState, } = {}) => {
+            const setState = (setter) => {
+                this.computeSetState({ invokerSetState, setter });
             };
+            return setState;
         };
-        this.globalSetter = ({ setter, invokerSetState }) => {
-            const newState = typeof setter === 'function' ? setter(this.getStateCopy()) : setter;
-            this.state = newState;
-            // execute the invoke setter before the batched updates to avoid delays on the UI
-            invokerSetState === null || invokerSetState === void 0 ? void 0 : invokerSetState(newState);
-            // update all the subscribers
-            this.subscribers.forEach((setState) => {
-                if (setState === invokerSetState)
+        /**
+         * Calculate whenever or not we should compute the callback parameters on the state change
+         * @returns {boolean} - True if we should compute the callback parameters on the state change
+         * */
+        this.hasStateCallbacks = () => {
+            const { computePreventStateChange, onStateChanged } = this;
+            const { computePreventStateChange: computePreventStateChangeFromConfig, onStateChanged: onStateChangedFromConfig, } = this.config;
+            const preventStateChangesCalls = computePreventStateChange || computePreventStateChangeFromConfig;
+            const stateChangeCalls = onStateChanged || onStateChangedFromConfig;
+            const shouldComputeParameter = preventStateChangesCalls || stateChangeCalls;
+            return !!shouldComputeParameter;
+        };
+        /**
+         * This is responsible for defining whenever or not the state change should be allowed or prevented
+         * the function also execute the functions:
+         * - onStateChanged (if defined) - this function is executed after the state change
+         * - computePreventStateChange (if defined) - this function is executed before the state change and it should return a boolean value that will be used to determine if the state change should be prevented or not
+         * @param {{ setter: StateSetter<TState>; invokerSetState?: React.Dispatch<React.SetStateAction<TState>> }} parameters - The state setter and 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.computeSetState = ({ setter, invokerSetState, }) => {
+            const isSetterFunction = typeof setter === 'function';
+            const previousState = this.getStateClone();
+            const newState = isSetterFunction
+                ? setter(previousState)
+                : setter;
+            const itHasStateCallbacks = this.hasStateCallbacks();
+            const actions = itHasStateCallbacks && this.getStoreActionsMap({});
+            const setState = itHasStateCallbacks && this.getSetStateWrapper({ invokerSetState });
+            const { setMetadata, getMetadataClone: getMetadata, getStateClone: getState, } = this;
+            const callbackParameter = {
+                setMetadata,
+                getMetadata,
+                setState,
+                getState,
+                actions,
+                previousState,
+                state: newState,
+            };
+            const { computePreventStateChange } = this;
+            const { computePreventStateChange: computePreventStateChangeFromConfig } = this.config;
+            // check if the state change should be prevented
+            if (computePreventStateChange || computePreventStateChangeFromConfig) {
+                const preventStateChange = (computePreventStateChange === null || computePreventStateChange === void 0 ? void 0 : computePreventStateChange(callbackParameter)) ||
+                    (computePreventStateChangeFromConfig === null || computePreventStateChangeFromConfig === void 0 ? void 0 : computePreventStateChangeFromConfig(callbackParameter));
+                if (preventStateChange)
                     return;
-                setState(newState);
+            }
+            this.setState({
+                invokerSetState,
+                state: newState,
             });
+            const { onStateChanged } = this;
+            const { onStateChanged: onStateChangedFromConfig } = this.config;
+            if (!onStateChanged && !onStateChangedFromConfig)
+                return;
+            onStateChanged === null || onStateChanged === void 0 ? void 0 : onStateChanged(callbackParameter);
+            onStateChangedFromConfig === null || onStateChangedFromConfig === void 0 ? void 0 : onStateChangedFromConfig(callbackParameter);
         };
-        this.globalSetterToPersistStoreAsync = ({ setter, invokerSetState }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            this.globalSetter({ invokerSetState, setter });
-            yield this.setAsyncStoreItem();
-            return this.state;
-        });
-        this.getApiActions = ({ invokerSetState }) => {
-            const actionsConfig = this.actions;
+        /**
+         * This creates a map of actions that can be used to modify or interact with the state
+         * @param {{ invokerSetState?: React.Dispatch<React.SetStateAction<TState>> }} parameters - 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
+         * @returns {ActionCollectionResult<TState, TMetadata, TStateSetter>} - The actions map result of the configuration object passed to the constructor
+         * */
+        this.getStoreActionsMap = ({ invokerSetState, }) => {
+            if (!this.setterConfig)
+                return null;
+            const { setterConfig, setMetadata } = this;
+            const actionsConfig = setterConfig;
             const actionsKeys = Object.keys(actionsConfig);
-            const internalSetter = this.getInternalSetter({ invokerSetState });
-            const actionsApi = actionsKeys.reduce((accumulator, key) => (Object.assign(Object.assign({}, accumulator), { [key]: (...parameres) => {
-                    const actionConfig = actionsConfig[key];
-                    const action = actionConfig(...parameres);
+            const setState = this.getSetStateWrapper({
+                invokerSetState,
+            });
+            // we expose a copy of the state and metadata to the actions to prevent them from modifying the state directly
+            const { getStateClone: getState, getMetadataClone: getMetadata } = this;
+            // we bind the functions to the actions object to allow reusing actions in the same api config by using the -this- keyword
+            const actions = actionsKeys.reduce((accumulator, action_key) => (Object.assign(Object.assign({}, accumulator), { [action_key](...parameres) {
+                    const actionConfig = actionsConfig[action_key];
+                    const action = actionConfig.apply(actions, parameres);
+                    const actionIsNotAFunction = typeof action !== 'function';
+                    // we throw an error if the action is not a function, this is mandatory for the correct execution of the actions
+                    if (actionIsNotAFunction) {
+                        throwWrongKeyOnActionCollectionConfig(action_key);
+                    }
                     // executes the actions bringing access to the state setter and a copy of the state
-                    const result = action(internalSetter, this.getStateCopy());
+                    const result = action.call(actions, {
+                        setState,
+                        getState,
+                        setMetadata,
+                        getMetadata,
+                    });
+                    // we return the result of the actions to the invoker
                     return result;
                 } })), {});
-            return actionsApi;
+            return actions;
         };
-        this.deleteAsyncStoreItem = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (!this.isPersistStore)
-                return;
-            yield async_storage_1.default.removeItem(this.persistStoreAs);
-        });
-    }
-    get isStoredStateItemUpdated() {
-        return this.storedStateItem !== undefined;
-    }
-    asyncStorageGetItem() {
-        return async_storage_1.default.getItem(this.persistStoreAs);
-    }
-    getAsyncStoreItem({ invokerSetState }) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            // If the state is already updated, return it
-            if (this.isStoredStateItemUpdated)
-                return this.storedStateItem;
-            // If the promise to get the state is already running, return it
-            if (this.getAsyncStoreItemPromise)
-                return this.getAsyncStoreItemPromise;
-            this.getAsyncStoreItemPromise = new Promise((resolve) => {
-                (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const item = yield this.asyncStorageGetItem();
-                    if (item) {
-                        let value = JSON.parse(item);
-                        /** This allow users to review what is been stored */
-                        value = (_a = this.onPersistStorageLoad(value)) !== null && _a !== void 0 ? _a : value;
-                        const newState = (0, json_storage_formatter_1.formatFromStore)(value);
-                        const stateSetter = this.getInternalSetter({ invokerSetState });
-                        stateSetter(newState);
-                    }
-                    resolve(this.state);
-                }))();
-            });
-            return this.getAsyncStoreItemPromise;
-        });
-    }
-    asyncStorageSetItem(valueToStore) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            yield async_storage_1.default.setItem(this.persistStoreAs, valueToStore);
-        });
-    }
-    setAsyncStoreItem() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
-            if (this.storedStateItem === this.state)
-                return;
-            this.storedStateItem = this.state;
-            const valueToStore = (0, json_storage_formatter_1.formatToStore)(this.state);
-            yield this.asyncStorageSetItem(JSON.stringify(valueToStore));
-        });
+        this.onInitializeStore();
     }
+    /**
+     * Returns the state setter or the actions map
+     * @param {{ invokerSetState?: React.Dispatch<React.SetStateAction<TState>> }} parameters - 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
+     * @returns {TStateSetter} - The state setter or the actions map
+     * */
     getStateOrchestrator(invokerSetState) {
-        if (this.actions) {
-            return this.getApiActions({
-                invokerSetState,
-            });
+        const stateHasCustomActions = this.setterConfig;
+        if (stateHasCustomActions) {
+            return this.getStoreActionsMap({ invokerSetState });
         }
-        return this.getInternalSetter({ invokerSetState });
+        return this.getSetStateWrapper({ invokerSetState });
     }
 }
 exports.GlobalStore = GlobalStore;

package/lib/GlobalStore.types.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @param {StateSetter<TState>} setter - add a new state to an existing state
+ * @returns {void} result - void
+ */
+export type StateSetter<TState> = (setter: TState | ((state: TState) => TState)) => void;
+/**
+ * Parameters of the onStateChanged callback function
+ * @param {TState} state - the new state
+ * @param {TState} previousState - the previous state
+ **/
+export type StateChanges<TState> = {
+    state: TState;
+    previousState?: TState;
+};
+/**
+ * Callbacks to be passed to the configurating function of the store
+ * @template {TState} TState - The state type
+ * @template {TMetadata} TMetadata - The metadata type
+ * @property {StateSetter<TState>} setMetadata - Set the metadata
+ * @property {StateSetter<TState>} setState - Set the state
+ * @property {() => TState} getState - Get the state
+ * @property {() => TMetadata} getMetadata - Get the metadata
+ **/
+export type StoreTools<TState, TMetadata = null> = {
+    setMetadata: StateSetter<TMetadata>;
+    setState: StateSetter<TState>;
+    getState: () => TState;
+    getMetadata: () => TMetadata;
+};
+/**
+ * Basic contract for the storeActionsConfig configuration
+ * @template {TState} TState - The state type
+ * @template {TMetadata} TMetadata - The metadata type
+ * @property {string} key - The action name
+ * @property {(...parameters: unknown[]) => (storeTools: { setMetadata: StateSetter<TMetadata>; setState: StateSetter<TState>; getState: () => TState; getMetadata: () => TMetadata; }) => unknown | void} value - The action function
+ * @returns {ActionCollectionConfig<TState, TMetadata>} result - The action collection configuration
+ */
+export interface ActionCollectionConfig<TState, TMetadata> {
+    [key: string]: (...parameters: any[]) => (storeTools: StoreTools<TState, TMetadata>) => unknown | void;
+}
+/**
+ * This is the actions object returned by the hook when you pass an storeActionsConfig configuration
+ * if you pass an storeActionsConfig configuration, the hook will return an object with the actions
+ * whatever data manipulation of the state should be executed through the custom actions with as access to the state and metadata
+ * @template {TState} TState - The state type
+ * @template {TMetadata} TMetadata - The metadata type
+ * @template {TStateSetter} TStateSetter - The storeActionsConfig type (optional) - if you pass an storeActionsConfig the hook will return an object with the actions
+ *
+ * @example
+ *
+ * const store = new GlobalStore(0, {
+ *  increment: () => ({ setState }) => {
+ *    setState((state) => state + 1);
+ *  },
+ *  decrement: () => ({ setState }) => {
+ *    setState((state) => state - 1);
+ *  },
+ * });
+ *
+ * const [state, actions] = store.getHook();
+ *
+ * actions.increment();
+ * actions.decrement();
+ *
+ * console.log(state); // 0
+ */
+export type ActionCollectionResult<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> = TStateSetter extends ActionCollectionConfig<TState, TMetadata> ? {
+    [key in keyof TStateSetter]: (...params: Parameters<TStateSetter[key]>) => ReturnType<ReturnType<TStateSetter[key]>>;
+} : null;
+/**
+ * Common parameters of the store configuration callback functions
+ * @param {StateSetter<TState>} setState - add a new value to the state
+ * @param {() => TState} getState - get the current state
+ * @param {StateSetter<TMetadata>} setMetadata - add a new value to the metadata
+ * @param {() => TMetadata} getMetadata - get the current metadata
+ * @param {ActionCollectionResult<TState, ActionCollectionConfig<TState, TMetadata>> | null} actions - the actions object returned by the hook when you pass an storeActionsConfig configuration otherwise null
+ * @template {TState} TState - The state type
+ * @template {TMetadata} TMetadata - The metadata type
+ * @template {TStateSetter} TStateSetter - The storeActionsConfig type (optional) - if you pass an storeActionsConfig the hook will return an object with the actions
+ * @template {ActionCollectionResult<TState, TStateSetter>} TStateSetter - the result of the API (optional) - if you don't pass an API as a parameter, you can pass null
+ * */
+export type StateConfigCallbackParam<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> = {
+    actions: TStateSetter extends ActionCollectionConfig<TState, TMetadata> ? ActionCollectionResult<TState, TMetadata, TStateSetter> : null;
+} & StoreTools<TState, TMetadata>;
+/**
+ * Parameters of the onStateChanged callback function
+ * @template {TState} TState - The state type
+ * @template {TMetadata} TMetadata - The metadata type
+ * @template {TStateSetter} TStateSetter - The storeActionsConfig type (optional) - if you pass an storeActionsConfig the hook will return an object with the actions
+ */
+export type StateChangesParam<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> = StateConfigCallbackParam<TState, TMetadata, TStateSetter> & StateChanges<TState>;
+/**
+ * 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 ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> = {
+    onInit?: (parameters: StateConfigCallbackParam<TState, TMetadata, TStateSetter>) => void;
+    onStateChanged?: (parameters: StateChangesParam<TState, TMetadata, TStateSetter>) => void;
+    onSubscribed?: (parameters: StateConfigCallbackParam<TState, TMetadata, TStateSetter>) => void;
+    computePreventStateChange?: (parameters: StateChangesParam<TState, TMetadata, TStateSetter>) => boolean;
+};
+//# 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":"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"}

package/lib/GlobalStore.utils.d.ts

@@ -0,0 +1,3 @@
+import { clone } from 'json-storage-formatter';
+export { clone };
+//# sourceMappingURL=GlobalStore.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"GlobalStore.utils.d.ts","sourceRoot":"","sources":["../src/GlobalStore.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAG/C,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/lib/GlobalStore.utils.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = void 0;
+const json_storage_formatter_1 = require("json-storage-formatter");
+Object.defineProperty(exports, "clone", { enumerable: true, get: function () { return json_storage_formatter_1.clone; } });

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './GlobalStore.types';
+export * from './GlobalStore.utils';
+export * from './GlobalStore';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC"}

package/lib/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./GlobalStore.types"), exports);
+tslib_1.__exportStar(require("./GlobalStore.utils"), exports);
+tslib_1.__exportStar(require("./GlobalStore"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-global-state-hooks",
-  "version": "2.0.7",
+  "version": "2.1.1",
   "description": "This is a package to easily handling global-state across your react-native-components No-redux",
   "main": "lib/GlobalStore.js",
   "files": [
@@ -40,7 +40,6 @@
   },
   "homepage": "https://github.com/johnny-quesada-developer/react-native-global-state-hooks#readme",
   "devDependencies": {
-    "@react-native-async-storage/async-storage": "workspace:*",
     "@types/jest": "^26.0.17",
     "@types/lodash": "^4.14.165",
     "@types/react": "^17.0.0",
@@ -48,6 +47,7 @@
     "@types/react-test-renderer": "^17.0.0",
     "@typescript-eslint/eslint-plugin": "^4.9.1",
     "@typescript-eslint/parser": "^4.9.1",
+    "cancelable-promise-jq": "^1.0.4",
     "eslint": "^7.15.0",
     "eslint-config-airbnb": "^18.2.1",
     "eslint-plugin-import": "^2.22.1",
@@ -59,13 +59,12 @@
     "react-test-renderer": "^17.0.1",
     "ts-jest": "^26.4.4",
     "tslib": "^2.5.0",
-    "typescript": "^4.1.2"
+    "typescript": "^4.9.5"
   },
   "peerDependencies": {
-    "@react-native-async-storage/async-storage": "workspace:*",
     "react": "workspace:*"
   },
   "dependencies": {
-    "json-storage-formatter": "^1.0.2"
+    "json-storage-formatter": "^1.0.3"
   }
 }