@chhsiao1981/use-thunk 11.0.0 → 13.0.0

package/types/defaultThunks/index.d.ts

@@ -0,0 +1,10 @@
+import { INIT, type InitParams, init, reduceInit } from './init';
+export { INIT, type InitParams, init, reduceInit };
+import { reduceUpdate, UPDATE, update } from './update';
+export { reduceUpdate, UPDATE, update };
+import { REMOVE, reduceRemove, remove } from './remove';
+export { REMOVE, reduceRemove, remove };
+import { reduceUpsert, UPSERT, upsert } from './upsert';
+export { UPSERT, upsert, reduceUpsert };
+import { reduceSetDefaultID, SET_DEFAULT_ID, setDefaultID } from './setDefaultID';
+export { SET_DEFAULT_ID, setDefaultID, reduceSetDefaultID };

package/types/defaultThunks/init/index.d.ts

@@ -0,0 +1,9 @@
+import type { Thunk } from '../../action';
+import type { State } from '../../states';
+import { INIT, reduceInit } from './initCore';
+export { INIT, reduceInit };
+export interface InitParams<S extends State> {
+    myID?: string;
+    state: S;
+}
+export declare const init: <S extends State>(params: InitParams<S>) => Thunk<S>;

package/types/{init → defaultThunks/init}/initCore.d.ts

@@ -1,5 +1,5 @@
-import type BaseAction from '../action/baseAction';
-import type { ModuleState, State } from '../stateTypes';
+import type { BaseAction } from '../../action';
+import type { ModuleState, State } from '../../states';
 export interface InitAction<S extends State> extends BaseAction {
     state: S;
 }

package/types/{remove.d.ts → defaultThunks/remove.d.ts}

@@ -1,5 +1,5 @@
-import type BaseAction from './action/baseAction';
-import type { ModuleState, State } from './stateTypes';
+import type { BaseAction } from '../action';
+import type { ModuleState, State } from '../states';
 export declare const REMOVE = "@chhsiao1981/use-thunk/REMOVE";
 export declare const remove: (myID: string) => BaseAction;
 export declare const reduceRemove: <S extends State>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/{setDefaultID.d.ts → defaultThunks/setDefaultID.d.ts}

@@ -1,5 +1,5 @@
-import type BaseAction from './action/baseAction';
-import type { ModuleState, State } from './stateTypes';
+import type { BaseAction } from '../action';
+import type { ModuleState, State } from '../states';
 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>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/{update.d.ts → defaultThunks/update.d.ts}

@@ -1,6 +1,5 @@
-import type BaseAction from './action/baseAction';
-import type { ModuleState, State } from './stateTypes';
+import type { BaseAction } from '../action';
+import type { ModuleState, State } from '../states';
 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/defaultThunks/upsert.d.ts

@@ -0,0 +1,5 @@
+import type { BaseAction } from '../action';
+import type { ModuleState, State } from '../states';
+export declare const UPSERT = "@chhsiao1981/use-thunk/UPSERT";
+export declare const upsert: <S extends State>(myID: string, data: Partial<S>) => BaseAction;
+export declare const reduceUpsert: <S extends State>(moduleState: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/dispatch.d.ts

@@ -1,4 +1,4 @@
-import type { Dispatch as rDispatch } from 'react';
-import type { ActionOrThunk } from './action/ActionOrThunk';
-import type { State } from './stateTypes';
-export type Dispatch<S extends State> = rDispatch<ActionOrThunk<S>>;
+import type { Dispatch } from 'react';
+import type { ActionOrThunk } from './action';
+import type { State } from './states';
+export type dispatch<S extends State> = Dispatch<ActionOrThunk<S>>;

package/types/get.d.ts

@@ -0,0 +1,3 @@
+import type { State } from './states';
+export type get<S extends State> = (id?: string) => S;
+export type getOrNull<S extends State> = (id?: string) => S | null | undefined;

package/types/index.d.ts

@@ -1,21 +1,12 @@
-import type { GetModuleState, Thunk } from './action';
-import createThunk, { registerThunk } from './createThunk';
-import { genUUID } from './genUUID';
-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 type { ModuleState, State } from './stateTypes';
-import ThunkContext from './ThunkContext';
-import type { ThunkModule, ThunkModuleToFunc } from './thunkModule';
-import { setData, update } from './update';
+import type { getModuleState, Thunk, ThunkFunc } from './action';
+import { type InitParams, init, remove, setDefaultID, update, upsert } from './defaultThunks';
+import type { dispatch } from './dispatch';
+import type { get, getOrNull } from './get';
+import registerThunk from './registerThunk';
+import type { set, setMap } from './set';
+import { getDefaultID, getNodeOrNull, getState, getStateByModule, getStateOrNullByModule, type ModuleState, type State } from './states';
+import { ThunkContext } from './thunkContext';
+import type { doModule, ThunkModule, toDoModule } from './thunkModule';
 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, };
+import { genID } from './utils';
+export { type Thunk, type set, type get, type getOrNull, type dispatch, type getModuleState, registerThunk, useThunk, type UseThunk, ThunkContext, type State, getState, type ModuleState, type ThunkModule, type toDoModule, type doModule, type ThunkFunc, init, type InitParams, update, upsert, remove, genID, type setMap, setDefaultID, getNodeOrNull, getDefaultID, getStateOrNullByModule, getStateByModule, };

package/types/reducer/createReducer.d.ts

@@ -0,0 +1,3 @@
+import type { State } from '../states';
+import type { Reducer } from './index';
+export declare const createReducer: <S extends State>() => Reducer<S>;

package/types/reducer/defaultReduceMap.d.ts

@@ -0,0 +1,2 @@
+import type { ReduceMap } from './reduceMap';
+export declare const DEFAULT_REDUCE_MAP: ReduceMap<any>;

package/types/{reducer.d.ts → reducer/index.d.ts}

@@ -1,5 +1,7 @@
 import type { Reducer as rReducer } from 'react';
-import type BaseAction from './action/baseAction';
-import type { ModuleState, State } from './stateTypes';
+import type { BaseAction } from '../action';
+import type { ModuleState, State } from '../states';
+import { createReducer } from './createReducer';
+export { createReducer };
 export type Reducer<S extends State> = rReducer<ModuleState<S>, BaseAction>;
 export type ReduceFunc<S extends State> = (state: ModuleState<S>, action: BaseAction) => ModuleState<S>;

package/types/reducer/reduceMap.d.ts

@@ -0,0 +1,5 @@
+import type { State } from '../states';
+import type { ReduceFunc } from './index';
+export interface ReduceMap<S extends State> {
+    [type: string]: ReduceFunc<S>;
+}

package/types/{createThunk.d.ts → registerThunk.d.ts}

@@ -1,5 +1,4 @@
-import type { State } from './stateTypes';
+import type { State } from './states';
 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/set/index.d.ts

@@ -0,0 +1,5 @@
+import type { ActionOrThunk } from '../action';
+import type { State } from '../states';
+import { constructSetMap, type DefaultSetMap, type setMap, type setMapByModuleMap } from './setMap';
+export { constructSetMap, type DefaultSetMap, type setMap, type setMapByModuleMap };
+export type set<S extends State> = (actionOrID: ActionOrThunk<S> | string, data?: Partial<S>) => void;

package/types/set/setMap.d.ts

@@ -0,0 +1,16 @@
+import type { set } from '../set';
+import type { State } from '../states';
+import type { doModule, ThunkModule } from '../thunkModule';
+import { type defaultDoModule } from '../thunkModule';
+type VoidReturnType<T extends (...params: any[]) => unknown> = (...params: Parameters<T>) => void;
+export type setMap<S extends State, T extends doModule<S>> = {
+    [action in keyof T]: VoidReturnType<T[action]>;
+} & Omit<DefaultSetMap, keyof T>;
+export type DefaultSetMap = {
+    [action in keyof defaultDoModule]: VoidReturnType<defaultDoModule[action]>;
+};
+export interface setMapByModuleMap<S extends State, T extends doModule<S>> {
+    [moduleMap: string]: setMap<S, T>;
+}
+export declare const constructSetMap: <S extends State, T extends doModule<S>>(theDo: ThunkModule<S>, set: set<S>, setMap: setMap<S, T>) => setMap<S, T>;
+export {};

package/types/states/index.d.ts

@@ -0,0 +1,10 @@
+import type { setMap } from '../set';
+import type { doModule } from '../thunkModule';
+import type { UseThunk } from '../useThunk';
+import type { ModuleState, NodeState, NodeStateMap, State } from './types';
+export type { ModuleState, NodeState, State, NodeStateMap };
+export declare const getDefaultID: <S extends State>(moduleState: ModuleState<S>) => string;
+export declare const getNodeOrNull: <S extends State>(moduleState: ModuleState<S>, myID?: string) => Readonly<NodeState<S> | null>;
+export declare const getStateOrNullByModule: <S extends State>(moduleState: ModuleState<S>, myID?: string) => Readonly<S | null>;
+export declare const getStateByModule: <S extends State>(moduleState: ModuleState<S>, myID?: string) => Readonly<S>;
+export declare const getState: <S extends State, R extends doModule<S>>(theUseThunk: UseThunk<S, R>, myID?: string) => [Readonly<S>, setMap<S, R>, string];

package/types/{stateTypes.d.ts → states/types.d.ts}

@@ -5,13 +5,13 @@ export type NodeState<S extends State> = {
     id: string;
     state: S;
 };
-export type NodeStateMap<S extends State> = {
-    [key: string]: NodeState<S>;
-};
 export type ModuleState<S extends State> = {
-    name?: string;
-    myClass?: string;
-    defaultID?: string | null;
+    name: string;
     nodes: NodeStateMap<S>;
     defaultState: S;
+    defaultID?: string | null;
+    isInitDefaultID?: boolean;
+};
+export type NodeStateMap<S extends State> = {
+    [key: string]: NodeState<S>;
 };

package/types/thunkContext/index.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from './types';
+export type { Context };
+import { THUNK_CONTEXT_MAP, type ThunkContextMap } from './thunkContextMap';
+export { THUNK_CONTEXT_MAP, type ThunkContextMap };
+import ThunkContext from './ThunkContext';
+export { ThunkContext };

package/types/{thunkContextMap.d.ts → thunkContext/thunkContextMap.d.ts}

@@ -1,6 +1,6 @@
 import type { Context as rContext } from 'react';
-import type { ModuleState } from './stateTypes';
-import type { Context } from './thunkContextTypes';
+import type { ModuleState } from '../states';
+import type { Context } from './types';
 export type ThunkContextMap = {
     theMap: {
         [moduleName: string]: {

package/types/{thunkContextTypes.d.ts → thunkContext/types.d.ts}

@@ -1,5 +1,5 @@
 import type { Dispatch, SetStateAction } from 'react';
-import type { ModuleState, State } from './stateTypes';
+import type { ModuleState, State } from '../states';
 export type Context<S extends State> = {
     refModuleState: {
         current: ModuleState<S>;

package/types/thunkModule/defaultDoModule.d.ts

@@ -0,0 +1,5 @@
+import type { ActionFunc } from '../action';
+export declare const DEFAULT_DO_MODULE: defaultDoModule;
+export type defaultDoModule = {
+    [action: string]: ActionFunc<any>;
+};

package/types/thunkModule/index.d.ts

@@ -1,16 +1,13 @@
 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> {
+import type { State } from '../states';
+import { DEFAULT_DO_MODULE, type defaultDoModule } from './defaultDoModule';
+export { DEFAULT_DO_MODULE, type defaultDoModule };
+export interface doModule<S extends State> {
     [action: string]: ThunkFunc<S>;
 }
 export type ThunkModule<S extends State> = {
-    name?: string;
-    myClass?: string;
-    default?: Reducer<S>;
+    name: string;
     defaultState: S;
-} & ThunkModuleBase<S>;
-export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'myClass' | 'default' | 'defaultState'>;
+    [action: string]: ThunkFunc<S> | string | S;
+};
+export type toDoModule<T extends ThunkModule<any>> = Omit<T, 'name' | 'default' | 'defaultState'>;

package/types/useThunk/index.d.ts

@@ -0,0 +1,9 @@
+import { type setMap } from '../set';
+import type { ModuleState, State } from '../states';
+import type { doModule, ThunkModule } from '../thunkModule';
+export type UseThunk<S extends State, R extends doModule<S>> = [Readonly<ModuleState<S>>, setMap<S, R>];
+/**********
+ * useThunk
+ **********/
+declare const _default: <S extends State, R extends doModule<S>>(theDo: ThunkModule<S>) => UseThunk<S, R>;
+export default _default;

package/types/{useThunkReducer.d.ts → useThunk/useThunkReducer.d.ts}

@@ -1,6 +1,6 @@
-import type { Reducer } from './reducer';
-import type { set } from './set';
-import type { ModuleState, State } from './stateTypes';
+import type { Reducer } from '../reducer';
+import type { set } from '../set';
+import { type ModuleState, type State } from '../states';
 /**
  * useThunkReducer
  *

package/types/utils/deepCopy.d.ts

@@ -0,0 +1,2 @@
+declare const deepCopy: (obj: any) => any;
+export default deepCopy;

package/types/utils/genID.d.ts

@@ -0,0 +1 @@
+export declare const genID: () => string;

package/types/utils/index.d.ts

@@ -0,0 +1,3 @@
+import deepCopy from './deepCopy';
+import { genID } from './genID';
+export { deepCopy, genID };

package/src/createReducer.ts

@@ -1,24 +0,0 @@
-import type BaseAction from './action/baseAction'
-import { DEFAULT_REDUCE_MAP, type ReduceMap } from './reduceMap'
-import type { Reducer } from './reducer'
-
-import type { ModuleState, State } from './stateTypes'
-
-export const createReducer = <S extends State>(reduceMap?: ReduceMap<S>): Reducer<S> => {
-  return (moduleState: ModuleState<S>, action: BaseAction): ModuleState<S> => {
-    if (!action) {
-      return moduleState
-    }
-
-    if (reduceMap?.[action.type]) {
-      return reduceMap[action.type](moduleState, action)
-    }
-
-    const defaultReduceMap = DEFAULT_REDUCE_MAP<S>()
-    if (defaultReduceMap?.[action.type]) {
-      return defaultReduceMap[action.type](moduleState, action)
-    }
-
-    return moduleState
-  }
-}

package/src/genUUID.ts

@@ -1,38 +0,0 @@
-import { v4 as uuidv4 } from 'uuid'
-
-const _GLOBAL_IDS = new Set()
-
-const _GEN_UUID_COUNT = 3
-
-const _GEN_UUID_STATE = {
-  iterate: 1,
-}
-
-export const genUUID = (myuuidv4?: () => string): string => {
-  let theID = ''
-  let isAdd = false
-  for (let i = 0; i < _GEN_UUID_COUNT; i++) {
-    theID = genUUIDCore(myuuidv4)
-    if (_GLOBAL_IDS.has(theID)) {
-      continue
-    }
-    _GLOBAL_IDS.add(theID)
-    isAdd = true
-    break
-  }
-  if (isAdd) {
-    return theID
-  }
-
-  _GEN_UUID_STATE.iterate += 1
-  theID = genUUIDCore(myuuidv4)
-  return theID
-}
-
-const genUUIDCore = (myuuid: () => string = uuidv4): string => {
-  let theID = ''
-  for (let j = 0; j < _GEN_UUID_STATE.iterate; j++) {
-    theID += myuuid()
-  }
-  return theID
-}

package/src/init/index.ts

@@ -1,26 +0,0 @@
-import type { Thunk } from '../action'
-import { genUUID } from '../genUUID'
-import { setDefaultID } from '../setDefaultID'
-import type { State } from '../stateTypes'
-import initCore from './initCore'
-
-// InitParams
-export interface InitParams<S extends State> {
-  myID?: string
-  state: S
-}
-
-export const init = <S extends State>(params: InitParams<S>, myuuidv4?: () => string): Thunk<S> => {
-  return (set, getModuleState) => {
-    const myID = params.myID ?? genUUID(myuuidv4)
-
-    const { state } = params
-    set(initCore(myID, state))
-
-    const { defaultID } = getModuleState()
-
-    if (!defaultID) {
-      set(setDefaultID(myID))
-    }
-  }
-}

package/src/reduceMap.ts

@@ -1,22 +0,0 @@
-import { INIT, reduceInit } from './init/initCore'
-import type { ReduceFunc } from './reducer'
-import { REMOVE, reduceRemove } from './remove'
-import { reduceSetDefaultID, SET_DEFAULT_ID } from './setDefaultID'
-import type { State } from './stateTypes'
-import { reduceUpdate, UPDATE } from './update'
-
-export interface ReduceMap<S extends State> {
-  [type: string]: ReduceFunc<S>
-}
-
-// default reduceMap
-export const DEFAULT_REDUCE_MAP: <S extends State>() => ReduceMap<S> = () => ({
-  [INIT]: reduceInit,
-  [UPDATE]: reduceUpdate,
-  [REMOVE]: reduceRemove,
-
-  // setDefaultID.
-  // Typically we don't need this in programming.
-  // The defaultID is automatically determined if defaultID is not set.
-  [SET_DEFAULT_ID]: reduceSetDefaultID,
-})

package/src/set.ts

@@ -1,7 +0,0 @@
-import type { Dispatch } from 'react'
-// XXX requiring to import directly from action/ActionOrThunk, or it will cause looping.
-import type { ActionOrThunk } from './action/ActionOrThunk'
-import type { State } from './stateTypes'
-
-// set
-export type set<S extends State> = Dispatch<ActionOrThunk<S>>

package/src/states.ts

@@ -1,47 +0,0 @@
-import type { setMap } from './setMap'
-import type { ModuleState, NodeState, State } from './stateTypes'
-import type { ThunkModuleFunc } from './thunkModule'
-import type { UseThunk } from './useThunk'
-
-export const getDefaultID = <S extends State>(moduleState: ModuleState<S>): string => {
-  return moduleState.defaultID ?? ''
-}
-
-export const getNode = <S extends State>(
-  moduleState: ModuleState<S>,
-  myID?: string,
-): NodeState<S> | null => {
-  const theID = myID ? myID : getDefaultID(moduleState)
-  if (!theID) {
-    return null
-  }
-
-  return moduleState.nodes[theID] || null
-}
-
-export const getState = <S extends State>(moduleState: ModuleState<S>, myID?: string): S | null => {
-  const theID = myID ? myID : getDefaultID(moduleState)
-  if (!theID) {
-    return null
-  }
-
-  const me = moduleState.nodes[theID]
-  if (!me) {
-    return null
-  }
-  return me.state
-}
-
-export const mustGetState = <S extends State>(moduleState: ModuleState<S>, myID?: string): S => {
-  return getState(moduleState, myID) || moduleState.defaultState
-}
-
-export const mustGetStateByThunk = <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)
-  return [state, theDo, theID]
-}

package/src/thunkModule/defaultThunkModuleFuncMap.ts

@@ -1,16 +0,0 @@
-import type { ActionFunc } from '../action'
-import { init } from '../init'
-import { remove } from '../remove'
-import { setData, update } from '../update'
-
-export const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap = {
-  init,
-  update,
-  setData,
-  remove,
-}
-
-export type DefaultThunkModuleFuncMap = {
-  // biome-ignore lint/suspicious/noExplicitAny: DefaultThunkModuleFuncMap can be any type.
-  [action: string]: ActionFunc<any>
-}

package/types/createReducer.d.ts

@@ -1,4 +0,0 @@
-import { type ReduceMap } from './reduceMap';
-import type { Reducer } from './reducer';
-import type { State } from './stateTypes';
-export declare const createReducer: <S extends State>(reduceMap?: ReduceMap<S>) => Reducer<S>;

package/types/dispatchFuncMap.d.ts

@@ -1,17 +0,0 @@
-import type { Dispatch } from './dispatch';
-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 DispatchFuncMap<S extends State, T extends ThunkModuleFunc<S>> = {
-    [action in keyof T]: VoidReturnType<T[action]>;
-} & Omit<DefaultDispatchFuncMap, keyof T>;
-export type DefaultDispatchFuncMap = {
-    [action in keyof DefaultThunkModuleFuncMap]: VoidReturnType<DefaultThunkModuleFuncMap[action]>;
-};
-export interface DispatchFuncMapByClassMap<S extends State, T extends ThunkModuleFunc<S>> {
-    [className: string]: DispatchFuncMap<S, T>;
-}
-export declare const DISPATCH_FUNC_MAP_BY_CLASS_MAP: DispatchFuncMapByClassMap<any, any>;
-export declare const constructDispatchMap: <S extends State, T extends ThunkModuleFunc<S>>(theDo: ThunkModule<S>, dispatch: Dispatch<S>, dispatchMap: DispatchFuncMap<S, T>) => DispatchFuncMap<S, T>;
-export {};

package/types/genUUID.d.ts

@@ -1 +0,0 @@
-export declare const genUUID: (myuuidv4?: () => string) => string;

package/types/init/index.d.ts

@@ -1,7 +0,0 @@
-import type { Thunk } from '../action';
-import type { State } from '../stateTypes';
-export interface InitParams<S extends State> {
-    myID?: string;
-    state: S;
-}
-export declare const init: <S extends State>(params: InitParams<S>, myuuidv4?: () => string) => Thunk<S>;

package/types/reduceMap.d.ts

@@ -1,6 +0,0 @@
-import type { ReduceFunc } from './reducer';
-import type { State } from './stateTypes';
-export interface ReduceMap<S extends State> {
-    [type: string]: ReduceFunc<S>;
-}
-export declare const DEFAULT_REDUCE_MAP: <S extends State>() => ReduceMap<S>;

package/types/set.d.ts

@@ -1,4 +0,0 @@
-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/setMap.d.ts

@@ -1,17 +0,0 @@
-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/states.d.ts

@@ -1,9 +0,0 @@
-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>(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/thunkModule/defaultThunkModuleFuncMap.d.ts

@@ -1,5 +0,0 @@
-import type { ActionFunc } from '../action';
-export declare const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap;
-export type DefaultThunkModuleFuncMap = {
-    [action: string]: ActionFunc<any>;
-};

package/types/useThunk.d.ts

@@ -1,9 +0,0 @@
-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>) => UseThunk<S, R>;
-export default _default;