@chhsiao1981/use-thunk 10.4.0 → 12.0.0

package/src/useThunkReducer.ts

@@ -1,71 +1,70 @@
 //https://medium.com/solute-labs/configuring-thunk-action-creators-and-redux-dev-tools-with-reacts-usereducer-hook-5a1608476812
 //https://github.com/nathanbuchar/react-hook-thunk-reducer/blob/master/src/thunk-reducer.js
 
-import { type Dispatch, type Reducer, useCallback, useContext } from 'react'
-import type { BaseAction } from './action'
-import type { ClassState, State } from './stateTypes'
+import { useCallback, useContext } from 'react'
+import type BaseAction from './action/baseAction'
+import type { Reducer } from './reducer'
+import type { set } from './set'
+import { getStateOrNullByModule } from './states'
+import type { ModuleState, State } from './stateTypes'
 import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 
-export type Thunk<S extends State, A extends BaseAction> = (
-  dispatch: Dispatch<ActionOrThunk<S, A>>,
-  getClassState: () => ClassState<S>,
-) => void
-
-export type ActionOrThunk<S extends State, A extends BaseAction> = A | Thunk<S, A>
 /**
  * useThunkReducer
  *
  * Augments React's useReducer() hook so that the action
- * dispatcher supports thunks.
- *
- * @param {Function} reducer
- * @param {string} className
- * @returns {[ClassState<S>, Dispatch]}
+ * setter (dispatcher) supports thunks.
  */
-export default <S extends State, A extends BaseAction>(
-  reducer: Reducer<ClassState<S>, A>,
-  className: string,
-): [ClassState<S>, Dispatch<A | Thunk<S, A>>] => {
-  const { context } = THUNK_CONTEXT_MAP.theMap[className]
+export default <S extends State>(reducer: Reducer<S>, moduleName: string): [ModuleState<S>, set<S>] => {
+  const { context } = THUNK_CONTEXT_MAP.theMap[moduleName]
+
+  const { refModuleState, setModuleState: setModuleState_c } = useContext(context)
+  const getModuleState = useCallback(() => {
+    return refModuleState.current
+  }, [refModuleState]) as () => ModuleState<S>
 
-  const { refClassState, setClassState: setClassState_c } = useContext(context)
-  const getClassState = useCallback(() => {
-    return refClassState.current
-  }, [refClassState])
+  const setModuleState = useCallback(
+    (newModuleState: ModuleState<S>) => {
+      refModuleState.current = newModuleState
+      setModuleState_c(newModuleState)
+    },
+    [refModuleState, setModuleState_c],
+  )
 
-  const setClassState = useCallback(
-    (newClassState: ClassState<S>) => {
-      refClassState.current = newClassState
-      setClassState_c(newClassState)
+  const get = useCallback(
+    (id?: string) => {
+      const moduleState = getModuleState()
+      const state = getStateOrNullByModule(moduleState, id)
+      return state
     },
-    [refClassState, setClassState_c],
+    [getModuleState],
   )
 
   // 5. reducer.
   const reduce = useCallback(
-    (action: A): ClassState<S> => {
-      const classState = getClassState()
-      const newClassState = reducer(classState, action)
-      return newClassState
+    (action: BaseAction): ModuleState<S> => {
+      const moduleState = getModuleState()
+      const newModuleState = reducer(moduleState, action)
+      return newModuleState
     },
-    [reducer, getClassState],
+    [reducer, getModuleState],
   )
 
-  // augmented dispatcher.
-  const dispatch = useCallback(
-    (action: A | Thunk<S, A>) => {
+  // augmented setter.
+  const set: set<S> = useCallback(
+    (action) => {
       if (typeof action === 'function') {
         // action is Thunk<S, A>
-        action(dispatch, getClassState)
+        action(set, get, getModuleState)
         return
       }
 
-      // action is not function. so action is A
-      const newClassState = reduce(action)
-      setClassState(newClassState)
+      // action is not function. so action is BaseAction
+      const newModuleState = reduce(action)
+      setModuleState(newModuleState)
     },
-    [getClassState, setClassState, reduce],
+    [getModuleState, setModuleState, reduce],
   )
 
-  return [refClassState.current, dispatch]
+  return [refModuleState.current, set]
 }

package/types/ThunkContext.d.ts

@@ -1,7 +1,7 @@
-import { type JSX } from 'react';
+import { type ReactNode } from 'react';
 type Props = {
-    classes?: string[];
-    children?: JSX.Element | JSX.Element[];
+    modules?: string[];
+    children?: ReactNode;
 };
-declare const ThunkContext: (props: Props) => JSX.Element;
+declare const ThunkContext: (props: Props) => ReactNode;
 export default ThunkContext;

package/types/action/ActionOrThunk.d.ts

@@ -0,0 +1,4 @@
+import type { State } from '../stateTypes';
+import type BaseAction from './baseAction';
+import type { Thunk } from './thunk';
+export type ActionOrThunk<S extends State> = BaseAction | Thunk<S>;

package/types/action/baseAction.d.ts

@@ -0,0 +1,5 @@
+export default interface BaseAction {
+    myID: string;
+    type: string;
+    [key: string]: unknown;
+}

package/types/action/index.d.ts

@@ -0,0 +1,8 @@
+import type { ModuleState, State } from '../stateTypes';
+import type { ActionOrThunk } from './ActionOrThunk';
+import type BaseAction from './baseAction';
+import type { Thunk } from './thunk';
+export type { Thunk, ActionOrThunk, BaseAction };
+export type ActionFunc<S extends State> = (...params: any[]) => ActionOrThunk<S>;
+export type ThunkFunc<S extends State> = (...params: any[]) => Thunk<S>;
+export type GetModuleState<S extends State> = () => ModuleState<S>;

package/types/action/thunk.d.ts

@@ -0,0 +1,3 @@
+import type { set } from '../set';
+import type { ModuleState, State } from '../stateTypes';
+export type Thunk<S extends State> = (set: set<S>, get: (id?: string) => S | null, getModuleState: () => ModuleState<S>) => void;

package/types/createThunk.d.ts

@@ -0,0 +1,4 @@
+import type { State } from './stateTypes';
+import type { ThunkModule } from './thunkModule';
+declare const _default: <S extends State>(theDo: ThunkModule<S>) => void;
+export default _default;

package/types/dispatch.d.ts

@@ -1,4 +1,4 @@
 import type { Dispatch as rDispatch } from 'react';
-import type { ActionOrThunk } from './action';
+import type { ActionOrThunk } from './action/ActionOrThunk';
 import type { State } from './stateTypes';
 export type Dispatch<S extends State> = rDispatch<ActionOrThunk<S>>;

package/types/dispatchFuncMap.d.ts

@@ -1,8 +1,7 @@
-import type { BaseAction } from './action';
+import type { Dispatch } from './dispatch';
 import type { State } from './stateTypes';
-import type { ThunkModule, ThunkModuleFunc } from './thunk';
-import { type DefaultThunkModuleFuncMap } from './thunkModuleFuncMap';
-import type { Thunk as rThunk } from './useThunkReducer';
+import type { ThunkModule, ThunkModuleFunc } from './thunkModule';
+import { type DefaultThunkModuleFuncMap } from './thunkModule/defaultThunkModuleFuncMap';
 type VoidReturnType<T extends (...params: any[]) => unknown> = (...params: Parameters<T>) => void;
 export type DispatchFuncMap<S extends State, T extends ThunkModuleFunc<S>> = {
     [action in keyof T]: VoidReturnType<T[action]>;
@@ -14,5 +13,5 @@ export interface DispatchFuncMapByClassMap<S extends State, T extends ThunkModul
     [className: string]: DispatchFuncMap<S, T>;
 }
 export declare const DISPATCH_FUNC_MAP_BY_CLASS_MAP: DispatchFuncMapByClassMap<any, any>;
-export declare const constructDispatchMap: <S extends State, T extends ThunkModuleFunc<S>, A extends BaseAction>(theDo: ThunkModule<S, T>, dispatch: (action: A | rThunk<S, A>) => void, dispatchMap: DispatchFuncMap<S, T>) => DispatchFuncMap<S, T>;
+export declare const constructDispatchMap: <S extends State, T extends ThunkModuleFunc<S>>(theDo: ThunkModule<S>, dispatch: Dispatch<S>, dispatchMap: DispatchFuncMap<S, T>) => DispatchFuncMap<S, T>;
 export {};

package/types/get.d.ts

@@ -0,0 +1,2 @@
+import type { State } from './stateTypes';
+export type get = <S extends State>(id: string) => S;

package/types/index.d.ts

@@ -1,15 +1,16 @@
-import type { GetClassState, Thunk } from './action';
-import type { Dispatch } from './dispatch';
-import type { DispatchFuncMap } from './dispatchFuncMap';
+import type { GetModuleState, Thunk } from './action';
+import createThunk from './createThunk';
 import { genUUID } from './genUUID';
+import type { get } from './get';
 import { type InitParams, init } from './init';
-import registerThunk from './registerThunk';
 import { remove } from './remove';
-import { setData } from './setData';
+import type { set } from './set';
 import { setDefaultID } from './setDefaultID';
-import { getDefaultID, getNode, getState, mustGetState, mustGetStateByThunk } from './states';
-import type { ClassState, NodeState, NodeStateMap, State } from './stateTypes';
+import type { setMap } from './setMap';
+import { getDefaultID, getNode, getState, getStateByModule, getStateOrNullByModule } from './states';
+import type { ModuleState, State } from './stateTypes';
 import ThunkContext from './ThunkContext';
-import type { ThunkModule, ThunkModuleToFunc } from './thunk';
+import type { ThunkModule, ThunkModuleToFunc } from './thunkModule';
+import { update } from './update';
 import useThunk, { type UseThunk } from './useThunk';
-export { registerThunk, useThunk, ThunkContext, type UseThunk, type State, type NodeState, type NodeStateMap, type ClassState, type GetClassState, type Thunk, type ThunkModule, type ThunkModuleToFunc, type Dispatch, type DispatchFuncMap, getDefaultID, getNode, getState, mustGetState, mustGetStateByThunk, init, type InitParams, setData, remove, setDefaultID, genUUID, };
+export { createThunk, useThunk, type UseThunk, ThunkContext, type State, type ModuleState, type GetModuleState, type Thunk, type ThunkModule, type ThunkModuleToFunc, type set, type setMap, type get, getNode, getDefaultID, getStateOrNullByModule, getStateByModule, getState, init, type InitParams, update, remove, setDefaultID, genUUID, };

package/types/init/index.d.ts

@@ -0,0 +1,7 @@
+import type { Thunk } from '../action';
+import type { State } from '../stateTypes';
+export interface InitParams<S extends State> {
+    myID?: string;
+    state: S;
+}
+export declare const init: <S extends State>(params: InitParams<S>, myuuidv4?: () => string) => Thunk<S>;

package/types/init/initCore.d.ts

@@ -0,0 +1,9 @@
+import type BaseAction from '../action/baseAction';
+import type { ModuleState, State } from '../stateTypes';
+export interface InitAction<S extends State> extends BaseAction {
+    state: S;
+}
+export declare const INIT = "@chhsiao1981/use-thunk/INIT";
+declare const _default: <S extends State>(myID: string, state: S) => InitAction<S>;
+export default _default;
+export declare const reduceInit: <S extends State>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/reducer.d.ts

@@ -1,5 +1,5 @@
 import type { Reducer as rReducer } from 'react';
-import type { BaseAction } from './action';
-import type { ClassState, State } from './stateTypes';
-export type Reducer<S extends State> = rReducer<ClassState<S>, BaseAction>;
-export type ReduceFunc<S extends State> = (state: ClassState<S>, action: BaseAction) => ClassState<S>;
+import type BaseAction from './action/baseAction';
+import type { ModuleState, State } from './stateTypes';
+export type Reducer<S extends State> = rReducer<ModuleState<S>, BaseAction>;
+export type ReduceFunc<S extends State> = (state: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/remove.d.ts

@@ -1,5 +1,5 @@
-import type { BaseAction, Thunk } from './action';
-import type { ClassState, State } from './stateTypes';
-export declare const remove: <S extends State>(myID: string) => Thunk<S>;
+import type BaseAction from './action/baseAction';
+import type { ModuleState, State } from './stateTypes';
 export declare const REMOVE = "@chhsiao1981/use-thunk/REMOVE";
-export declare const reduceRemove: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;
+export declare const remove: (myID: string) => BaseAction;
+export declare const reduceRemove: <S extends State>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/set.d.ts

@@ -0,0 +1,4 @@
+import type { Dispatch } from 'react';
+import type { ActionOrThunk } from './action/ActionOrThunk';
+import type { State } from './stateTypes';
+export type set<S extends State> = Dispatch<ActionOrThunk<S>>;

package/types/setDefaultID.d.ts

@@ -1,5 +1,5 @@
-import type { BaseAction } from './action';
-import type { ClassState, State } from './stateTypes';
+import type BaseAction from './action/baseAction';
+import type { ModuleState, State } from './stateTypes';
 export declare const SET_DEFAULT_ID = "@chhsiao1981/use-thunk/SET_DEFAULT_ID";
 export declare const setDefaultID: (myID: string) => BaseAction;
-export declare const reduceSetDefaultID: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;
+export declare const reduceSetDefaultID: <S extends State>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/setMap.d.ts

@@ -0,0 +1,17 @@
+import type { set } from './set';
+import type { State } from './stateTypes';
+import type { ThunkModule, ThunkModuleFunc } from './thunkModule';
+import { type DefaultThunkModuleFuncMap } from './thunkModule/defaultThunkModuleFuncMap';
+type VoidReturnType<T extends (...params: any[]) => unknown> = (...params: Parameters<T>) => void;
+export type setMap<S extends State, T extends ThunkModuleFunc<S>> = {
+    [action in keyof T]: VoidReturnType<T[action]>;
+} & Omit<DefaultSetMap, keyof T>;
+export type DefaultSetMap = {
+    [action in keyof DefaultThunkModuleFuncMap]: VoidReturnType<DefaultThunkModuleFuncMap[action]>;
+};
+export interface setMapByModuleMap<S extends State, T extends ThunkModuleFunc<S>> {
+    [name: string]: setMap<S, T>;
+}
+export declare const SET_MAP_BY_MODULE_MAP: setMapByModuleMap<any, any>;
+export declare const constructSetMap: <S extends State, T extends ThunkModuleFunc<S>>(theDo: ThunkModule<S>, set: set<S>, setMap: setMap<S, T>) => setMap<S, T>;
+export {};

package/types/stateTypes.d.ts

@@ -8,8 +8,8 @@ export type NodeState<S extends State> = {
 export type NodeStateMap<S extends State> = {
     [key: string]: NodeState<S>;
 };
-export type ClassState<S extends State> = {
-    myClass: string;
+export type ModuleState<S extends State> = {
+    name: string;
     defaultID?: string | null;
     nodes: NodeStateMap<S>;
     defaultState: S;

package/types/states.d.ts

@@ -1,9 +1,9 @@
-import type { DispatchFuncMap } from './dispatchFuncMap';
-import type { ClassState, NodeState, State } from './stateTypes';
-import type { ThunkModuleFunc } from './thunk';
+import type { setMap } from './setMap';
+import type { ModuleState, NodeState, State } from './stateTypes';
+import type { ThunkModuleFunc } from './thunkModule';
 import type { UseThunk } from './useThunk';
-export declare const getDefaultID: <S extends State>(classState: ClassState<S>) => string;
-export declare const getNode: <S extends State>(classState: ClassState<S>, myID?: string) => NodeState<S> | null;
-export declare const getState: <S extends State>(classState: ClassState<S>, myID?: string) => S | null;
-export declare const mustGetState: <S extends State>(classState: ClassState<S>, myID?: string) => S;
-export declare const mustGetStateByThunk: <S extends State, R extends ThunkModuleFunc<S>>(theUseThunk: UseThunk<S, R>, myID?: string) => [S, DispatchFuncMap<S, R>, string];
+export declare const getDefaultID: <S extends State>(moduleState: ModuleState<S>) => string;
+export declare const getNode: <S extends State>(moduleState: ModuleState<S>, myID?: string) => NodeState<S> | null;
+export declare const getStateOrNullByModule: <S extends State>(moduleState: ModuleState<S>, myID?: string) => S | null;
+export declare const getStateByModule: <S extends State>(moduleState: ModuleState<S>, myID?: string) => S;
+export declare const getState: <S extends State, R extends ThunkModuleFunc<S>>(theUseThunk: UseThunk<S, R>, myID?: string) => [S, setMap<S, R>, string];

package/types/thunkContextMap.d.ts

@@ -1,12 +1,12 @@
 import type { Context as rContext } from 'react';
-import type { ClassState } from './stateTypes';
+import type { ModuleState } from './stateTypes';
 import type { Context } from './thunkContextTypes';
 export type ThunkContextMap = {
     theMap: {
-        [classname: string]: {
+        [moduleName: string]: {
             context: rContext<Context<any>>;
-            refClassState: {
-                current: ClassState<any>;
+            refModuleState: {
+                current: ModuleState<any>;
             };
         };
     };

package/types/thunkContextTypes.d.ts

@@ -1,8 +1,8 @@
 import type { Dispatch, SetStateAction } from 'react';
-import type { ClassState, State } from './stateTypes';
+import type { ModuleState, State } from './stateTypes';
 export type Context<S extends State> = {
-    refClassState: {
-        current: ClassState<S>;
+    refModuleState: {
+        current: ModuleState<S>;
     };
-    setClassState: Dispatch<SetStateAction<ClassState<S>>>;
+    setModuleState: Dispatch<SetStateAction<ModuleState<S>>>;
 };

package/types/thunkModule/defaultThunkModuleFuncMap.d.ts

@@ -0,0 +1,5 @@
+import type { ActionFunc } from '../action';
+export declare const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap;
+export type DefaultThunkModuleFuncMap = {
+    [action: string]: ActionFunc<any>;
+};

package/types/thunkModule/index.d.ts

@@ -0,0 +1,15 @@
+import type { ThunkFunc } from '../action';
+import type { Reducer } from '../reducer';
+import type { State } from '../stateTypes';
+export interface ThunkModuleBase<S extends State> {
+    [idx: string]: ThunkFunc<S> | string | Reducer<S> | S | undefined;
+}
+export interface ThunkModuleFunc<S extends State> extends ThunkModuleBase<S> {
+    [action: string]: ThunkFunc<S>;
+}
+export type ThunkModule<S extends State> = {
+    name: string;
+    default?: Reducer<S>;
+    defaultState: S;
+} & ThunkModuleBase<S>;
+export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'default' | 'defaultState'>;

package/types/update.d.ts

@@ -0,0 +1,5 @@
+import type BaseAction from './action/baseAction';
+import type { ModuleState, State } from './stateTypes';
+export declare const UPDATE = "@chhsiao1981/use-thunk/UPDATE";
+export declare const update: <S extends State>(myID: string, data: Partial<S>) => BaseAction;
+export declare const reduceUpdate: <S extends State>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/useThunk.d.ts

@@ -1,12 +1,9 @@
-import { type DispatchFuncMap } from './dispatchFuncMap';
-import type { ClassState, State } from './stateTypes';
-import type { ThunkModule, ThunkModuleFunc } from './thunk';
-export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [
-    ClassState<S>,
-    DispatchFuncMap<S, R>
-];
+import { type setMap } from './setMap';
+import type { ModuleState, State } from './stateTypes';
+import type { ThunkModule, ThunkModuleFunc } from './thunkModule';
+export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [ModuleState<S>, setMap<S, R>];
 /**********
  * useThunk
  **********/
-declare const _default: <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModule<S, R>) => UseThunk<S, R>;
+declare const _default: <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModule<S>) => UseThunk<S, R>;
 export default _default;

package/types/useThunkReducer.d.ts

@@ -1,17 +1,11 @@
-import { type Dispatch, type Reducer } from 'react';
-import type { BaseAction } from './action';
-import type { ClassState, State } from './stateTypes';
-export type Thunk<S extends State, A extends BaseAction> = (dispatch: Dispatch<ActionOrThunk<S, A>>, getClassState: () => ClassState<S>) => void;
-export type ActionOrThunk<S extends State, A extends BaseAction> = A | Thunk<S, A>;
+import type { Reducer } from './reducer';
+import type { set } from './set';
+import type { ModuleState, State } from './stateTypes';
 /**
  * useThunkReducer
  *
  * Augments React's useReducer() hook so that the action
- * dispatcher supports thunks.
- *
- * @param {Function} reducer
- * @param {string} className
- * @returns {[ClassState<S>, Dispatch]}
+ * setter (dispatcher) supports thunks.
  */
-declare const _default: <S extends State, A extends BaseAction>(reducer: Reducer<ClassState<S>, A>, className: string) => [ClassState<S>, Dispatch<A | Thunk<S, A>>];
+declare const _default: <S extends State>(reducer: Reducer<S>, moduleName: string) => [ModuleState<S>, set<S>];
 export default _default;