@chhsiao1981/use-thunk 9.0.3 → 9.0.5

package/package.json

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

package/src/action.ts

@@ -1,5 +1,5 @@
 import type { ClassState, State } from './stateTypes'
-import type { ActionOrThunk as rActionOrThunk, Thunk as rThunk } from './thunkReducer'
+import type { ActionOrThunk as rActionOrThunk, Thunk as rThunk } from './useThunkReducer'
 
 // BaseAction contains only object-based actions, no thunk-based actions.
 export interface BaseAction {
@@ -8,9 +8,9 @@ export interface BaseAction {
   [key: string]: unknown
 }
 // Thunk
-export type Thunk<S extends State> = rThunk<ClassState<S>, BaseAction>
+export type Thunk<S extends State> = rThunk<S, BaseAction>
 
-export type ActionOrThunk<S extends State> = rActionOrThunk<ClassState<S>, BaseAction>
+export type ActionOrThunk<S extends State> = rActionOrThunk<S, BaseAction>
 
 // ActionFunc
 // biome-ignore lint/suspicious/noExplicitAny: unknown requires same type in list. use any for possible different types.

package/src/setData.ts

@@ -2,7 +2,7 @@ import type { BaseAction } from './action'
 import type { ClassState, State } from './stateTypes'
 
 export const SET_DATA = '@chhsiao1981/use-thunk/SET_DATA'
-export const setData = <S extends State>(myID: string, data: S): BaseAction => ({
+export const setData = <S extends State>(myID: string, data: Partial<S>): BaseAction => ({
   myID,
   type: SET_DATA,
   data,

package/src/useThunk.ts

@@ -5,7 +5,7 @@ import type { DispatchFuncMap, DispatchFuncMapByClassMap, RefDispatchFuncMapByCl
 import type { ClassState, NodeStateMap, State } from './stateTypes'
 import type { ThunkModule, ThunkModuleFunc } from './thunk'
 import { DEFAULT_THUNK_MODULE_FUNC_MAP } from './thunkModuleFuncMap'
-import useThunkReducer from './thunkReducer'
+import useThunkReducer from './useThunkReducer'
 
 export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [ClassState<S>, DispatchFuncMap<S, R>]
 
@@ -47,7 +47,7 @@ export default <S extends State, R extends ThunkModuleFunc<S>>(
   const [theReducer, _] = useState(() => theDo.default ?? createReducer<S>())
 
   // 5. useThunkReducer
-  const [state, dispatch] = useThunkReducer(
+  const [classState, dispatch] = useThunkReducer(
     theReducer,
     {
       myClass,
@@ -61,7 +61,7 @@ export default <S extends State, R extends ThunkModuleFunc<S>>(
   // 7. the dispatchMap is always the same.
   //    we can do early return if not first time.
   if (!isFirstTime) {
-    return [state, dispatchMap]
+    return [classState, dispatchMap]
   }
 
   // 8. setup dispatchMap
@@ -91,5 +91,5 @@ export default <S extends State, R extends ThunkModuleFunc<S>>(
     return val
   }, dispatchMap)
 
-  return [state, dispatchMap]
+  return [classState, dispatchMap]
 }

package/src/{thunkReducer.ts → useThunkReducer.ts}

@@ -3,11 +3,11 @@
 
 import { type Dispatch, type Reducer, useCallback, useRef, useState } from 'react'
 import type { BaseAction } from './action'
-import type { State } from './stateTypes'
+import type { ClassState, State } from './stateTypes'
 
 export type Thunk<S extends State, A extends BaseAction> = (
   dispatch: Dispatch<ActionOrThunk<S, A>>,
-  getState: () => S,
+  getClassState: () => ClassState<S>,
 ) => void
 
 export type ActionOrThunk<S extends State, A extends BaseAction> = A | Thunk<S, A>
@@ -23,51 +23,50 @@ export type ActionOrThunk<S extends State, A extends BaseAction> = A | Thunk<S,
  * @returns {[State, Dispatch]}
  */
 export default <S extends State, A extends BaseAction>(
-  reducer: Reducer<S, A>,
-  initArg: S,
-  // biome-ignore lint/suspicious/noExplicitAny: params can by any types.
-  init?: (...params: any[]) => S,
-): [S, Dispatch<A | Thunk<S, A>>] => {
+  reducer: Reducer<ClassState<S>, A>,
+  initArg: ClassState<S>,
+  init?: (initArg: ClassState<S>) => ClassState<S>,
+): [ClassState<S>, Dispatch<A | Thunk<S, A>>] => {
   // 1. initState
-  const initState = init ? () => init(initArg) : initArg
+  const initClassState = init ? () => init(initArg) : initArg
 
   // 2. renderState
-  const [renderState, setRenderState] = useState(initState)
+  const [renderClassState, setRenderClassState] = useState(initClassState)
 
   // 3. hookState
-  const hookState = renderState
+  const hookClassState = renderClassState
 
   // 4. state management.
-  const state = useRef(hookState)
-  const getState = useCallback(() => state.current, [state])
-  const setState = useCallback(
-    (newState: S) => {
-      state.current = newState
-      setRenderState(newState)
+  const classState = useRef(hookClassState)
+  const getClassState = useCallback(() => classState.current, [classState])
+  const setClassState = useCallback(
+    (newClassState: ClassState<S>) => {
+      classState.current = newClassState
+      setRenderClassState(newClassState)
     },
-    [state, setRenderState],
+    [classState, setRenderClassState],
   )
 
   // 5. reducer.
   const reduce = useCallback(
-    (action: A): S => {
-      return reducer(getState(), action)
+    (action: A): ClassState<S> => {
+      return reducer(getClassState(), action)
     },
-    [reducer, getState],
+    [reducer, getClassState],
   )
 
   // augmented dispatcher.
   const dispatch = useCallback(
     (action: A | Thunk<S, A>) => {
       if (typeof action === 'function') {
-        action(dispatch, getState)
+        action(dispatch, getClassState)
         return
       }
 
-      setState(reduce(action))
+      setClassState(reduce(action))
     },
-    [getState, setState, reduce],
+    [getClassState, setClassState, reduce],
   )
 
-  return [hookState, dispatch]
+  return [hookClassState, dispatch]
 }

package/types/action.d.ts

@@ -1,11 +1,11 @@
 import type { ClassState, State } from './stateTypes';
-import type { ActionOrThunk as rActionOrThunk, Thunk as rThunk } from './thunkReducer';
+import type { ActionOrThunk as rActionOrThunk, Thunk as rThunk } from './useThunkReducer';
 export interface BaseAction {
     myID: string;
     type: string;
     [key: string]: unknown;
 }
-export type Thunk<S extends State> = rThunk<ClassState<S>, BaseAction>;
-export type ActionOrThunk<S extends State> = rActionOrThunk<ClassState<S>, BaseAction>;
+export type Thunk<S extends State> = rThunk<S, BaseAction>;
+export type ActionOrThunk<S extends State> = rActionOrThunk<S, BaseAction>;
 export type ActionFunc<S extends State> = (...params: any[]) => ActionOrThunk<S>;
 export type GetClassState<S extends State> = () => ClassState<S>;

package/types/setData.d.ts

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

package/types/thunkModuleFuncMap.d.ts

@@ -1,6 +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>;
-    setData: <S extends import("./stateTypes").State>(myID: string, data: 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, isFromParent?: boolean) => import("./action").Thunk<S>;
     addChild: (myID: string, child: import("./stateTypes").NodeMeta) => import("./addRelation").AddRelationAction;
     removeChild: <S extends import("./stateTypes").State>(myID: string, childID: string, childClass: string, isFromChild?: boolean) => import("./action").Thunk<S>;

package/types/useThunkReducer.d.ts

@@ -0,0 +1,18 @@
+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 {State} initArg
+ * @param {Function} [init]
+ * @returns {[State, Dispatch]}
+ */
+declare const _default: <S extends State, A extends BaseAction>(reducer: Reducer<ClassState<S>, A>, initArg: ClassState<S>, init?: (initArg: ClassState<S>) => ClassState<S>) => [ClassState<S>, Dispatch<A | Thunk<S, A>>];
+export default _default;