using 'data' instead of the misleading 'action' on reducers

Author: jhonnymichel

src/index.js

@@ -18,7 +18,7 @@ class StoreInterface {
 
   /**
    * Subscribe to store changes
-   * @param {(state:any, action:any) => void} callback - The function to be invoked everytime the store is updated
+   * @param {(state:any, data:any) => void} callback - The function to be invoked everytime the store is updated
    * @return {Function} - Call the function returned by the method to cancel the subscription
    */
   subscribe(callback) {
@@ -35,11 +35,18 @@ class StoreInterface {
     }
   }
 
-  setState() {
+  /**
+   * Set the store state
+   * @param {any} data - The new state value.
+   */
+  setState(data) {
     console.warn(`[React Hookstore] Store ${this.name} uses a reducer to handle its state updates. use dispatch instead of setState`)
   }
-
-  dispatch() {
+  /**
+   * Dispatch data to the store reducer
+   * @param {any} data - The data payload the reducer receives
+   */
+  dispatch(data) {
     console.warn(`[React Hookstore] Store ${this.name} does not use a reducer to handle state updates. use setState instead of dispatch`)
   }
 }
@@ -56,7 +63,7 @@ function getStoreByIdentifier(identifier) {
  * Creates a new store
  * @param {String} name - The store namespace.
  * @param {*} state [{}] - The store initial state. It can be of any type.
- * @param {(state:any, action:any) => any} reducer [null] - The reducer handler. Optional
+ * @param {(state:any, data:any) => any} reducer [null] - The reducer handler. Optional
  * @returns {StoreInterface} The store instance.
  */
 export function createStore(name, state = {}, reducer=defaultReducer) {
@@ -66,23 +73,24 @@ export function createStore(name, state = {}, reducer=defaultReducer) {
   if (stores[name]) {
     throw `Store with name ${name} already exists`;
   }
+  
 
   const store = {
     state,
     reducer,
-    setState(action, callback) {
+    setState(data, callback) {
       const isPrimitiveStateWithoutReducerAndIsPreviousState =
         this.reducer === defaultReducer
-          && action === this.state
-          && typeof action !== 'object';
+          && data === this.state
+          && typeof data !== 'object';
 
       if (isPrimitiveStateWithoutReducerAndIsPreviousState) {
         if (typeof callback === 'function') callback(this.state)
         return;
       }
 
       const currentState = this.state;
-      const newState = this.reducer(this.state, action);
+      const newState = this.reducer(this.state, data);
       this.state = newState;
 
       this.updatersPerMemoFunction.forEach((updaters, memoFn) => {
@@ -97,7 +105,7 @@ export function createStore(name, state = {}, reducer=defaultReducer) {
       });
 
       if (subscriptions[name].length) {
-        subscriptions[name].forEach(c => c(this.state, action));
+        subscriptions[name].forEach(c => c(this.state, data));
       }
 
       if (typeof callback === 'function') callback(this.state)

types/index.d.ts

@@ -1,22 +1,22 @@
 declare module 'react-hookstore' {
   type StateCallback<TState> = (state: TState) => void;
 
-  type ReducerType<TState, TPayload = any> = (state: TState, payload: TPayload) => TState;
+  type ReducerType<TState, TData = any> = (state: TState, data: TData) => TState;
 
   type SetStateType<TState> = (state: TState, callback?: StateCallback<TState>) => void;
 
-  type DispatchType<TState, TPayload = any> = (payload: TPayload, callback?: StateCallback<TState>) => void;
+  type DispatchType<TState, TData = any> = (data: TData, callback?: StateCallback<TState>) => void;
 
   type StoreStateHookType<TState> = [TState, SetStateType<TState>];
 
-  type StoreDispatchHookType<TState, TPayload = any> = [TState, DispatchType<TState, TPayload>];
+  type StoreDispatchHookType<TState, TData = any> = [TState, DispatchType<TState, TData>];
 
   const defaultReducer: ReducerType<any>;
 
-  export interface StoreSpec<TState, TPayload = any> {
+  export interface StoreSpec<TState, TData = any> {
       state: TState;
-      reducer: ReducerType<TState, TPayload>;
-      setState: SetStateType<TState> | DispatchType<TState, TPayload>;
+      reducer: ReducerType<TState, TData>;
+      setState: SetStateType<TState> | DispatchType<TState, TData>;
       setters: StateCallback<TState>[]
   }
 
@@ -26,27 +26,27 @@ declare module 'react-hookstore' {
       setState(state: TState, callback?: StateCallback<TState>): void;
   }
 
-  export interface ReducerStoreInterface<TState, TPayload = any> {
+  export interface ReducerStoreInterface<TState, TData = any> {
       readonly name: string;
       getState(): TState;
-      dispatch<TPayload>(payload: TPayload, callback?: StateCallback<TState>): void;
+      dispatch<TData>(data: TData, callback?: StateCallback<TState>): void;
   }
 
-  export function createStore<TState, TPayload = any>(name: string, state: TState, reducer: ReducerType<TState, TPayload>): ReducerStoreInterface<TState, TPayload>;
+  export function createStore<TState, TData = any>(name: string, state: TState, reducer: ReducerType<TState, TData>): ReducerStoreInterface<TState, TData>;
 
   export function createStore<TState>(name: string, state: TState): StateStoreInterface<TState>;
 
   export function createStore<TState>(name: string, state: TState, reducer: ReducerType<TState>): ReducerStoreInterface<TState>;
 
-  export function getStoreByName<TState, TPayload = any>(name: string): StateStoreInterface<TState> | ReducerStoreInterface<TState>;
+  export function getStoreByName<TState, TData = any>(name: string): StateStoreInterface<TState> | ReducerStoreInterface<TState>;
 
   export function getStoreByName<TState>(name: string): StateStoreInterface<TState> | ReducerStoreInterface<TState>;
 
   export function useStore<TState>(identifier: string): StoreStateHookType<TState> | StoreDispatchHookType<TState>;
 
-  export function useStore<TState, TPayload = any>(identifier: string): StoreDispatchHookType<TState, TPayload>;
+  export function useStore<TState, TData = any>(identifier: string): StoreDispatchHookType<TState, TData>;
 
   export function useStore<TState>(store: StateStoreInterface<TState>): StoreStateHookType<TState>;
 
-  export function useStore<TState, TPayload = any>(store: ReducerStoreInterface<TState, TPayload>): StoreDispatchHookType<TState, TPayload>;
+  export function useStore<TState, TData = any>(store: ReducerStoreInterface<TState, TData>): StoreDispatchHookType<TState, TData>;
 }