@chhsiao1981/use-thunk 10.3.0 → 11.0.0

package/types/index.d.ts

@@ -1,15 +1,21 @@
-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, 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, remove, setDefaultID, genUUID, };
+export { createThunk, registerThunk, // to deprecate
+useThunk, type UseThunk, ThunkContext, type State, type ModuleState, type ModuleState as ClassState, // to deprecate
+type GetModuleState, type GetModuleState as GetClassState, // to deprecate
+type Thunk, type ThunkModule, type ThunkModuleToFunc, 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, // to deprecate
+update, remove, setDefaultID, genUUID, };

package/types/init/index.d.ts

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

package/types/init/initCore.d.ts

@@ -0,0 +1,9 @@
+import type BaseAction from '../action/baseAction';
+import type { ModuleState, State } from '../stateTypes';
+export interface InitAction<S extends State> extends BaseAction {
+    state: S;
+}
+export declare const INIT = "@chhsiao1981/use-thunk/INIT";
+declare const _default: <S extends State>(myID: string, state: S) => InitAction<S>;
+export default _default;
+export declare const reduceInit: <S extends State>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/reducer.d.ts

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

package/types/remove.d.ts

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

package/types/set.d.ts

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

package/types/setDefaultID.d.ts

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

package/types/setMap.d.ts

@@ -0,0 +1,17 @@
+import type { set } from './set';
+import type { State } from './stateTypes';
+import type { ThunkModule, ThunkModuleFunc } from './thunkModule';
+import { type DefaultThunkModuleFuncMap } from './thunkModule/defaultThunkModuleFuncMap';
+type VoidReturnType<T extends (...params: any[]) => unknown> = (...params: Parameters<T>) => void;
+export type setMap<S extends State, T extends ThunkModuleFunc<S>> = {
+    [action in keyof T]: VoidReturnType<T[action]>;
+} & Omit<DefaultSetMap, keyof T>;
+export type DefaultSetMap = {
+    [action in keyof DefaultThunkModuleFuncMap]: VoidReturnType<DefaultThunkModuleFuncMap[action]>;
+};
+export interface setMapByModuleMap<S extends State, T extends ThunkModuleFunc<S>> {
+    [name: string]: setMap<S, T>;
+}
+export declare const SET_MAP_BY_MODULE_MAP: setMapByModuleMap<any, any>;
+export declare const constructSetMap: <S extends State, T extends ThunkModuleFunc<S>>(theDo: ThunkModule<S>, set: set<S>, setMap: setMap<S, T>) => setMap<S, T>;
+export {};

package/types/stateTypes.d.ts

@@ -8,8 +8,9 @@ export type NodeState<S extends State> = {
 export type NodeStateMap<S extends State> = {
     [key: string]: NodeState<S>;
 };
-export type ClassState<S extends State> = {
-    myClass: string;
+export type ModuleState<S extends State> = {
+    name?: string;
+    myClass?: string;
     defaultID?: string | null;
     nodes: NodeStateMap<S>;
     defaultState: S;

package/types/states.d.ts

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

package/types/thunkContextMap.d.ts

@@ -1,12 +1,12 @@
 import type { Context as rContext } from 'react';
-import type { ClassState } from './stateTypes';
+import type { ModuleState } from './stateTypes';
 import type { Context } from './thunkContextTypes';
 export type ThunkContextMap = {
     theMap: {
-        [classname: string]: {
+        [moduleName: string]: {
             context: rContext<Context<any>>;
-            refClassState: {
-                current: ClassState<any>;
+            refModuleState: {
+                current: ModuleState<any>;
             };
         };
     };

package/types/thunkContextTypes.d.ts

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

package/types/thunkModule/defaultThunkModuleFuncMap.d.ts

@@ -0,0 +1,5 @@
+import type { ActionFunc } from '../action';
+export declare const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap;
+export type DefaultThunkModuleFuncMap = {
+    [action: string]: ActionFunc<any>;
+};

package/types/thunkModule/index.d.ts

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

package/types/update.d.ts

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

package/types/useThunk.d.ts

@@ -1,12 +1,9 @@
-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>
-];
+import { type setMap } from './setMap';
+import type { ModuleState, State } from './stateTypes';
+import type { ThunkModule, ThunkModuleFunc } from './thunkModule';
+export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [ModuleState<S>, setMap<S, R>];
 /**********
  * useThunk
  **********/
-declare const _default: <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModule<S, R>) => UseThunk<S, R>;
+declare const _default: <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModule<S>) => UseThunk<S, R>;
 export default _default;

package/types/useThunkReducer.d.ts

@@ -1,17 +1,11 @@
-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>;
+import type { Reducer } from './reducer';
+import type { set } from './set';
+import type { ModuleState, State } from './stateTypes';
 /**
  * useThunkReducer
  *
  * Augments React's useReducer() hook so that the action
- * dispatcher supports thunks.
- *
- * @param {Function} reducer
- * @param {string} className
- * @returns {[ClassState<S>, Dispatch]}
+ * setter (dispatcher) supports thunks.
  */
-declare const _default: <S extends State, A extends BaseAction>(reducer: Reducer<ClassState<S>, A>, className: string) => [ClassState<S>, Dispatch<A | Thunk<S, A>>];
+declare const _default: <S extends State>(reducer: Reducer<S>, moduleName: string) => [ModuleState<S>, set<S>];
 export default _default;