@chhsiao1981/use-thunk 10.4.0 → 12.0.0

package/src/createThunk.ts

@@ -0,0 +1,24 @@
+import { createContext, type Dispatch, type SetStateAction } from 'react'
+import type { ModuleState, State } from './stateTypes'
+import { THUNK_CONTEXT_MAP } from './thunkContextMap'
+import type { ThunkModule } from './thunkModule'
+
+export default <S extends State>(theDo: ThunkModule<S>) => {
+  const { name, defaultState } = theDo
+
+  if (THUNK_CONTEXT_MAP.theMap[name]) {
+    console.warn('createThunk: already init:', name)
+    return
+  }
+
+  const moduleState: ModuleState<S> = { name, nodes: {}, defaultState }
+  const setModuleState: Dispatch<SetStateAction<ModuleState<S>>> = () => {}
+  const refModuleState = { current: moduleState }
+  const context = createContext({ refModuleState: refModuleState, setModuleState })
+
+  THUNK_CONTEXT_MAP.theMap[name] = { context, refModuleState }
+  const theList = Object.keys(THUNK_CONTEXT_MAP.theMap).sort()
+  THUNK_CONTEXT_MAP.theList = theList
+
+  console.info('createThunk: done:', name)
+}

package/src/get.ts

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

package/src/index.ts

@@ -1,52 +1,42 @@
-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,
+  createThunk,
   useThunk,
-  ThunkContext,
   type UseThunk,
+  ThunkContext,
   type State,
-  type NodeState,
-  type NodeStateMap,
-  // type NodeStateMapByClass, // XXX for global state
-  type ClassState,
-  type GetClassState,
-  // type BaseAction, // XXX deemphasize action
+  type ModuleState,
+  type GetModuleState,
   type Thunk,
-  // type ActionOrThunk, // XXX deemphasize action
-  // type ActionFunc, // XXX deemphasize action
-  // type Reducer, // XXX deemphasize reducer
   type ThunkModule,
   type ThunkModuleToFunc,
-  // type ReduceFunc, // XXX deemphasize reducer
-  type Dispatch,
-  type DispatchFuncMap,
-  // type DefaultDispatchFuncMap, // XXX deemphasize default
-  getDefaultID,
+  type set,
+  type setMap,
+  type get,
   getNode,
+  getDefaultID,
+  getStateOrNullByModule,
+  getStateByModule,
   getState,
-  mustGetState,
-  mustGetStateByThunk,
   init,
   type InitParams,
-  setData,
+  update,
   remove,
-  // type DefaultThunkModuleFuncMap as DefaultReducerModuleFuncMap, // XXX deemphasize default
-  // type ReduceMap, // XXX deemphasize reducer
-  // createReducer, // XXX deemphasize reducer
   setDefaultID,
   genUUID,
 }

package/src/init/index.ts

@@ -0,0 +1,26 @@
+import type { Thunk } from '../action'
+import { genUUID } from '../genUUID'
+import { setDefaultID } from '../setDefaultID'
+import type { State } from '../stateTypes'
+import initCore from './initCore'
+
+// InitParams
+export interface InitParams<S extends State> {
+  myID?: string
+  state: S
+}
+
+export const init = <S extends State>(params: InitParams<S>, myuuidv4?: () => string): Thunk<S> => {
+  return (set, _, getModuleState) => {
+    const myID = params.myID ?? genUUID(myuuidv4)
+
+    const { state } = params
+    set(initCore(myID, state))
+
+    const { defaultID } = getModuleState()
+
+    if (!defaultID) {
+      set(setDefaultID(myID))
+    }
+  }
+}

package/src/init/initCore.ts

@@ -0,0 +1,31 @@
+import type BaseAction from '../action/baseAction'
+import type { ModuleState, NodeState, NodeStateMap, State } from '../stateTypes'
+
+export interface InitAction<S extends State> extends BaseAction {
+  state: S
+}
+
+export const INIT = '@chhsiao1981/use-thunk/INIT'
+export default <S extends State>(myID: string, state: S): InitAction<S> => {
+  return {
+    myID,
+    type: INIT,
+    state,
+  }
+}
+
+export const reduceInit = <S extends State>(
+  moduleState: ModuleState<S>,
+  action: BaseAction,
+): ModuleState<S> => {
+  const { myID, state } = action as InitAction<S>
+
+  const myNode: NodeState<S> = {
+    id: myID,
+    state: state,
+  }
+  const newNodes: NodeStateMap<S> = Object.assign({}, moduleState.nodes, { [myID]: myNode })
+  const newModuleState: ModuleState<S> = Object.assign({}, moduleState, { nodes: newNodes })
+
+  return newModuleState
+}

package/src/reduceMap.ts

@@ -1,9 +1,9 @@
-import { INIT, reduceInit } from './init'
+import { INIT, reduceInit } from './init/initCore'
 import type { ReduceFunc } from './reducer'
 import { REMOVE, reduceRemove } from './remove'
-import { reduceSetData, SET_DATA } from './setData'
 import { reduceSetDefaultID, SET_DEFAULT_ID } from './setDefaultID'
 import type { State } from './stateTypes'
+import { reduceUpdate, UPDATE } from './update'
 
 export interface ReduceMap<S extends State> {
   [type: string]: ReduceFunc<S>
@@ -11,9 +11,8 @@ export interface ReduceMap<S extends State> {
 
 // default reduceMap
 export const DEFAULT_REDUCE_MAP: <S extends State>() => ReduceMap<S> = () => ({
-  // @ts-expect-error baseAction in ReduceMap
   [INIT]: reduceInit,
-  [SET_DATA]: reduceSetData,
+  [UPDATE]: reduceUpdate,
   [REMOVE]: reduceRemove,
 
   // setDefaultID.

package/src/reducer.ts

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

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,9 @@ 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
   defaultID?: string | null
   nodes: NodeStateMap<S>
   defaultState: S

package/src/states.ts

@@ -1,47 +1,50 @@
-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 getStateOrNullByModule = <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 getStateByModule = <S extends State>(moduleState: ModuleState<S>, myID?: string): S => {
+  return getStateOrNullByModule(moduleState, myID) || moduleState.defaultState
 }
 
-export const mustGetStateByThunk = <S extends State, R extends ThunkModuleFunc<S>>(
+export const getState = <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 = getStateByModule(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>>
 
-      // 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,15 @@
+import type { ActionFunc } from '../action'
+import { init } from '../init'
+import { remove } from '../remove'
+import { update } from '../update'
+
+export const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap = {
+  init,
+  update,
+  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,20 @@
+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
+  default?: Reducer<S>
+  defaultState: S
+} & ThunkModuleBase<S>
+
+export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'default' | 'defaultState'>

package/src/update.ts

@@ -0,0 +1,26 @@
+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 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,21 +1,14 @@
 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
@@ -23,49 +16,35 @@ export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [
 export default <S extends State, R extends ThunkModuleFunc<S>>(
   theDo: ThunkModule<S>,
 ): UseThunk<S, R> => {
-  const { myClass } = theDo
+  const { name } = theDo
 
-  // 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
 }