@chhsiao1981/use-thunk 10.3.0 → 11.0.0

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.3.0",
+  "version": "11.0.0",
   "type": "module",
   "description": "A framework easily using useThunk to manage the data-state.",
   "homepage": "https://github.com/chhsiao1981/use-thunk",
@@ -56,7 +56,7 @@
     "vite": "^6.4.1",
     "vitest": "^4.1.0"
   },
-  "dependencies": {
+  "peerDependencies": {
     "react": ">=18.3.1",
     "uuid": "^14.0.0"
   }

package/src/ThunkContext.tsx

@@ -1,40 +1,45 @@
-import { type JSX, useMemo, useState } from 'react'
+import { type ReactNode, useMemo, useState } from 'react'
 import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 
 type Props = {
-  classes?: string[]
-  children?: JSX.Element | JSX.Element[]
+  modules?: string[]
+  children?: ReactNode
 }
-const ThunkContext = (props: Props): JSX.Element => {
-  let { classes, children } = props
-  if (!classes) {
-    classes = THUNK_CONTEXT_MAP.theList
-  }
-  if (classes.length === 0) {
-    // @ts-expect-error with children
+
+const ThunkContext = (props: Props): ReactNode => {
+  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
   }
 
-  const theClass = classes[0]
+  // render the 0th module.
+  const theModule = modules[0]
 
-  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 moduleState.
   // biome-ignore lint/correctness/useHookAtTopLevel: the order is fixed.
-  const [classState, setClassState] = useState(refClassState.current)
+  const [moduleState, setModuleState] = useState(refModuleState.current)
+  refModuleState.current = moduleState
 
-  refClassState.current = classState
+  // 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,5 @@
+import type { set } from '../set'
+import type { ModuleState, State } from '../stateTypes'
+
+// Thunk
+export type Thunk<S extends State> = (set: set<S>, 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
   }
 }

package/src/createThunk.ts

@@ -0,0 +1,31 @@
+import { createContext, type Dispatch, type SetStateAction } from 'react'
+import { createThunk } from '.'
+import type { ModuleState, State } from './stateTypes'
+import { THUNK_CONTEXT_MAP } from './thunkContextMap'
+import type { ThunkModule } from './thunkModule'
+
+export default <S extends State>(theDo: ThunkModule<S>) => {
+  const { name: propsName, myClass, defaultState } = theDo
+  const name = (propsName ? propsName : myClass) || ''
+
+  if (THUNK_CONTEXT_MAP.theMap[name]) {
+    console.warn('createThunk: already init:', name)
+    return
+  }
+
+  const moduleState: ModuleState<S> = { myClass, 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)
+}
+
+export const registerThunk = <S extends State>(theDo: ThunkModule<S>) => {
+  console.warn('registerThunk will be deprecated in the next version.')
+  return createThunk(theDo)
+}

package/src/index.ts

@@ -1,52 +1,46 @@
-import type { GetClassState, Thunk } from './action'
-import type { Dispatch } from './dispatch'
-import type { DispatchFuncMap } from './dispatchFuncMap'
+import type { GetModuleState, Thunk } from './action'
+import createThunk, { registerThunk } from './createThunk'
 import { genUUID } from './genUUID'
 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 type { setMap } from './setMap'
 import { getDefaultID, getNode, getState, mustGetState, mustGetStateByThunk } from './states'
-import type { ClassState, NodeState, NodeStateMap, State } from './stateTypes'
+import type { ModuleState, State } from './stateTypes'
 import ThunkContext from './ThunkContext'
-import type { ThunkModule, ThunkModuleToFunc } from './thunk'
+import type { ThunkModule, ThunkModuleToFunc } from './thunkModule'
+import { setData, update } from './update'
 import useThunk, { type UseThunk } from './useThunk'
 
 export {
-  registerThunk,
+  createThunk,
+  registerThunk, // to deprecate
   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 ModuleState as ClassState, // to deprecate
+  type GetModuleState,
+  type GetModuleState as GetClassState, // to deprecate
   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 as Dispatch, // to deprecate
+  type set,
+  type setMap as DispatchFuncMap, // to deprecate
+  type setMap,
   getNode,
+  getDefaultID,
   getState,
   mustGetState,
   mustGetStateByThunk,
   init,
   type InitParams,
-  setData,
+  setData, // to deprecate
+  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>