@chhsiao1981/use-thunk 10.4.0 → 12.0.0

package/README.md

@@ -19,9 +19,15 @@ Please check [demo-use-thunk](https://github.com/chhsiao1981/demo-use-thunk) for
 
 ### Breaking Changes
 
-* Starting from `10.0.0`: The ClassState is shared globally, with `registerThunk` and `ThunkContext`.
-* Starting from `9.0.0`: npm package is renamed as [@chhsiao1981/use-thunk](https://www.npmjs.com/package/%40chhsiao1981/use-thunk)
-* Starting from `8.0.0`: [Totally renamed as `useThunk`](https://github.com/chhsiao1981/use-thunk/issues/105).
+* Starting from [`12.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/12.0.0): redefining the `getState` functions.
+    1. `getState` => `getStateOrNullByModule`, `mustGetState` => `getStateByModule`.
+    2. `mustGetStateByThunk` => `getState`.
+* Starting from [`11.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/11.0.0):
+    1. `setData` => `update`, `registerThunk` => `createThunk`, `dispatch` => `set`, `ClassState` => `ModuleState`, and `ModuleState.myClass` => `ModuleState.name`.
+    2. `Thunk` is `(set, get, getModuleState) => {}`, where `get(id)` directly returns object-level state.
+* Starting from [`10.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/10.0.0): The ClassState is shared globally, with `registerThunk` and `ThunkContext`.
+* Starting from [`9.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/9.0.0): npm package is renamed as [@chhsiao1981/use-thunk](https://www.npmjs.com/package/%40chhsiao1981/use-thunk)
+* Starting from [`8.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/8.0.0): [Totally renamed as `useThunk`](https://github.com/chhsiao1981/use-thunk/issues/105).
 
 ## Install
 
@@ -32,9 +38,9 @@ Please check [demo-use-thunk](https://github.com/chhsiao1981/demo-use-thunk) for
 Thunk module able to do increment (reducers/increment.ts):
 
 ```ts
-import { init as _init, setData, Thunk, getState, type State as rState, genUUID } from '@chhsiao1981/use-thunk'
+import { init as _init, update, Thunk, type State as rState, genUUID } from '@chhsiao1981/use-thunk'
 
-export const myClass = 'demo/Increment'
+export const name = 'demo/Increment'
 
 export interface State extends rState {
   count: number
@@ -46,20 +52,20 @@ export const defaultState: State = {
 
 export const init = (): Thunk<State> => {
   const myID = genUUID()
-  return async (dispatch, getClassState) => {
-    dispatch(_init({myID, state: defaultState}))
+  return async (set) => {
+    set(_init({myID, state: defaultState}))
   }
 }
 
 export const increment = (myID: string): Thunk<State> => {
-  return async (dispatch, getClassState) => {
-    let classState = getClassState()
-    let me = getState(classState, myID)
+  return async (set, get) => {
+    let me = get(myID)
     if(!me) {
       return
     }
+    const {count} = me
 
-    dispatch(setData(myID, { count: me.count + 1 }))
+    set(update(myID, { count: count + 1 }))
   }
 }
 ```
@@ -67,7 +73,7 @@ export const increment = (myID: string): Thunk<State> => {
 App.tsx:
 
 ```tsx
-import { type ThunkModuleToFunc, useThunk, getDefaultID, getState } from '@chhsiao1981/use-thunk'
+import { type ThunkModuleToFunc, useThunk, getState } from '@chhsiao1981/use-thunk'
 import * as DoIncrement from './reducers/increment'
 
 type TDoIncrement = ThunkModuleToFunc(typeof DoIncrement)
@@ -76,17 +82,14 @@ type Props = {
 }
 
 export default (props: Props) => {
-  const [classStateIncrement, doIncrement] = useThunk<DoIncrement.State, TDoIncrement>(DoIncrement, StateType.LOCAL)
+  const useIncrement = useThunk<DoIncrement.State, TDoIncrement>(DoIncrement, StateType.LOCAL)
+  const [increment, doIncrement, incrementID] = getState(useIncrement)
 
   //init
   useEffect(() => {
     doIncrement.init()
   }, [])
 
-  // states
-  const incrementID = getDefaultID(classStateIncrement)
-  const increment = getState(classStateIncrement) || DoIncrement.defaultState
-
   // to render
   return (
     <div>
@@ -99,13 +102,13 @@ export default (props: Props) => {
 
 main.tsx:
 ```tsx
-import { registerThunk, ThunkContext } from "@chhsiao1981/use-thunk";
+import { createThunk, ThunkContext } from "@chhsiao1981/use-thunk";
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
 import * as DoIncrement from './reducers/increment'
 import App from "./App.tsx";
 
-registerThunk(DoIncrement)
+createThunk(DoIncrement)
 
 createRoot(document.getElementById("root")!).render(
   <StrictMode>
@@ -121,13 +124,15 @@ createRoot(document.getElementById("root")!).render(
 ```ts
 import type { State as rState } from '@chhsiao1981/use-thunk'
 
-// reducer class name.
-export const myClass = ""
+// Thunk-module name.
+export const name = ""
 
 // state definition of the reducer.
 export interface State extends rState {
 }
 
+export const defaultState: State = {}
+
 .
 .
 .
@@ -136,18 +141,16 @@ export interface State extends rState {
 ### Must Included in a Top-level Component
 
 ```ts
-import { type ThunkModuleToFunc, useThunk, getDefaultID, getState } from '@chhsiao1981/use-thunk'
+import { type ThunkModuleToFunc, useThunk, getState } from '@chhsiao1981/use-thunk'
 import * as DoModule from '../reducers/module'
 
 type TDoModule = ThunkModuleToFunc<typeof DoModule>
 
 const Component = () => {
-  const [stateModule, doModule] = useThunk<DoModule.State, TDoModule>(DoModule)
-
-  const moduleID = getDefaultID(stateModule)
-  const theModule = getState(stateModule)
+  const useModule = useThunk<DoModule.State, TDoModule>(DoModule)
+  const [module, doModule, moduleID] = getState(useModule)
 
-  .
+.
   .
   .
 }
@@ -156,7 +159,8 @@ const Component = () => {
 ### Must Included in main.tsx
 
 ```tsx
-registerThunk(...)
+import { createThunk, ThunkContext } from '@chhsiao1981/use-thunk'
+createThunk(...)
 .
 .
 .
@@ -182,8 +186,8 @@ with the following features:
 For example, the example [in the redux link](https://redux.js.org/recipes/structuring-reducers/normalizing-state-shape) is represented as:
 
 ```ts
-classStatePost = {
-  myClass: 'post',
+moduleStatePost = {
+  name: 'post',
   nodes: {
     [uuid-post1] : {
       id: uuid-post1,
@@ -202,7 +206,7 @@ classStatePost = {
       }
     }
   },
-  defaultID,
+  defaultID,s
   defaultState,
 }
 ```
@@ -210,8 +214,8 @@ classStatePost = {
 and:
 
 ```ts
-classStateComment = {
-  myClass: 'comment',
+moduleStateComment = {
+  myClass: 'module',
   nodes: {
     [uuid-comment1] : {
       id: uuid-comment1,
@@ -256,8 +260,8 @@ classStateComment = {
 
 and:
 ```ts
-classStateUser = {
-  myClass: 'user',
+moduleStateUser = {
+  name: 'user',
   nodes: {
     [uuid-user1] : {
       id: uuid-user1,
@@ -290,50 +294,50 @@ classStateUser = {
 
 ### Basic
 
-##### `useThunk(theDo: ThunkModuleFunc): [ClassState, DispatchedFuncMap]`
+##### `createThunk(theModule: ThunkModule)`
 
-Similar to `React.useReducer`, but we use `useThunk`, and we also bind the actions with dispatch (similar concept as `mapDispatchToProps`).s
+Create a module state for `theModule`.
 
-return: `[ClassState<S>, DispatchedFuncMap<S, R>]`
+##### `<ThunkContext>{children}</ThunkContext>`
 
-##### `init({myID, parentID, doParent, state}, myuuidv4?)`
+Rendering Thunk context.
 
-initializing the react-object.
+##### `useThunk(theDo: ThunkModule): UseThunk`
 
-##### `setData(myID, data)`
+Similar to `React.useReducer`, but we use `useThunk`, and we also bind the actions with set (similar concept as `mapDispatchToProps`).
 
-set the data to myID.
+return: `UseThunk`
 
-##### `remove(myID, isFromParent=false)`
+### Default Thunk functions.
 
-remove the react-object.
+##### `init({myID, parentID, doParent, state}, myuuidv4?)`
 
-##### `genUUID(myuuidv4?: () => string): string`
+initializing the state.
 
-generate uuid for react-object.
+##### `update(myID, data)`
 
-### State
+update the data to myID.
 
-##### `getState(state: ClassState, myID?: string): State | null`
+##### `remove(myID)`
 
-Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `null` if not available.
+remove the state.
 
-##### `mustGetState(state: ClassState, myID?: string): State`
+##### `genUUID(myuuidv4?: () => string): string`
 
-Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
+generate uuid for the state.
 
-##### `mustGetStateByThunk(theUseThunk: UseThunk, myID?: string): [State, DispatchedActionMap, theID]`
+### State
 
-Get the state of `myID` by `UseThunk`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
+##### `getState(theUseThunk: UseThunk, myID?: string): [state, doModule, theID]`
 
-return: `[S, DispatchedFuncMap<S, R>, theID]`
+Get the state of `myID` by `UseThunk`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
 
-##### `getDefaultID(state: ClassState): string`
+return: `[state, doModule, theID]`
 
-get the default id.
+##### `getStateOrNullByModule(moduleState: ModuleState, myID?: string): state | null`
 
-### NodeState
+Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `null` if not available.
 
-##### `getNode(state: ClassState, myID?: string): NodeState`
+##### `getStateByModule(moduleState: ModuleState, myID?: string): state`
 
-Get the node of `myID`. Get the node of `defaultID` if `myID` is not present.
+Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.

package/dist/ThunkContext.d.ts

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

package/dist/createReducer.d.ts

@@ -0,0 +1,4 @@
+import { type ReduceMap } from './reduceMap';
+import type { Reducer } from './reducer';
+import type { State } from './stateTypes';
+export declare const createReducer: <S extends State>(reduceMap?: ReduceMap<S>) => Reducer<S>;

package/dist/createThunk.d.ts

@@ -0,0 +1,4 @@
+import type { State } from './stateTypes';
+import type { ThunkModule } from './thunk';
+export default function createThunk<S extends State>(theDo: ThunkModule<S>): void;
+export declare function registerThunk<S extends State>(theDo: ThunkModule<S>): void;

package/dist/dispatch.d.ts

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

package/dist/dispatchFuncMap.d.ts

@@ -0,0 +1,18 @@
+import type { BaseAction } from './action';
+import type { State } from './stateTypes';
+import type { ThunkModule, ThunkModuleFunc } from './thunk';
+import { type DefaultThunkModuleFuncMap } from './thunkModuleFuncMap';
+import type { Thunk as rThunk } from './useThunkReducer';
+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]>;
+} & Omit<DefaultDispatchFuncMap, keyof T>;
+export type DefaultDispatchFuncMap = {
+    [action in keyof DefaultThunkModuleFuncMap]: VoidReturnType<DefaultThunkModuleFuncMap[action]>;
+};
+export interface DispatchFuncMapByClassMap<S extends State, T extends ThunkModuleFunc<S>> {
+    [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>, dispatch: (action: A | rThunk<S, A>) => void, dispatchMap: DispatchFuncMap<S, T>) => DispatchFuncMap<S, T>;
+export {};

package/dist/genUUID.d.ts

@@ -0,0 +1 @@
+export declare const genUUID: (myuuidv4?: () => string) => string;

package/dist/index.d.ts

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

package/{types → dist}/init.d.ts

@@ -2,9 +2,6 @@ import type { BaseAction, Thunk } from './action';
 import type { ClassState, State } from './stateTypes';
 export interface InitParams<S extends State> {
     myID?: string;
-    parentID?: string;
-    doParent?: DispatchFuncMap;
-    parentClass?: string;
     state: S;
 }
 export declare const init: <S extends State>(params: InitParams<S>, myuuidv4?: () => string) => Thunk<S>;

package/dist/reduceMap.d.ts

@@ -0,0 +1,6 @@
+import type { ReduceFunc } from './reducer';
+import type { State } from './stateTypes';
+export interface ReduceMap<S extends State> {
+    [type: string]: ReduceFunc<S>;
+}
+export declare const DEFAULT_REDUCE_MAP: <S extends State>() => ReduceMap<S>;

package/dist/reducer.d.ts

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

package/dist/remove.d.ts

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

package/dist/setDefaultID.d.ts

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

package/dist/stateTypes.d.ts

@@ -0,0 +1,16 @@
+export interface State {
+    [key: string]: unknown;
+}
+export type NodeState<S extends State> = {
+    id: string;
+    state: S;
+};
+export type NodeStateMap<S extends State> = {
+    [key: string]: NodeState<S>;
+};
+export type ClassState<S extends State> = {
+    myClass: string;
+    defaultID?: string | null;
+    nodes: NodeStateMap<S>;
+    defaultState: S;
+};

package/dist/states.d.ts

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

package/{types → dist}/thunk.d.ts

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

package/dist/thunkContextMap.d.ts

@@ -0,0 +1,15 @@
+import type { Context as rContext } from 'react';
+import type { ClassState } from './stateTypes';
+import type { Context } from './thunkContextTypes';
+export type ThunkContextMap = {
+    theMap: {
+        [classname: string]: {
+            context: rContext<Context<any>>;
+            refClassState: {
+                current: ClassState<any>;
+            };
+        };
+    };
+    theList: string[];
+};
+export declare const THUNK_CONTEXT_MAP: ThunkContextMap;

package/dist/thunkContextTypes.d.ts

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

package/{types → dist}/thunkModuleFuncMap.d.ts

@@ -1,5 +1,6 @@
 export declare const DEFAULT_THUNK_MODULE_FUNC_MAP: {
     init: <S extends import("./stateTypes").State>(params: import("./init").InitParams<S>, myuuidv4?: () => string) => import("./action").Thunk<S>;
+    update: <S extends import("./stateTypes").State>(myID: string, data: Partial<S>) => import("./action").BaseAction;
     setData: <S extends import("./stateTypes").State>(myID: string, data: Partial<S>) => import("./action").BaseAction;
     remove: <S extends import("./stateTypes").State>(myID: string) => import("./action").Thunk<S>;
 };

package/dist/update.d.ts

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

package/dist/useThunk.d.ts

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

package/dist/useThunkReducer.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chhsiao1981/use-thunk",
-  "version": "10.4.0",
+  "version": "12.0.0",
   "type": "module",
   "description": "A framework easily using useThunk to manage the data-state.",
   "homepage": "https://github.com/chhsiao1981/use-thunk",

package/src/ThunkContext.tsx

@@ -2,42 +2,42 @@ import { type ReactNode, useMemo, useState } from 'react'
 import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 
 type Props = {
-  classes?: string[]
+  modules?: string[]
   children?: ReactNode
 }
 
 const ThunkContext = (props: Props): ReactNode => {
-  const { classes: propsClasses, children } = props
-  const classes = propsClasses || THUNK_CONTEXT_MAP.theList
-  // 0. if there is no Thunk classes (no registerThunk): return children.
-  if (classes.length === 0) {
+  const { modules: propsModules, children } = props
+  const modules = propsModules || THUNK_CONTEXT_MAP.theList
+  // 0. if there is no Thunk modules (no createThunk): return children.
+  if (modules.length === 0) {
     return children
   }
 
-  // render the 0th class.
-  const theClass = classes[0]
+  // render the 0th module.
+  const theModule = modules[0]
 
-  // 1. get the context and classState from context map.
-  const { context: Context_m, refClassState } = THUNK_CONTEXT_MAP.theMap[theClass]
+  // 1. get the context and moduleState from context map.
+  const { context: Context_m, refModuleState } = THUNK_CONTEXT_MAP.theMap[theModule]
 
-  // 2. setup classState.
+  // 2. setup moduleState.
   // biome-ignore lint/correctness/useHookAtTopLevel: the order is fixed.
-  const [classState, setClassState] = useState(refClassState.current)
-  refClassState.current = classState
+  const [moduleState, setModuleState] = useState(refModuleState.current)
+  refModuleState.current = moduleState
 
-  // 3. value reset only if classState is changed.
+  // 3. value reset only if moduleState is changed.
   // biome-ignore lint/correctness/useHookAtTopLevel: the order is fixed.
   const value = useMemo(
     () => ({
-      refClassState,
-      setClassState,
+      refModuleState: refModuleState,
+      setModuleState: setModuleState,
     }),
-    [classState],
+    [moduleState],
   )
 
   // 4. get theChildren
   const theChildren =
-    classes.length === 1 ? children : ThunkContext({ classes: classes.slice(1), children })
+    modules.length === 1 ? children : ThunkContext({ modules: modules.slice(1), children })
 
   // 5. return context.
   return <Context_m.Provider value={value}>{theChildren}</Context_m.Provider>

package/src/action/ActionOrThunk.ts

@@ -0,0 +1,5 @@
+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/src/action/baseAction.ts

@@ -0,0 +1,6 @@
+// BaseAction contains only object-based actions, no thunk-based actions.
+export default interface BaseAction {
+  myID: string
+  type: string
+  [key: string]: unknown
+}

package/src/action/index.ts

@@ -0,0 +1,16 @@
+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 }
+
+// ActionFunc
+// biome-ignore lint/suspicious/noExplicitAny: params can be any type.
+export type ActionFunc<S extends State> = (...params: any[]) => ActionOrThunk<S>
+
+// biome-ignore lint/suspicious/noExplicitAny: params can by any type.
+export type ThunkFunc<S extends State> = (...params: any[]) => Thunk<S>
+
+// GetModuleState
+export type GetModuleState<S extends State> = () => ModuleState<S>

package/src/action/thunk.ts

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

package/src/createReducer.ts

@@ -1,24 +1,24 @@
-import type { BaseAction } from './action'
+import type BaseAction from './action/baseAction'
 import { DEFAULT_REDUCE_MAP, type ReduceMap } from './reduceMap'
 import type { Reducer } from './reducer'
 
-import type { ClassState, State } from './stateTypes'
+import type { ModuleState, State } from './stateTypes'
 
 export const createReducer = <S extends State>(reduceMap?: ReduceMap<S>): Reducer<S> => {
-  return (classState: ClassState<S>, action: BaseAction): ClassState<S> => {
+  return (moduleState: ModuleState<S>, action: BaseAction): ModuleState<S> => {
     if (!action) {
-      return classState
+      return moduleState
     }
 
     if (reduceMap?.[action.type]) {
-      return reduceMap[action.type](classState, action)
+      return reduceMap[action.type](moduleState, action)
     }
 
     const defaultReduceMap = DEFAULT_REDUCE_MAP<S>()
     if (defaultReduceMap?.[action.type]) {
-      return defaultReduceMap[action.type](classState, action)
+      return defaultReduceMap[action.type](moduleState, action)
     }
 
-    return classState
+    return moduleState
   }
 }