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

package/README.md

@@ -1,29 +1,52 @@
 # react-native-global-state-hooks
+
 This is a package to easily handling global-state across your react-native-components **No-redux**, **No-context**
 
 This utility follows the same style as the default **useState** hook, with a subscription pattern and **HOFs** to create a more intuitive, atomic and easy way of sharing state between components
 
-**after version 1.0.4, we migrated to @react-native-async-storage/async-storage, because @react-native-async-storage/async-storage has been deprecated!!**
+...
+
+...
 
-## Creating a global store, an a simple hook
+# Creating a global store, an a simple hook
 
 We are gonna create a global count example **useCountGlobal.ts**:
 
-```JSX
-// Import the store costructor
-import GlobalStore from 'react-native-global-state-hooks';
+```ts
+import { GlobalStore } from 'react-native-global-state-hooks';
 
 // initialize your store with the default value of the same.
 const countStore = new GlobalStore(0);
 
-// you'll use this function the same way you'll use the **useState**
+// get the hook
 export const useCountGlobal = countStore.getHook();
 
+// inside your component just call...
+const [count, setCount] = useCountGlobal(); // no paremeters are needed since this is a global store
+
 // That's it, that's a global store... Strongly typed, with a global-hook that we could reuse cross all our react-components.
+
+// #### Optionally you are able to use a decoupled hook,
+// #### This function is linked to the store hooks but is not a hook himself.
+
+export const [getCount, sendCount] = countStore.getHookDecoupled();
+
+// @example
+console.log(getCount()); // 0;
+
+// components subscribed to the global hook if there are so
+sendCount(5);
+
+console.log(getCount()); // 5;
 ```
 
-## Implementing your global hook into your components
-Let's say we have two components **MyFirstComponent**, **MySecondComponent**, in order to use our global hook they will look just like: 
+...
+
+...
+
+# Implementing your global hook into your components
+
+Let's say we have two components **MyFirstComponent**, **MySecondComponent**, in order to use our global hook they will look just like:
 
 ```JSX
 import { useCountGlobal } from './useCountGlobal'
@@ -37,59 +60,34 @@ const MyFirstComponent: React.FC = () => {
 
 const MySecondComponent: React.FC = () => {
   const [count, setter] = useCountGlobal();
-  const onClickAddTwo = () => setter(count + 2);
-  
+
+  // it can also be use as a normal setter into a callback or other hooks
+  const onClickAddTwo = useCallback(() => setter(state => state + 2), [])
+
   return (<Button title={`count: ${count}`} onPress={onClickAddOne} />);
 }
 
-// Just like that! You are now using a global state!!
+// It's so simple to share information between components
 ```
 
 Note that the only difference between this and the default **useState** hook is that you are not adding the initial value, cause you already did that when you created the store:
 
-```JSX
+```ts
 const countStore = new GlobalStore(0);
 ```
 
-## Persisted store
+...
 
-You could persist the state with **@react-native-async-storage** by just adding the **storage-key** to the constructor of your global-store, for example: 
+...
 
-```JSX
-// The FIRST parameter is the initial value of the state
-// The Second parameter is an API to restrict access to the state, will talk about that later on [README]:./README.advance.md
-// The Third parameter is the key that will be used on the async-storage
-const countStore = new GlobalStore(0, null, 'GLOBAL_COUNT');
-```
+# Decoupled hook
 
-## Consuming Persisted Store
+If you want to access the global state outside a component or outside a hook, or without subscribing the component to the state changes...
 
-```JSX
-const MyComponent: React.FC = () => {
-  // connect the component to the global persisted storage
-  const [count, setCount, isCountReady] = useCountGlobal();
-  const onClickAddOne = () => setCount(count + 1);
-  
-  /**
-   *  since the async storage is ASYNC, the first time the hook is called into a component we may get the default value, instead of the one from the storage.
-   * 
-   *  We are able to validate this with the third value returned in the hook array **isCountReady**, which is a boolean which let us now if the async storage already was reached out.
-  */
-  const countLabel = isCountReady ? `count: ${count}` : 'Loading async storage...';
+This is especially useful when you want to create components that have edition access to a certain store, but they actually don't need to be reactive to the state changes, like a search component that just need to get the current state every time that is going to search the data; but actually don't need to be subscribed to the changes over the collection he is going to be filtering.
 
-  return (<Button title={countLabel} onPress={onClickAddOne} />);
-}
-```
-
-## Decoupled hook
-
-If you want to access the global state outside a component or outside a hook, or without subscribing the component to the state changes... 
-
-This is especially useful when you want to create components that have edition access to a certain store, but they actually don't need to be reactive to the state changes, like a search component that just need to get the current state every time that is going to search the data; but actually don't need to be subscribed to the changes over the collection he is going to be filtering. 
-
-
-```JSX
-import GlobalStore from 'react-native-global-state-hooks';
+```ts
+import { GlobalStore } from 'react-native-global-state-hooks';
 
 const countStore = new GlobalStore(0);
 
@@ -97,14 +95,15 @@ const countStore = new GlobalStore(0);
 export const useCountGlobal = countStore.getHook();
 
 // this functions are not hooks, and they can be used in whatever place into your code, ClassComponents, OtherHooks, Services etc.
-export const [getCountGlobalValue, setCountGlobalValue] = countStore.getHookDecoupled();
-
+export const [getCount, sendCount] = countStore.getHookDecoupled();
 ```
 
-Let's see a trivial example: 
+Let's see a trivial example:
+
+...
 
 ```JSX
-import { useCountGlobal, setCountGlobalValue } from './useCountGlobal'
+import { useCountGlobal, sendCount } from './useCountGlobal'
 
 const CountDisplayerComponent: React.FC = () => {
   const [count] = useCountGlobal();
@@ -112,10 +111,12 @@ const CountDisplayerComponent: React.FC = () => {
   return (<Text>{count}<Text/>);
 }
 
+// here we have a separate component that is gonna handle the state of the previous component we created,
+// this new component is not gonna be affected by the changes applied on <CountDisplayerComponent/>
 // Stage2 does not need to be updated once the global count changes
 const CountManagerComponent: React.FC = () => {
-  const increaseClick = () => setCountGlobalValue(count => count + 1);
-  const decreaseClick = () => setCountGlobalValue(count => count - 1);
+  const increaseClick = useCallback(() => sendCount(count => count + 1), []);
+  const decreaseClick = useCallback(() => sendCount(count => count - 1), []);
 
   return (<>
       <Button onPress={increaseClick} title={'increase'} />
@@ -124,18 +125,263 @@ const CountManagerComponent: React.FC = () => {
 }
 ```
 
-## Advance Config
-Here you can see more information how to create more complex services for your global stores.
-[README]:./README.advance.md
+...
+
+...
+
+# Extending the global storage
+
+Implementing extra functionality to extend the capabilities of the GlobalStorage couldn't be easier!!!
+
+Here is an example of how you could create your custom store that for example stores the state into a async-storage persistente...
+
+You could just use this code right as it is by just adding also into your project **@react-native-async-storage** or whatever another async storage library.
+
+```ts
+export class GlobalStoreAsync<
+  TState,
+  TMetadata extends { readonly isAsyncStorageReady: boolean },
+  TStateSetter extends
+    | ActionCollectionConfig<TState, TMetadata>
+    | StateSetter<TState>
+    | null = StateSetter<TState>
+> extends GlobalStore<TState, TMetadata, TStateSetter> {
+  protected isAsyncStorageReady: boolean = false;
+
+  constructor(
+    state: TState,
+    metadata: TMetadata = { isAsyncStorageReady: false } as TMetadata,
+    setterConfig: TStateSetter | null = null,
+    config: GlobalStoreConfig<TState, TMetadata, NonNullable<TStateSetter>> & {
+      asyncStorageKey: string; // key of the async storage
+    }
+  ) {
+    super(state, metadata, setterConfig, config);
+  }
+
+  /**
+   * This method will be called once the store is created after the constructor,
+   * this method is different from the onInit of the confg property and it won't be overriden
+   */
+  protected onInit = async ({
+    setState,
+    setMetadata,
+    getMetadata,
+  }: StateConfigCallbackParam<
+    TState,
+    TMetadata,
+    NonNullable<TStateSetter>
+  >) => {
+    const storedItem: string = await asyncStorage.getItem('items');
+
+    this.isAsyncStorageReady = true;
+
+    setMetadata({
+      ...getMetadata(),
+      isAsyncStorageReady: true,
+    });
+
+    if (!storedItem) return;
+
+    const jsonParsed = JSON.parse(storedItem);
+    const items = formatFromStore<TState>(jsonParsed);
+
+    setState(items);
+  };
+
+  protected onStateChanged = ({
+    getState,
+  }: StateChangesParam<TState, TMetadata, NonNullable<TStateSetter>>) => {
+    const state = getState();
+    const formattedObject: Object = formatToStore(state);
+    const jsonValue = JSON.stringify(formattedObject);
+
+    asyncStorage.setItem('items', jsonValue);
+  };
+}
+```
+
+The methods **formatToStore** and **formatFromStore** are part of another library of my [json-storage-formatter](https://www.npmjs.com/package/json-storage-formatter)...
+
+this super small library will help you to transform objects into json string and get them back without losing any of the original data types... no more problems when **stringify** Dates, Maps, Sets, etc...
+
+...
+
+Originally the library was implementing persistent storage by using the package **@react-native-async-storage**, but not all people want to use it or need to use it... so it has been removed. Feel free to use the above example to get back that functionality if you were using the previous versions of the package.
+
+You could find this example on the [**GitHub** of the project](https://github.com/johnny-quesada-developer/json-storage-formatter), between the unit test sources when the case scenario was tested [GlobalStoreAsyc.ts](https://github.com/johnny-quesada-developer/react-native-global-state-hooks/blob/master/%40tests/__test__/GlobalStoreAsyc.ts)
+
+...
+
+...
+
+# Restricting the manipulation of the global **state**
+
+## Who hate reducers?
+
+It's super common to have the wish or the necessity of restricting the manipulation of the **state** through a specific set of actions or manipulations...**Dispatches**? **Actions**? Let's make it simple BY adding a custom **API** to the configuration of our **GlobalStore**
+...
+
+```ts
+const initialValue = 0;
+
+// this is not reactive information that you could also store in the async storage
+// upating the metadata will not trigger the onStateChanged method or any update on the components
+const metadata = null;
+
+const countStore = new GlobalStore(
+  initialValue,
+  metadata,
+  {
+    log: (message: string) => (): void => {
+      console.log(message);
+    },
+
+    increase(message: string) {
+      return (storeTools: StoreTools<number>) => {
+        this.log(message);
+
+        return storeTools.getState();
+      };
+    },
+
+    decrease(message: string) {
+      return (storeTools: StoreTools<number>) => {
+        this.log(message);
+
+        return storeTools.getState();
+      };
+    },
+  } as const // the -as const- is necessary to avoid typescript errors
+);
+
+// the way to get the hook is the same as for simple setters
+const useCountStore = countStore.getHook();
+
+// now instead of a setState method, you'll get an actions object
+// that contains all the actions that you defined in the setterConfig
+const [count, countActions] = useCountStore();
+
+// count is the current state - 0 (number)
+// countActions is an object that contains all the actions that you defined in the setterConfig
+// countActions.increase(); // this will increase the count by 1, returns the new count (number)
+// countActions.decrease(); // this will decrease the count by 1, returns the new count (number)
+```
+
+...
+
+# Configuration callbacks
+
+## config.onInit
+
+This method will be called once the store is created after the constructor,
+
+@examples
+
+```ts
+import { GlobalStore } from 'react-native-global-state-hooks';
+
+const initialValue = 0;
+
+const store = new GlobalStore(0, null, null, {
+  onInit: async ({ setMetadata, setState }) => {
+    const data = await someApiCall();
+
+    setState(data);
+    setMetadata({ isDataUpdated: true });
+  },
+});
+```
+
+...
+
+## config.onStateChanged
+
+This method will be called every time the state is changed
+
+@examples
+
+```ts
+import { GlobalStore } from 'react-native-global-state-hooks';
+
+const store = new GlobalStore(0, null, null, {
+  onStateChanged: ({ getState }) => {
+    const state = getState();
+
+    console.log(state);
+  },
+});
+```
+
+...
+
+## config.onSubscribed
+
+This method will be called every time a component is subscribed to the store
+
+@examples
+
+```ts
+import { GlobalStore } from 'react-native-global-state-hooks';
+
+const store = new GlobalStore(0, null, null, {
+  onSubscribed: ({ getState }) => {
+    console.log('A component was subscribed to the store');
+  },
+});
+```
+
+...
+
+## config.computePreventStateChange
+
+This method will be called every time the state is going to be changed, if it returns true the state won't be changed
+
+@examples
+
+```ts
+import { GlobalStore } from 'react-native-global-state-hooks';
+
+const store = new GlobalStore(0, null, null, {
+  computePreventStateChange: ({ getState }) => {
+    const state = getState();
+    const shouldPrevent = state < 0;
+
+    if (shouldPrevent) return true;
+
+    return false;
+  },
+});
+```
+
+...
+
+...
+
+...
+
+...
+
+...
 
 ## Advantages:
+
 1. Using REACT's simplest and default way to deal with the state.
 2. Adding partial state designations (This is not on useState default functionality)
 3. Added availability to create actions and decoupled access to the states, no more connects, and dispatches, just call your actions as a normal service of whatever other libraries.
 4. This library is already taking care of avoiding re-renders if the new state does not have changes
-5. This tool also take care for you to avoid **async-storage*** data to lose the data types that you stored. For example when you are using datetimes
+5. This tool also take care for you to avoid **async-storage\*** data to lose the data types that you stored. For example when you are using datetimes
+
+...
+
+...
+
+...
+
+...
 
 # Finallly notes:
-Are concern about performance? this library is for you, instead of handling huge complex stores with options like redux, or by passing the setState to a context Provider (because of the limitations that the context has)... You should just use this library, we are using the more atomic and 'native' way that REACT gives to handle the state, and that is the hook **useState**... 
 
-This utility is just including the implementation of the use state into a subscriber pattern, to enable you to create hooks that will be subscribed to specific store changes, does how we'll be creating a global state hook. 
+Are concern about performance? this library is for you, instead of handling huge complex stores with options like redux, or by passing the setState to a context Provider (because of the limitations that the context has)... You should just use this library, we are using the more atomic and 'native' way that REACT gives to handle the state, and that is the hook **useState**...
+
+This utility is just including the implementation of the use state into a subscriber pattern, to enable you to create hooks that will be subscribed to specific store changes, does how we'll be creating a global state hook.

package/lib/GlobalStore.d.ts

@@ -1,48 +1,165 @@
-import * as IGlobalStore from './GlobalStoreTypes';
-export declare type IValueWithMedaData = {
-    _type_?: 'map' | 'set' | 'date';
-    value?: unknown;
-};
-export declare const debounce: <T extends Function>(callback: T, wait?: number) => T;
-export declare class GlobalStore<IState, IPersist extends string | null, IActions extends IGlobalStore.IActionCollectionConfig<IState> | null = null> implements IGlobalStore.IGlobalState<IState, IPersist, IActions> {
-    protected state: IState;
-    protected actions: IActions;
-    persistStoreAs: IPersist;
-    /**
-     * This function can be used to format the data after it is loaded from the asyncStorage
-    */
-    onPersistStorageLoad: (obj: unknown) => (IState | null);
-    subscribers: IGlobalStore.StateSetter<IState>[];
-    get isPersistStore(): boolean;
-    constructor(state: IState, actions?: IActions, persistStoreAs?: IPersist, 
-    /**
-     * This function can be used to format the data after it is loaded from the asyncStorage
-    */
-    onPersistStorageLoad?: (obj: unknown) => (IState | null));
-    private get isStoredStateItemUpdated();
-    private storedStateItem;
-    protected getAsyncStoreItemPromise: Promise<IState> | null;
-    protected asyncStorageGetItem(): Promise<string | null>;
-    protected getAsyncStoreItem(): Promise<IState>;
-    protected asyncStorageSetItem(valueToStore: string): Promise<void>;
-    protected setAsyncStoreItem(): Promise<void>;
-    protected getStateCopy: () => IState;
-    getHook: <IApi extends IGlobalStore.IActionCollectionResult<IState, IActions> | null = IActions extends null ? null : IGlobalStore.IActionCollectionResult<IState, IActions>>() => () => [IState, IGlobalStore.IHookResult<IState, IActions, IApi>, IPersist extends null ? false : boolean];
-    getHookDecoupled: <IApi extends IGlobalStore.IActionCollectionResult<IState, IActions> | null = IActions extends null ? null : IGlobalStore.IActionCollectionResult<IState, IActions>>() => [() => IPersist extends string ? Promise<IState> : IState, IGlobalStore.IHookResult<IState, IActions, IApi>];
-    private _stateOrchestrator;
-    protected get stateOrchestrator(): IGlobalStore.StateSetter<IState> | IGlobalStore.IActionCollectionResult<IState, IActions>;
-    /**
-    **  [subscriber-update-callback, hook]
-    */
-    protected static batchedUpdates: [() => void, object][];
-    protected globalSetter: (setter: IState | ((state: IState) => IState)) => void;
-    protected globalSetterToPersistStoreAsync: (setter: IState | ((state: IState) => IState)) => Promise<IState>;
-    /**
-     * React native cannot use unstable_batchedUpdates
-    */
-    static ExecutePendingBatches: () => void;
-    protected getActions: <IApi extends IGlobalStore.IActionCollectionResult<IState, IGlobalStore.IActionCollectionConfig<IState>>>() => IApi;
-    deleteAsyncStoreItem: () => Promise<void>;
+import { Dispatch, SetStateAction } from 'react';
+import { ActionCollectionConfig, StateSetter, GlobalStoreConfig, ActionCollectionResult, StateConfigCallbackParam } from './GlobalStore.types';
+/**
+ * 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
+ * */
+export declare class GlobalStore<TState, TMetadata = null, TStateSetter extends ActionCollectionConfig<TState, TMetadata> | StateSetter<TState> | null = StateSetter<TState>> {
+    protected state: TState;
+    protected metadata: TMetadata;
+    protected setterConfig: TStateSetter | null;
+    private config;
+    /**
+     * list of all the subscribers setState functions
+     * @template {TState} TState - The type of the state object
+     * */
+    subscribers: Set<StateSetter<TState>>;
+    /**
+     * 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
+     * */
+    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 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
+     * */
+    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 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
+     * */
+    protected onSubscribed?: GlobalStoreConfig<TState, TMetadata, TStateSetter>['onSubscribed'];
+    /**
+     * 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
+     * */
+    protected computePreventStateChange?: GlobalStoreConfig<TState, TMetadata, TStateSetter>['computePreventStateChange'];
+    /**
+     * 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: TState, metadata?: TMetadata, setterConfig?: TStateSetter | null, config?: GlobalStoreConfig<TState, TMetadata, TStateSetter>);
+    protected onInitializeStore: () => void;
+    /**
+     * gets a clone of the state
+     * @returns {TState} - The state clone
+     * */
+    protected getStateClone: () => TState;
+    /**
+     * gets a clone of the metadata
+     * @returns {TMetadata} - The metadata clone
+     * */
+    protected getMetadataClone: () => TMetadata;
+    /**
+     * 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
+     * */
+    protected setState: ({ invokerSetState, state, }: {
+        state: TState;
+        invokerSetState?: React.Dispatch<React.SetStateAction<TState>>;
+    }) => void;
+    /**
+     * 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
+     * */
+    protected setMetadata: StateSetter<TMetadata>;
+    /**
+     * 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
+     * */
+    protected getConfigCallbackParam: ({ invokerSetState, }: {
+        invokerSetState?: React.Dispatch<React.SetStateAction<TState>>;
+    }) => StateConfigCallbackParam<TState, TMetadata, TStateSetter>;
+    /**
+     * 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: () => () => [TState, TStateSetter extends StateSetter<TState> ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TStateSetter>, 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: () => [() => TState, TStateSetter extends StateSetter<TState> ? StateSetter<TState> : ActionCollectionResult<TState, TMetadata, TStateSetter>, () => TMetadata];
+    /**
+     * 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
+     * */
+    protected getSetStateWrapper: ({ invokerSetState, }?: {
+        invokerSetState?: React.Dispatch<React.SetStateAction<TState>>;
+    }) => StateSetter<TState>;
+    /**
+     * 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
+     * */
+    protected getStateOrchestrator(invokerSetState?: React.Dispatch<React.SetStateAction<TState>>): 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
+     * @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
+     */
+    protected computeSetState: ({ setter, invokerSetState, }: {
+        setter: StateSetter<TState>;
+        invokerSetState?: React.Dispatch<React.SetStateAction<TState>>;
+    }) => void;
+    /**
+     * 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
+     * */
+    protected getStoreActionsMap: ({ invokerSetState, }: {
+        invokerSetState?: React.Dispatch<React.SetStateAction<TState>>;
+    }) => ActionCollectionResult<TState, TMetadata, TStateSetter>;
 }
 export default GlobalStore;
 //# sourceMappingURL=GlobalStore.d.ts.map