react-native-global-state-hooks 2.0.6 → 2.1.0

package/lib/GlobalStore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalStore.d.ts","sourceRoot":"","sources":["../src/GlobalStore.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAC;AAEnD,oBAAY,kBAAkB,GAAG;IAC/B,MAAM,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAA;AAED,eAAO,MAAM,QAAQ,uDAUpB,CAAC;AAEF,qBAAa,WAAW,CACtB,MAAM,EACN,QAAQ,SAAS,MAAM,GAAG,IAAI,EAC9B,QAAQ,SAAS,YAAY,CAAC,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAC3E,YAAW,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC;IAS9D,SAAS,CAAC,KAAK,EAAE,MAAM;IACvB,SAAS,CAAC,OAAO,EAAE,QAAQ;IACpB,cAAc,EAAE,QAAQ;IAE/B;;MAEE;IACK,oBAAoB,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;IAdzD,WAAW,EAAE,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAM;IAE5D,IAAW,cAAc,IAAI,OAAO,CAEnC;gBAGW,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,QAA2B,EACvC,cAAc,GAAE,QAA2B;IAElD;;MAEE;IACK,oBAAoB,GAAE,CAAC,GAAG,EAAE,OAAO,KAAK,CAAC,MAAM,GAAG,IAAI,CAAc;IAG7E,OAAO,KAAK,wBAAwB,GAEnC;IAED,OAAO,CAAC,eAAe,CAAiC;IAExD,SAAS,CAAC,wBAAwB,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAQ;IAElE,SAAS,CAAC,mBAAmB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;cAIvC,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;cA2BpC,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;cAIxD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAUlD,SAAS,CAAC,YAAY,QAAO,MAAM,CAAqC;IAEjE,OAAO,sRA2BZ;IAEK,gBAAgB,mLAGV,QAAQ,SAAS,MAAM,GAAG,QAAQ,MAAM,CAAC,GAAG,MAAM,oDAO7D;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;;MAEE;IACF,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,MAAM,IAAI,EAAE,MAAM,CAAC,EAAE,CAAM;IAE7D,SAAS,CAAC,YAAY,6BAA8B,MAAM,KAAK,MAAM,WAoBnE;IAEF,SAAS,CAAC,+BAA+B,6BAAoC,MAAM,KAAK,MAAM,MAAI,QAAQ,MAAM,CAAC,CAK/G;IAEF;;MAEE;IACF,MAAM,CAAC,qBAAqB,aAM3B;IAED,SAAS,CAAC,UAAU,sHA0BlB;IAEK,oBAAoB,QAAa,QAAQ,IAAI,CAAC,CAIpD;CAEF;AAED,eAAe,WAAW,CAAC"}
+{"version":3,"file":"GlobalStore.d.ts","sourceRoot":"","sources":["../src/GlobalStore.ts"],"names":[],"mappings":"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"}

package/lib/GlobalStore.js

@@ -1,176 +1,309 @@
 "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 = (0, 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 {
-    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, setter] = (0, react_1.useState)(() => this.state);
+            const [value, invokerSetState] = (0, react_1.useState)(() => this.state);
             (0, react_1.useEffect)(() => {
-                this.subscribers.push(setter);
-                if (this.isPersistStore) {
-                    this.getAsyncStoreItem();
+                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) => setter !== hook);
+                    this.subscribers.delete(invokerSetState);
                 };
             }, []);
-            return [
-                value,
-                this.stateOrchestrator,
-                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 valueWrapper = this.isPersistStore ? this.getAsyncStoreItem() : () => this.state;
-            return [
-                valueWrapper,
-                this.stateOrchestrator,
-            ];
+            const { getStateClone: getState, getMetadataClone: getMetadata } = this;
+            const stateOrchestrator = this.getStateOrchestrator();
+            return [getState, stateOrchestrator, getMetadata];
         };
-        this._stateOrchestrator = null;
-        this.globalSetter = (setter) => {
-            // avoid perform multiple updates over the same state
-            GlobalStore.batchedUpdates = GlobalStore.batchedUpdates.filter(([, hook]) => {
-                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');
-                }
-                return !isSameHook;
-            });
-            const newState = typeof setter === 'function' ? setter(this.getStateCopy()) : setter;
-            this.state = newState;
-            // batch store updates
-            GlobalStore.batchedUpdates.push([() => this.subscribers.forEach((updateChild) => updateChild(newState)), this]);
-            GlobalStore.ExecutePendingBatches();
+        /**
+         * 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.globalSetterToPersistStoreAsync = (setter) => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            this.globalSetter(setter);
-            yield this.setAsyncStoreItem();
-            return this.state;
-        });
-        this.getActions = () => {
-            const actions = this.actions;
-            // Setter is allways async because of the render batch
-            // but we are typing the setter as synchronous to avoid the developer has extra complexity that useState do not handle
-            const setter = this.isPersistStore ? this.globalSetterToPersistStoreAsync : this.globalSetter;
-            return Object.keys(actions).reduce((accumulator, key) => (Object.assign(Object.assign({}, accumulator), { [key]: (...parameres) => (0, 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;
-                }) })), {});
+        /**
+         * 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.deleteAsyncStoreItem = () => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            if (!this.isPersistStore)
-                return;
-            yield async_storage_1.default.removeItem(this.persistStoreAs);
-        });
-    }
-    get isPersistStore() {
-        return !!this.persistStoreAs;
-    }
-    get isStoredStateItemUpdated() {
-        return this.storedStateItem !== undefined;
-    }
-    asyncStorageGetItem() {
-        return async_storage_1.default.getItem(this.persistStoreAs);
-    }
-    getAsyncStoreItem() {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            if (this.isStoredStateItemUpdated)
-                return this.storedStateItem;
-            if (this.getAsyncStoreItemPromise)
-                return this.getAsyncStoreItemPromise;
-            this.getAsyncStoreItemPromise = new Promise((resolve) => {
-                (() => (0, 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);
-                        yield this.globalSetter(newState);
-                    }
-                    resolve(this.state);
-                }))();
+        /**
+         * 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;
+            }
+            this.setState({
+                invokerSetState,
+                state: newState,
             });
-            return this.getAsyncStoreItemPromise;
-        });
-    }
-    asyncStorageSetItem(valueToStore) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            yield async_storage_1.default.setItem(this.persistStoreAs, valueToStore);
-        });
-    }
-    setAsyncStoreItem() {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            if (this.storedStateItem === this.state)
+            const { onStateChanged } = this;
+            const { onStateChanged: onStateChangedFromConfig } = this.config;
+            if (!onStateChanged && !onStateChangedFromConfig)
                 return;
-            this.storedStateItem = this.state;
-            const valueToStore = (0, json_storage_formatter_1.formatToStore)(this.state);
-            yield this.asyncStorageSetItem(JSON.stringify(valueToStore));
-        });
+            onStateChanged === null || onStateChanged === void 0 ? void 0 : onStateChanged(callbackParameter);
+            onStateChangedFromConfig === null || onStateChangedFromConfig === void 0 ? void 0 : onStateChangedFromConfig(callbackParameter);
+        };
+        /**
+         * 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 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.call(actions, {
+                        setState,
+                        getState,
+                        setMetadata,
+                        getMetadata,
+                    });
+                    // we return the result of the actions to the invoker
+                    return result;
+                } })), {});
+            return actions;
+        };
+        this.onInitializeStore();
     }
-    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;
+    /**
+     * 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) {
+        const stateHasCustomActions = this.setterConfig;
+        if (stateHasCustomActions) {
+            return this.getStoreActionsMap({ invokerSetState });
         }
-        return this._stateOrchestrator;
+        return this.getSetStateWrapper({ invokerSetState });
     }
 }
 exports.GlobalStore = GlobalStore;
-/**
-**  [subscriber-update-callback, hook]
-*/
-GlobalStore.batchedUpdates = [];
-/**
- * React native cannot use unstable_batchedUpdates
-*/
-GlobalStore.ExecutePendingBatches = () => {
-    GlobalStore.batchedUpdates.forEach(([execute]) => {
-        execute();
-    });
-    GlobalStore.batchedUpdates = [];
-};
 exports.default = 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,10 @@
+import { formatToStore, formatFromStore, clone } from 'json-storage-formatter';
+export { formatToStore, formatFromStore, clone };
+/**
+ * Debounce function to prevent multiple calls to the same function in a short period of time
+ * @param callback Function to be called
+ * @param wait Time to wait before calling the function
+ * @returns Function to be called
+ */
+export declare const debounce: <T extends Function>(callback: T, wait?: number) => T;
+//# 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,aAAa,EAAE,eAAe,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAG/E,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,KAAK,EAAE,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,uDAUpB,CAAC"}