@chhsiao1981/use-thunk 12.0.0 → 14.0.0

package/README.md

@@ -2,43 +2,26 @@
 
 [![codecov](https://codecov.io/gh/chhsiao1981/use-thunk/branch/main/graph/badge.svg)](https://codecov.io/gh/chhsiao1981/use-thunk)
 
-A framework easily using `useThunk` to manage the data-state.
+A framework for easily managing global data state with `useThunk`, with [`zustand`](https://github.com/pmndrs/zustand)-like taste.
 
-Adopted concept of [redux-thunk](https://redux.js.org/usage/writing-logic-thunks) and [redux-duck](https://github.com/PlatziDev/redux-duck)
+Inspired by the concepts of [Redux Thunk](https://redux.js.org/usage/writing-logic-thunks) and [Redux Duck](https://github.com/PlatziDev/redux-duck).
 
-[src/useThunkReducer.ts](src/useThunkReducer.ts) is adopted from [nathanbuchar/react-hook-thunk-reducer](https://github.com/nathanbuchar/react-hook-thunk-reducer/blob/master/src/thunk-reducer.js).
+[src/useThunkReducer.ts](src/useThunkReducer.ts) is adapted from [nathanbuchar/react-hook-thunk-reducer](https://github.com/nathanbuchar/react-hook-thunk-reducer/blob/master/src/thunk-reducer.js).
 
-`use-thunk` is with the following additional features:
+For more information, please check [docs/00-introduction.md](docs/00-introduction.md).
 
-1. The development of the thunk modules follows the concept of `redux-duck`.
-2. Instead of action / reducer, we focus only on `thunk`, and have the primitive actions/reducers.
-
-Please check [docs/00-introduction.md](docs/00-introduction.md) for more information.
-
-Please check [demo-use-thunk](https://github.com/chhsiao1981/demo-use-thunk) for a demo to use Thunk.
-
-### Breaking Changes
-
-* 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).
+For usage examples, please refer to [demo-use-thunk](https://github.com/chhsiao1981/demo-use-thunk).
 
 ## Install
 
-    npm install --save @chhsiao1981/use-thunk
+    npm install @chhsiao1981/use-thunk
 
-## Example
+## Getting Started
 
-Thunk module able to do increment (reducers/increment.ts):
+Thunk module able to do increment (thunks/increment.ts):
 
 ```ts
-import { init as _init, update, Thunk, type State as rState, genUUID } from '@chhsiao1981/use-thunk'
+import { type Thunk, type State as rState, update } from '@chhsiao1981/use-thunk'
 
 export const name = 'demo/Increment'
 
@@ -50,51 +33,53 @@ export const defaultState: State = {
   count: 0
 }
 
-export const init = (): Thunk<State> => {
-  const myID = genUUID()
-  return async (set) => {
-    set(_init({myID, state: defaultState}))
+// upsert directly with set.
+export const increment = (myID: string, num: number = 1): Thunk<State> => {
+  return async (set, get) => {
+    let me = get(myID)
+    const {count} = me
+
+    set(myID, { count: count + num })
   }
 }
 
-export const increment = (myID: string): Thunk<State> => {
+// or we can treat set as dispatching a base action.
+export const increment2 = (myID: string): Thunk<State> => {
   return async (set, get) => {
     let me = get(myID)
-    if(!me) {
-      return
-    }
     const {count} = me
 
-    set(update(myID, { count: count + 1 }))
+    set(update({ count: count + 2 }))
+  }
+}
+
+// or we can use set as dispatching a thunk function.
+export const increment3 = (myID: string): Thunk<State> => {
+  return async (set) => {
+    set(increment(myID, 3))
   }
 }
 ```
 
-App.tsx:
+components/App.tsx:
 
 ```tsx
 import { type ThunkModuleToFunc, useThunk, getState } from '@chhsiao1981/use-thunk'
-import * as DoIncrement from './reducers/increment'
+import * as DoIncrement from './thunks/increment'
 
-type TDoIncrement = ThunkModuleToFunc(typeof DoIncrement)
+type doIncrement = toDoModule(typeof DoIncrement)
 
-type Props = {
-}
-
-export default (props: Props) => {
-  const useIncrement = useThunk<DoIncrement.State, TDoIncrement>(DoIncrement, StateType.LOCAL)
+export default () => {
+  const useIncrement = useThunk<DoIncrement.State, doIncrement>(DoIncrement)
   const [increment, doIncrement, incrementID] = getState(useIncrement)
 
-  //init
-  useEffect(() => {
-    doIncrement.init()
-  }, [])
-
   // to render
   return (
     <div>
       <p>count: {increment.count}</p>
-      <button onClick={() => doIncrement.increment(incrementID)}>increase</button>
+      <button onClick={() => doIncrement.increment(incrementID)}>increase 1</button>
+      <button onClick={() => doIncrement.increment2(incrementID)}>increase 2</button>
+      <button onClick={() => doIncrement.increment3(incrementID)}>increase 3</button>
     </div>
   )
 }
@@ -102,13 +87,13 @@ export default (props: Props) => {
 
 main.tsx:
 ```tsx
-import { createThunk, ThunkContext } from "@chhsiao1981/use-thunk";
+import { registerThunk, 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";
+import * as DoIncrement from './thunks/increment'
+import App from "./components/App";
 
-createThunk(DoIncrement)
+registerThunk(DoIncrement)
 
 createRoot(document.getElementById("root")!).render(
   <StrictMode>
@@ -119,6 +104,7 @@ createRoot(document.getElementById("root")!).render(
 )
 ```
 
+## Development Pattern
 ### Must Included in a Thunk Module
 
 ```ts
@@ -138,29 +124,30 @@ export const defaultState: State = {}
 .
 ```
 
-### Must Included in a Top-level Component
+### Must Included in a Statically-allocated (always allocated) Component
 
 ```ts
-import { type ThunkModuleToFunc, useThunk, getState } from '@chhsiao1981/use-thunk'
-import * as DoModule from '../reducers/module'
+import { type toDoModule, useThunk, getState } from '@chhsiao1981/use-thunk'
+import * as DoModule from '../thunks/module'
 
-type TDoModule = ThunkModuleToFunc<typeof DoModule>
+type doModule = toDoModule<typeof DoModule>
 
 const Component = () => {
-  const useModule = useThunk<DoModule.State, TDoModule>(DoModule)
+  const useModule = useThunk<DoModule.State, doModule>(DoModule)
   const [module, doModule, moduleID] = getState(useModule)
 
 .
-  .
-  .
+.
+.
 }
 ```
 
-### Must Included in main.tsx
+### Must Included in `main.tsx`
 
 ```tsx
-import { createThunk, ThunkContext } from '@chhsiao1981/use-thunk'
-createThunk(...)
+import { registerThunk, ThunkContext } from '@chhsiao1981/use-thunk'
+import * as DoModule from '../thunks/module'
+registerThunk(DoModule)
 .
 .
 .
@@ -174,14 +161,23 @@ createRoot(document.getElementById("root")!).render(
 )
 ```
 
-## Normalized State
+## Introduction
+
+Global state management (GSM) is tricky when developing complex ReactJS applications. [Redux/RTK](https://redux-toolkit.js.org/) and [zustand](https://zustand-demo.pmnd.rs/) focus on "We create stores that manage the global states". However, the stores can quickly become gigantic functions in complex ReacJS applications. On the other hand, `useContext` is too primitive for complex ReactJS applications.
+
+`use-thunk` uses a different approach: All the data management is through module-based functions. With `use-thunk`:
+1. We treat the files as modules, and we write the module-based functions like what we typically do in other programming languages.
+2. React components can focus on data presentation, with obtaining the data from thunk modules.
+3. From React components' perspective, we directly call `do[Module].function(id)`.
+4. There is only 1 `ThunkContext`, which wraps around `<App />` in `main.tsx`. We no longer need to worry that the `Context` may appear in unexpected code-base and affect the underlying `useContext`.
+
+### Normalized State
 
-The general concept of normalized state can be found in [Normalizing State Shape](https://redux.js.org/recipes/structuring-reducers/normalizing-state-shape)
-with the following features:
+The general concept of normalized state can be found in [Normalizing State Shape](https://redux.js.org/recipes/structuring-reducers/normalizing-state-shape). We use the following hierarchy to represent the normalized states:
 
-1. ClassState: the state of the class, including the nodes and the defaultID of the class.
-2. NodeState: the state of a node, including the id of the node and the content (state) of the node.
-3. State: the content of the node, represented as a state.
+1. ModuleState: the state of a module, including the nodes and related information of the module.
+2. NodeState: the state of a node, including the id of the node and the data (state) of the node.
+3. State: the data of the node, represented as a state.
 
 For example, the example [in the redux link](https://redux.js.org/recipes/structuring-reducers/normalizing-state-shape) is represented as:
 
@@ -189,24 +185,24 @@ For example, the example [in the redux link](https://redux.js.org/recipes/struct
 moduleStatePost = {
   name: 'post',
   nodes: {
-    [uuid-post1] : {
-      id: uuid-post1,
+    [postID1] : {
+      id: postID1,
       state: {
-        author : uuid-user1,
+        author : userID1,
         body : "......",
-        comments: [uuid-comment1, uuid-comment2]
+        comments: [commentID1, commentID2]
       },
     },
-    [uuid-post2] : {
-      id : uuid-post2,
+    [postID2] : {
+      id : postID2,
       state: {
-        author : uuid-user2,
+        author : userID2,
         body : "......",
-        comments: [uuid-comment3, uuid-comment4, uuid-comment5]
+        comments: [commentID3, commentID4, commentID5]
       }
     }
   },
-  defaultID,s
+  defaultID,
   defaultState,
 }
 ```
@@ -215,40 +211,40 @@ and:
 
 ```ts
 moduleStateComment = {
-  myClass: 'module',
+  name: 'comment',
   nodes: {
-    [uuid-comment1] : {
-      id: uuid-comment1,
+    [commentID1] : {
+      id: commentID1,
       state: {
-        author : uuid-user2,
+        author : userID2,
         comment : ".....",
       }
     },
-    [uuid-comment2] : {
-      id : uuid-comment2,
+    [commentID2] : {
+      id : commentID2,
       state: {
-        author : uuid-user3,
+        author : userID3,
         comment : ".....",
       }
     },
-    [uuid-comment3] : {
-      id : uuid-comment3,
+    [commentID3] : {
+      id : commentID3,
       state: {
-        author : uuid-user3,
+        author : userID3,
         comment : ".....",
       }
     },
-    [uuid-comment4] : {
-      id : uuid-comment4,
+    [commentID4] : {
+      id : commentID4,
       state: {
-        author : uuid-user1,
+        author : userID1,
         comment : ".....",
       }
     },
-    [uuid-comment5] : {
-      id : uuid-comment5,
+    [commentID5] : {
+      id : commentID5,
       state: {
-        author : uuid-user3,
+        author : userID3,
         comment : ".....",
       }
     }
@@ -263,22 +259,22 @@ and:
 moduleStateUser = {
   name: 'user',
   nodes: {
-    [uuid-user1] : {
-      id: uuid-user1,
+    [userID1] : {
+      id: userID1,
       state: {
         username : "user1",
         name : "User 1",
       }
     },
-    [uuid-user2] : {
-      id: uuid-user2,
+    [userID2] : {
+      id: userID2,
       state: {
         username : "user2",
         name : "User 2",
       }
     },
-    [uuid-user3] : {
-      id: uuid-user3,
+    [userID3] : {
+      id: userID3,
       state: {
         username : "user3",
         name : "User 3",
@@ -292,52 +288,145 @@ moduleStateUser = {
 
 ## [APIs](https://github.com/chhsiao1981/use-thunk/blob/main/src/index.d.ts)
 
-### Basic
+#### Types
+
+##### `ThunkModule<S extends State>`
+
+```ts
+export type ThunkModule<S extends State> = {
+  name: string
+  defaultState: S
+
+  // The rest of the variables are doModule.
+  // Specifying index-signatures to include all the variables.
+  [action: string]: ThunkFunc<S> | string | S
+}
+```
+
+A ThunkModule represents a self-contained domain state slice implemented within a single file. It encapsulates the module's identity, its initial data structure, and the business logic workflows (thunk functions) that act upon it.
+
+##### `ThunkFunc<S extends State>`
+
+```ts
+export type ThunkFunc<S extends State> = (...params: any[]) => Thunk<S>
+```
+
+The thunk functions in a thunk module.
 
-##### `createThunk(theModule: ThunkModule)`
+##### `Thunk`
 
-Create a module state for `theModule`.
+`Thunk` is defined as:
+
+```ts
+export type Thunk<S extends State> = async (
+  set: set<S>,
+  get: (id?: string) => S,
+  getOrNull: (id?: string) => S | null | undefined,
+  dispatch: dispatch<S>,
+  getModuleState: () => ModuleState<S>,
+) => void
+```
+
+`Thunk`s can be async functions if needed (ex: `fetch` data).
+
+We generally use only `set` and `get`.
+
+* `set`: can be used in the following setting:
+    * `set(ThunkFunc())`: calling a thunk function.
+    * `set(id, data: Partial<S>)`: upsert state of `id` (syntax sugar of `set(upsert(id, data))`).
+* `get`: (Guaranteed) get the state of `id` (or `defaultID` if `id` is not present).
+* `getOrNull`: get the state of `id`. Get the state of `defaultID` if `id` is not present. Return `null` if `id` or state is not available.
+* `dispatch`: `dispatch(ThunkFunc())` (calling a thunk function).
+* `getModuleState`: get the whole module state.
+
+##### `doModule<S extends State>`
+
+```ts
+export interface doModule<S extends State> {
+  [action: string]: ThunkFunc<S>
+}
+```
+
+##### `toDoModule`
+
+```ts
+export type toDoModule<T extends ThunkModule<any>> = Omit<T, 'name' | 'defaultState'>
+```
+
+Converting `ThunkModule` to `doModule` by omitting `name` and `defaultState`.
+
+#### RegisterThunk / ThunkContext / useThunk
+
+##### `registerThunk(module: ThunkModule)`
+
+Register a thunk module.
 
 ##### `<ThunkContext>{children}</ThunkContext>`
 
-Rendering Thunk context.
+Rendering thunk context.
 
 ##### `useThunk(theDo: ThunkModule): UseThunk`
 
-Similar to `React.useReducer`, but we use `useThunk`, and we also bind the actions with set (similar concept as `mapDispatchToProps`).
+Similar to `React.useReducer`, but we use `useThunk`. In addition, we bind the thunk functions with `dispatch`, so we can directly use `do[Module].[function]()` (similar concept as `zustand`).
 
 return: `UseThunk`
 
-### Default Thunk functions.
+#### State
 
-##### `init({myID, parentID, doParent, state}, myuuidv4?)`
+##### `getState(theUseThunk: UseThunk, id?: string): [state, doModule, theID]`
 
-initializing the state.
+(Guaranteed) Get the state of `id` (or `defaultID` if `id` is not present) by `UseThunk`. If `defaultID` is not available, generate new ID as `defaultID`. If state is not available, clone `defaultState` as the state.
 
-##### `update(myID, data)`
+return: `[state, doModule, theID]`
 
-update the data to myID.
+#### Misc
 
-##### `remove(myID)`
+##### `genID(): string`
 
-remove the state.
+Generate `id` for the state.
 
-##### `genUUID(myuuidv4?: () => string): string`
+### Advanced Usage
 
-generate uuid for the state.
+#### types
 
-### State
+##### `UseThunk`
 
-##### `getState(theUseThunk: UseThunk, myID?: string): [state, doModule, theID]`
+```ts
+export type UseThunk<S extends State, R extends doModule<S>> = [Readonly<ModuleState<S>>, setMap<S, R>]
+```
 
-Get the state of `myID` by `UseThunk`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
+##### `setMap`
 
-return: `[state, doModule, theID]`
+```ts
+export type setMap<S extends State, T extends doModule<S>> = {
+  [action in keyof T]: VoidReturnType<T[action]>
+} & Omit<DefaultSetMap, keyof T>
+```
+
+#### Primitive Thunk Functions.
+
+##### `init({id, parentID, doParent, state})`
+
+Initialize the state.
+
+##### `update(id, data)`
+
+Update the data to `id`.
+
+##### `upsert(id, data)`
+
+Initialize the state with `defaultState` if it does not exist, and update the data to `id`.
+
+##### `remove(id)`
+
+Remove the state.
+
+#### State
 
-##### `getStateOrNullByModule(moduleState: ModuleState, myID?: string): state | null`
+##### `getStateOrNullByModule(moduleState: ModuleState, id?: string): state | null`
 
-Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `null` if not available.
+Get the state of `id`. Get the state of `defaultID` if `id` is not present. Return `null` if not available.
 
-##### `getStateByModule(moduleState: ModuleState, myID?: string): state`
+##### `getStateByModule(moduleState: ModuleState, id?: string): state`
 
-Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
+(Guaranteed) Get the state of `id` (or `defaultID` if `id` is not present) by module state. If `defaultID` is not available, generate new ID as `defaultID`. If state is not available, clone `defaultState` as the state.

package/{types → dist}/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 → dist}/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/dist/action/thunk.d.ts

@@ -0,0 +1,5 @@
+import type { dispatch } from '../dispatch';
+import type { get, getOrNull } from '../get';
+import type { set } from '../set';
+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/dist/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/dist/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 → dist/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 → dist/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 → dist/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 → dist/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/dist/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/dist/dispatch.d.ts

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

package/dist/get.d.ts

@@ -0,0 +1,3 @@
+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/dist/index.d.ts

@@ -1,15 +1,12 @@
-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 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, 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, };
+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, };