react-native-global-state-hooks 2.1.8 → 2.1.10

package/README.md

@@ -138,83 +138,72 @@ Here is an example of how you could create your custom store that for example st
 You could just use this code right as it is by just adding also into your project **@react-native-async-storage** or whatever another async storage library.
 
 ```ts
-export class GlobalStoreAsync<
+/**
+ * GlobalStore is an store that could also persist the state in the async storage
+ * @template {TState} TState - The state of the store
+ * @template {TMetadata} TMetadata - The metadata of the store, it must contain a readonly property called isAsyncStorageReady which cannot be set from outside the store
+ * @template {TStateSetter} TStateSetter - The storeActionsConfig of the store
+ */
+export class GlobalStore<
   TState,
-  TMetadata extends { readonly isAsyncStorageReady: never },
   // this restriction is needed to avoid the consumers to set the isAsyncStorageReady property from outside the store,
-  // even when the value will be ignored is better to avoid it to avoid confusion
-  TStateSetter extends
-    | ActionCollectionConfig<
-        TState,
-        Omit<TMetadata, 'isAsyncStorageReady'> & {
-          readonly isAsyncStorageReady: boolean;
-        }
-      >
-    | StateSetter<TState>
-    | null = StateSetter<TState>
-> extends GlobalStore<
-  TState,
-  Omit<TMetadata, 'isAsyncStorageReady'> & {
-    readonly isAsyncStorageReady: boolean;
-  },
-  TStateSetter
-> {
-  protected config: NonNullable<
-    GlobalStoreConfig<
-      TState,
-      Omit<TMetadata, 'isAsyncStorageReady'> & {
-        readonly isAsyncStorageReady: boolean;
-      },
-      NonNullable<TStateSetter>
-    >
-  > & {
-    asyncStorageKey: string;
-  };
+  // ... even when the value will be ignored is better to avoid it to avoid confusion
+  TMetadata extends { readonly isAsyncStorageReady: never },
+  TStateSetter extends StorageSetter<TState, TMetadata> = StateSetter<TState>
+> extends GlobalStoreBase<TState, StorageMetadata<TMetadata>, TStateSetter> {
+  /**
+   * Config for the async storage
+   * includes the asyncStorageKey and the metadata which will be used to determine if the async storage is ready or not
+   * @template {TState} TState - The state of the store
+   * @template {TMetadata} TMetadata - The metadata of the store
+   * @template {TStateSetter} TStateSetter - The storeActionsConfig of the store
+   **/
+  protected config: StorageConfig<TState, TMetadata, TStateSetter>;
 
+  /**
+   * Creates a new instance of the GlobalStore
+   * @param {TState} state - The initial state of the store
+   * @param {GlobalStoreConfig<TState, TMetadata, ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>> & { asyncStorageKey: string; }} config - The config of the store
+   * @param  {GlobalStoreConfig<TState, TMetadata, ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>> & { asyncStorageKey: string; }} config.metadata - The metadata of the store which will be used to determine if the async storage is ready or not, also it could store no reactive data
+   * @param  {GlobalStoreConfig<TState, TMetadata, ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>> & { asyncStorageKey: string; }} config.asyncStorageKey - The key of the async storage
+   * @param  {GlobalStoreConfig<TState, TMetadata, ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>> & { asyncStorageKey: string; }} config.onInit - The callback that will be called once the store is created
+   * @param  {GlobalStoreConfig<TState, TMetadata, ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>> & { asyncStorageKey: string; }} config.onStateChange - The callback that will be called once the state is changed
+   * @param  {GlobalStoreConfig<TState, TMetadata, ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>> & { asyncStorageKey: string; }} config.onSubscribed - The callback that will be called every time a new component is subscribed to the store
+   * @param  {GlobalStoreConfig<TState, TMetadata, ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>> & { asyncStorageKey: string; }} config.computePreventStateChange - The callback that will be called before the state is changed, if it returns true the state will not be changed
+   * @param {TStateSetter} setterConfig - The actions configuration object (optional) (default: null) if not null the store manipulation will be done through the actions
+   */
   constructor(
     state: TState,
-    config: GlobalStoreConfig<
-      TState,
-      TMetadata,
-      ActionCollectionConfig<TState, TMetadata> | StateSetter<TState>
-    > & {
-      asyncStorageKey: string;
-    },
+    config: StorageConfig<TState, TMetadata, TStateSetter> | null = null,
     setterConfig: TStateSetter | null = null
   ) {
-    type TConfig = NonNullable<
-      GlobalStoreConfig<
-        TState,
-        Omit<TMetadata, 'isAsyncStorageReady'> & {
-          readonly isAsyncStorageReady: boolean;
-        },
-        NonNullable<TStateSetter>
-      >
-    > & {
-      asyncStorageKey: string;
-    };
-
-    const { onInit: onInitConfig, ...configParameters } = config as TConfig;
+    const { onInit, asyncStorageKey, ...configParameters } = config ?? {};
 
     super(state, configParameters, setterConfig as TStateSetter);
 
+    // if there is not async storage key this is not a persistent store
+    const isAsyncStorageReady = asyncStorageKey ? false : null;
+
     this.config = {
       ...config,
       metadata: {
         ...configParameters.metadata,
-        isAsyncStorageReady: false,
+        isAsyncStorageReady,
       },
-    } as TConfig;
+    } as StorageConfig<TState, TMetadata, TStateSetter>;
+
+    const hasInitCallbacks = !!(asyncStorageKey || onInit);
+    if (!hasInitCallbacks) return;
 
     const parameters = this.getConfigCallbackParam({});
 
     this.onInit(parameters);
-    onInitConfig?.(parameters);
+    onInit?.(parameters);
   }
 
   /**
    * This method will be called once the store is created after the constructor,
-   * this method is different from the onInit of the config property and it won't be overriden
+   * this method is different from the onInit of the confg property and it won't be overriden
    */
   protected onInit = async ({
     setState,
@@ -222,12 +211,12 @@ export class GlobalStoreAsync<
     getMetadata,
   }: StateConfigCallbackParam<
     TState,
-    Omit<TMetadata, 'isAsyncStorageReady'> & {
-      readonly isAsyncStorageReady: boolean;
-    },
+    StorageMetadata<TMetadata>,
     NonNullable<TStateSetter>
   >) => {
     const { asyncStorageKey } = this.config;
+    if (!asyncStorageKey) return;
+
     const storedItem: string = await asyncStorage.getItem(asyncStorageKey);
 
     setMetadata({
@@ -247,12 +236,11 @@ export class GlobalStoreAsync<
     getState,
   }: StateChangesParam<
     TState,
-    Omit<TMetadata, 'isAsyncStorageReady'> & {
-      readonly isAsyncStorageReady: boolean;
-    },
+    StorageMetadata<TMetadata>,
     NonNullable<TStateSetter>
   >) => {
     const { asyncStorageKey } = this.config;
+    if (!asyncStorageKey) return;
 
     const state = getState();
     const formattedObject = formatToStore(state, {
@@ -262,6 +250,76 @@ export class GlobalStoreAsync<
     asyncStorage.setItem(asyncStorageKey, formattedObject);
   };
 }
+
+/**
+ * Metadata of the store
+ * @template {TMetadata} TMetadata - The metadata type which also contains the isAsyncStorageReady property
+ */
+type StorageMetadata<TMetadata> = Omit<TMetadata, 'isAsyncStorageReady'> & {
+  readonly isAsyncStorageReady: boolean | null;
+};
+
+/**
+ * The setter of the store
+ * @template {TState} TState - The state of the store
+ * @template {TMetadata} TMetadata - The metadata of the store, it must contain a readonly property called isAsyncStorageReady which cannot be set from outside the store
+ * */
+type StorageSetter<TState, TMetadata> =
+  | ActionCollectionConfig<TState, StorageMetadata<TMetadata>>
+  | StateSetter<TState>
+  | null;
+
+/**
+ * Config for the async storage
+ * includes the asyncStorageKey
+ * @template {TState} TState - The state of the store
+ * @template {TMetadata} TMetadata - The metadata of the store, it must contain a readonly property called isAsyncStorageReady which cannot be set from outside the store
+ * @template {TStateSetter} TStateSetter - The storeActionsConfig of the store
+ */
+type StorageConfig<
+  TState,
+  TMetadata extends { readonly isAsyncStorageReady: never },
+  TStateSetter extends
+    | ActionCollectionConfig<TState, StorageMetadata<TMetadata>>
+    | StateSetter<TState>
+    | null = StateSetter<TState>
+> = {
+  asyncStorageKey?: string;
+
+  metadata?: TMetadata;
+
+  onInit?: (
+    parameters: StateConfigCallbackParam<
+      TState,
+      StorageMetadata<TMetadata>,
+      NonNullable<TStateSetter>
+    >
+  ) => void;
+
+  onStateChanged?: (
+    parameters: StateChangesParam<
+      TState,
+      StorageMetadata<TMetadata>,
+      NonNullable<TStateSetter>
+    >
+  ) => void;
+
+  onSubscribed?: (
+    parameters: StateConfigCallbackParam<
+      TState,
+      StorageMetadata<TMetadata>,
+      NonNullable<TStateSetter>
+    >
+  ) => void;
+
+  computePreventStateChange?: (
+    parameters: StateChangesParam<
+      TState,
+      StorageMetadata<TMetadata>,
+      NonNullable<TStateSetter>
+    >
+  ) => boolean;
+};
 ```
 
 The methods **formatToStore** and **formatFromStore** are part of another library of my [json-storage-formatter](https://www.npmjs.com/package/json-storage-formatter)...
@@ -439,24 +497,391 @@ const store = new GlobalStore(0, {
 
 ...
 
-## Advantages:
+# Examples and Comparison:
 
-1. Using REACT's simplest and default way to deal with the state.
-2. Adding partial state designations (This is not on useState default functionality)
-3. Added availability to create actions and decoupled access to the states, no more connects, and dispatches, just call your actions as a normal service of whatever other libraries.
-4. This library is already taking care of avoiding re-renders if the new state does not have changes
-5. This tool also take care for you to avoid **async-storage\*** data to lose the data types that you stored. For example when you are using datetimes
+## 1. Lets try to share some state between components
 
-...
+### **With the GlobalStore approach, it will look like this:**
 
-...
+```tsx
+type TUser = {
+  name: string;
+  email: string;
+};
 
-...
+const useUserStore = new GlobalStore<TUser>({
+  name: null,
+  email: null,
+}).getHook();
 
-...
+const Component = () => {
+  const [currentUser] = useUserStore();
+
+  return <Text>{currentUser.name}</Text>;
+};
+```
+
+## Simple, right?
+
+### Let's now see how this same thing would look like by using context:
+
+```tsx
+type TUser = {
+  name: string;
+  email: string;
+};
+
+const UserContext = createContext<{
+  currentUser: TUser;
+}>({
+  currentUser: null,
+});
+
+const UserProvider: React.FC<PropsWithChildren> = ({ children }) => {
+  const [currentUser, setCurrentUser] = useState<TUser>(null);
+
+  // ...get current user information
+
+  return (
+    <UserContext.Provider value={{ currentUser }}>
+      {children}
+    </UserContext.Provider>
+  );
+};
+
+const Component = () => {
+  const { currentUser } = useContext(UserContext);
+
+  return <Text>{currentUser.name}</Text>;
+};
+
+const App = () => {
+  return (
+    <UserProvider>
+      <Component />
+    </UserProvider>
+  );
+};
+```
+
+### We already are able to notice a couple of extra lines right?
+
+Let's now add another simple store to the equation
+
+### **With the GlobalStore approach, it will look like this:**
+
+```tsx
+type TUser = {
+  name: string;
+  email: string;
+};
+
+const useUserStore = new GlobalStore<TUser>({
+  name: null,
+  email: null,
+}).getHook();
+
+// we create the store
+const useCountStore = new GlobalStore(0).getHook();
+
+const Component = () => {
+  const [currentUser] = useUserStore();
 
-# Finallly notes:
+  // from the component we consume the new store
+  const [count, setCount] = useCountStore();
+
+  return <Text>{currentUser.name}</Text>;
+};
+```
+
+With context, we'll have again to create all the boilerplate, and wrap the component into the new provider...
+
+### **Lets see that**
+
+```tsx
+type TUser = {
+  name: string;
+  email: string;
+};
+
+const UserContext = createContext<{
+  currentUser: TUser;
+}>({
+  currentUser: null,
+});
+
+// let's create the context
+const CountContext = createContext({
+  count: 0,
+  setCount: (() => {
+    throw new Error('not implemented');
+  }) as Dispatch<SetStateAction<number>>,
+});
 
-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**...
+const UserProvider: React.FC<PropsWithChildren> = ({ children }) => {
+  const [currentUser, setCurrentUser] = useState<TUser>(null);
+
+  // ...
+
+  return (
+    <UserContext.Provider value={{ currentUser }}>
+      {children}
+    </UserContext.Provider>
+  );
+};
+
+// we also need another provider
+const CountProvider: React.FC<PropsWithChildren> = ({ children }) => {
+  const [count, setCount] = useState(0);
+
+  return (
+    <CountContext.Provider value={{ count, setCount }}>
+      {children}
+    </CountContext.Provider>
+  );
+};
+
+// we need to wrap the component into the new provider (this is for each future context)
+const App = () => {
+  return (
+    <UserProvider>
+      <CountProvider>
+        <Component />
+      </CountProvider>
+    </UserProvider>
+  );
+};
+
+const Component = () => {
+  const { currentUser } = useContext(UserContext);
+
+  // finally we are able to get access to the new context...
+  const { count, setCount } = useContext(CountContext);
+
+  return <Text>{currentUser.name}</Text>;
+};
+```
+
+In this example, we are able to see how every time along with creating a good amount of repetitive code, we also have to wrap the necessary components into the Provider... Also, notice how every time we need to modify the **App** component, even when the App component is not gonna use the new state.
+
+### Let's make this a little more complex, now I want to implement custom methods for manipulating the count state, I also want to have the ability to modify the count state **without** having to be subscribed to the changes of the state... have you ever done that?
+
+This is a common scenery, and guess what? in the **context** examples, we'll have to create another context, another provider, wrap and everything again...
+
+## Let's see this time first the **context** approach
+
+```tsx
+type TUser = {
+  name: string;
+  email: string;
+};
+
+const UserContext = createContext<{
+  currentUser: TUser;
+}>({
+  currentUser: null,
+});
+
+// let's remove the setter from this context
+const CountContext = createContext({
+  count: 0,
+});
+
+// lets create another context to share the actions
+const CountContextSetter = createContext({
+  increase: (): void => {
+    throw new Error('increase is not implemented');
+  },
+  decrease: (): void => {
+    throw new Error('decrease is not implemented');
+  },
+});
+
+const UserProvider: React.FC<PropsWithChildren> = ({ children }) => {
+  const [currentUser, setCurrentUser] = useState<TUser>(null);
+
+  // ...
+
+  return (
+    <UserContext.Provider value={{ currentUser }}>
+      {children}
+    </UserContext.Provider>
+  );
+};
+
+// To don't overcomplicate the example let's just add but providers into this component, that will be enough
+const CountProvider: React.FC<PropsWithChildren> = ({ children }) => {
+  const [count, setCount] = useState(0);
+
+  const increase = () => setCount(count + 1);
+  const decrease = () => setCount(count - 1);
+
+  return (
+    //one context is gonna share the edition of the state
+    <CountContext.Provider value={{ count }}>
+      {/* this second component will share the mutations of the state */}
+      <CountContextSetter.Provider value={{ increase, decrease }}>
+        {children}
+      </CountContextSetter.Provider>
+    </CountContext.Provider>
+  );
+};
+
+// Since we used the same provider we don't need to modify the  **App** component, but we do are **Wrapping** everything into one more **Provider**
+const App = () => {
+  return (
+    <UserProvider>
+      <CountProvider>
+        {/* lets create two componets instead of one */}
+        <ComponentSetter />
+        <Component />
+      </CountProvider>
+    </UserProvider>
+  );
+};
+
+const ComponentSetter = () => {
+  const { increase, decrease } = useContext(CountContextSetter);
+
+  return (
+    <View>
+      <Button title='Increase' onPress={increase} />
+      <Button title='Decrease' onPress={decrease} />
+    </View>
+  );
+};
+
+const Component = () => {
+  const { currentUser } = useContext(UserContext);
+
+  // finally we are able to get access to the new context...
+  const { count } = useContext(CountContext);
+
+  return (
+    <View>
+      <Text>{currentUser.name}</Text>
+      <Text>{count}</Text>
+    </View>
+  );
+};
+```
+
+Wow, a lot!!! just to be able to separate the mutations... and have mutations!!
+
+### it would be easier with the GlobalStore? Let's see.
+
+```tsx
+type TUser = {
+  name: string;
+  email: string;
+};
+
+const useUser = new GlobalStore<TUser>({
+  name: null,
+  email: null,
+}).getHook();
+
+// let's modify the store to add custom actions, the second parameter is configuration let's just pass null for now
+const countStore = new GlobalStore(0, null, {
+  increase() {
+    return ({ setState }: StoreTools<number>) => {
+      setState((state) => state + 1);
+    };
+  },
+
+  decrease() {
+    return ({ setState }: StoreTools<number>) => {
+      setState((state) => state - 1);
+    };
+  },
+} as const);
+
+const useCount = countStore.getHook();
+
+// this actions don't use hooks, but are connected to the store and all the subscribers will be notified
+const [, countActions] = countStore.getHookDecoupled();
+
+// this component is not subscribed to the store, so it will not be notified when the state changes
+const ComponentSetter = () => {
+  return (
+    <View>
+      <Button title='Increase' onPress={countActions.increase} />
+      <Button title='Decrease' onPress={countActions.decrease} />
+    </View>
+  );
+};
+
+// this component is subscribed to the store, so it will be notified when the state changes
+const Component = () => {
+  const [user] = useUser();
+  const [count, actions] = useCount();
+
+  return (
+    <View>
+      <Text>{count}</Text>
+    </View>
+  );
+};
+```
+
+### So let's analyze what happened
+
+To restrict the state manipulations with the custom actions, we just need to add a third parameter to the store.
+
+```ts
+const countStore = new GlobalStore(0, null, {
+  log: (action: string) => () => console.log(action),
+
+  // every action is a function that returns a function that receives the store tools
+  increase() {
+    return ({ setState, getState }: StoreTools<number>): number => {
+      setState((state) => state + 1);
+
+      // actions are able to communicate between them
+      this.log('increase');
+
+      return getState();
+    };
+  },
+} as const);
+
+// the const is necessary to avoid typescript errors
+```
+
+All the library is strongly typed, we use generics to return the correct data type in each action.
+
+```ts
+const [, actions] = countStore.getHookDecoupled();
+
+// for example the type of actions.increase will be: () => number
+// just in case, even the parameters of the actions are gonna be exposed through TS
+```
+
+## getHookDecoupled
+
+### **getHookDecoupled** returns a tuple with the state and the actions,
+
+This is so useful when you want to use the actions without having to be subscribed to changes of the state.
+There is also a third element in the tuple which is a function for getting the metadata of the store
+
+### the metadata of the store is not reactive information which could be shared through the store
+
+## Adding metadata to the store
+
+```tsx
+const [, , getMetadata] = new GlobalStore(0, {
+  metadata: {
+    isStoredSyncronized: false,
+  },
+}).getHookDecoupled();
+
+console.log(getMetadata().isStoredSyncronized); // false
+```
+
+The setMetadata is part of the store tools, so it can be used in the actions, but againg the metadata is not reactive!! so it will not trigger a re-render on the subscribers
+
+...
+
+...
 
-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.
+# That's it for now!! hope you enjoy coding!!

package/lib/GlobalStore.d.ts.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-global-state-hooks",
-  "version": "2.1.8",
+  "version": "2.1.10",
   "description": "This is a package to easily handling global-state across your react-native-components No-redux",
   "main": "lib/GlobalStore.js",
   "files": [
@@ -65,6 +65,6 @@
     "react": "workspace:*"
   },
   "dependencies": {
-    "json-storage-formatter": "^1.0.4"
+    "json-storage-formatter": "^1.0.5"
   }
 }