@chhsiao1981/use-thunk 10.1.2 → 10.3.0

package/README.md

@@ -184,7 +184,6 @@ For example, the example [in the redux link](https://redux.js.org/recipes/struct
 ```ts
 classStatePost = {
   myClass: 'post',
-  doMe: (DispatchedAction<Post>),
   nodes: {
     [uuid-post1] : {
       id: uuid-post1,
@@ -202,7 +201,9 @@ classStatePost = {
         comments: [uuid-comment3, uuid-comment4, uuid-comment5]
       }
     }
-  }
+  },
+  defaultID,
+  defaultState,
 }
 ```
 
@@ -211,7 +212,6 @@ and:
 ```ts
 classStateComment = {
   myClass: 'comment',
-  doMe: (DispatchedAction<Comment>),
   nodes: {
     [uuid-comment1] : {
       id: uuid-comment1,
@@ -249,6 +249,8 @@ classStateComment = {
       }
     }
   }
+  defaultID,
+  defaultState,
 }
 ```
 
@@ -256,7 +258,6 @@ and:
 ```ts
 classStateUser = {
   myClass: 'user',
-  doMe: (DispatchedAction<User>),
   nodes: {
     [uuid-user1] : {
       id: uuid-user1,
@@ -280,6 +281,8 @@ classStateUser = {
       }
     }
   }
+  defaultID,
+  defaultState,
 }
 ```
 
@@ -287,11 +290,11 @@ classStateUser = {
 
 ### Basic
 
-##### `useThunk(theDo: ThunkModuleFunc): [ClassState, DispatchedAction]`
+##### `useThunk(theDo: ThunkModuleFunc): [ClassState, DispatchedFuncMap]`
 
 Similar to `React.useReducer`, but we use `useThunk`, and we also bind the actions with dispatch (similar concept as `mapDispatchToProps`).s
 
-return: `[ClassState<S>, DispatchedAction<S>]`
+return: `[ClassState<S>, DispatchedFuncMap<S, R>]`
 
 ##### `init({myID, parentID, doParent, state}, myuuidv4?)`
 
@@ -311,18 +314,23 @@ generate uuid for react-object.
 
 ### State
 
-##### `getState(state: ClassState, myID?: string): State`
+##### `getState(state: ClassState, myID?: string): State | null`
 
-Get the state of `myID`. Get the state of `defaultID` if `myID` is not present.
+Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `null` if not available.
 
-##### `getDefaultID(state: ClassState): string`
+##### `mustGetState(state: ClassState, myID?: string): State`
 
-get the default id.
+Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
+
+##### `mustGetStateByThunk(theUseThunk: UseThunk, myID?: string): [State, DispatchedActionMap, theID]`
 
-##### `getRootID(state: ClassState): string`
+Get the state of `myID` by `UseThunk`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
 
-(to be deprecated in 10.2.0.)
-alias of `getDefaultID` for compatibility.
+return: `[S, DispatchedFuncMap<S, R>, theID]`
+
+##### `getDefaultID(state: ClassState): string`
+
+get the default id.
 
 ### NodeState
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chhsiao1981/use-thunk",
-  "version": "10.1.2",
+  "version": "10.3.0",
   "type": "module",
   "description": "A framework easily using useThunk to manage the data-state.",
   "homepage": "https://github.com/chhsiao1981/use-thunk",
@@ -58,6 +58,6 @@
   },
   "dependencies": {
     "react": ">=18.3.1",
-    "uuid": "^13.0.0"
+    "uuid": "^14.0.0"
   }
 }

package/src/ThunkContext.tsx

@@ -1,5 +1,4 @@
 import { type JSX, useMemo, useState } from 'react'
-import type { ClassState } from './stateTypes'
 import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 
 type Props = {
@@ -21,8 +20,7 @@ const ThunkContext = (props: Props): JSX.Element => {
   const { context: Context_m, refClassState } = THUNK_CONTEXT_MAP.theMap[theClass]
 
   // biome-ignore lint/correctness/useHookAtTopLevel: the order is fixed.
-  // biome-ignore lint/suspicious/noExplicitAny: This generalized state can be any type.
-  const [classState, setClassState] = useState<ClassState<any>>({ myClass: theClass, nodes: {} })
+  const [classState, setClassState] = useState(refClassState.current)
 
   refClassState.current = classState
   // biome-ignore lint/correctness/useHookAtTopLevel: the order is fixed.

package/src/index.ts

@@ -7,8 +7,8 @@ import registerThunk from './registerThunk'
 import { remove } from './remove'
 import { setData } from './setData'
 import { setDefaultID } from './setDefaultID'
-import { getDefaultID, getNode, getRootID, getState } from './states'
-import type { ClassState, NodeMeta, NodeState, NodeStateMap, State } from './stateTypes'
+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 useThunk, { type UseThunk } from './useThunk'
@@ -20,7 +20,6 @@ export {
   type UseThunk,
   type State,
   type NodeState,
-  type NodeMeta,
   type NodeStateMap,
   // type NodeStateMapByClass, // XXX for global state
   type ClassState,
@@ -37,9 +36,10 @@ export {
   type DispatchFuncMap,
   // type DefaultDispatchFuncMap, // XXX deemphasize default
   getDefaultID,
-  getRootID,
   getNode,
   getState,
+  mustGetState,
+  mustGetStateByThunk,
   init,
   type InitParams,
   setData,

package/src/registerThunk.ts

@@ -4,7 +4,7 @@ import type { ThunkModule, ThunkModuleFunc } from './thunk'
 import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 
 export default <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModule<S, R>) => {
-  const { myClass } = theDo
+  const { myClass, defaultState } = theDo
 
   if (THUNK_CONTEXT_MAP.theMap[myClass]) {
     // already init
@@ -15,6 +15,7 @@ export default <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModul
   const classState: ClassState<S> = {
     myClass,
     nodes: {},
+    defaultState,
   }
   const setClassState: Dispatch<SetStateAction<ClassState<S>>> = () => {}
   const refClassState = { current: classState }

package/src/stateTypes.ts

@@ -13,24 +13,10 @@ export type NodeStateMap<S extends State> = {
   [key: string]: NodeState<S>
 }
 
-export type NodeStateMapByClass<S extends State> = {
-  [className: string]: NodeStateMap<S>
-}
-
 // ClassState
 export type ClassState<S extends State> = {
   myClass: string
   defaultID?: string | null
-  // XXX doMe is a hidden variable for ClassState
-  //     used only for parents / children / links.
-  // doMe: DispatchFuncMap
   nodes: NodeStateMap<S>
-}
-
-// Node
-export type NodeMeta = {
-  id: string
-  theClass: string
-  // @ts-expect-error do can be any type.
-  do: DispatchFuncMap
+  defaultState: S
 }

package/src/states.ts

@@ -1,14 +1,12 @@
+import type { DispatchFuncMap } from './dispatchFuncMap'
 import type { ClassState, NodeState, State } from './stateTypes'
+import type { ThunkModuleFunc } from './thunk'
+import type { UseThunk } from './useThunk'
 
 export const getDefaultID = <S extends State>(classState: ClassState<S>): string => {
   return classState.defaultID ?? ''
 }
 
-export const getRootID = <S extends State>(classState: ClassState<S>): string => {
-  console.warn('[DEPRECATE] getRootID will be deprecated in 10.2.0.')
-  return getDefaultID(classState)
-}
-
 export const getNode = <S extends State>(
   classState: ClassState<S>,
   myID?: string,
@@ -33,3 +31,17 @@ export const getState = <S extends State>(classState: ClassState<S>, myID?: stri
   }
   return me.state
 }
+
+export const mustGetState = <S extends State>(classState: ClassState<S>, myID?: string): S => {
+  return getState(classState, myID) || classState.defaultState
+}
+
+export const mustGetStateByThunk = <S extends State, R extends ThunkModuleFunc<S>>(
+  theUseThunk: UseThunk<S, R>,
+  myID?: string,
+): [S, DispatchFuncMap<S, R>, string] => {
+  const [classState, theDo] = theUseThunk
+  const theID = myID ? myID : getDefaultID(classState)
+  const state = mustGetState(classState, theID)
+  return [state, theDo, theID]
+}

package/types/index.d.ts

@@ -7,9 +7,9 @@ import registerThunk from './registerThunk';
 import { remove } from './remove';
 import { setData } from './setData';
 import { setDefaultID } from './setDefaultID';
-import { getDefaultID, getNode, getRootID, getState } from './states';
-import type { ClassState, NodeMeta, NodeState, NodeStateMap, State } from './stateTypes';
+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 useThunk, { type UseThunk } from './useThunk';
-export { registerThunk, useThunk, ThunkContext, type UseThunk, type State, type NodeState, type NodeMeta, type NodeStateMap, type ClassState, type GetClassState, type Thunk, type ThunkModule, type ThunkModuleToFunc, type Dispatch, type DispatchFuncMap, getDefaultID, getRootID, getNode, getState, init, type InitParams, setData, remove, setDefaultID, genUUID, };
+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, };

package/types/stateTypes.d.ts

@@ -8,16 +8,9 @@ export type NodeState<S extends State> = {
 export type NodeStateMap<S extends State> = {
     [key: string]: NodeState<S>;
 };
-export type NodeStateMapByClass<S extends State> = {
-    [className: string]: NodeStateMap<S>;
-};
 export type ClassState<S extends State> = {
     myClass: string;
     defaultID?: string | null;
     nodes: NodeStateMap<S>;
-};
-export type NodeMeta = {
-    id: string;
-    theClass: string;
-    do: DispatchFuncMap;
+    defaultState: S;
 };

package/types/states.d.ts

@@ -1,5 +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 getRootID: <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];