@chhsiao1981/use-thunk 10.4.0 → 11.0.0

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;