react-native-global-state-hooks 5.0.15 → 6.0.1

package/lib/bundle.js.LICENSE.txt

@@ -1,10 +1 @@
 /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
-
-/**
- * @license
- * Lodash <https://lodash.com/>
- * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
- * Released under MIT license <https://lodash.com/license>
- * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
- * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
- */

package/lib/src/GlobalStore.d.ts

@@ -1,201 +1,28 @@
-import { ActionCollectionConfig, StateSetter, GlobalStoreConfig, ActionCollectionResult, StateConfigCallbackParam, MetadataSetter, UseHookConfig, StateGetter, SubscribeCallbackConfig, SubscribeCallback, SelectorCallback, SubscriberParameters, SubscriptionCallback, MetadataGetter } from "./GlobalStore.types";
-export declare const throwNoSubscribersWereAdded: () => never;
-/**
- * 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 actionsConfig 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
- * */
-export declare class GlobalStore<TState, TMetadata = null, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> {
-    protected actionsConfig: TStateSetter | null;
-    /**
-     * list of all the subscribers setState functions
-     * @template {TState} TState - The type of the state object
-     * */
-    subscribers: Map<string, SubscriberParameters>;
-    /**
-     * Actions of the store
-     */
-    actions?: ActionCollectionResult<TState, TMetadata, TStateSetter>;
-    /**
-     * 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 actionsConfig 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)
-     */
+import * as GlobalStoreBase from "react-hooks-global-states";
+import { GlobalStoreConfig, StateChangesParam, TMetadataResult, ActionCollectionConfig, ActionCollectionResult } from "./GlobalStore.types";
+import { GlobalStoreAbstract, MetadataGetter, StateGetter, StateSetter } from "react-hooks-global-states";
+export declare class GlobalStore<TState, TMetadata = null, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> = StateSetter<TState>> extends GlobalStoreAbstract<TState, TMetadata, NonNullable<TStateSetter>> {
     protected config: GlobalStoreConfig<TState, TMetadata, TStateSetter>;
-    /**
-     * 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 actionsConfig 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
-     * */
-    protected onInit?: GlobalStoreConfig<TState, TMetadata, TStateSetter>["onInit"];
-    /**
-     * 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 actionsConfig 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
-     * */
-    protected onStateChanged?: GlobalStoreConfig<TState, TMetadata, TStateSetter>["onStateChanged"];
-    /**
-     * 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 actionsConfig 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
-     * */
-    protected onSubscribed?: GlobalStoreConfig<TState, TMetadata, TStateSetter>["onSubscribed"];
-    /**
-     * Execute every time 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 actionsConfig 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
-     * */
-    protected computePreventStateChange?: GlobalStoreConfig<TState, TMetadata, TStateSetter>["computePreventStateChange"];
-    /**
-     * We use a wrapper in order to be able to force the state update when necessary even with primitive types
-     */
-    protected stateWrapper: {
-        state: TState;
-    };
-    /**
-     * @deprecated direct modifications of the state could end up in unexpected behaviors
-     */
-    protected get state(): TState;
-    /**
-     * Create a simple global store
-     * @param {TState} state - The initial state
-     * */
-    constructor(state: TState);
-    /**
-     * Create a new global store with custom action
-     * The metadata object could be null if not needed
-     * The setter Object is used to define the actions that will be used to manipulate the state
-     * @param {TState} state - The initial state
-     * @param {TStateSetter} actionsConfig - The actions configuration object (optional) (default: null) if not null the store manipulation will be done through the actions
-     * */
-    constructor(state: TState, config: GlobalStoreConfig<TState, TMetadata, TStateSetter>);
-    /**
-     * Create a new global store with custom action
-     * The metadata object could be null if not needed
-     * The setter Object is used to define the actions that will be used to manipulate the state
-     * The config object is used to define the callbacks that will be executed during the store lifecycle
-     * The lifecycle callbacks are: onInit, onStateChanged, onSubscribed and computePreventStateChange
-     * @param {TState} state - The initial state
-     * @param {GlobalStoreConfig<TState, TMetadata>} config - The configuration object (optional) (default: { metadata: null })
-     * @param {GlobalStoreConfig<TState, TMetadata>} config.metadata - The metadata object (optional) (default: null) if not null the metadata object will be reactive
-     * @param {GlobalStoreConfig<TState, TMetadata>} config.onInit - The callback to execute when the store is initialized (optional) (default: null)
-     * @param {GlobalStoreConfig<TState, TMetadata>} config.onStateChanged - The callback to execute when the state is changed (optional) (default: null)
-     * @param {GlobalStoreConfig<TState, TMetadata>} config.onSubscribed - The callback to execute when a new component gets subscribed to the store (optional) (default: null)
-     * @param {GlobalStoreConfig<TState, TMetadata>} config.computePreventStateChange - The callback to execute every time a state change is triggered and before the state is updated, it allows to prevent the state change by returning true (optional) (default: null)
-     * @param {TStateSetter} actionsConfig - The actions configuration object (optional) (default: null) if not null the store manipulation will be done through the actions
-     * */
-    constructor(state: TState, config: GlobalStoreConfig<TState, TMetadata, TStateSetter>, actionsConfig: TStateSetter);
-    protected initialize: () => Promise<void>;
-    /**
-     * set the state and update all the subscribers
-     * @param {StateSetter<TState>} setter - The setter function or the value to set
-     * */
-    protected setState: ({ state, forceUpdate, }: {
-        state: TState;
-        forceUpdate: boolean;
-    }) => void;
-    /**
-     * Set the value of the metadata property, this is no reactive and will not trigger a re-render
-     * @param {MetadataSetter<TMetadata>} setter - The setter function or the value to set
-     * */
-    protected setMetadata: MetadataSetter<TMetadata>;
-    protected getMetadata: () => TMetadata;
-    protected createChangesSubscriber: ({ callback, selector, config, }: {
-        selector?: SelectorCallback<unknown, unknown>;
-        callback: SubscribeCallback<unknown>;
-        config: SubscribeCallbackConfig<unknown>;
-    }) => {
-        stateWrapper: {
-            state: unknown;
-        };
-        subscriptionCallback: SubscriptionCallback;
-    };
-    /**
-     * Return current state of the store
-     * Optionally you can use this method to subscribe a callback to the store changes
-     * @param {UseHookConfig<TState, TDerivate>} config - The configuration object (optional) (default: { selector: null, subscriptionCallback: null, config: null })
-     * @param {TSelector} config.selector - The selector function to derive the state (optional) (default: null)
-     * @param {TSubscriptionCallback} config.subscriptionCallback - The callback to execute every time the state is changed
-     * @param {UseHookConfig<TState, TDerivate>} config.config - The configuration for the callback (optional) (default: null)
-     * @param {UseHookConfig<TState, TDerivate>} config.config.isEqual - The compare function to check if the state is changed (optional) (default: shallowCompare)
-     * @returns The state of the store, optionally if you provide a subscriptionCallback it this method will return the unsubscribe function
-     */
-    protected getState: StateGetter<TState>;
-    /**
-     * 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
-     * @returns {StateConfigCallbackParam<TState, TMetadata>} - The parameters object
-     * */
-    protected getConfigCallbackParam: () => StateConfigCallbackParam<TState, TMetadata, TStateSetter>;
-    protected updateSubscription: ({ subscriptionId, callback, selector, config, stateWrapper: { state }, }: Omit<SubscriberParameters, "currentState"> & {
-        stateWrapper: {
-            state: unknown;
-        };
-    }) => SubscriberParameters;
-    protected executeOnSubscribed: () => void;
-    /**
-     * 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
-     * */
-    getHook: () => <State = TState>(selector?: SelectorCallback<TState, State>, config?: UseHookConfig<State>) => [state: State extends null ? TState : State, setter: keyof TStateSetter extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TStateSetter>, metadata: TMetadata];
+    constructor(state: TState, config?: GlobalStoreConfig<TState, TMetadata, TStateSetter>, actionsConfig?: TStateSetter | null);
+    protected getMetadata: () => TMetadata | TMetadataResult<TMetadata>;
     /**
      * 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
      * */
-    getHookDecoupled: () => [StateGetter<TState>, keyof TStateSetter extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TStateSetter>, MetadataGetter<TMetadata>];
+    getHookDecoupled: () => [
+        StateGetter<TState>,
+        keyof TStateSetter extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TStateSetter>,
+        MetadataGetter<TMetadataResult<TMetadata>>
+    ];
     /**
-     * Returns the state setter or the actions map
-     * @returns {TStateSetter} - The state setter or the actions map
-     * */
-    protected getStateOrchestrator: () => keyof TStateSetter extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TStateSetter>;
-    /**
-     * 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
-     * */
-    protected hasStateCallbacks: () => boolean;
-    /**
-     * 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
-     */
-    protected setStateWrapper: StateSetter<TState>;
-    /**
-     * This creates a map of actions that can be used to modify or interact with the state
-     * @returns {ActionCollectionResult<TState, TMetadata, TStateSetter>} - The actions map result of the configuration object passed to the constructor
+     * 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
      * */
-    protected getStoreActionsMap: () => ActionCollectionResult<TState, TMetadata, TStateSetter>;
+    getHook: () => () => [
+        state: TState,
+        setter: keyof TStateSetter extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TStateSetter>,
+        metadata: MetadataGetter<TMetadataResult<TMetadata>>
+    ];
+    protected onInitialize: ({ setState, getState, setMetadata, }: GlobalStoreBase.StateConfigCallbackParam<TState, TMetadata>) => void;
+    protected onChange: ({ getState, }: StateChangesParam<TState, TMetadata, TStateSetter>) => void;
 }

package/lib/src/GlobalStore.functionHooks.d.ts

@@ -1,28 +1,19 @@
-import { ActionCollectionConfig, StateSetter, ActionCollectionResult, UseHookConfig, AvoidNever, UnsubscribeCallback, StateHook, StateGetter, createStateConfig, CustomGlobalHookBuilderParams, CustomGlobalHookParams, SelectorCallback, SubscribeToEmitter } from "./GlobalStore.types";
+import * as GlobalStoreBase from "react-hooks-global-states";
+import { createStateConfig, CustomGlobalHookParams, TMetadataResult, ActionCollectionConfig, ActionCollectionResult } from "./GlobalStore.types";
+import { AvoidNever, CustomGlobalHookBuilderParams } from "react-hooks-global-states";
 /**
  * Creates a global state with the given state and config.
  * @returns {} [HOOK, DECOUPLED_GETTER, DECOUPLED_SETTER] this is an array with the hook, the decoupled getState function and the decoupled setter of the state
  */
-export declare const createGlobalStateWithDecoupledFuncs: <TState, TMetadata = null, TActions extends ActionCollectionConfig<TState, TMetadata> = null>(state: TState, { actions, ...config }?: createStateConfig<TState, TMetadata, TActions>) => [StateHook<TState, keyof TActions extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>, TMetadata>, StateGetter<TState>, keyof TActions extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>];
+export declare const createGlobalStateWithDecoupledFuncs: <TState, TMetadata = null, TActions extends ActionCollectionConfig<TState, TMetadata> = null>(state: TState, { actions, ...config }?: createStateConfig<TState, TMetadata, TActions>) => [hook: GlobalStoreBase.StateHook<TState, keyof TActions extends never ? GlobalStoreBase.StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>, TMetadataResult<TMetadata>>, getter: GlobalStoreBase.StateGetter<TState>, setter: keyof TActions extends never ? GlobalStoreBase.StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>];
 /**
  * Creates a global hook that can be used to access the state and actions across the application
  * @returns {} - () => [TState, Setter, TMetadata] the hook that can be used to access the state and the setter of the state
  */
-export declare const createGlobalState: <TState, TMetadata = null, TActions extends ActionCollectionConfig<TState, TMetadata> = null>(state: TState, config?: createStateConfig<TState, TMetadata, TActions>) => StateHook<TState, keyof TActions extends never ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>, TMetadata>;
+export declare const createGlobalState: <TState, TMetadata = null, TActions extends ActionCollectionConfig<TState, TMetadata> = null>(state: TState, config?: createStateConfig<TState, TMetadata, TActions>) => GlobalStoreBase.StateHook<TState, keyof TActions extends never ? GlobalStoreBase.StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>, TMetadataResult<TMetadata>>;
 /**
  * @description
  * Use this function to create a custom global store.
  * You can use this function to create a store with async storage.
  */
-export declare const createCustomGlobalStateWithDecoupledFuncs: <TInheritMetadata = null, TCustomConfig = null>({ onInitialize, onChange, }: CustomGlobalHookBuilderParams<TInheritMetadata, TCustomConfig>) => <TState, TMetadata = null, TActions extends ActionCollectionConfig<TState, AvoidNever<TInheritMetadata> & AvoidNever<TMetadata>> = null>(state: TState, { config: customConfig, onInit, onStateChanged, ...parameters }?: CustomGlobalHookParams<TCustomConfig, TState, AvoidNever<TInheritMetadata> & AvoidNever<TMetadata>, TActions>) => [StateHook<TState, keyof TActions extends never ? StateSetter<TState> : ActionCollectionResult<TState, AvoidNever<TInheritMetadata> & AvoidNever<TMetadata>, TActions>, AvoidNever<TInheritMetadata> & AvoidNever<TMetadata>>, StateGetter<TState>, keyof TActions extends never ? StateSetter<TState> : ActionCollectionResult<TState, AvoidNever<TInheritMetadata> & AvoidNever<TMetadata>, TActions>];
-/**
- * @description
- * Use this function to create a custom global hook which contains a fragment of the state of another hook or a fragment
- */
-export declare const createDerivate: <TState, TSetter, TMetadata, TDerivate>(useHook: StateHook<TState, TSetter, TMetadata>, selector_: SelectorCallback<TState, TDerivate>, config_?: UseHookConfig<TDerivate>) => <State = TDerivate>(selector?: SelectorCallback<TDerivate, State>, config?: UseHookConfig<State>) => [state: State, setter: TSetter, metadata: TMetadata];
-/**
- * @description
- * This function allows you to create a derivate emitter
- * With this approach, you can subscribe to changes in a specific fragment or subset of the state.
- */
-export declare const createDerivateEmitter: <TDerivate, TGetter extends StateGetter<unknown>, TState = Exclude<ReturnType<TGetter>, UnsubscribeCallback>>(getter: TGetter, selector: SelectorCallback<TState, TDerivate>) => SubscribeToEmitter<TDerivate>;
+export declare const createCustomGlobalStateWithDecoupledFuncs: <TInheritMetadata extends Record<string, unknown>, TCustomConfig extends Record<string, unknown>>({ onInitialize, onChange, }: GlobalStoreBase.CustomGlobalHookBuilderParams<GlobalStoreBase.AvoidNever<TInheritMetadata>, GlobalStoreBase.AvoidNever<TCustomConfig>>) => <TState, TMetadata = null, TActions extends ActionCollectionConfig<TState, TMetadata> = null>(state: TState, { config: customConfig, onInit, onStateChanged, ...parameters }?: GlobalStoreBase.CustomGlobalHookParams<TCustomConfig, TState, TMetadata, TActions>) => [hook: GlobalStoreBase.StateHook<TState, keyof TActions extends never ? GlobalStoreBase.StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>, TMetadataResult<TMetadata>>, getter: GlobalStoreBase.StateGetter<TState>, setter: keyof TActions extends never ? GlobalStoreBase.StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TActions>];

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

@@ -1,62 +1,31 @@
+import * as GlobalStoreBase from "react-hooks-global-states";
+import { MetadataSetter, StateSetter } from "react-hooks-global-states";
 /**
- * @param {StateSetter<TState>} setter - set the state
- * @returns {void} result - void
+ * Configuration of the async storage (optional)
  */
-export type StateSetter<TState> = (
-/**
- * @param {StateSetter<TState>} setter - set the state
- * @param {{ forceUpdate?: boolean }} options - Options to be passed to the setter
- * @param {{ forceUpdate?: boolean }} options.forceUpdate - Force the re-render of the subscribers even if the state is the same
- * @returns {void} result - void
- * */
-setter: TState | ((state: TState) => TState), 
-/**
- * This parameter indicate whether we should force the re-render of the subscribers even if the state is the same,
- * Do
- */
-{ forceUpdate, }?: {
+export type AsyncStorageConfig = {
     /**
-     * @deprecated forceUpdate normally should not be used inside components
-     * Use this flag just in custom implementations of the global store
+     * async storage configuration
      */
-    forceUpdate?: boolean;
-}) => void;
-/**
- * @description
- * The hook to use the global state
- * @returns {[State, StateSetter<TState>, TMetadata]} result - the state, the setter and the metadata
- */
-export type StateHook<TState, TSetter, TMetadata> = <State = TState>(selector?: (state: TState) => State, config?: UseHookConfig<State>) => [state: State, setter: TSetter, metadata: TMetadata];
-/**
- * @description
- * Type that prevent ts issues with merging never with other types
- */
-export type AvoidNever<T> = T extends never | null | undefined ? {} : T;
-/**
- * @param {TMetadata} setter - set the metadata
- * @returns {void} result - void
- */
-export type MetadataSetter<TMetadata> = (
-/**
- * @param {TMetadata} setter - set the metadata
- * @returns {void} result - void
- * */
-setter: TMetadata | ((metadata: TMetadata) => TMetadata)) => void;
-/**
- * Parameters of the onStateChanged callback function
- * @param {TState} state - the new state
- * @param {TState} previousState - the previous state
- **/
-export type StateChanges<TState> = {
-    /**
-     * The new state
-     * */
-    state: TState;
-    /**
-     * The previous state
-     * */
-    previousState?: TState;
+    asyncStorage?: {
+        /**
+         * The key of the async storage
+         */
+        key?: string;
+        /**
+         * The function used to encrypt the async storage, it can be a custom function or a boolean value (true = atob)
+         */
+        encrypt?: boolean | ((value: string) => string);
+        /**
+         * The function used to decrypt the async storage, it can be a custom function or a boolean value (true = atob)
+         */
+        decrypt?: boolean | ((value: string) => string);
+    };
 };
+export type TMetadataResult<TMetadata = null> = {
+    isAsyncStorageReady?: boolean;
+    asyncStorageKey?: string;
+} & Omit<NonNullable<TMetadata>, "isAsyncStorageReady" | "asyncStorageKey">;
 /**
  * Callbacks to be passed to the configurations function of the store
  * @template {TState} TState - The state type
@@ -67,34 +36,9 @@ export type StateChanges<TState> = {
  * @property {() => TMetadata} getMetadata - Get the metadata
  * @property {ActionCollectionResult<TState, TMetadata>} actions - The actions collection if any
  **/
-export type StoreTools<TState = any, TMetadata = any, TActions = any> = {
-    /**
-     * Set the metadata
-     * @param {TMetadata} setter - The metadata or a function that will receive the metadata and return the new metadata
-     * @returns {void} result - void
-     * */
-    setMetadata: MetadataSetter<TMetadata>;
-    /**
-     * Set the state
-     * @param {TState} setter - The state or a function that will receive the state and return the new state
-     * @param {{ forceUpdate?: boolean }} options - Options
-     * @returns {void} result - void
-     * */
-    setState: StateSetter<TState>;
-    /**
-     * Get the state
-     * @returns {TState} result - The state
-     * */
-    getState: StateGetter<TState>;
-    /**
-     * Get the metadata
-     * @returns {TMetadata} result - The metadata
-     * */
-    getMetadata: () => TMetadata;
-    /**
-     * Actions of the hook
-     */
-    actions: TActions;
+export type StoreTools<TState = any, TMetadata = any, TActions = any> = Omit<GlobalStoreBase.StoreTools<TState, TMetadata, TActions>, "getMetadata" | "setMetadata"> & {
+    getMetadata: () => TMetadataResult<TMetadata>;
+    setMetadata: MetadataSetter<TMetadataResult<TMetadata>> | MetadataSetter<TMetadata>;
 };
 /**
  * Basic contract for the storeActionsConfig configuration
@@ -105,7 +49,7 @@ export type StoreTools<TState = any, TMetadata = any, TActions = any> = {
  * @returns {ActionCollectionConfig<TState, TMetadata>} result - The action collection configuration
  */
 export interface ActionCollectionConfig<TState, TMetadata = null> {
-    [key: string]: (...parameters: any[]) => (storeTools: StoreTools<TState, TMetadata>) => unknown | void;
+    [key: string]: (...parameters: any[]) => (storeTools: any) => unknown | void;
 }
 /**
  * This is the actions object returned by the hook when you pass an storeActionsConfig configuration
@@ -148,7 +92,7 @@ export type ActionCollectionResult<TState, TMetadata, TStateSetter extends Actio
  * @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>> = {
+export type StateConfigCallbackParam<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | GlobalStoreBase.StateSetter<TState> = GlobalStoreBase.StateSetter<TState>> = {
     actions: ActionCollectionResult<TState, TMetadata, TStateSetter>;
 } & StoreTools<TState, TMetadata>;
 /**
@@ -157,7 +101,7 @@ export type StateConfigCallbackParam<TState, TMetadata, TStateSetter extends Act
  * @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>;
+export type StateChangesParam<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | GlobalStoreBase.StateSetter<TState> = GlobalStoreBase.StateSetter<TState>> = StateConfigCallbackParam<TState, TMetadata, TStateSetter> & GlobalStoreBase.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
@@ -168,149 +112,13 @@ export type StateChangesParam<TState, TMetadata, TStateSetter extends ActionColl
  * @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>> = {
-    /**
-     * @param {StateConfigCallbackParam<TState, TMetadata> => void} metadata - the initial value of the metadata
-     * */
-    metadata?: TMetadata;
-    /**
-     * @param {StateConfigCallbackParam<TState, TMetadata> => void} onInit - callback function called when the store is initialized
-     * @returns {void} result - void
-     * */
-    onInit?: (parameters: StateConfigCallbackParam<TState, TMetadata, TStateSetter>) => void;
-    /**
-     * @param {StateChangesParam<TState, TMetadata> => void} onStateChanged - callback function called every time the state is changed
-     * @returns {void} result - void
-     */
-    onStateChanged?: (parameters: StateChangesParam<TState, TMetadata, TStateSetter>) => void;
-    /**
-     * @param {StateConfigCallbackParam<TState, TMetadata> => void} onSubscribed - callback function called every time a component is subscribed to the store
-     * @returns {void} result - void
-     */
-    onSubscribed?: (parameters: StateConfigCallbackParam<TState, TMetadata, TStateSetter>) => void;
-    /**
-     * @param {StateChangesParam<TState, TMetadata> => boolean} computePreventStateChange - callback function called every time the state is about to change and it allows you to prevent the state change
-     * @returns {boolean} result - true if you want to prevent the state change, false otherwise
-     */
-    computePreventStateChange?: (parameters: StateChangesParam<TState, TMetadata, TStateSetter>) => boolean;
-} | null;
-export type UseHookConfig<TState> = {
-    /**
-     * The callback to execute when the state is changed to check if the same really changed
-     * If the function is not provided the derived state will perform a shallow comparison
-     */
-    isEqual?: (current: TState, next: TState) => boolean;
-};
-/**
- * Callback function to unsubscribe from the store
- */
-export type UnsubscribeCallback = () => void;
-/**
- * Configuration of the subscribe callbacks
- */
-export type SubscribeCallbackConfig<TState> = UseHookConfig<TState> & {
-    /**
-     * By default the callback is executed immediately after the subscription
-     */
-    skipFirst?: boolean;
-};
-/**
- * Callback function to subscribe to the store changes
- */
-export type SubscribeCallback<TState> = (state: TState) => void;
-/**
- * Callback function to subscribe to the store changes from a getter
- */
-export type SubscriberCallback<TState> = (subscribe: SubscribeToEmitter<TState>) => void;
-/**
- * Callback function to get the current state of the store or to subscribe to the store changes
- * @template TState - the type of the state
- * @param {SubscriberCallback<TState> | null} callback - the callback function to subscribe to the store changes (optional)
- * use the methods subscribe and subscribeSelect to subscribe to the store changes
- * if you don't pass a callback function the hook will return the current state of the store
- * @returns {UnsubscribeCallback | TState} result - the state or the unsubscribe callback if you pass a callback function
- */
-export type StateGetter<TState> = <Subscription extends Subscribe | false = false>(
-/**
- * @param {SubscriberCallback<TState> | null} callback - the callback function to subscribe to the store changes (optional)
- * use the methods subscribe and subscribeSelect to subscribe to the store changes
- */
-callback?: Subscription extends Subscribe ? SubscriberCallback<TState> : null) => Subscription extends Subscribe ? UnsubscribeCallback : TState;
-export type MetadataGetter<TMetadata> = () => TMetadata;
-/**
- * Constant value type to indicate that the getter is a subscription
- */
-export type Subscribe = true;
+export type GlobalStoreConfig<TState, TMetadata, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | GlobalStoreBase.StateSetter<TState> = GlobalStoreBase.StateSetter<TState>> = GlobalStoreBase.GlobalStoreConfig<TState, TMetadata, TStateSetter> & AsyncStorageConfig;
 /**
  * Configuration of the state (optional) - if you don't need to use the state configuration you don't need to pass this parameter
  */
-export type createStateConfig<TState, TMetadata, TActions extends ActionCollectionConfig<TState, TMetadata> | null = null> = {
-    /**
-     * @description
-     * The type of the actionsConfig 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
-     */
-    actions?: TActions;
-} & GlobalStoreConfig<TState, TMetadata, TActions>;
-export type CustomGlobalHookBuilderParams<TInheritMetadata = null, TCustomConfig = {}> = {
-    /**
-     * @description
-     * This function is called when the state is initialized.
-     */
-    onInitialize: ({ setState, setMetadata, getMetadata, getState, actions, }: StateConfigCallbackParam<any, TInheritMetadata>, config: TCustomConfig) => void;
-    /**
-     * @description
-     * This function is called when the state is changed.
-     */
-    onChange: ({ setState, setMetadata, getMetadata, getState, actions, }: StateChangesParam<any, TInheritMetadata>, config: TCustomConfig) => void;
-};
+export type createStateConfig<TState, TMetadata, TActions extends ActionCollectionConfig<TState, TMetadata> | null = null> = GlobalStoreBase.createStateConfig<TState, TMetadata, TActions> & AsyncStorageConfig;
 /**
  * @description
  * Configuration of the custom global hook
  */
-export type CustomGlobalHookParams<TCustomConfig, TState, TMetadata, TActions extends ActionCollectionConfig<TState, TMetadata> | null> = {
-    /**
-     * @description
-     * Type of the configuration object that the custom hook will require or accept
-     */
-    config?: TCustomConfig;
-    /**
-     * @description
-     * The type of the actionsConfig 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
-     */
-    actions?: TActions;
-} & GlobalStoreConfig<TState, TMetadata, TActions>;
-export type SelectorCallback<TState, TDerivate> = (state: TState) => TDerivate;
-/**
- * @description
- * Function to subscribe to the store changes
- * @returns {UnsubscribeCallback} result - Function to unsubscribe from the store
- */
-export type SubscribeToEmitter<TState> = <TParam1 extends SubscribeCallback<TState> | SelectorCallback<TState, unknown>, TResult = ReturnType<TParam1>, TConfig = TResult extends void | null | undefined | never ? SubscribeCallbackConfig<TState> : SubscribeCallbackConfig<TResult>, TParam2 extends SubscribeCallbackConfig<TState> | SubscribeCallback<TResult> = TResult extends void | null | undefined | never ? TConfig : SubscribeCallback<TResult>, TParam3 = TResult extends void | null | undefined | never ? never : TConfig>(
-/**
- * @description
- * The callback function to subscribe to the store changes or a selector function to derive the state
- */
-param1: TParam1, 
-/**
- * @description
- * The configuration object or the callback function to subscribe to the store changes
- */
-param2?: TParam2, 
-/**
- * @description
- * The configuration object
- */
-param3?: TParam3) => UnsubscribeCallback;
-export type SubscriberParameters = {
-    subscriptionId: string;
-    selector: SelectorCallback<any, any>;
-    config: UseHookConfig<any> | SubscribeCallbackConfig<any>;
-    currentState: unknown;
-    callback: SubscriptionCallback;
-};
-export type SubscriptionCallback = (params: {
-    state: unknown;
-}) => void;
-export type SetStateCallback = (parameters: {
-    state: unknown;
-}) => void;
+export type CustomGlobalHookParams<TCustomConfig, TState, TMetadata, TActions extends ActionCollectionConfig<TState, TMetadata> | null> = GlobalStoreBase.CustomGlobalHookParams<TCustomConfig, TState, TMetadata, TActions> & AsyncStorageConfig;

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

@@ -1,13 +1,16 @@
+import { GlobalStoreConfig } from "./GlobalStore.types";
 /**
- * Shallow compare two values and return true if they are equal.
- * This function just compare the first level of the values.
- * @param value1
- * @param value2
- * @returns {boolean} true if the values are equal, false otherwise
+ * @description
+ * Get an item from local storage using the config provided.
  */
-export declare const shallowCompare: <T>(value1: T, value2: T) => boolean;
+export declare const getAsyncStorageItem: <TState, TMetadata = null>({ config, }: {
+    config: GlobalStoreConfig<TState, TMetadata, import("react-hooks-global-states").StateSetter<TState>>;
+}) => Promise<TState>;
 /**
- * Debounce a function.
+ * @description
+ * Set an item to local storage using the config provided.
  */
-export declare const debounce: <T extends (...args: any[]) => any>(callback: T, delay?: number) => (...args: Parameters<T>) => ReturnType<T>;
-export declare const uniqueId: () => string;
+export declare const setAsyncStorageItem: <TState, TMetadata = null>({ item, config, }: {
+    config: GlobalStoreConfig<TState, TMetadata, import("react-hooks-global-states").StateSetter<TState>>;
+    item: TState;
+}) => Promise<void>;

package/lib/src/GlobalStoreAbstract.d.ts

@@ -1,5 +1,6 @@
-import { StateSetter, StateConfigCallbackParam, StateChangesParam, ActionCollectionConfig, GlobalStoreConfig } from "./GlobalStore.types";
+import { StateSetter } from "react-hooks-global-states";
 import { GlobalStore } from "./GlobalStore";
+import { GlobalStoreConfig, StateConfigCallbackParam, StateChangesParam, ActionCollectionConfig } from "./GlobalStore.types";
 /**
  * @description
  * Use this class to extends the capabilities of the GlobalStore.