@chhsiao1981/use-thunk 12.0.0 → 13.0.0

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,13 +1,18 @@
+// 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 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, defaultState } = theDo
 
   if (THUNK_CONTEXT_MAP.theMap[name]) {
-    console.warn('createThunk: already init:', name)
+    console.warn('registerThunk: already init:', name)
     return
   }
 
@@ -20,5 +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)
+  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,14 +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
-  defaultID?: string | null
   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,20 +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
-  default?: Reducer<S>
   defaultState: S
-} & ThunkModuleBase<S>
 
-export type ThunkModuleToFunc<T> = Omit<T, 'name' | '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,21 +1,19 @@
 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> => {
+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.

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

@@ -2,12 +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 { getStateOrNullByModule } from './states'
-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
@@ -31,7 +33,7 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
     [refModuleState, setModuleState_c],
   )
 
-  const get = useCallback(
+  const getOrNull: getOrNull<S> = useCallback(
     (id?: string) => {
       const moduleState = getModuleState()
       const state = getStateOrNullByModule(moduleState, id)
@@ -40,7 +42,15 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
     [getModuleState],
   )
 
-  // 5. reducer.
+  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()
@@ -50,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, get, getModuleState)
+        action(set, get, getOrNull, dispatch, getModuleState)
         return
       }
 
@@ -66,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>, get: (id?: string) => S | null, 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;

package/types/defaultThunks/index.d.ts

@@ -0,0 +1,10 @@
+import { INIT, type InitParams, init, reduceInit } from './init';
+export { INIT, type InitParams, init, reduceInit };
+import { reduceUpdate, UPDATE, update } from './update';
+export { reduceUpdate, UPDATE, update };
+import { REMOVE, reduceRemove, remove } from './remove';
+export { REMOVE, reduceRemove, remove };
+import { reduceUpsert, UPSERT, upsert } from './upsert';
+export { UPSERT, upsert, reduceUpsert };
+import { reduceSetDefaultID, SET_DEFAULT_ID, setDefaultID } from './setDefaultID';
+export { SET_DEFAULT_ID, setDefaultID, reduceSetDefaultID };

package/types/defaultThunks/init/index.d.ts

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

package/types/{init → defaultThunks/init}/initCore.d.ts

@@ -1,5 +1,5 @@
-import type BaseAction from '../action/baseAction';
-import type { ModuleState, State } from '../stateTypes';
+import type { BaseAction } from '../../action';
+import type { ModuleState, State } from '../../states';
 export interface InitAction<S extends State> extends BaseAction {
     state: S;
 }

package/types/{remove.d.ts → defaultThunks/remove.d.ts}

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

package/types/{setDefaultID.d.ts → defaultThunks/setDefaultID.d.ts}

@@ -1,5 +1,5 @@
-import type BaseAction from './action/baseAction';
-import type { ModuleState, State } from './stateTypes';
+import type { BaseAction } from '../action';
+import type { ModuleState, State } from '../states';
 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>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/{update.d.ts → defaultThunks/update.d.ts}

@@ -1,5 +1,5 @@
-import type BaseAction from './action/baseAction';
-import type { ModuleState, State } from './stateTypes';
+import type { BaseAction } from '../action';
+import type { ModuleState, State } from '../states';
 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/defaultThunks/upsert.d.ts

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

package/types/dispatch.d.ts

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

package/types/get.d.ts

@@ -1,2 +1,3 @@
-import type { State } from './stateTypes';
-export type get = <S extends State>(id: string) => S;
+import type { State } from './states';
+export type get<S extends State> = (id?: string) => S;
+export type getOrNull<S extends State> = (id?: string) => S | null | undefined;

package/types/index.d.ts

@@ -1,16 +1,12 @@
-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 { remove } from './remove';
-import type { set } from './set';
-import { setDefaultID } from './setDefaultID';
-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 './thunkModule';
-import { 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';
-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, };
+import { genID } from './utils';
+export { type Thunk, type set, type get, type getOrNull, type dispatch, type getModuleState, registerThunk, useThunk, type UseThunk, ThunkContext, type State, getState, type ModuleState, type ThunkModule, type toDoModule, type doModule, type ThunkFunc, init, type InitParams, update, upsert, remove, genID, type setMap, setDefaultID, getNodeOrNull, getDefaultID, getStateOrNullByModule, getStateByModule, };

package/types/reducer/createReducer.d.ts

@@ -0,0 +1,3 @@
+import type { State } from '../states';
+import type { Reducer } from './index';
+export declare const createReducer: <S extends State>() => Reducer<S>;

package/types/reducer/defaultReduceMap.d.ts

@@ -0,0 +1,2 @@
+import type { ReduceMap } from './reduceMap';
+export declare const DEFAULT_REDUCE_MAP: ReduceMap<any>;