@chhsiao1981/use-thunk 10.3.0 → 11.0.0

package/src/remove.ts

@@ -1,47 +1,32 @@
-import type { BaseAction, Thunk } from './action'
-import type { ClassState, NodeStateMap, State } from './stateTypes'
-
-export const remove = <S extends State>(myID: string): Thunk<S> => {
-  return (dispatch, getClassState) => {
-    const state = getClassState()
-    const {
-      nodes: { [myID]: me },
-    } = state
-    if (!me) {
-      return
-    }
-
-    // remove me from myClass list
-    dispatch(removeCore(myID))
-  }
-}
+import type BaseAction from './action/baseAction'
+import type { ModuleState, NodeStateMap, State } from './stateTypes'
 
 export const REMOVE = '@chhsiao1981/use-thunk/REMOVE'
-const removeCore = (myID: string): BaseAction => ({
+export const remove = (myID: string): BaseAction => ({
   myID,
   type: REMOVE,
 })
 
 export const reduceRemove = <S extends State>(
-  classState: ClassState<S>,
+  moduleState: ModuleState<S>,
   action: BaseAction,
-): ClassState<S> => {
+): ModuleState<S> => {
   const { myID } = action
 
-  const myNode = classState.nodes[myID]
+  const myNode = moduleState.nodes[myID]
   if (!myNode) {
-    return classState
+    return moduleState
   }
 
-  const newNodes = Object.keys(classState.nodes)
+  const newNodes = Object.keys(moduleState.nodes)
     .filter((each) => each !== myID)
     .reduce((r: NodeStateMap<S>, x) => {
-      r[x] = classState.nodes[x]
+      r[x] = moduleState.nodes[x]
       return r
     }, {})
 
   // defaultID
-  const newState = Object.assign({}, classState, { nodes: newNodes })
+  const newState = Object.assign({}, moduleState, { nodes: newNodes })
   if (newState.defaultID === myID) {
     newState.defaultID = null
   }

package/src/set.ts

@@ -0,0 +1,7 @@
+import type { Dispatch } from 'react'
+// XXX requiring to import directly from action/ActionOrThunk, or it will cause looping.
+import type { ActionOrThunk } from './action/ActionOrThunk'
+import type { State } from './stateTypes'
+
+// set
+export type set<S extends State> = Dispatch<ActionOrThunk<S>>

package/src/setDefaultID.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 const SET_DEFAULT_ID = '@chhsiao1981/use-thunk/SET_DEFAULT_ID'
 export const setDefaultID = (myID: string): BaseAction => ({
@@ -8,10 +8,10 @@ export const setDefaultID = (myID: string): BaseAction => ({
 })
 
 export const reduceSetDefaultID = <S extends State>(
-  classState: ClassState<S>,
+  moduleState: ModuleState<S>,
   action: BaseAction,
-): ClassState<S> => {
+): ModuleState<S> => {
   const { myID } = action
 
-  return Object.assign({}, classState, { defaultID: myID })
+  return Object.assign({}, moduleState, { defaultID: myID })
 }

package/src/setMap.ts

@@ -0,0 +1,65 @@
+import type { ActionFunc } from './action'
+import type { set } from './set'
+import type { State } from './stateTypes'
+import type { ThunkModule, ThunkModuleFunc } from './thunkModule'
+import {
+  DEFAULT_THUNK_MODULE_FUNC_MAP,
+  type DefaultThunkModuleFuncMap,
+} from './thunkModule/defaultThunkModuleFuncMap'
+
+// biome-ignore lint/suspicious/noExplicitAny: unknown requires same type in list, use any for possible different types.
+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>
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: set map by module map can be any.
+export const SET_MAP_BY_MODULE_MAP: setMapByModuleMap<any, any> = {}
+
+export const constructSetMap = <S extends State, T extends ThunkModuleFunc<S>>(
+  theDo: ThunkModule<S>,
+  set: set<S>,
+  setMap: setMap<S, T>,
+) => {
+  Object.keys(theDo)
+    // default and name are reserved words.
+    // functions starting reduce are included in default and not exported.
+    .filter((each) => typeof theDo[each] === 'function')
+    .reduce((val, eachAction) => {
+      if (val[eachAction]) {
+        return val
+      }
+
+      // because action is a function.
+      const action = theDo[eachAction] as ActionFunc<S>
+
+      // @ts-expect-error eachAction is in setMap<S, R>
+      // biome-ignore lint/suspicious/noExplicitAny: action parameters can be any types.
+      val[eachAction] = (...params: any[]) => set(action(...params))
+      return val
+    }, setMap)
+
+  Object.keys(DEFAULT_THUNK_MODULE_FUNC_MAP).reduce((val, eachAction) => {
+    if (val[eachAction]) {
+      return val
+    }
+
+    const action = DEFAULT_THUNK_MODULE_FUNC_MAP[eachAction]
+
+    // @ts-expect-error eachAction is in setMap<S, R>
+    // biome-ignore lint/suspicious/noExplicitAny: action parameters can be any types.
+    val[eachAction] = (...params: any[]) => set(action(...params))
+    return val
+  }, setMap)
+
+  return setMap
+}

package/src/stateTypes.ts

@@ -13,9 +13,10 @@ export type NodeStateMap<S extends State> = {
   [key: string]: NodeState<S>
 }
 
-// ClassState
-export type ClassState<S extends State> = {
-  myClass: string
+// ModuleState
+export type ModuleState<S extends State> = {
+  name?: string
+  myClass?: string // XXX to deprecated
   defaultID?: string | null
   nodes: NodeStateMap<S>
   defaultState: S

package/src/states.ts

@@ -1,47 +1,47 @@
-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 const getDefaultID = <S extends State>(classState: ClassState<S>): string => {
-  return classState.defaultID ?? ''
+export const getDefaultID = <S extends State>(moduleState: ModuleState<S>): string => {
+  return moduleState.defaultID ?? ''
 }
 
 export const getNode = <S extends State>(
-  classState: ClassState<S>,
+  moduleState: ModuleState<S>,
   myID?: string,
 ): NodeState<S> | null => {
-  const theID = myID ? myID : getDefaultID(classState)
+  const theID = myID ? myID : getDefaultID(moduleState)
   if (!theID) {
     return null
   }
 
-  return classState.nodes[theID] || null
+  return moduleState.nodes[theID] || null
 }
 
-export const getState = <S extends State>(classState: ClassState<S>, myID?: string): S | null => {
-  const theID = myID ? myID : getDefaultID(classState)
+export const getState = <S extends State>(moduleState: ModuleState<S>, myID?: string): S | null => {
+  const theID = myID ? myID : getDefaultID(moduleState)
   if (!theID) {
     return null
   }
 
-  const me = classState.nodes[theID]
+  const me = moduleState.nodes[theID]
   if (!me) {
     return null
   }
   return me.state
 }
 
-export const mustGetState = <S extends State>(classState: ClassState<S>, myID?: string): S => {
-  return getState(classState, myID) || classState.defaultState
+export const mustGetState = <S extends State>(moduleState: ModuleState<S>, myID?: string): S => {
+  return getState(moduleState, myID) || moduleState.defaultState
 }
 
 export const mustGetStateByThunk = <S extends State, R extends ThunkModuleFunc<S>>(
   theUseThunk: UseThunk<S, R>,
   myID?: string,
-): [S, DispatchFuncMap<S, R>, string] => {
-  const [classState, theDo] = theUseThunk
-  const theID = myID ? myID : getDefaultID(classState)
-  const state = mustGetState(classState, theID)
+): [S, setMap<S, R>, string] => {
+  const [moduleState, theDo] = theUseThunk
+  const theID = myID ? myID : getDefaultID(moduleState)
+  const state = mustGetState(moduleState, theID)
   return [state, theDo, theID]
 }

package/src/thunkContextMap.ts

@@ -1,16 +1,16 @@
 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]: {
       // biome-ignore lint/suspicious/noExplicitAny: ThunkContextMap can be any type
       context: rContext<Context<any>>
 
-      // INFO We need to use refClassState to sync all the classState in all ops.
+      // we need to use refModuleState to sync all the moduleState in all ops.
       // biome-ignore lint/suspicious/noExplicitAny: ThunkContextMap can be any type
-      refClassState: { current: ClassState<any> }
+      refModuleState: { current: ModuleState<any> }
     }
   }
   theList: string[]

package/src/thunkContextTypes.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> = {
-  // INFO: we use refClassState to reference across all the useThunk of the same class in different ops.
-  refClassState: { current: ClassState<S> }
-  setClassState: Dispatch<SetStateAction<ClassState<S>>>
+  // INFO: we use refModuleState to reference across all the useThunk of the same module in different ops.
+  refModuleState: { current: ModuleState<S> }
+  setModuleState: Dispatch<SetStateAction<ModuleState<S>>>
 }

package/src/thunkModule/defaultThunkModuleFuncMap.ts

@@ -0,0 +1,16 @@
+import type { ActionFunc } from '../action'
+import { init } from '../init'
+import { remove } from '../remove'
+import { setData, update } from '../update'
+
+export const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap = {
+  init,
+  update,
+  setData,
+  remove,
+}
+
+export type DefaultThunkModuleFuncMap = {
+  // biome-ignore lint/suspicious/noExplicitAny: DefaultThunkModuleFuncMap can be any type.
+  [action: string]: ActionFunc<any>
+}

package/src/thunkModule/index.ts

@@ -0,0 +1,21 @@
+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>
+}
+
+// This is used as the parameter for useThunk.
+export type ThunkModule<S extends State> = {
+  name?: string
+  myClass?: string // XXX to deprecate
+  default?: Reducer<S>
+  defaultState: S
+} & ThunkModuleBase<S>
+
+export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'myClass' | 'default' | 'defaultState'>

package/src/update.ts

@@ -0,0 +1,31 @@
+import type BaseAction from './action/baseAction'
+import type { ModuleState, State } from './stateTypes'
+
+export const UPDATE = '@chhsiao1981/use-thunk/UPDATE'
+export const update = <S extends State>(myID: string, data: Partial<S>): BaseAction => ({
+  myID,
+  type: UPDATE,
+  data,
+})
+
+export const setData = <S extends State>(myID: string, data: Partial<S>): BaseAction => {
+  console.warn('setData will be deprecated in the next version.')
+  return update(myID, data)
+}
+
+export const reduceUpdate = <S extends State>(
+  moduleState: ModuleState<S>,
+  action: BaseAction,
+): ModuleState<S> => {
+  const { myID, data } = action
+
+  const myNode = moduleState.nodes[myID]
+  if (!myNode) return moduleState
+
+  const newMyState = Object.assign({}, myNode.state, data)
+  const newMyNode = Object.assign({}, myNode, { state: newMyState })
+  const newNodes = Object.assign({}, moduleState.nodes, { [myID]: newMyNode })
+  const newModuleState = Object.assign({}, moduleState, { nodes: newNodes })
+
+  return newModuleState
+}

package/src/useThunk.ts

@@ -1,71 +1,51 @@
 import { useMemo } from 'react'
 import { createReducer } from './createReducer'
-import {
-  constructDispatchMap,
-  type DispatchFuncMap,
-  type DispatchFuncMapByClassMap,
-} from './dispatchFuncMap'
-import type { ClassState, State } from './stateTypes'
-import type { ThunkModule, ThunkModuleFunc } from './thunk'
+import { constructSetMap, type setMap, type setMapByModuleMap } from './setMap'
+import type { ModuleState, State } from './stateTypes'
+import type { ThunkModule, ThunkModuleFunc } from './thunkModule'
 import useThunkReducer from './useThunkReducer'
 
-// biome-ignore lint/suspicious/noExplicitAny: DISPACH_MAP_BY_CLASS can by any type
-const DISPACH_MAP_BY_CLASS: DispatchFuncMapByClassMap<any, any> = {}
+// biome-ignore lint/suspicious/noExplicitAny: SET_MAP_BY_MODULE can by any type
+const SET_MAP_BY_MODULE: setMapByModuleMap<any, any> = {}
 
-export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [
-  ClassState<S>,
-  DispatchFuncMap<S, R>,
-]
+export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [ModuleState<S>, setMap<S, R>]
 
 /**********
  * useThunk
  **********/
 export default <S extends State, R extends ThunkModuleFunc<S>>(
-  theDo: ThunkModule<S, R>,
+  theDo: ThunkModule<S>,
 ): UseThunk<S, R> => {
-  const { myClass } = theDo
+  const { name: propsName, myClass } = theDo
+  const name = (propsName ? propsName : myClass) || ''
 
-  // 1. dispatchMapByClass
-  //
-  // INFO The reason why we need to useRef is because we don't want to
-  //        rebuild dispatchMap every time we call useThunk.
-  const dispatchMapByClass: DispatchFuncMapByClassMap<S, R> = DISPACH_MAP_BY_CLASS
-
-  // 2. It requires shared nodes for the same class to have the same dispatchMap.
-  // We don't optimize the dispatchMap in this PR.
-  const isFirstTime = !dispatchMapByClass[myClass]
+  // 1. It requires shared nodes for the same module to have the same setMap.
+  const isFirstTime = !SET_MAP_BY_MODULE[name]
   if (isFirstTime) {
-    // @ts-expect-error init dispatchMap
-    dispatchMapByClass[myClass] = {}
+    SET_MAP_BY_MODULE[name] = {}
   }
-  const dispatchMap = dispatchMapByClass[myClass]
+  const setMap = SET_MAP_BY_MODULE[name] as setMap<S, R>
 
-  // 4. reducer.
-  //    using useState to have theDo.default as optional.
-  //    theReducer won't be changed.
-  //
-  //    theReducer is different for different reducers,
-  //    even within the same class.
-  //    However, because theReducer is a pure function
-  //    having ClassState as the input. It is ok to have
-  //    different reducers within the same class.
-  //
-  // INFO useMemo is to avoid accidental re-init createReducer every-time.
-  const theReducer = useMemo(() => theDo.default ?? createReducer<S>(), [])
+  // 2. reducer.
+  //    theReducer is different for different useThunk,
+  //    even within the same module.
+  //    However, because theReducer is a pure function by
+  //    having ModuleState as the input. It is ok to have
+  //    different reducers within the same module.
+  const theReducer = useMemo(() => createReducer<S>(), [])
 
-  // 5. useThunkReducer
-  const [classState, dispatch] = useThunkReducer(theReducer, myClass)
+  // 3. useThunkReducer
+  const [moduleState, set] = useThunkReducer(theReducer, name)
 
-  // INFO useMemo is to avoid accidental included in useEffect.
   const ret: UseThunk<S, R> = useMemo(() => {
-    return [classState, dispatchMap]
-  }, [classState, dispatchMap])
+    return [moduleState, setMap]
+  }, [moduleState, setMap])
 
   if (!isFirstTime) {
     return ret
   }
 
-  constructDispatchMap(theDo, dispatch, dispatchMap)
+  constructSetMap(theDo, set, setMap)
 
   return ret
 }

package/src/useThunkReducer.ts

@@ -1,69 +1,60 @@
 //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 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]
-
-  const { refClassState, setClassState: setClassState_c } = useContext(context)
-  const getClassState = useCallback(() => {
-    return refClassState.current
-  }, [refClassState])
-
-  const setClassState = useCallback(
-    (newClassState: ClassState<S>) => {
-      refClassState.current = newClassState
-      setClassState_c(newClassState)
+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])
+
+  const setModuleState = useCallback(
+    (newModuleState: ModuleState<S>) => {
+      refModuleState.current = newModuleState
+      setModuleState_c(newModuleState)
     },
-    [refClassState, setClassState_c],
+    [refModuleState, setModuleState_c],
   )
 
   // 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(dispatch, getClassState)
+        // action is Thunk<S, A>
+        action(set, getModuleState)
         return
       }
 
-      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>, getModuleState: () => ModuleState<S>) => void;

package/types/createThunk.d.ts

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

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 {};