react-native-global-state-hooks 1.1.3 → 2.0.0

package/README.advance.md

@@ -0,0 +1,78 @@
+
+## 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. 
+
+## 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 * as IGlobalState from 'react-native-global-state-hooks/lib/GlobalStoreTypes';
+import GlobalStore from 'react-native-global-state-hooks';
+
+export interface ICountActionsConfig extends IGlobalState.IActionCollectionConfig<number> {
+  decrease: (decrease: number) => (setter: IGlobalState.StateSetter<number>, state: number) => Promise<void>,
+  increase: (increase: number) => (setter: IGlobalState.StateSetter<number>, state: number) => Promise<void>,
+}
+
+export interface ICountActions extends IGlobalState.IActionCollectionResult {
+  decrease: (decrease: number) => Promise<void>,
+  increase: (increase: number) => Promise<void>,
+}
+
+const countActions: IActionCollectionConfig<number> = {
+  decrease: (decrease: number) => async (setter: IGlobalState.StateSetter<number>, state: number) => {
+    setter(state - decrease);
+  },
+  increase: (increase: number) => async (setter: IGlobalState.StateSetter<number>, state: number) => {
+    setter(state + increase);
+  },
+};
+
+const countStore = new GlobalStore(0, countActions);
+
+export const useCountGlobal = countStore.getHook<ICountActions>();
+
+```
+
+Now the result of our useCountGlobal will return our actions instead of a simple setter... Let's see:
+
+```JSX
+import { useCountGlobal } from './useCountGlobal'
+
+function Stage1() {
+  const [count, actions] = useCountGlobal();
+
+  const increaseClick = () => actions.increase(1);
+  const decreaseClick = () => actions.decrease(1);
+
+  return (<>
+      <label>{count}<label/><br/>
+      <button onPress={increaseClick}>increase<button/>
+      <button onPress={decreaseClick}>decrease<button/>
+    </>);
+}
+
+```
+
+```JSX
+import GlobalState from 'react-native-global-state-hooks';
+import secureStorage from 'react-native-secure-storage';
+import { IActionCollection } from 'react-native-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 asyncStorageGetItem = () => secureStorage.getItem(this.persistStoreAs as string, config);
+
+  protected asyncStorageSetItem = (value: string) => secureStorage.setItem(this.persistStoreAs as string, value, config);
+  
+}
+
+export default SecureGlobalState;
+```

package/README.md

@@ -1,178 +1,101 @@
 # 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, this in order to be an intuitive tool to help you to quickly migrate from complex options as redux to the new react-hooks.
+This utility follows the same style as the default useState hook, this in order to be an intuitive and easy to use
 
 **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
 
-We are gonna create a global count example **count.ts**:
+We are gonna create a global count example **useCountGlobal.ts**:
 
-```
+```JSX
 import GlobalStore from 'react-native-global-state-hooks';
 
 const countStore = new GlobalStore(0);
 
-export const useCount = countStore.getHook();
+export const useCountGlobal = countStore.getHook();
 ```
 
 That's it, that's a global store... Strongly typed, with a global-hook that we could reuse cross all our react-components.
 
 ## Consuming global hook
-Let's say we have two components stage1, stage2, in order to use our global hook they will look just like: 
-```
-import { useCount } from './count'
+Let's say we have two components **Stage1**, **Stage2**, in order to use our global hook they will look just like: 
+```JSX
+import { useCountGlobal } from './useCountGlobal'
 
-function Stage1() {
-  const [count, setter] = useCount();
-  const onClick = useCallback(() => setter(currentState => currentState + 1), []);
-  return (<button onPress={onClick}>count: {count}<button/>);
-}
+const Stage1: React.FC = () => {
+  const [count, setter] = useCountGlobal();
+  const onClickAddOne = () => setter(count + 1);
 
-function Stage2() {
-  const [count, setter] = useCount();
-  const onClick = useCallback(() => setter(currentState => currentState + 1));
-  return (<button onPress={onClick}>count: {count}<button/>);
+  return (<button onPress={onClickAddOne}>count: {count}<button/>);
 }
-```
-Just like that, you are using a global state. 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. 
-
-## Persisted store
-
-You could persist the state in the local-storage by just adding a name to the constructor of your global-store let's see. 
-```
-const countStore = new GlobalStore(0, null, 'GLOBAL_COUNT');
-```
-
-## Customize persist storage
-
-Let suppose you don't like async storage, or you also want to implement some kind of secure storage. You could easily extends the GlobalStore Class, and customize your persist store implementation. 
-
-```
-import GlobalState from 'react-native-global-state-hooks';
-import secureStorage from 'react-native-secure-storage';
-import { IActionCollection } from 'react-native-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 asyncStorageGetItem = () => secureStorage.getItem(this.persistStoreAs as string, config);
-
-  protected asyncStorageSetItem = (value: string) => secureStorage.setItem(this.persistStoreAs as string, value, config);
+const Stage2: React.FC = () => {
+  const [count, setter] = useCountGlobal();
+  const onClickAddTwo = () => setter(count + 2);
   
+  return (<button onPress={onClickAddTwo}>count: {count}<button/>);
 }
-
-export default SecureGlobalState;
 ```
 
-## Consuming Persisted Store
-```
-const [refresh, setter, state, isUpdated] = useCount();
-
-useEffect(() => {
-  refresh();
-}, []);
+Just like that! You now are using a global state. 
 
+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
+const countStore = new GlobalStore(0);
 ```
-With the persistent storage, I preferred to change a little the format of the result... To let know developers what they are doing, because **asyncStorage** is ASYNC, so if I were automatically updating the state the first time that the hook is called, it could be ending into an INEXPLICABLE re-render of components...
-
-But even with the above, you could still automatically adding that behavior if you want, just by wrapping the hook:
-```
-export const usePersistedCount = () => {
-  const [refresh, setter, state, isUpdated] = useCount();
-
-  useEffect(() => {
-    refresh();
-  }, []);
-
-  return [state, setter, isUpdated];
-}
-```
-Don't worry about calling the refresh method every time you reuse the hook, that use case is already being handled by the GlobalState, and is not gonna perform any re-render... actually is just gonna read the asyncStorage the first time that you'll call the REFRESH method. Again this is strongly typed, so you'll don't have to guess what is happening.
 
-## 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 **plus** and **decrease** actions to our COUNT-store. **count.ts**:
+## Persisted store
 
+You could persist the state in the **async-storage** by just adding the **key-name** 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.
+// The Third parameter is the key that will use on the async-storage
+const countStore = new GlobalStore(0, null, 'GLOBAL_COUNT');
 ```
-import * as IGlobalState from 'react-native-global-state-hooks/lib/GlobalStoreTypes';
-import GlobalStore from 'react-native-global-state-hooks';
 
-const countStore = new GlobalStore(0, {
-  plus: (increase: number) => async (setter: IGlobalStore.StateSetter<number>, currentState: number) => {
-    // perfom whatever login you want
-    setter(currentState + increase);
-  },
-  decrease: (decrease: number) => async (setter: IGlobalStore.StateSetter<number>, currentState: number) => {
-    // perfom whatever login you want
-    setter(currentState - decrease);
-  },
-});
-
-export const useCount = countStore.getHook();
+## Consuming Persisted Store
 
+```JSX
+const [count, setCount, isCountUpdated] = useCountGlobal();
 ```
 
-Now the result of our useCount will return our actions instead of a simple setter... Let's see:
-
-```
-import { useCount } from './count'
+**isCountUpdated**: With the persist storage, the first time the hooks is called the same is gonna return the default value declared in the **new GlobalStore**, at the same time will perform an **async** request to the **async-storage** in order to get the stored value, to validate if that call was already performed, youl'll get an extra boolean value.
 
-function Stage1() {
-  const [count, actions] = useCount();
-  const increaseClick = useCallback(() => actions.plus(1), []);
-  const decreaseClick = useCallback(() => actions.decrease(1), []);
+## Decoupled hook
 
-  return (<>
-      <label>{count}<label/><br/>
-      <button onPress={increaseClick}>increase<button/>
-      <button onPress={decreaseClick}>decrease<button/>
-    </>);
-}
+```JSX
+import GlobalStore from 'react-native-global-state-hooks';
 
-```
+const countStore = new GlobalStore(0);
 
-You could also type the API contract, in order to take more advantage of typescript, just by passing an interface to getHook method:
+export const useCountGlobal = countStore.getHook();
 
-```
-export interface ICountActions {
-  plus: (increase: number) => Promise<void>,
-  decrease: (decrease: number) => Promise<void>,
-}
+export const [getCountGlobalValue, setCountGlobalValue] = countStore.getHookDecoupled();
 
-export const useCount = countStore.getHook<ICountActions>();
 ```
-The above step is necessary to get the correct typing of the parameters of your actions, otherwise, you'll get the name of the actions but the parameters would be all TYPE-ANY
 
-## 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... 
 
-Finally, if you want to access the global state outside a component, or without subscribing the component to the state changes... 
+This is especially useful when you want when you 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. 
 
-This is especially useful when you want to reuse an action into another one, or when you wrote 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 is gonna search the data, but actually don't need to hear all changes over the collection he is gonna be filtering. 
-```
-export const useCount = countStore.getHook<ICountActions>();
-export const useCountDecoupled = countStore.getHookDecoupled<ICountActions>();
-```
 
 Let's see a trivial example: 
-```
-import { useCount, useCountDecoupled } from './count'
+```JSX
+import { useCountGlobal, setCountGlobalValue } from './useCountGlobal'
 
-function Stage1() {
-  const [count] = useCount();
+const Stage1: React.FC = () => {
+  const [count] = useCountGlobal();
 
   return (<label>{count}<label/><br/>);
 }
 
-function Stage2() {
-  const [, actions] = useCountDecoupled();
-  const increaseClick = useCallback(() => actions.plus(1), []);
-  const decreaseClick = useCallback(() => actions.decrease(1), []);
+// Stage2 does not need to be updated once the global count changes
+const Stage2: React.FC = () => {
+  const increaseClick = () => setCountGlobalValue(count => count + 1);
+  const decreaseClick = () => setCountGlobalValue(count => count - 1);
 
   return (<>
       <button onPress={increaseClick}>increase<button/>
@@ -181,17 +104,10 @@ function Stage2() {
 }
 ```
 
-Now our stage 1, is just listening to the changes of the state, while stage 2 is just acting as an orchestrator, but stage 2 is not actively listening to state changes, so, actually is not gonna be re-render while stage 1 does. 
-
-# Important 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)... If does, 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. 
-
 ## 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 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
-6. 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
+2. 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
+3. 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
+
+## Advance Config
+[README]: ./README.advance.md

package/lib/GlobalStore.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="lodash" />
 import * as IGlobalStore from './GlobalStoreTypes';
 export declare const isPrimitive: <T>(value: T) => boolean;
-export declare class GlobalStore<IState, IPersist extends string | null = null, IsPersist extends boolean = IPersist extends null ? false : true, IActions extends IGlobalStore.IActionCollection<IState> | null = null> implements IGlobalStore.IGlobalState<IState, IPersist, IsPersist, IActions> {
+export declare class GlobalStore<IState, IPersist extends string | null = null, IsPersist extends boolean = IPersist extends null ? false : true, IActions extends IGlobalStore.IActionCollectionConfig<IState> | null = null> implements IGlobalStore.IGlobalState<IState, IPersist, IsPersist, IActions> {
     protected state: IState;
     protected actions: IActions;
     persistStoreAs: IPersist;
@@ -10,29 +10,28 @@ export declare class GlobalStore<IState, IPersist extends string | null = null,
     constructor(state: IState, actions?: IActions, persistStoreAs?: IPersist);
     private get isStoredStateItemUpdated();
     private storedStateItem;
-    protected formatItemFromStore<T>(obj: T): any;
-    protected formatToStore<T>(obj: T): any;
+    protected formatItemFromStore<T>(obj: T): unknown;
+    protected formatToStore<T>(obj: T): unknown;
     protected getAsyncStoreItemPromise: Promise<IState> | null;
     protected asyncStorageGetItem(): Promise<string | null>;
     protected getAsyncStoreItem(): Promise<IState>;
     protected asyncStorageSetItem(valueToStore: string): Promise<void>;
     protected setAsyncStoreItem(): Promise<void>;
-    getPersistStoreValue: () => () => Promise<IState>;
     protected getStateCopy: () => IState;
-    getHook: <IApi extends IGlobalStore.ActionCollectionResult<IActions> | null = IActions extends null ? null : IGlobalStore.ActionCollectionResult<IActions>>() => () => [IPersist extends string ? () => Promise<IState> : IState, IGlobalStore.IHookResult<IState, IActions, IApi>, IsPersist extends true ? IState : null, IsPersist extends true ? boolean : null];
-    getHookDecoupled: <IApi extends IGlobalStore.ActionCollectionResult<IActions> | null = IActions extends null ? null : IGlobalStore.ActionCollectionResult<IActions>>() => () => [() => IPersist extends string ? Promise<IState> : IState, IGlobalStore.IHookResult<IState, IActions, IApi>, IsPersist extends true ? IState : null, IsPersist extends true ? boolean : null];
+    getHook: <IApi extends IGlobalStore.ActionCollectionResult<IState, IActions> | null = IActions extends null ? null : IGlobalStore.ActionCollectionResult<IState, IActions>>() => () => [IState, IGlobalStore.IHookResult<IState, IActions, IApi>, IsPersist extends true ? boolean : null];
+    getHookDecoupled: <IApi extends IGlobalStore.ActionCollectionResult<IState, IActions> | null = IActions extends null ? null : IGlobalStore.ActionCollectionResult<IState, IActions>>() => [() => IPersist extends string ? Promise<IState> : IState, IGlobalStore.IHookResult<IState, IActions, IApi>];
     private _stateOrchestrator;
-    protected get stateOrchestrator(): IGlobalStore.StateSetter<IState> | IGlobalStore.ActionCollectionResult<IActions>;
+    protected get stateOrchestrator(): IGlobalStore.StateSetter<IState> | IGlobalStore.ActionCollectionResult<IState, IActions>;
     /**
-    **  [subscriber-update-callback, hook, newState]
+    **  [subscriber-update-callback, hook]
     */
-    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>;
+    protected static batchedUpdates: [() => void, object][];
+    protected globalSetter: (setter: IState | ((state: IState) => IState), callback: () => void) => void;
+    protected globalSetterAsync: (setter: IState | ((state: IState) => IState)) => Promise<void>;
+    protected globalSetterToPersistStoreAsync: (setter: IState | ((state: IState) => IState)) => Promise<void>;
     static ExecutePendingBatchesCallbacks: (() => void)[];
     static ExecutePendingBatches: import("lodash").DebouncedFunc<() => void>;
-    protected getActions: <IApi extends IGlobalStore.ActionCollectionResult<IGlobalStore.IActionCollection<IState>>>() => IApi;
+    protected getActions: <IApi extends IGlobalStore.ActionCollectionResult<IState, IGlobalStore.IActionCollectionConfig<IState>>>() => IApi;
 }
 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":";AAMA,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAC;AAEnD,eAAO,MAAM,WAAW,0BAAuH,CAAC;AAEhJ,qBAAa,WAAW,CACtB,MAAM,EACN,QAAQ,SAAS,MAAM,GAAG,IAAI,GAAG,IAAI,EACrC,SAAS,SAAS,OAAO,GAAG,QAAQ,SAAS,IAAI,GAAG,KAAK,GAAG,IAAI,EAChE,QAAQ,SAAS,YAAY,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CACrE,YAAW,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC;IAQ/D,SAAS,CAAC,KAAK,EAAE,MAAM;IAAE,SAAS,CAAC,OAAO,EAAE,QAAQ;IAA4B,cAAc,EAAE,QAAQ;IAN7G,WAAW,EAAE,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAM;IAE5D,IAAW,cAAc,IAAI,OAAO,CAEnC;gBAEqB,KAAK,EAAE,MAAM,EAAY,OAAO,GAAE,QAA2B,EAAS,cAAc,GAAE,QAA2B;IAEvI,OAAO,KAAK,wBAAwB,GAEnC;IAED,OAAO,CAAC,eAAe,CAAiC;IAExD,SAAS,CAAC,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG;IAoB7C,SAAS,CAAC,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,GAAG;IAavC,SAAS,CAAC,wBAAwB,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAQ;IAElE,SAAS,CAAC,mBAAmB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;cAIvC,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;cAwBpC,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;cAIxD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAU3C,oBAAoB,cAAmB,QAAQ,MAAM,CAAC,CAA6B;IAE1F,SAAS,CAAC,YAAY,QAAO,MAAM,CAAyC;IAErE,OAAO,iMAGoB,QAAQ,MAAM,CAAC,8IAsB/C;IAEK,gBAAgB,uKAGf,QAAQ,SAAS,MAAM,GAAG,QAAQ,MAAM,CAAC,GAAG,MAAM,qIAaxD;IAEF,OAAO,CAAC,kBAAkB,CAAiG;IAE3H,SAAS,KAAK,iBAAiB,IAAI,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,sBAAsB,CAAC,QAAQ,CAAC,CAYlH;IAED;;MAEE;IACF,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,UAuB5G;IAEF,SAAS,CAAC,iBAAiB,sCAA6C,MAAM,KAAK,QAAQ,MAAM,CAAC,MAChG,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;IAI3D,MAAM,CAAC,qBAAqB,6CAWtB;IAEN,SAAS,CAAC,UAAU,uGAyBlB;CAEH;AAED,eAAe,WAAW,CAAC"}
+{"version":3,"file":"GlobalStore.d.ts","sourceRoot":"","sources":["../src/GlobalStore.ts"],"names":[],"mappings":";AAMA,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAC;AAEnD,eAAO,MAAM,WAAW,0BAAuH,CAAC;AAEhJ,qBAAa,WAAW,CACtB,MAAM,EACN,QAAQ,SAAS,MAAM,GAAG,IAAI,GAAG,IAAI,EACrC,SAAS,SAAS,OAAO,GAAG,QAAQ,SAAS,IAAI,GAAG,KAAK,GAAG,IAAI,EAChE,QAAQ,SAAS,YAAY,CAAC,uBAAuB,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAC3E,YAAW,YAAY,CAAC,YAAY,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,CAAC;IAQ/D,SAAS,CAAC,KAAK,EAAE,MAAM;IAAE,SAAS,CAAC,OAAO,EAAE,QAAQ;IAA4B,cAAc,EAAE,QAAQ;IAN7G,WAAW,EAAE,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAM;IAE5D,IAAW,cAAc,IAAI,OAAO,CAEnC;gBAEqB,KAAK,EAAE,MAAM,EAAY,OAAO,GAAE,QAA2B,EAAS,cAAc,GAAE,QAA2B;IAEvI,OAAO,KAAK,wBAAwB,GAEnC;IAED,OAAO,CAAC,eAAe,CAAiC;IAExD,SAAS,CAAC,mBAAmB,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO;IA0BjD,SAAS,CAAC,aAAa,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO;IAmB3C,SAAS,CAAC,wBAAwB,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,CAAQ;IAElE,SAAS,CAAC,mBAAmB,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;cAIvC,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;cAwBpC,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;cAIxD,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAUlD,SAAS,CAAC,YAAY,QAAO,MAAM,CAAyC;IAErE,OAAO,oRA2BZ;IAEK,gBAAgB,iLAGV,QAAQ,SAAS,MAAM,GAAG,QAAQ,MAAM,CAAC,GAAG,MAAM,oDAO7D;IAEF,OAAO,CAAC,kBAAkB,CAAyG;IAEnI,SAAS,KAAK,iBAAiB,IAAI,YAAY,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,YAAY,CAAC,sBAAsB,CAAC,MAAM,EAAE,QAAQ,CAAC,CAY1H;IAED;;MAEE;IACF,SAAS,CAAC,MAAM,CAAC,cAAc,EAAE,CAAC,MAAM,IAAI,EAAE,MAAM,CAAC,EAAE,CAAM;IAE7D,SAAS,CAAC,YAAY,6BAA8B,MAAM,KAAK,MAAM,aAAa,MAAM,IAAI,UAqB1F;IAEF,SAAS,CAAC,iBAAiB,6BAAoC,MAAM,KAAK,MAAM,MAC9E,QAAQ,IAAI,CAAC,CAAyE;IAExF,SAAS,CAAC,+BAA+B,6BAAoC,MAAM,KAAK,MAAM,MAAI,QAAQ,IAAI,CAAC,CAG7G;IAEF,MAAM,CAAC,8BAA8B,EAAE,CAAC,MAAM,IAAI,CAAC,EAAE,CAAM;IAI3D,MAAM,CAAC,qBAAqB,6CAWtB;IAEN,SAAS,CAAC,UAAU,qHAyBlB;CAEH;AAED,eAAe,WAAW,CAAC"}

package/lib/GlobalStore.js

@@ -4,9 +4,9 @@ exports.GlobalStore = exports.isPrimitive = void 0;
 const tslib_1 = require("tslib");
 const react_1 = require("react");
 const lodash_1 = require("lodash");
-const async_storage_1 = tslib_1.__importDefault(require("@react-native-async-storage/async-storage"));
-const react_dom_1 = tslib_1.__importDefault(require("react-dom"));
-const isPrimitive = (value) => lodash_1.isNil(value) || lodash_1.isNumber(value) || lodash_1.isBoolean(value) || lodash_1.isString(value) || typeof value === 'symbol';
+const async_storage_1 = (0, tslib_1.__importDefault)(require("@react-native-async-storage/async-storage"));
+const react_dom_1 = (0, tslib_1.__importDefault)(require("react-dom"));
+const isPrimitive = (value) => (0, lodash_1.isNil)(value) || (0, lodash_1.isNumber)(value) || (0, lodash_1.isBoolean)(value) || (0, lodash_1.isString)(value) || typeof value === 'symbol';
 exports.isPrimitive = isPrimitive;
 class GlobalStore {
     constructor(state, actions = null, persistStoreAs = null) {
@@ -16,55 +16,51 @@ class GlobalStore {
         this.subscribers = [];
         this.storedStateItem = undefined;
         this.getAsyncStoreItemPromise = null;
-        this.getPersistStoreValue = () => () => tslib_1.__awaiter(this, void 0, void 0, function* () { return this.getAsyncStoreItem(); });
-        this.getStateCopy = () => Object.freeze(lodash_1.cloneDeep(this.state));
+        this.getStateCopy = () => Object.freeze((0, lodash_1.cloneDeep)(this.state));
         this.getHook = () => () => {
-            const [value, setter] = react_1.useState(this.state);
-            const valueWrapper = this.isPersistStore ? this.getPersistStoreValue() : value;
-            react_1.useEffect(() => {
+            const [value, setter] = (0, react_1.useState)(() => this.state);
+            (0, react_1.useEffect)(() => {
                 this.subscribers.push(setter);
+                if (this.isPersistStore) {
+                    this.getAsyncStoreItem();
+                }
                 return () => {
                     this.subscribers = this.subscribers.filter((hook) => setter !== hook);
                 };
             }, []);
             return [
-                valueWrapper,
+                value,
                 this.stateOrchestrator,
-                this.state,
                 this.isStoredStateItemUpdated,
             ];
         };
-        this.getHookDecoupled = () => () => {
-            const valueWrapper = this.isPersistStore ? this.getPersistStoreValue() : () => this.state;
+        this.getHookDecoupled = () => {
+            const valueWrapper = this.isPersistStore ? this.getAsyncStoreItem() : () => this.state;
             return [
                 valueWrapper,
                 this.stateOrchestrator,
-                this.state,
-                this.isStoredStateItemUpdated,
             ];
         };
         this._stateOrchestrator = null;
         this.globalSetter = (setter, callback) => {
-            const partialState = typeof setter === 'function' ? setter(this.getStateCopy()) : setter;
-            let newState = exports.isPrimitive(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]) => {
+            // avoid perform multiple updates over the same state
+            GlobalStore.batchedUpdates = GlobalStore.batchedUpdates.filter(([, hook]) => {
                 const isSameHook = hook === this;
                 if (isSameHook) {
                     // eslint-disable-next-line no-console
                     console.warn('You should try avoid call the same state-setter multiple times at one execution line');
-                    newState = exports.isPrimitive(newState) ? newState : Object.assign(Object.assign({}, previousState), newState);
                 }
                 return !isSameHook;
             });
+            const newState = typeof setter === 'function' ? setter(this.getStateCopy()) : setter;
             this.state = newState;
             // batch store updates
-            GlobalStore.batchedUpdates.push([() => this.subscribers.forEach((updateChild) => updateChild(newState)), this, newState]);
+            GlobalStore.batchedUpdates.push([() => this.subscribers.forEach((updateChild) => updateChild(newState)), this]);
             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* () {
+        this.globalSetterAsync = (setter) => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () { return new Promise((resolve) => this.globalSetter(setter, () => resolve())); });
+        this.globalSetterToPersistStoreAsync = (setter) => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             yield this.globalSetterAsync(setter);
             yield this.setAsyncStoreItem();
         });
@@ -73,7 +69,7 @@ class GlobalStore {
             // Setter is allways async because of the render batch
             // but we are typing the setter as synchronous to avoid the developer has extra complexity that useState do not handle
             const setter = this.isPersistStore ? this.globalSetterToPersistStoreAsync : this.globalSetterAsync;
-            return Object.keys(actions).reduce((accumulator, key) => (Object.assign(Object.assign({}, accumulator), { [key]: (...parameres) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return Object.keys(actions).reduce((accumulator, key) => (Object.assign(Object.assign({}, accumulator), { [key]: (...parameres) => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
                     let promise;
                     const setterWrapper = (value) => {
                         promise = setter(value);
@@ -93,6 +89,10 @@ class GlobalStore {
         return this.storedStateItem !== undefined;
     }
     formatItemFromStore(obj) {
+        const isArray = Array.isArray(obj);
+        if (isArray) {
+            return obj.map((item) => this.formatItemFromStore(item));
+        }
         return Object.keys(obj).filter((key) => !key.includes('_type')).reduce((acumulator, key) => {
             const type = obj[`${key}_type`];
             const unformatedValue = obj[key];
@@ -100,32 +100,36 @@ class GlobalStore {
             if (isDateType) {
                 return Object.assign(Object.assign({}, acumulator), { [key]: new Date(unformatedValue) });
             }
-            return Object.assign(Object.assign({}, acumulator), { [key]: exports.isPrimitive(unformatedValue) ? unformatedValue : this.formatItemFromStore(unformatedValue) });
+            return Object.assign(Object.assign({}, acumulator), { [key]: (0, exports.isPrimitive)(unformatedValue) ? unformatedValue : this.formatItemFromStore(unformatedValue) });
         }, {});
     }
     formatToStore(obj) {
+        const isArray = Array.isArray(obj);
+        if (isArray) {
+            return obj.map((item) => this.formatToStore(item));
+        }
         return Object.keys(obj).reduce((acumulator, key) => {
             const value = obj[key];
             const isDatetime = value instanceof Date;
-            return (Object.assign(Object.assign({}, acumulator), { [key]: exports.isPrimitive(value) || isDatetime ? value : this.formatToStore(value), [`${key}_type`]: isDatetime ? 'date' : typeof value }));
+            return (Object.assign(Object.assign({}, acumulator), { [key]: (0, exports.isPrimitive)(value) || isDatetime ? value : this.formatToStore(value), [`${key}_type`]: isDatetime ? 'date' : typeof value }));
         }, {});
     }
     asyncStorageGetItem() {
         return async_storage_1.default.getItem(this.persistStoreAs);
     }
     getAsyncStoreItem() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (this.isStoredStateItemUpdated)
                 return this.storedStateItem;
             if (this.getAsyncStoreItemPromise)
                 return this.getAsyncStoreItemPromise;
             this.getAsyncStoreItemPromise = new Promise((resolve) => {
-                (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                (() => (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
                     const item = yield this.asyncStorageGetItem();
                     if (item) {
                         const value = JSON.parse(item);
-                        const primitive = exports.isPrimitive(value);
-                        const newState = primitive ? value : this.formatItemFromStore(value);
+                        const primitive = (0, exports.isPrimitive)(value);
+                        const newState = primitive || Array.isArray(value) ? value : this.formatItemFromStore(value);
                         yield this.globalSetterAsync(newState);
                     }
                     resolve(this.state);
@@ -135,16 +139,16 @@ class GlobalStore {
         });
     }
     asyncStorageSetItem(valueToStore) {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             yield async_storage_1.default.setItem(this.persistStoreAs, valueToStore);
         });
     }
     setAsyncStoreItem() {
-        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
             if (this.storedStateItem === this.state)
                 return;
             this.storedStateItem = this.state;
-            const valueToStore = exports.isPrimitive(this.state) ? this.state : this.formatToStore(lodash_1.cloneDeep(this.state));
+            const valueToStore = (0, exports.isPrimitive)(this.state) ? this.state : this.formatToStore((0, lodash_1.cloneDeep)(this.state));
             yield this.asyncStorageSetItem(JSON.stringify(valueToStore));
         });
     }
@@ -165,13 +169,13 @@ class GlobalStore {
 }
 exports.GlobalStore = GlobalStore;
 /**
-**  [subscriber-update-callback, hook, newState]
+**  [subscriber-update-callback, hook]
 */
 GlobalStore.batchedUpdates = [];
 GlobalStore.ExecutePendingBatchesCallbacks = [];
 // avoid multiples calls to batchedUpdates
 // eslint-disable-next-line @typescript-eslint/no-empty-function
-GlobalStore.ExecutePendingBatches = lodash_1.debounce(() => {
+GlobalStore.ExecutePendingBatches = (0, lodash_1.debounce)(() => {
     const reactBatchedUpdates = react_dom_1.default.unstable_batchedUpdates || ((mock) => mock());
     reactBatchedUpdates(() => {
         GlobalStore.batchedUpdates.forEach(([execute]) => {

package/lib/GlobalStoreTypes.d.ts

@@ -1,28 +1,34 @@
 /**
 * @param {StateSetter<IState>} setter - add a new value to the state
-* @returns {Promise<void>} result - resolves when update_batches finished
+* @returns {void} result - void
 */
-export declare type StateSetter<IState> = (setter: Partial<IState> | ((state: IState) => Partial<IState>)) => Promise<void>;
+export declare type StateSetter<IState> = (setter: IState | ((state: IState) => IState)) => 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 declare type IAction<IState> = <IResult>(...params: any[]) => (setter: StateSetter<IState>, currentState: IState) => Promise<unknown> | IResult;
+export declare type IActionConfig<IState> = (...params: any[]) => (setter: StateSetter<IState>, currentState: IState) => Promise<unknown>;
 /**
 * Configuration of you API
 */
-export interface IActionCollection<IState> {
-    [key: string]: IAction<IState>;
+export interface IActionCollectionConfig<IState> {
+    [key: string]: IActionConfig<IState>;
+}
+/**
+* This should be the API format of the hook (if you passed an API as a parameter)
+*/
+export interface IActionCollectionResult {
+    [key: string]: (...params: any[]) => Promise<unknown>;
 }
 /**
 * This is the API result of the hook (if you passed an API as a parameter)
 */
-export declare type ActionCollectionResult<IActions> = {
-    [key in keyof IActions]: <IResult>(...params: any[]) => any | IResult;
+export declare type ActionCollectionResult<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 declare type IHookResult<IState, IActions extends IActionCollection<IState> | null = null, IApi extends ActionCollectionResult<IActions> | null = IActions extends null ? null : ActionCollectionResult<IActions>> = IApi extends null ? StateSetter<IState> : IActions extends IActionCollection<IState> ? IApi extends ActionCollectionResult<IActions> ? IApi : StateSetter<IState> : StateSetter<IState>;
+export declare type IHookResult<IState, IActions extends IActionCollectionConfig<IState> | null = null, IApi extends ActionCollectionResult<IState, IActions> | null = IActions extends null ? null : ActionCollectionResult<IState, IActions>> = IApi extends null ? StateSetter<IState> : IActions extends IActionCollectionConfig<IState> ? IApi extends ActionCollectionResult<IState, IActions> ? IApi : StateSetter<IState> : StateSetter<IState>;
 /**
 * This is a class to create global-store objects
 * @template IState
@@ -36,34 +42,31 @@ export declare type IHookResult<IState, IActions extends IActionCollection<IStat
 * 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, IPersist extends string | null = null, IsPersist extends boolean = IPersist extends null ? false : true, IActions extends IActionCollection<IState> | null = null> {
+export interface IGlobalState<IState, IPersist extends string | null = null, IsPersist extends boolean = IPersist extends null ? false : true, IActions extends IActionCollectionConfig<IState> | null = null> {
     persistStoreAs: IPersist;
     isPersistStore: boolean;
     /**
     * Returns a global hook that will share information across components by subscribing them to a specific store.
     * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>, initialStatePersistStorage | null, isUpdatedPersistStorage | null]
     */
-    getHook: <IApi extends IActions extends ActionCollectionResult<IActions> ? ActionCollectionResult<IActions> : null>() => () => [
-        IPersist extends string ? () => Promise<IState> : IState,
+    getHook: <IApi extends IActions extends ActionCollectionResult<IState, IActions> ? ActionCollectionResult<IState, IActions> : null>() => () => [
+        IState,
         IHookResult<IState, IActions, IApi>,
-        IsPersist extends true ? IState : null,
         IsPersist extends true ? boolean : null
     ];
     /**
     * 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>, initialStatePersistStorage | null, isUpdatedPersistStorage | null]
+    * @return [currentState, GlobalState.IHookResult<IState, IActions, IApi>]
     */
-    getHookDecoupled: <IApi extends IActions extends ActionCollectionResult<IActions> ? ActionCollectionResult<IActions> : null>() => () => [
+    getHookDecoupled: <IApi extends IActions extends ActionCollectionResult<IState, IActions> ? ActionCollectionResult<IState, IActions> : null>() => [
         () => IPersist extends string ? Promise<IState> : IState,
-        IHookResult<IState, IActions, IApi>,
-        IsPersist extends true ? IState : null,
-        IsPersist extends true ? boolean : null
+        IHookResult<IState, IActions, IApi>
     ];
 }
 /**
  * @deprecated This interface name is deprecated, use instead IGlobalState
  */
-export interface IGlobalStateFactory<IState, IPersist extends string | null = null, IsPersist extends boolean = IPersist extends null ? false : true, IActions extends IActionCollection<IState> | null = null> extends IGlobalState<IState, IPersist, IsPersist, IActions> {
+export interface IGlobalStateFactory<IState, IPersist extends string | null = null, IsPersist extends boolean = IPersist extends null ? false : true, IActions extends IActionCollectionConfig<IState> | null = null> extends IGlobalState<IState, IPersist, IsPersist, IActions> {
 }
 //# sourceMappingURL=GlobalStoreTypes.d.ts.map

package/lib/GlobalStoreTypes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GlobalStoreTypes.d.ts","sourceRoot":"","sources":["../src/GlobalStoreTypes.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"GlobalStoreTypes.d.ts","sourceRoot":"","sources":["../src/GlobalStoreTypes.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-global-state-hooks",
-  "version": "1.1.3",
-  "description": "This is a package to easily handling global-state across your react-native-components No-redux, No-context.",
+  "version": "2.0.0",
+  "description": "This is a package to easily handling global-state across your react-native-components No-redux",
   "main": "lib/GlobalStore.js",
   "files": [
     "lib"
@@ -63,5 +63,11 @@
     "lodash": "workspace:*",
     "react": "workspace:*",
     "react-dom": "workspace:*"
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.15.14",
+    "lodash": "^4.17.21",
+    "react": "^17.0.2",
+    "react-dom": "^17.0.2"
   }
 }