@chhsiao1981/use-thunk 9.0.1 → 9.0.3

package/package.json

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

package/src/addChild.ts

@@ -8,6 +8,9 @@ export const addChild = (myID: string, child: NodeMeta): AddRelationAction => ({
   relaton: child,
 })
 
-export const reduceAddChild = <S extends State>(state: ClassState<S>, action: AddRelationAction): ClassState<S> => {
-  return reduceAddRelation(state, action, Relation.CHILDREN)
+export const reduceAddChild = <S extends State>(
+  classState: ClassState<S>,
+  action: AddRelationAction,
+): ClassState<S> => {
+  return reduceAddRelation(classState, action, Relation.CHILDREN)
 }

package/src/addLink.ts

@@ -22,6 +22,6 @@ const addLinkCore = (myID: string, link: NodeMeta): AddRelationAction => ({
   relaton: link,
 })
 
-export const reduceAddLink = <S extends State>(state: ClassState<S>, action: AddRelationAction): ClassState<S> => {
-  return reduceAddRelation(state, action, Relation.LINKS)
+export const reduceAddLink = <S extends State>(classState: ClassState<S>, action: AddRelationAction): ClassState<S> => {
+  return reduceAddRelation(classState, action, Relation.LINKS)
 }

package/src/addRelation.ts

@@ -6,27 +6,27 @@ export interface AddRelationAction extends BaseAction {
 }
 
 export const reduceAddRelation = <S extends State>(
-  state: ClassState<S>,
+  classState: ClassState<S>,
   action: AddRelationAction,
   relationName: Relation,
 ): ClassState<S> => {
   const { myID, relaton: relation } = action
-  const me = state.nodes[myID]
-  if (!me) {
-    return state
+  const myNode = classState.nodes[myID]
+  if (!myNode) {
+    return classState
   }
 
   const { theClass, id: theID, do: theDo } = relation
 
-  const relations = me[relationName] ?? {}
+  const relations = myNode[relationName] ?? {}
   const relationsByClass = relations[theClass] ?? { list: [] }
   const relationIDs = relationsByClass.list ?? []
   const newIDs = theID ? relationIDs.concat([theID]) : relationIDs
 
-  const newRelations = Object.assign({}, me[relationName], { [theClass]: { list: newIDs, do: theDo } })
-  const newMe = Object.assign({}, me, { [relationName]: newRelations })
-  const newNodes = Object.assign({}, state.nodes, { [myID]: newMe })
-  const newState = Object.assign({}, state, { nodes: newNodes })
+  const newRelations = Object.assign({}, myNode[relationName], { [theClass]: { list: newIDs, do: theDo } })
+  const newMyNode = Object.assign({}, myNode, { [relationName]: newRelations })
+  const newNodes = Object.assign({}, classState.nodes, { [myID]: newMyNode })
+  const newClassState = Object.assign({}, classState, { nodes: newNodes })
 
-  return newState
+  return newClassState
 }

package/src/createReducer.ts

@@ -5,20 +5,20 @@ import type { Reducer } from './reducer'
 import type { ClassState, State } from './stateTypes'
 
 export const createReducer = <S extends State>(reduceMap?: ReduceMap<S>): Reducer<S> => {
-  return (state: ClassState<S>, action: BaseAction): ClassState<S> => {
+  return (classState: ClassState<S>, action: BaseAction): ClassState<S> => {
     if (!action) {
-      return state
+      return classState
     }
 
     if (reduceMap?.[action.type]) {
-      return reduceMap[action.type](state, action)
+      return reduceMap[action.type](classState, action)
     }
 
     const defaultReduceMap = DEFAULT_REDUCE_MAP<S>()
     if (defaultReduceMap?.[action.type]) {
-      return defaultReduceMap[action.type](state, action)
+      return defaultReduceMap[action.type](classState, action)
     }
 
-    return state
+    return classState
   }
 }

package/src/getRelation.ts

@@ -1,23 +1,27 @@
 import { type NodeState, Relation, type State } from './stateTypes'
 
-export const getChildIDs = <S extends State>(me: NodeState<S>, childClass: string): string[] => {
-  return getRelationIDs(me, childClass, Relation.CHILDREN)
+export const getChildIDs = <S extends State>(myNode: NodeState<S>, childClass: string): string[] => {
+  return getRelationIDs(myNode, childClass, Relation.CHILDREN)
 }
 
-export const getChildID = <S extends State>(me: NodeState<S>, childClass: string): string => {
-  return getRelationID(me, childClass, Relation.CHILDREN)
+export const getChildID = <S extends State>(myNode: NodeState<S>, childClass: string): string => {
+  return getRelationID(myNode, childClass, Relation.CHILDREN)
 }
 
-export const getLinkIDs = <S extends State>(me: NodeState<S>, linkClass: string): string[] => {
-  return getRelationIDs(me, linkClass, Relation.LINKS)
+export const getLinkIDs = <S extends State>(myNode: NodeState<S>, linkClass: string): string[] => {
+  return getRelationIDs(myNode, linkClass, Relation.LINKS)
 }
 
-export const getLinkID = <S extends State>(me: NodeState<S>, linkClass: string): string => {
-  return getRelationID(me, linkClass, Relation.LINKS)
+export const getLinkID = <S extends State>(myNode: NodeState<S>, linkClass: string): string => {
+  return getRelationID(myNode, linkClass, Relation.LINKS)
 }
 
-const getRelationIDs = <S extends State>(me: NodeState<S>, relationClass: string, relationName: Relation): string[] => {
-  const relations = me[relationName]
+const getRelationIDs = <S extends State>(
+  myNode: NodeState<S>,
+  relationClass: string,
+  relationName: Relation,
+): string[] => {
+  const relations = myNode[relationName]
   if (!relations) {
     return []
   }
@@ -29,7 +33,11 @@ const getRelationIDs = <S extends State>(me: NodeState<S>, relationClass: string
   return relationsByClass.list
 }
 
-const getRelationID = <S extends State>(me: NodeState<S>, relationClass: string, relationName: Relation): string => {
-  const ids = getRelationIDs(me, relationClass, relationName)
+const getRelationID = <S extends State>(
+  myNode: NodeState<S>,
+  relationClass: string,
+  relationName: Relation,
+): string => {
+  const ids = getRelationIDs(myNode, relationClass, relationName)
   return ids.length ? ids[0] : ''
 }

package/src/index.ts

@@ -15,10 +15,11 @@ import { setData } from './setData'
 import { getNode, getRootID, getState } from './states'
 import type { ClassState, NodeMeta, NodeState, NodeStateMap, State } from './stateTypes'
 import type { ThunkModule, ThunkModuleToFunc } from './thunk'
-import useThunk from './useThunk'
+import useThunk, { type UseThunk } from './useThunk'
 
 export {
   useThunk,
+  type UseThunk,
   // StateType, // XXX for global state
   type State,
   type NodeState,

package/src/init.ts

@@ -62,21 +62,21 @@ const initCore = <S extends State>(
   }
 }
 
-export const reduceInit = <S extends State>(state: ClassState<S>, action: InitAction<S>): ClassState<S> => {
+export const reduceInit = <S extends State>(classState: ClassState<S>, action: InitAction<S>): ClassState<S> => {
   const { myID, parentID, doParent, parentClass, state: initState } = action
 
-  const me: NodeState<S> = {
+  const myNode: NodeState<S> = {
     id: myID,
     state: initState,
     [Relation.CHILDREN]: {},
     [Relation.LINKS]: {},
   }
   if (parentID && doParent) {
-    me[PARENT] = { id: parentID, do: doParent, theClass: parentClass ?? '' }
+    myNode[PARENT] = { id: parentID, do: doParent, theClass: parentClass ?? '' }
   }
 
-  const newNodes: NodeStateMap<S> = Object.assign({}, state.nodes, { [myID]: me })
-  const newState: ClassState<S> = Object.assign({}, state, { nodes: newNodes })
+  const newNodes: NodeStateMap<S> = Object.assign({}, classState.nodes, { [myID]: myNode })
+  const newClassState: ClassState<S> = Object.assign({}, classState, { nodes: newNodes })
 
-  return newState
+  return newClassState
 }

package/src/reducer.ts

@@ -1,5 +1,5 @@
 import type { Reducer as rReducer } from 'react'
-import type { ActionFunc, BaseAction } from './action'
+import type { BaseAction } from './action'
 import type { ClassState, State } from './stateTypes'
 
 // Reducer

package/src/remove.ts

@@ -51,23 +51,23 @@ const removeCore = (myID: string): BaseAction => ({
   type: REMOVE,
 })
 
-export const reduceRemove = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+export const reduceRemove = <S extends State>(classState: ClassState<S>, action: BaseAction): ClassState<S> => {
   const { myID } = action
 
-  const me = state.nodes[myID]
-  if (!me) {
-    return state
+  const myNode = classState.nodes[myID]
+  if (!myNode) {
+    return classState
   }
 
-  const newNodes = Object.keys(state.nodes)
+  const newNodes = Object.keys(classState.nodes)
     .filter((each) => each !== myID)
     .reduce((r: NodeStateMap<S>, x) => {
-      r[x] = state.nodes[x]
+      r[x] = classState.nodes[x]
       return r
     }, {})
 
   // root
-  const newState = Object.assign({}, state, { nodes: newNodes })
+  const newState = Object.assign({}, classState, { nodes: newNodes })
   if (newState.root === myID) {
     newState.root = null
   }

package/src/removeChild.ts

@@ -37,10 +37,10 @@ const removeChildCore = (myID: string, childID: string, childClass: string): Rem
 })
 
 export const reduceRemoveChild = <S extends State>(
-  state: ClassState<S>,
+  classState: ClassState<S>,
   action: RemoveRelationAction,
 ): ClassState<S> => {
   const { myID, relationID, relationClass } = action
 
-  return reduceRemoveRelation(state, myID, relationID, relationClass, Relation.CHILDREN)
+  return reduceRemoveRelation(classState, myID, relationID, relationClass, Relation.CHILDREN)
 }

package/src/removeLink.ts

@@ -38,10 +38,10 @@ const removeLinkCore = (myID: string, linkID: string, linkClass: string): Remove
 })
 
 export const reduceRemoveLink = <S extends State>(
-  state: ClassState<S>,
+  classState: ClassState<S>,
   action: RemoveRelationAction,
 ): ClassState<S> => {
   const { myID, relationID, relationClass } = action
 
-  return reduceRemoveRelation(state, myID, relationID, relationClass, Relation.LINKS)
+  return reduceRemoveRelation(classState, myID, relationID, relationClass, Relation.LINKS)
 }

package/src/removeRelation.ts

@@ -22,14 +22,14 @@ export const removeRelation = <S extends State>(
   removeRelationCore: RemoveRelationCore,
   relationName: Relation,
 ) => {
-  const state = getClassState()
+  const classState = getClassState()
 
-  const me = state.nodes[myID]
-  if (!me) {
+  const myNode = classState.nodes[myID]
+  if (!myNode) {
     return
   }
 
-  const relation = me[relationName]
+  const relation = myNode[relationName]
   if (!relation) {
     return
   }
@@ -49,24 +49,24 @@ export const removeRelation = <S extends State>(
 }
 
 export const reduceRemoveRelation = <S extends State>(
-  state: ClassState<S>,
+  classState: ClassState<S>,
   myID: string,
   relationID: string,
   relationClass: string,
   relationName: Relation.LINKS | Relation.CHILDREN,
 ): ClassState<S> => {
-  const me = state.nodes[myID]
-  if (!me) return state
+  const myNode = classState.nodes[myID]
+  if (!myNode) return classState
 
-  const relation = me[relationName]
-  if (!relation) return state
+  const relation = myNode[relationName]
+  if (!relation) return classState
 
   const relationByClass = relation[relationClass]
-  if (!relationByClass) return state
+  if (!relationByClass) return classState
 
   const relationIDs = relationByClass.list || []
   const newIDs = relationIDs.filter((eachID: string) => eachID !== relationID)
-  if (relationIDs.length === newIDs.length) return state
+  if (relationIDs.length === newIDs.length) return classState
 
   const newRelation = Object.assign({}, relation)
   if (newIDs.length === 0) {
@@ -76,9 +76,9 @@ export const reduceRemoveRelation = <S extends State>(
     newRelation[relationClass] = newRelationByClass
   }
 
-  const newMe = Object.assign({}, me, { [relationName]: newRelation })
-  const newNodes = Object.assign({}, state.nodes, { [myID]: newMe })
-  const newState = Object.assign({}, state, { nodes: newNodes })
+  const newMyNode = Object.assign({}, myNode, { [relationName]: newRelation })
+  const newNodes = Object.assign({}, classState.nodes, { [myID]: newMyNode })
+  const newClassState = Object.assign({}, classState, { nodes: newNodes })
 
-  return newState
+  return newClassState
 }

package/src/setData.ts

@@ -8,16 +8,16 @@ export const setData = <S extends State>(myID: string, data: S): BaseAction => (
   data,
 })
 
-export const reduceSetData = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+export const reduceSetData = <S extends State>(classState: ClassState<S>, action: BaseAction): ClassState<S> => {
   const { myID, data } = action
 
-  const me = state.nodes[myID]
-  if (!me) return state
+  const myNode = classState.nodes[myID]
+  if (!myNode) return classState
 
-  const newMyState = Object.assign({}, me.state, data)
-  const newMe = Object.assign({}, me, { state: newMyState })
-  const newNodes = Object.assign({}, state.nodes, { [myID]: newMe })
-  const newState = Object.assign({}, state, { nodes: newNodes })
+  const newMyState = Object.assign({}, myNode.state, data)
+  const newMyNode = Object.assign({}, myNode, { state: newMyState })
+  const newNodes = Object.assign({}, classState.nodes, { [myID]: newMyNode })
+  const newClassState = Object.assign({}, classState, { nodes: newNodes })
 
-  return newState
+  return newClassState
 }

package/src/setRoot.ts

@@ -7,8 +7,8 @@ export const setRoot = (myID: string): BaseAction => ({
   type: SET_ROOT,
 })
 
-export const reduceSetRoot = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+export const reduceSetRoot = <S extends State>(classState: ClassState<S>, action: BaseAction): ClassState<S> => {
   const { myID } = action
 
-  return Object.assign({}, state, { root: myID })
+  return Object.assign({}, classState, { root: myID })
 }

package/src/stateTypes.ts

@@ -8,6 +8,9 @@ export enum Relation {
   LINKS = '_links',
 }
 
+// XXX PARENT is considered as a special relation
+//     and is not part of the enum Relation.
+//     The relation-ops does not apply to PARENT.
 export const PARENT = '_parent'
 
 //State

package/src/states.ts

@@ -1,43 +1,43 @@
 import type { ClassState, NodeState, State } from './stateTypes'
 
-export const getRootNode = <S extends State>(state: ClassState<S>): NodeState<S> | null => {
-  const root = state.root
+const getRootNode = <S extends State>(classState: ClassState<S>): NodeState<S> | null => {
+  const root = classState.root
   if (!root) {
     return null
   }
-  return state.nodes[root] || null
+  return classState.nodes[root] || null
 }
 
-export const getRootID = <S extends State>(state: ClassState<S>): string => {
-  return state.root ?? ''
+export const getRootID = <S extends State>(classState: ClassState<S>): string => {
+  return classState.root ?? ''
 }
 
-export const getRoot = <S extends State>(state: ClassState<S>): S | null => {
-  const root = state.root
+const getRoot = <S extends State>(classState: ClassState<S>): S | null => {
+  const root = classState.root
   if (!root) {
     return null
   }
-  const me = state.nodes[root]
+  const me = classState.nodes[root]
   if (!me) {
     return null
   }
   return me.state
 }
 
-export const getNode = <S extends State>(state: ClassState<S>, myID?: string): NodeState<S> | null => {
+export const getNode = <S extends State>(classState: ClassState<S>, myID?: string): NodeState<S> | null => {
   if (!myID) {
-    return getRootNode(state)
+    return getRootNode(classState)
   }
 
-  return state.nodes[myID] || null
+  return classState.nodes[myID] || null
 }
 
-export const getState = <S extends State>(state: ClassState<S>, myID?: string): S | null => {
+export const getState = <S extends State>(classState: ClassState<S>, myID?: string): S | null => {
   if (!myID) {
-    return getRoot(state)
+    return getRoot(classState)
   }
 
-  const me = state.nodes[myID]
+  const me = classState.nodes[myID]
   if (!me) {
     return null
   }

package/src/useThunk.ts

@@ -2,7 +2,7 @@ import { useRef, useState } from 'react'
 import type { ActionFunc } from './action'
 import { createReducer } from './createReducer'
 import type { DispatchFuncMap, DispatchFuncMapByClassMap, RefDispatchFuncMapByClassMap } from './dispatchFuncMap'
-import type { ClassState, NodeStateMap, State, StateType } from './stateTypes'
+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'

package/types/addChild.d.ts

@@ -2,4 +2,4 @@ import { type AddRelationAction } from './addRelation';
 import { type ClassState, type NodeMeta, type State } from './stateTypes';
 export declare const ADD_CHILD = "@chhsiao1981/use-thunk/ADD_CHILD";
 export declare const addChild: (myID: string, child: NodeMeta) => AddRelationAction;
-export declare const reduceAddChild: <S extends State>(state: ClassState<S>, action: AddRelationAction) => ClassState<S>;
+export declare const reduceAddChild: <S extends State>(classState: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addLink.d.ts

@@ -3,4 +3,4 @@ import { type AddRelationAction } from './addRelation';
 import { type ClassState, type NodeMeta, type State } from './stateTypes';
 export declare const addLink: <S extends State>(myID: string, link: NodeMeta, isFromLink?: boolean) => Thunk<S>;
 export declare const ADD_LINK = "@chhsiao1981/use-thunk/ADD_LINK";
-export declare const reduceAddLink: <S extends State>(state: ClassState<S>, action: AddRelationAction) => ClassState<S>;
+export declare const reduceAddLink: <S extends State>(classState: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addRelation.d.ts

@@ -3,4 +3,4 @@ import type { ClassState, NodeMeta, Relation, State } from './stateTypes';
 export interface AddRelationAction extends BaseAction {
     relaton: NodeMeta;
 }
-export declare const reduceAddRelation: <S extends State>(state: ClassState<S>, action: AddRelationAction, relationName: Relation) => ClassState<S>;
+export declare const reduceAddRelation: <S extends State>(classState: ClassState<S>, action: AddRelationAction, relationName: Relation) => ClassState<S>;

package/types/getRelation.d.ts

@@ -1,5 +1,5 @@
 import { type NodeState, type State } from './stateTypes';
-export declare const getChildIDs: <S extends State>(me: NodeState<S>, childClass: string) => string[];
-export declare const getChildID: <S extends State>(me: NodeState<S>, childClass: string) => string;
-export declare const getLinkIDs: <S extends State>(me: NodeState<S>, linkClass: string) => string[];
-export declare const getLinkID: <S extends State>(me: NodeState<S>, linkClass: string) => string;
+export declare const getChildIDs: <S extends State>(myNode: NodeState<S>, childClass: string) => string[];
+export declare const getChildID: <S extends State>(myNode: NodeState<S>, childClass: string) => string;
+export declare const getLinkIDs: <S extends State>(myNode: NodeState<S>, linkClass: string) => string[];
+export declare const getLinkID: <S extends State>(myNode: NodeState<S>, linkClass: string) => string;

package/types/index.d.ts

@@ -15,5 +15,5 @@ import { setData } from './setData';
 import { getNode, getRootID, getState } from './states';
 import type { ClassState, NodeMeta, NodeState, NodeStateMap, State } from './stateTypes';
 import type { ThunkModule, ThunkModuleToFunc } from './thunk';
-import useThunk from './useThunk';
-export { useThunk, type State, type NodeState, type NodeMeta, type NodeStateMap, type ClassState, type GetClassState, type Thunk, type ThunkModule, type ThunkModuleToFunc, type Dispatch, type DispatchFuncMap, getRootID, getNode, getState, getChildIDs, getChildID, getLinkIDs, getLinkID, init, type InitParams, setData, remove, addChild, removeChild, addLink, removeLink, type AddRelationAction, type RemoveRelationAction, genUUID, };
+import useThunk, { type UseThunk } from './useThunk';
+export { useThunk, type UseThunk, type State, type NodeState, type NodeMeta, type NodeStateMap, type ClassState, type GetClassState, type Thunk, type ThunkModule, type ThunkModuleToFunc, type Dispatch, type DispatchFuncMap, getRootID, getNode, getState, getChildIDs, getChildID, getLinkIDs, getLinkID, init, type InitParams, setData, remove, addChild, removeChild, addLink, removeLink, type AddRelationAction, type RemoveRelationAction, genUUID, };

package/types/init.d.ts

@@ -15,5 +15,5 @@ interface InitAction<S extends State> extends BaseAction {
     state: S;
 }
 export declare const INIT = "@chhsiao1981/use-thunk/INIT";
-export declare const reduceInit: <S extends State>(state: ClassState<S>, action: InitAction<S>) => ClassState<S>;
+export declare const reduceInit: <S extends State>(classState: ClassState<S>, action: InitAction<S>) => ClassState<S>;
 export {};

package/types/remove.d.ts

@@ -2,4 +2,4 @@ import type { BaseAction, Thunk } from './action';
 import { type ClassState, type State } from './stateTypes';
 export declare const remove: <S extends State>(myID: string, isFromParent?: boolean) => Thunk<S>;
 export declare const REMOVE = "@chhsiao1981/use-thunk/REMOVE";
-export declare const reduceRemove: <S extends State>(state: ClassState<S>, action: BaseAction) => ClassState<S>;
+export declare const reduceRemove: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/removeChild.d.ts

@@ -6,4 +6,4 @@ import { type ClassState, type State } from './stateTypes';
  */
 export declare const removeChild: <S extends State>(myID: string, childID: string, childClass: string, isFromChild?: boolean) => Thunk<S>;
 export declare const REMOVE_CHILD = "@chhsiao1981/use-thunk/REMOVE_CHILD";
-export declare const reduceRemoveChild: <S extends State>(state: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;
+export declare const reduceRemoveChild: <S extends State>(classState: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeLink.d.ts

@@ -6,4 +6,4 @@ import { type ClassState, type State } from './stateTypes';
  */
 export declare const removeLink: <S extends State>(myID: string, linkID: string, linkClass: string, isFromLink?: boolean) => Thunk<S>;
 export declare const REMOVE_LINK = "@chhsiao1981/use-thunk/REMOVE_LINK";
-export declare const reduceRemoveLink: <S extends State>(state: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;
+export declare const reduceRemoveLink: <S extends State>(classState: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeRelation.d.ts

@@ -8,5 +8,5 @@ export interface RemoveRelationAction extends BaseAction {
 type RelationRemove = (theDo: DispatchFuncMap) => void;
 type RemoveRelationCore = (myID: string, relationID: string, relationClass: string) => BaseAction;
 export declare const removeRelation: <S extends State>(dispatch: Dispatch<S>, getClassState: GetClassState<S>, myID: string, relationID: string, relationClass: string, isFromRelation: boolean, relationRemove: RelationRemove, removeRelationCore: RemoveRelationCore, relationName: Relation) => void;
-export declare const reduceRemoveRelation: <S extends State>(state: ClassState<S>, myID: string, relationID: string, relationClass: string, relationName: Relation.LINKS | Relation.CHILDREN) => ClassState<S>;
+export declare const reduceRemoveRelation: <S extends State>(classState: ClassState<S>, myID: string, relationID: string, relationClass: string, relationName: Relation.LINKS | Relation.CHILDREN) => ClassState<S>;
 export {};

package/types/setData.d.ts

@@ -2,4 +2,4 @@ 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 reduceSetData: <S extends State>(state: ClassState<S>, action: BaseAction) => ClassState<S>;
+export declare const reduceSetData: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/setRoot.d.ts

@@ -2,4 +2,4 @@ import type { BaseAction } from './action';
 import type { ClassState, State } from './stateTypes';
 export declare const SET_ROOT = "@chhsiao1981/use-thunk/SET_ROOT";
 export declare const setRoot: (myID: string) => BaseAction;
-export declare const reduceSetRoot: <S extends State>(state: ClassState<S>, action: BaseAction) => ClassState<S>;
+export declare const reduceSetRoot: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/states.d.ts

@@ -1,6 +1,4 @@
 import type { ClassState, NodeState, State } from './stateTypes';
-export declare const getRootNode: <S extends State>(state: ClassState<S>) => NodeState<S> | null;
-export declare const getRootID: <S extends State>(state: ClassState<S>) => string;
-export declare const getRoot: <S extends State>(state: ClassState<S>) => S | null;
-export declare const getNode: <S extends State>(state: ClassState<S>, myID?: string) => NodeState<S> | null;
-export declare const getState: <S extends State>(state: ClassState<S>, myID?: string) => S | null;
+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;