@chhsiao1981/use-thunk 11.0.0 → 12.0.0

package/README.md

@@ -19,9 +19,15 @@ Please check [demo-use-thunk](https://github.com/chhsiao1981/demo-use-thunk) for
 
 ### Breaking Changes
 
-* Starting from `10.0.0`: The ClassState is shared globally, with `registerThunk` and `ThunkContext`.
-* Starting from `9.0.0`: npm package is renamed as [@chhsiao1981/use-thunk](https://www.npmjs.com/package/%40chhsiao1981/use-thunk)
-* Starting from `8.0.0`: [Totally renamed as `useThunk`](https://github.com/chhsiao1981/use-thunk/issues/105).
+* Starting from [`12.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/12.0.0): redefining the `getState` functions.
+    1. `getState` => `getStateOrNullByModule`, `mustGetState` => `getStateByModule`.
+    2. `mustGetStateByThunk` => `getState`.
+* Starting from [`11.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/11.0.0):
+    1. `setData` => `update`, `registerThunk` => `createThunk`, `dispatch` => `set`, `ClassState` => `ModuleState`, and `ModuleState.myClass` => `ModuleState.name`.
+    2. `Thunk` is `(set, get, getModuleState) => {}`, where `get(id)` directly returns object-level state.
+* Starting from [`10.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/10.0.0): The ClassState is shared globally, with `registerThunk` and `ThunkContext`.
+* Starting from [`9.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/9.0.0): npm package is renamed as [@chhsiao1981/use-thunk](https://www.npmjs.com/package/%40chhsiao1981/use-thunk)
+* Starting from [`8.0.0`](https://github.com/chhsiao1981/use-thunk/releases/tag/8.0.0): [Totally renamed as `useThunk`](https://github.com/chhsiao1981/use-thunk/issues/105).
 
 ## Install
 
@@ -32,9 +38,9 @@ Please check [demo-use-thunk](https://github.com/chhsiao1981/demo-use-thunk) for
 Thunk module able to do increment (reducers/increment.ts):
 
 ```ts
-import { init as _init, setData, Thunk, getState, type State as rState, genUUID } from '@chhsiao1981/use-thunk'
+import { init as _init, update, Thunk, type State as rState, genUUID } from '@chhsiao1981/use-thunk'
 
-export const myClass = 'demo/Increment'
+export const name = 'demo/Increment'
 
 export interface State extends rState {
   count: number
@@ -46,20 +52,20 @@ export const defaultState: State = {
 
 export const init = (): Thunk<State> => {
   const myID = genUUID()
-  return async (dispatch, getClassState) => {
-    dispatch(_init({myID, state: defaultState}))
+  return async (set) => {
+    set(_init({myID, state: defaultState}))
   }
 }
 
 export const increment = (myID: string): Thunk<State> => {
-  return async (dispatch, getClassState) => {
-    let classState = getClassState()
-    let me = getState(classState, myID)
+  return async (set, get) => {
+    let me = get(myID)
     if(!me) {
       return
     }
+    const {count} = me
 
-    dispatch(setData(myID, { count: me.count + 1 }))
+    set(update(myID, { count: count + 1 }))
   }
 }
 ```
@@ -67,7 +73,7 @@ export const increment = (myID: string): Thunk<State> => {
 App.tsx:
 
 ```tsx
-import { type ThunkModuleToFunc, useThunk, getDefaultID, getState } from '@chhsiao1981/use-thunk'
+import { type ThunkModuleToFunc, useThunk, getState } from '@chhsiao1981/use-thunk'
 import * as DoIncrement from './reducers/increment'
 
 type TDoIncrement = ThunkModuleToFunc(typeof DoIncrement)
@@ -76,17 +82,14 @@ type Props = {
 }
 
 export default (props: Props) => {
-  const [classStateIncrement, doIncrement] = useThunk<DoIncrement.State, TDoIncrement>(DoIncrement, StateType.LOCAL)
+  const useIncrement = useThunk<DoIncrement.State, TDoIncrement>(DoIncrement, StateType.LOCAL)
+  const [increment, doIncrement, incrementID] = getState(useIncrement)
 
   //init
   useEffect(() => {
     doIncrement.init()
   }, [])
 
-  // states
-  const incrementID = getDefaultID(classStateIncrement)
-  const increment = getState(classStateIncrement) || DoIncrement.defaultState
-
   // to render
   return (
     <div>
@@ -99,13 +102,13 @@ export default (props: Props) => {
 
 main.tsx:
 ```tsx
-import { registerThunk, ThunkContext } from "@chhsiao1981/use-thunk";
+import { createThunk, ThunkContext } from "@chhsiao1981/use-thunk";
 import { StrictMode } from "react";
 import { createRoot } from "react-dom/client";
 import * as DoIncrement from './reducers/increment'
 import App from "./App.tsx";
 
-registerThunk(DoIncrement)
+createThunk(DoIncrement)
 
 createRoot(document.getElementById("root")!).render(
   <StrictMode>
@@ -121,13 +124,15 @@ createRoot(document.getElementById("root")!).render(
 ```ts
 import type { State as rState } from '@chhsiao1981/use-thunk'
 
-// reducer class name.
-export const myClass = ""
+// Thunk-module name.
+export const name = ""
 
 // state definition of the reducer.
 export interface State extends rState {
 }
 
+export const defaultState: State = {}
+
 .
 .
 .
@@ -136,18 +141,16 @@ export interface State extends rState {
 ### Must Included in a Top-level Component
 
 ```ts
-import { type ThunkModuleToFunc, useThunk, getDefaultID, getState } from '@chhsiao1981/use-thunk'
+import { type ThunkModuleToFunc, useThunk, getState } from '@chhsiao1981/use-thunk'
 import * as DoModule from '../reducers/module'
 
 type TDoModule = ThunkModuleToFunc<typeof DoModule>
 
 const Component = () => {
-  const [stateModule, doModule] = useThunk<DoModule.State, TDoModule>(DoModule)
-
-  const moduleID = getDefaultID(stateModule)
-  const theModule = getState(stateModule)
+  const useModule = useThunk<DoModule.State, TDoModule>(DoModule)
+  const [module, doModule, moduleID] = getState(useModule)
 
-  .
+.
   .
   .
 }
@@ -156,7 +159,8 @@ const Component = () => {
 ### Must Included in main.tsx
 
 ```tsx
-registerThunk(...)
+import { createThunk, ThunkContext } from '@chhsiao1981/use-thunk'
+createThunk(...)
 .
 .
 .
@@ -182,8 +186,8 @@ with the following features:
 For example, the example [in the redux link](https://redux.js.org/recipes/structuring-reducers/normalizing-state-shape) is represented as:
 
 ```ts
-classStatePost = {
-  myClass: 'post',
+moduleStatePost = {
+  name: 'post',
   nodes: {
     [uuid-post1] : {
       id: uuid-post1,
@@ -202,7 +206,7 @@ classStatePost = {
       }
     }
   },
-  defaultID,
+  defaultID,s
   defaultState,
 }
 ```
@@ -210,8 +214,8 @@ classStatePost = {
 and:
 
 ```ts
-classStateComment = {
-  myClass: 'comment',
+moduleStateComment = {
+  myClass: 'module',
   nodes: {
     [uuid-comment1] : {
       id: uuid-comment1,
@@ -256,8 +260,8 @@ classStateComment = {
 
 and:
 ```ts
-classStateUser = {
-  myClass: 'user',
+moduleStateUser = {
+  name: 'user',
   nodes: {
     [uuid-user1] : {
       id: uuid-user1,
@@ -290,50 +294,50 @@ classStateUser = {
 
 ### Basic
 
-##### `useThunk(theDo: ThunkModuleFunc): [ClassState, DispatchedFuncMap]`
+##### `createThunk(theModule: ThunkModule)`
 
-Similar to `React.useReducer`, but we use `useThunk`, and we also bind the actions with dispatch (similar concept as `mapDispatchToProps`).s
+Create a module state for `theModule`.
 
-return: `[ClassState<S>, DispatchedFuncMap<S, R>]`
+##### `<ThunkContext>{children}</ThunkContext>`
 
-##### `init({myID, parentID, doParent, state}, myuuidv4?)`
+Rendering Thunk context.
 
-initializing the react-object.
+##### `useThunk(theDo: ThunkModule): UseThunk`
 
-##### `setData(myID, data)`
+Similar to `React.useReducer`, but we use `useThunk`, and we also bind the actions with set (similar concept as `mapDispatchToProps`).
 
-set the data to myID.
+return: `UseThunk`
 
-##### `remove(myID, isFromParent=false)`
+### Default Thunk functions.
 
-remove the react-object.
+##### `init({myID, parentID, doParent, state}, myuuidv4?)`
 
-##### `genUUID(myuuidv4?: () => string): string`
+initializing the state.
 
-generate uuid for react-object.
+##### `update(myID, data)`
 
-### State
+update the data to myID.
 
-##### `getState(state: ClassState, myID?: string): State | null`
+##### `remove(myID)`
 
-Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `null` if not available.
+remove the state.
 
-##### `mustGetState(state: ClassState, myID?: string): State`
+##### `genUUID(myuuidv4?: () => string): string`
 
-Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
+generate uuid for the state.
 
-##### `mustGetStateByThunk(theUseThunk: UseThunk, myID?: string): [State, DispatchedActionMap, theID]`
+### State
 
-Get the state of `myID` by `UseThunk`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
+##### `getState(theUseThunk: UseThunk, myID?: string): [state, doModule, theID]`
 
-return: `[S, DispatchedFuncMap<S, R>, theID]`
+Get the state of `myID` by `UseThunk`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.
 
-##### `getDefaultID(state: ClassState): string`
+return: `[state, doModule, theID]`
 
-get the default id.
+##### `getStateOrNullByModule(moduleState: ModuleState, myID?: string): state | null`
 
-### NodeState
+Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `null` if not available.
 
-##### `getNode(state: ClassState, myID?: string): NodeState`
+##### `getStateByModule(moduleState: ModuleState, myID?: string): state`
 
-Get the node of `myID`. Get the node of `defaultID` if `myID` is not present.
+Get the state of `myID`. Get the state of `defaultID` if `myID` is not present. Return `defaultState` if not available.

package/package.json

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

package/src/action/thunk.ts

@@ -2,4 +2,8 @@ import type { set } from '../set'
 import type { ModuleState, State } from '../stateTypes'
 
 // Thunk
-export type Thunk<S extends State> = (set: set<S>, getModuleState: () => ModuleState<S>) => void
+export type Thunk<S extends State> = (
+  set: set<S>,
+  get: (id?: string) => S | null,
+  getModuleState: () => ModuleState<S>,
+) => void

package/src/createThunk.ts

@@ -1,19 +1,17 @@
 import { createContext, type Dispatch, type SetStateAction } from 'react'
-import { createThunk } from '.'
 import type { ModuleState, State } from './stateTypes'
 import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 import type { ThunkModule } from './thunkModule'
 
 export default <S extends State>(theDo: ThunkModule<S>) => {
-  const { name: propsName, myClass, defaultState } = theDo
-  const name = (propsName ? propsName : myClass) || ''
+  const { name, defaultState } = theDo
 
   if (THUNK_CONTEXT_MAP.theMap[name]) {
     console.warn('createThunk: already init:', name)
     return
   }
 
-  const moduleState: ModuleState<S> = { myClass, name, nodes: {}, defaultState }
+  const moduleState: ModuleState<S> = { name, nodes: {}, defaultState }
   const setModuleState: Dispatch<SetStateAction<ModuleState<S>>> = () => {}
   const refModuleState = { current: moduleState }
   const context = createContext({ refModuleState: refModuleState, setModuleState })
@@ -24,8 +22,3 @@ export default <S extends State>(theDo: ThunkModule<S>) => {
 
   console.info('createThunk: done:', name)
 }
-
-export const registerThunk = <S extends State>(theDo: ThunkModule<S>) => {
-  console.warn('registerThunk will be deprecated in the next version.')
-  return createThunk(theDo)
-}

package/src/get.ts

@@ -0,0 +1,3 @@
+import type { State } from './stateTypes'
+
+export type get = <S extends State>(id: string) => S

package/src/index.ts

@@ -1,44 +1,40 @@
 import type { GetModuleState, Thunk } from './action'
-import createThunk, { registerThunk } from './createThunk'
+import createThunk from './createThunk'
 import { genUUID } from './genUUID'
+import type { get } from './get'
 import { type InitParams, init } from './init'
 import { remove } from './remove'
 import type { set } from './set'
 import { setDefaultID } from './setDefaultID'
 import type { setMap } from './setMap'
-import { getDefaultID, getNode, getState, mustGetState, mustGetStateByThunk } from './states'
+import { getDefaultID, getNode, getState, getStateByModule, getStateOrNullByModule } from './states'
 import type { ModuleState, State } from './stateTypes'
 import ThunkContext from './ThunkContext'
 import type { ThunkModule, ThunkModuleToFunc } from './thunkModule'
-import { setData, update } from './update'
+import { update } from './update'
 import useThunk, { type UseThunk } from './useThunk'
 
 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,
+  type get,
   getNode,
   getDefaultID,
+  getStateOrNullByModule,
+  getStateByModule,
   getState,
-  mustGetState,
-  mustGetStateByThunk,
   init,
   type InitParams,
-  setData, // to deprecate
   update,
   remove,
   setDefaultID,

package/src/init/index.ts

@@ -11,7 +11,7 @@ export interface InitParams<S extends State> {
 }
 
 export const init = <S extends State>(params: InitParams<S>, myuuidv4?: () => string): Thunk<S> => {
-  return (set, getModuleState) => {
+  return (set, _, getModuleState) => {
     const myID = params.myID ?? genUUID(myuuidv4)
 
     const { state } = params

package/src/stateTypes.ts

@@ -15,8 +15,7 @@ export type NodeStateMap<S extends State> = {
 
 // ModuleState
 export type ModuleState<S extends State> = {
-  name?: string
-  myClass?: string // XXX to deprecated
+  name: string
   defaultID?: string | null
   nodes: NodeStateMap<S>
   defaultState: S

package/src/states.ts

@@ -19,7 +19,10 @@ export const getNode = <S extends State>(
   return moduleState.nodes[theID] || null
 }
 
-export const getState = <S extends State>(moduleState: ModuleState<S>, myID?: string): S | null => {
+export const getStateOrNullByModule = <S extends State>(
+  moduleState: ModuleState<S>,
+  myID?: string,
+): S | null => {
   const theID = myID ? myID : getDefaultID(moduleState)
   if (!theID) {
     return null
@@ -32,16 +35,16 @@ export const getState = <S extends State>(moduleState: ModuleState<S>, myID?: st
   return me.state
 }
 
-export const mustGetState = <S extends State>(moduleState: ModuleState<S>, myID?: string): S => {
-  return getState(moduleState, myID) || moduleState.defaultState
+export const getStateByModule = <S extends State>(moduleState: ModuleState<S>, myID?: string): S => {
+  return getStateOrNullByModule(moduleState, myID) || moduleState.defaultState
 }
 
-export const mustGetStateByThunk = <S extends State, R extends ThunkModuleFunc<S>>(
+export const getState = <S extends State, R extends ThunkModuleFunc<S>>(
   theUseThunk: UseThunk<S, R>,
   myID?: string,
 ): [S, setMap<S, R>, string] => {
   const [moduleState, theDo] = theUseThunk
   const theID = myID ? myID : getDefaultID(moduleState)
-  const state = mustGetState(moduleState, theID)
+  const state = getStateByModule(moduleState, theID)
   return [state, theDo, theID]
 }

package/src/thunkModule/defaultThunkModuleFuncMap.ts

@@ -1,12 +1,11 @@
 import type { ActionFunc } from '../action'
 import { init } from '../init'
 import { remove } from '../remove'
-import { setData, update } from '../update'
+import { update } from '../update'
 
 export const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap = {
   init,
   update,
-  setData,
   remove,
 }
 

package/src/thunkModule/index.ts

@@ -12,10 +12,9 @@ export interface ThunkModuleFunc<S extends State> extends ThunkModuleBase<S> {
 
 // This is used as the parameter for useThunk.
 export type ThunkModule<S extends State> = {
-  name?: string
-  myClass?: string // XXX to deprecate
+  name: string
   default?: Reducer<S>
   defaultState: S
 } & ThunkModuleBase<S>
 
-export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'myClass' | 'default' | 'defaultState'>
+export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'default' | 'defaultState'>

package/src/update.ts

@@ -8,11 +8,6 @@ export const update = <S extends State>(myID: string, data: Partial<S>): BaseAct
   data,
 })
 
-export const setData = <S extends State>(myID: string, data: Partial<S>): BaseAction => {
-  console.warn('setData will be deprecated in the next version.')
-  return update(myID, data)
-}
-
 export const reduceUpdate = <S extends State>(
   moduleState: ModuleState<S>,
   action: BaseAction,

package/src/useThunk.ts

@@ -16,8 +16,7 @@ export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [ModuleSta
 export default <S extends State, R extends ThunkModuleFunc<S>>(
   theDo: ThunkModule<S>,
 ): UseThunk<S, R> => {
-  const { name: propsName, myClass } = theDo
-  const name = (propsName ? propsName : myClass) || ''
+  const { name } = theDo
 
   // 1. It requires shared nodes for the same module to have the same setMap.
   const isFirstTime = !SET_MAP_BY_MODULE[name]

package/src/useThunkReducer.ts

@@ -5,6 +5,7 @@ import { useCallback, useContext } from 'react'
 import type BaseAction from './action/baseAction'
 import type { Reducer } from './reducer'
 import type { set } from './set'
+import { getStateOrNullByModule } from './states'
 import type { ModuleState, State } from './stateTypes'
 import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 
@@ -20,7 +21,7 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
   const { refModuleState, setModuleState: setModuleState_c } = useContext(context)
   const getModuleState = useCallback(() => {
     return refModuleState.current
-  }, [refModuleState])
+  }, [refModuleState]) as () => ModuleState<S>
 
   const setModuleState = useCallback(
     (newModuleState: ModuleState<S>) => {
@@ -30,6 +31,15 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
     [refModuleState, setModuleState_c],
   )
 
+  const get = useCallback(
+    (id?: string) => {
+      const moduleState = getModuleState()
+      const state = getStateOrNullByModule(moduleState, id)
+      return state
+    },
+    [getModuleState],
+  )
+
   // 5. reducer.
   const reduce = useCallback(
     (action: BaseAction): ModuleState<S> => {
@@ -45,7 +55,7 @@ export default <S extends State>(reducer: Reducer<S>, moduleName: string): [Modu
     (action) => {
       if (typeof action === 'function') {
         // action is Thunk<S, A>
-        action(set, getModuleState)
+        action(set, get, getModuleState)
         return
       }
 

package/types/action/thunk.d.ts

@@ -1,3 +1,3 @@
 import type { set } from '../set';
 import type { ModuleState, State } from '../stateTypes';
-export type Thunk<S extends State> = (set: set<S>, getModuleState: () => ModuleState<S>) => void;
+export type Thunk<S extends State> = (set: set<S>, get: (id?: string) => S | null, getModuleState: () => ModuleState<S>) => void;

package/types/createThunk.d.ts

@@ -2,4 +2,3 @@ import type { State } from './stateTypes';
 import type { ThunkModule } from './thunkModule';
 declare const _default: <S extends State>(theDo: ThunkModule<S>) => void;
 export default _default;
-export declare const registerThunk: <S extends State>(theDo: ThunkModule<S>) => void;

package/types/get.d.ts

@@ -0,0 +1,2 @@
+import type { State } from './stateTypes';
+export type get = <S extends State>(id: string) => S;

package/types/index.d.ts

@@ -1,21 +1,16 @@
 import type { GetModuleState, Thunk } from './action';
-import createThunk, { registerThunk } from './createThunk';
+import createThunk from './createThunk';
 import { genUUID } from './genUUID';
+import type { get } from './get';
 import { type InitParams, init } from './init';
 import { remove } from './remove';
 import type { set } from './set';
 import { setDefaultID } from './setDefaultID';
 import type { setMap } from './setMap';
-import { getDefaultID, getNode, getState, mustGetState, mustGetStateByThunk } from './states';
+import { getDefaultID, getNode, getState, getStateByModule, getStateOrNullByModule } from './states';
 import type { ModuleState, State } from './stateTypes';
 import ThunkContext from './ThunkContext';
 import type { ThunkModule, ThunkModuleToFunc } from './thunkModule';
-import { setData, update } from './update';
+import { update } from './update';
 import useThunk, { type UseThunk } from './useThunk';
-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, };
+export { createThunk, useThunk, type UseThunk, ThunkContext, type State, type ModuleState, type GetModuleState, type Thunk, type ThunkModule, type ThunkModuleToFunc, type set, type setMap, type get, getNode, getDefaultID, getStateOrNullByModule, getStateByModule, getState, init, type InitParams, update, remove, setDefaultID, genUUID, };

package/types/stateTypes.d.ts

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

package/types/states.d.ts

@@ -4,6 +4,6 @@ import type { ThunkModuleFunc } from './thunkModule';
 import type { UseThunk } from './useThunk';
 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];
+export declare const getStateOrNullByModule: <S extends State>(moduleState: ModuleState<S>, myID?: string) => S | null;
+export declare const getStateByModule: <S extends State>(moduleState: ModuleState<S>, myID?: string) => S;
+export declare const getState: <S extends State, R extends ThunkModuleFunc<S>>(theUseThunk: UseThunk<S, R>, myID?: string) => [S, setMap<S, R>, string];

package/types/thunkModule/index.d.ts

@@ -8,9 +8,8 @@ export interface ThunkModuleFunc<S extends State> extends ThunkModuleBase<S> {
     [action: string]: ThunkFunc<S>;
 }
 export type ThunkModule<S extends State> = {
-    name?: string;
-    myClass?: string;
+    name: string;
     default?: Reducer<S>;
     defaultState: S;
 } & ThunkModuleBase<S>;
-export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'myClass' | 'default' | 'defaultState'>;
+export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'default' | 'defaultState'>;

package/types/update.d.ts

@@ -2,5 +2,4 @@ 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>;