react-global-state-hooks 1.0.13 → 1.0.15

package/README.md

@@ -1,86 +1,113 @@
 # react-global-state-hooks
-This is a package to easily handling global-state across your react-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
+This is a package to easily handling global-state across your react components
 
-## Creating a global store, an a simple hook
+This utility uses the **useState** hook within a subscription pattern and **HOFs** to create a more intuitive, atomic and easy way of sharing state between components
 
-We are gonna create a global count example **count.ts**:
+...
 
-```JSX
-// Import the store costructor
-import GlobalStore from 'react-global-state-hooks';
+...
+
+# Creating a global store
+
+We are gonna create a global count example **useCountGlobal.ts**:
+
+```ts
+import { GlobalStore } from 'react-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 './count'
+import { useCountGlobal } from './useCountGlobal'
 
 const MyFirstComponent: React.FC = () => {
   const [count, setter] = useCountGlobal();
-  const onClick = useCallback(() => setter(currentState => currentState + 1), []);
+  const onClickAddOne = () => setter(count + 1);
 
-  return (<button onclick={onClick}>count: {count}<button/>);
+  return (<button onClick={onClickAddOne}>{`count: ${count}`}</button>);
 }
 
 const MySecondComponent: React.FC = () => {
   const [count, setter] = useCountGlobal();
-  const onClick = useCallback(() => setter(currentState => currentState + 1));
 
-  return (<button onclick={onClick}>count: {count}<button/>);
+  // it can also be use as a normal setter into a callback or other hooks
+  const onClickAddTwo = useCallback(() => setter(state => state + 2), [])
+
+  return (<button onClick={onClickAddOne}>{`count: ${count}`}</button>);
 }
 
-// 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 **local-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 local-storage
-const countStore = new GlobalStore(0, null, 'GLOBAL_COUNT');
-```
+# Persisting state into localhost
 
-## Consuming Persisted Store
+if you want to persist the value of the store into the. **localstorage**, you only have to add the property **localStorageKey** into the configuration parameter.
 
-```JSX
-const MyComponent: React.FC = () => {
-  // connect the component to the global persisted storage
-  const [count, setCount] = useCountGlobal();
-  const onClickAddOne = () => setCount(count + 1);
+```ts
+const countStore = new GlobalStore(0, {
+  localStorageKey: 'my_persisted_state',
 
-  return (<button onclick={onClickAddOne}>count: {count}<button/>);
-}
+  // by default, the state is encrypted to base64, but you can disable it, or use a custom encryptor
+  encrypt: false,
+
+  // by default, the state is encrypted to base64, but you can disable it, or use a custom decrypt
+  decrypt: false,
+});
 ```
 
-## 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. 
+# 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...
 
-```JSX
-import GlobalStore from 'react-global-state-hooks';
+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.
+
+```ts
+import { GlobalStore } from 'react-global-state-hooks';
 
 const countStore = new GlobalStore(0);
 
@@ -88,47 +115,189 @@ 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();
 
-  return (<label>{count}<label/>);
+  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 onclick={increaseClick}>increase<button/>
-      <button onclick={decreaseClick}>decrease<button/>
+      <button onClick={increaseClick} >increase</button>
+      <button onClick={decreaseClick} >decrease</button>
     </>);
 }
 ```
 
-## Advance Config
-Here you can see more information how to create more complex services for your global stores.
-[README]:./README.advance.md
+...
+
+...
+
+# 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;
+
+const config = {
+  // 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
+  metadata: null,
+
+  // The lifecycle callbacks are: onInit, onStateChanged, onSubscribed and computePreventStateChange
+};
+
+const countStore = new GlobalStore(
+  initialValue,
+  config,
+  {
+    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-global-state-hooks';
+
+const initialValue = 0;
+
+const store = new GlobalStore(0, {
+  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-global-state-hooks';
+
+const store = new GlobalStore(0, {
+  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-global-state-hooks';
+
+const store = new GlobalStore(0, {
+  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-global-state-hooks';
+
+const store = new GlobalStore(0, {
+  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 **localStorage** data to lose the data types that you stored. For example when you are using datetimes
-6. This library also is taking care of batching multiple stores updates by using **React unstable_batchedUpdates**; this is a problem that the **useState** have when you call multiple **setStates** into async flows as setTimeout
+...
 
-# 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. 
+...
 
+...

package/lib/GlobalStore.d.ts

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

package/lib/GlobalStore.d.ts.map

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

package/lib/GlobalStore.js

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

package/lib/GlobalStore.types.d.ts

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

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

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

package/package.json

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

package/README.advance.md

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

package/lib/GlobalStoreTypes.d.ts

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

package/lib/GlobalStoreTypes.d.ts.map

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