@chhsiao1981/use-thunk 11.0.0 → 13.0.0

package/src/index.ts

@@ -1,46 +1,58 @@
-import type { GetModuleState, Thunk } from './action'
-import createThunk, { registerThunk } from './createThunk'
-import { genUUID } from './genUUID'
-import { type InitParams, init } from './init'
-import { remove } from './remove'
-import type { set } from './set'
-import { setDefaultID } from './setDefaultID'
-import type { setMap } from './setMap'
-import { getDefaultID, getNode, getState, mustGetState, mustGetStateByThunk } from './states'
-import type { ModuleState, State } from './stateTypes'
-import ThunkContext from './ThunkContext'
-import type { ThunkModule, ThunkModuleToFunc } from './thunkModule'
-import { setData, update } from './update'
+import type { getModuleState, Thunk, ThunkFunc } from './action'
+import { type InitParams, init, remove, setDefaultID, update, upsert } from './defaultThunks'
+import type { dispatch } from './dispatch'
+import type { get, getOrNull } from './get'
+import registerThunk from './registerThunk'
+import type { set, setMap } from './set'
+import {
+  getDefaultID,
+  getNodeOrNull,
+  getState,
+  getStateByModule,
+  getStateOrNullByModule,
+  type ModuleState,
+  type State,
+} from './states'
+import { ThunkContext } from './thunkContext'
+import type { doModule, ThunkModule, toDoModule } from './thunkModule'
 import useThunk, { type UseThunk } from './useThunk'
+import { genID } from './utils'
 
 export {
-  createThunk,
-  registerThunk, // to deprecate
+  // thunk definition.
+  type Thunk,
+  type set,
+  type get,
+  type getOrNull,
+  type dispatch,
+  type getModuleState,
+  // registerThunk / useThunk / ThunkContext
+  registerThunk,
   useThunk,
   type UseThunk,
   ThunkContext,
+  // state related.
   type State,
+  getState,
   type ModuleState,
-  type ModuleState as ClassState, // to deprecate
-  type GetModuleState,
-  type GetModuleState as GetClassState, // to deprecate
-  type Thunk,
+  // module related.
   type ThunkModule,
-  type ThunkModuleToFunc,
-  type set as Dispatch, // to deprecate
-  type set,
-  type setMap as DispatchFuncMap, // to deprecate
-  type setMap,
-  getNode,
-  getDefaultID,
-  getState,
-  mustGetState,
-  mustGetStateByThunk,
+  type toDoModule,
+  type doModule,
+  type ThunkFunc,
+  // default thunks.
   init,
   type InitParams,
-  setData, // to deprecate
   update,
+  upsert,
   remove,
+  // genID
+  genID,
+  // advanced usage.
+  type setMap,
   setDefaultID,
-  genUUID,
+  getNodeOrNull,
+  getDefaultID,
+  getStateOrNullByModule,
+  getStateByModule,
 }

package/src/reducer/createReducer.ts

@@ -0,0 +1,18 @@
+import type { BaseAction } from '../action'
+import type { ModuleState, State } from '../states'
+import { DEFAULT_REDUCE_MAP } from './defaultReduceMap'
+import type { Reducer } from './index'
+
+export const createReducer = <S extends State>(): Reducer<S> => {
+  return (moduleState: ModuleState<S>, action: BaseAction): ModuleState<S> => {
+    if (!action) {
+      return moduleState
+    }
+
+    if (DEFAULT_REDUCE_MAP[action.type]) {
+      return DEFAULT_REDUCE_MAP[action.type](moduleState, action)
+    }
+
+    return moduleState
+  }
+}

package/src/reducer/defaultReduceMap.ts

@@ -0,0 +1,26 @@
+import {
+  INIT,
+  REMOVE,
+  reduceInit,
+  reduceRemove,
+  reduceSetDefaultID,
+  reduceUpdate,
+  reduceUpsert,
+  SET_DEFAULT_ID,
+  UPDATE,
+  UPSERT,
+} from '../defaultThunks'
+import type { ReduceMap } from './reduceMap'
+
+// biome-ignore lint/suspicious/noExplicitAny: DEFAULT_REDUCE_MAP can apply to any States.
+export const DEFAULT_REDUCE_MAP: ReduceMap<any> = {
+  [INIT]: reduceInit,
+  [UPDATE]: reduceUpdate,
+  [REMOVE]: reduceRemove,
+  [UPSERT]: reduceUpsert,
+
+  // setDefaultID.
+  // Typically we don't need this in programming.
+  // The defaultID is automatically determined if defaultID is not set.
+  [SET_DEFAULT_ID]: reduceSetDefaultID,
+}

package/src/{reducer.ts → reducer/index.ts}

@@ -1,6 +1,9 @@
 import type { Reducer as rReducer } from 'react'
-import type BaseAction from './action/baseAction'
-import type { ModuleState, State } from './stateTypes'
+import type { BaseAction } from '../action'
+import type { ModuleState, State } from '../states'
+
+import { createReducer } from './createReducer'
+export { createReducer }
 
 // Reducer
 export type Reducer<S extends State> = rReducer<ModuleState<S>, BaseAction>

package/src/reducer/reduceMap.ts

@@ -0,0 +1,6 @@
+import type { State } from '../states'
+import type { ReduceFunc } from './index'
+
+export interface ReduceMap<S extends State> {
+  [type: string]: ReduceFunc<S>
+}

package/src/{createThunk.ts → registerThunk.ts}

@@ -1,19 +1,22 @@
+// Reason for registerThunk instead of createThunk:
+//   I feel that createThunk needs to return some object
+//   as the proof of successful creation.
+//   However, we register Thunks to the global state management
+//   system and return void.
 import { createContext, type Dispatch, type SetStateAction } from 'react'
-import { createThunk } from '.'
-import type { ModuleState, State } from './stateTypes'
-import { THUNK_CONTEXT_MAP } from './thunkContextMap'
+import type { ModuleState, State } from './states'
+import { THUNK_CONTEXT_MAP } from './thunkContext'
 import type { ThunkModule } from './thunkModule'
 
 export default <S extends State>(theDo: ThunkModule<S>) => {
-  const { name: propsName, myClass, defaultState } = theDo
-  const name = (propsName ? propsName : myClass) || ''
+  const { name, defaultState } = theDo
 
   if (THUNK_CONTEXT_MAP.theMap[name]) {
-    console.warn('createThunk: already init:', name)
+    console.warn('registerThunk: already init:', name)
     return
   }
 
-  const moduleState: ModuleState<S> = { myClass, name, nodes: {}, defaultState }
+  const moduleState: ModuleState<S> = { name, nodes: {}, defaultState }
   const setModuleState: Dispatch<SetStateAction<ModuleState<S>>> = () => {}
   const refModuleState = { current: moduleState }
   const context = createContext({ refModuleState: refModuleState, setModuleState })
@@ -22,10 +25,5 @@ export default <S extends State>(theDo: ThunkModule<S>) => {
   const theList = Object.keys(THUNK_CONTEXT_MAP.theMap).sort()
   THUNK_CONTEXT_MAP.theList = theList
 
-  console.info('createThunk: done:', name)
-}
-
-export const registerThunk = <S extends State>(theDo: ThunkModule<S>) => {
-  console.warn('registerThunk will be deprecated in the next version.')
-  return createThunk(theDo)
+  console.info('registerThunk: done:', name)
 }

package/src/set/index.ts

@@ -0,0 +1,9 @@
+// XXX requiring to import directly from action/ActionOrThunk, or it will cause looping.
+import type { ActionOrThunk } from '../action'
+import type { State } from '../states'
+
+import { constructSetMap, type DefaultSetMap, type setMap, type setMapByModuleMap } from './setMap'
+export { constructSetMap, type DefaultSetMap, type setMap, type setMapByModuleMap }
+
+// set
+export type set<S extends State> = (actionOrID: ActionOrThunk<S> | string, data?: Partial<S>) => void

package/src/{setMap.ts → set/setMap.ts}

@@ -1,31 +1,25 @@
-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'
+import type { ActionFunc } from '../action'
+import type { set } from '../set'
+import type { State } from '../states'
+import type { doModule, ThunkModule } from '../thunkModule'
+import { DEFAULT_DO_MODULE, type defaultDoModule } from '../thunkModule'
 
 // 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>> = {
+export type setMap<S extends State, T extends doModule<S>> = {
   [action in keyof T]: VoidReturnType<T[action]>
 } & Omit<DefaultSetMap, keyof T>
 
 export type DefaultSetMap = {
-  [action in keyof DefaultThunkModuleFuncMap]: VoidReturnType<DefaultThunkModuleFuncMap[action]>
+  [action in keyof defaultDoModule]: VoidReturnType<defaultDoModule[action]>
 }
 
-export interface setMapByModuleMap<S extends State, T extends ThunkModuleFunc<S>> {
-  [name: string]: setMap<S, T>
+export interface setMapByModuleMap<S extends State, T extends doModule<S>> {
+  [moduleMap: 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>>(
+export const constructSetMap = <S extends State, T extends doModule<S>>(
   theDo: ThunkModule<S>,
   set: set<S>,
   setMap: setMap<S, T>,
@@ -48,12 +42,12 @@ export const constructSetMap = <S extends State, T extends ThunkModuleFunc<S>>(
       return val
     }, setMap)
 
-  Object.keys(DEFAULT_THUNK_MODULE_FUNC_MAP).reduce((val, eachAction) => {
+  Object.keys(DEFAULT_DO_MODULE).reduce((val, eachAction) => {
     if (val[eachAction]) {
       return val
     }
 
-    const action = DEFAULT_THUNK_MODULE_FUNC_MAP[eachAction]
+    const action = DEFAULT_DO_MODULE[eachAction]
 
     // @ts-expect-error eachAction is in setMap<S, R>
     // biome-ignore lint/suspicious/noExplicitAny: action parameters can be any types.

package/src/states/index.ts

@@ -0,0 +1,84 @@
+import type { setMap } from '../set'
+import type { doModule } from '../thunkModule'
+import type { UseThunk } from '../useThunk'
+import { deepCopy } from '../utils'
+import type { ModuleState, NodeState, NodeStateMap, State } from './types'
+
+export type { ModuleState, NodeState, State, NodeStateMap }
+
+export const getDefaultID = <S extends State>(moduleState: ModuleState<S>): string => {
+  return moduleState.defaultID ?? ''
+}
+
+export const getNodeOrNull = <S extends State>(
+  moduleState: ModuleState<S>,
+  myID?: string,
+): Readonly<NodeState<S> | null> => {
+  const theID = myID ? myID : getDefaultID(moduleState)
+  if (!theID) {
+    return null
+  }
+
+  return moduleState.nodes[theID] || null
+}
+
+export const getStateOrNullByModule = <S extends State>(
+  moduleState: ModuleState<S>,
+  myID?: string,
+): Readonly<S | null> => {
+  const theID = myID ? myID : getDefaultID(moduleState)
+  if (!theID) {
+    return null
+  }
+
+  const me = moduleState.nodes[theID]
+  if (!me) {
+    return null
+  }
+
+  return me.state
+}
+
+export const getStateByModule = <S extends State>(
+  moduleState: ModuleState<S>,
+  myID?: string,
+): Readonly<S> => {
+  const theID = myID ? myID : getDefaultID(moduleState)
+  if (!theID) {
+    return moduleState.defaultState
+  }
+
+  const state = getStateOrNullByModule(moduleState, theID)
+  if (state) {
+    return state
+  }
+
+  // XXX magic for new nodes
+  // 1. reduceInit
+  const newState = deepCopy(moduleState.defaultState)
+  const newNode = { id: theID, state: newState }
+  moduleState.nodes[theID] = newNode
+
+  // 2. already init default-id, no need to init default-id here.
+  if (moduleState.isInitDefaultID) {
+    return newState
+  }
+
+  // 3. check defaultID
+  if (!moduleState.defaultID) {
+    moduleState.defaultID = theID
+    moduleState.isInitDefaultID = true
+  }
+
+  return newState
+}
+
+export const getState = <S extends State, R extends doModule<S>>(
+  theUseThunk: UseThunk<S, R>,
+  myID?: string,
+): [Readonly<S>, setMap<S, R>, string] => {
+  const [moduleState, theDo] = theUseThunk
+  const theID = myID ? myID : getDefaultID(moduleState)
+  const state = getStateByModule(moduleState, theID)
+  return [state, theDo, theID]
+}

package/src/{stateTypes.ts → states/types.ts}

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

package/src/thunkContext/index.ts

@@ -0,0 +1,9 @@
+import type { Context } from './types'
+export type { Context }
+
+// THUNK_CONTEXT_MAP is used in registerThunk and useThunkReducer
+import { THUNK_CONTEXT_MAP, type ThunkContextMap } from './thunkContextMap'
+export { THUNK_CONTEXT_MAP, type ThunkContextMap }
+
+import ThunkContext from './ThunkContext'
+export { ThunkContext }

package/src/{thunkContextMap.ts → thunkContext/thunkContextMap.ts}

@@ -1,6 +1,6 @@
 import type { Context as rContext } from 'react'
-import type { ModuleState } from './stateTypes'
-import type { Context } from './thunkContextTypes'
+import type { ModuleState } from '../states'
+import type { Context } from './types'
 
 export type ThunkContextMap = {
   theMap: {

package/src/{thunkContextTypes.ts → thunkContext/types.ts}

@@ -1,5 +1,5 @@
 import type { Dispatch, SetStateAction } from 'react'
-import type { ModuleState, State } from './stateTypes'
+import type { ModuleState, State } from '../states'
 
 export type Context<S extends State> = {
   // INFO: we use refModuleState to reference across all the useThunk of the same module in different ops.

package/src/thunkModule/defaultDoModule.ts

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

package/src/thunkModule/index.ts

@@ -1,21 +1,21 @@
 import type { ThunkFunc } from '../action'
-import type { Reducer } from '../reducer'
-import type { State } from '../stateTypes'
+import type { State } from '../states'
+import { DEFAULT_DO_MODULE, type defaultDoModule } from './defaultDoModule'
+export { DEFAULT_DO_MODULE, type defaultDoModule }
 
-export interface ThunkModuleBase<S extends State> {
-  [idx: string]: ThunkFunc<S> | string | Reducer<S> | S | undefined
-}
-
-export interface ThunkModuleFunc<S extends State> extends ThunkModuleBase<S> {
+export interface doModule<S extends State> {
   [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>
+  name: string
   defaultState: S
-} & ThunkModuleBase<S>
 
-export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'myClass' | 'default' | 'defaultState'>
+  // The rest of the variables are doModule.
+  // Specifying index-signatures to include all the variables.
+  [action: string]: ThunkFunc<S> | string | S
+}
+
+// biome-ignore lint/suspicious/noExplicitAny: ok for type utility functions.
+export type toDoModule<T extends ThunkModule<any>> = Omit<T, 'name' | 'default' | 'defaultState'>

package/src/{useThunk.ts → useThunk/index.ts}

@@ -1,23 +1,20 @@
 import { useMemo } from 'react'
-import { createReducer } from './createReducer'
-import { constructSetMap, type setMap, type setMapByModuleMap } from './setMap'
-import type { ModuleState, State } from './stateTypes'
-import type { ThunkModule, ThunkModuleFunc } from './thunkModule'
+import { createReducer } from '../reducer'
+import { constructSetMap, type setMap, type setMapByModuleMap } from '../set'
+import type { ModuleState, State } from '../states'
+import type { doModule, ThunkModule } from '../thunkModule'
 import useThunkReducer from './useThunkReducer'
 
 // 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>> = [ModuleState<S>, setMap<S, R>]
+export type UseThunk<S extends State, R extends doModule<S>> = [Readonly<ModuleState<S>>, setMap<S, R>]
 
 /**********
  * useThunk
  **********/
-export default <S extends State, R extends ThunkModuleFunc<S>>(
-  theDo: ThunkModule<S>,
-): UseThunk<S, R> => {
-  const { name: propsName, myClass } = theDo
-  const name = (propsName ? propsName : myClass) || ''
+export default <S extends State, R extends doModule<S>>(theDo: ThunkModule<S>): UseThunk<S, R> => {
+  const { name } = theDo
 
   // 1. It requires shared nodes for the same module to have the same setMap.
   const isFirstTime = !SET_MAP_BY_MODULE[name]

package/src/{useThunkReducer.ts → useThunk/useThunkReducer.ts}

@@ -2,11 +2,14 @@
 //https://github.com/nathanbuchar/react-hook-thunk-reducer/blob/master/src/thunk-reducer.js
 
 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'
+import type { BaseAction } from '../action'
+import { upsert } from '../defaultThunks/upsert'
+import type { dispatch } from '../dispatch'
+import type { get, getOrNull } from '../get'
+import type { Reducer } from '../reducer'
+import type { set } from '../set'
+import { getStateByModule, getStateOrNullByModule, type ModuleState, type State } from '../states'
+import { THUNK_CONTEXT_MAP } from '../thunkContext'
 
 /**
  * useThunkReducer
@@ -20,7 +23,7 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
   const { refModuleState, setModuleState: setModuleState_c } = useContext(context)
   const getModuleState = useCallback(() => {
     return refModuleState.current
-  }, [refModuleState])
+  }, [refModuleState]) as () => ModuleState<S>
 
   const setModuleState = useCallback(
     (newModuleState: ModuleState<S>) => {
@@ -30,7 +33,24 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
     [refModuleState, setModuleState_c],
   )
 
-  // 5. reducer.
+  const getOrNull: getOrNull<S> = useCallback(
+    (id?: string) => {
+      const moduleState = getModuleState()
+      const state = getStateOrNullByModule(moduleState, id)
+      return state
+    },
+    [getModuleState],
+  )
+
+  const get: get<S> = useCallback(
+    (id?: string) => {
+      const moduleState = getModuleState()
+      const state = getStateByModule(moduleState, id)
+      return state
+    },
+    [getModuleState],
+  )
+
   const reduce = useCallback(
     (action: BaseAction): ModuleState<S> => {
       const moduleState = getModuleState()
@@ -40,12 +60,11 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
     [reducer, getModuleState],
   )
 
-  // augmented setter.
-  const set: set<S> = useCallback(
+  const dispatch: dispatch<S> = useCallback(
     (action) => {
       if (typeof action === 'function') {
         // action is Thunk<S, A>
-        action(set, getModuleState)
+        action(set, get, getOrNull, dispatch, getModuleState)
         return
       }
 
@@ -56,5 +75,26 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
     [getModuleState, setModuleState, reduce],
   )
 
+  const set: set<S> = useCallback(
+    (actionOrID, data) => {
+      if (typeof actionOrID === 'string') {
+        // actionOrID is id
+        if (!data) {
+          return
+        }
+
+        // we have the data, we can do upsert.
+        const action = upsert(actionOrID, data)
+        const newModuleState = reduce(action)
+        setModuleState(newModuleState)
+        return
+      }
+
+      // actionOrID is action
+      dispatch(actionOrID)
+    },
+    [getModuleState, setModuleState, reduce],
+  )
+
   return [refModuleState.current, set]
 }

package/src/utils/deepCopy.ts

@@ -0,0 +1,30 @@
+// biome-ignore lint/suspicious/noExplicitAny: obj in deepCopy can be any type.
+const deepCopy = (obj: any): any => {
+  // Handle primitives, functions, null, or undefined
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+
+  // Handle Date objects
+  if (obj instanceof Date) {
+    return new Date(obj.getTime())
+  }
+
+  // Handle Arrays
+  if (Array.isArray(obj)) {
+    return obj.map((item) => deepCopy(item))
+  }
+
+  // Handle Objects
+  // biome-ignore lint/suspicious/noExplicitAny: clonedObj can be any type.
+  const clonedObj: any = {}
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      clonedObj[key] = deepCopy(obj[key])
+    }
+  }
+
+  return clonedObj
+}
+
+export default deepCopy

package/src/utils/genID.ts

@@ -0,0 +1,6 @@
+let _GLOBAL_ID = 1
+
+export const genID = (): string => {
+  _GLOBAL_ID += 1
+  return `${_GLOBAL_ID}`
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+import deepCopy from './deepCopy'
+import { genID } from './genID'
+export { deepCopy, genID }

package/types/action/ActionOrThunk.d.ts

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

package/types/action/index.d.ts

@@ -1,8 +1,8 @@
-import type { ModuleState, State } from '../stateTypes';
+import type { ModuleState, State } from '../states';
 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>;
+export type getModuleState<S extends State> = () => ModuleState<S>;

package/types/action/thunk.d.ts

@@ -1,3 +1,5 @@
+import type { dispatch } from '../dispatch';
+import type { get, getOrNull } from '../get';
 import type { set } from '../set';
-import type { ModuleState, State } from '../stateTypes';
-export type Thunk<S extends State> = (set: set<S>, getModuleState: () => ModuleState<S>) => void;
+import type { ModuleState, State } from '../states';
+export type Thunk<S extends State> = (set: set<S>, get: get<S>, getOrNull: getOrNull<S>, dispatch: dispatch<S>, getModuleState: () => ModuleState<S>) => void;