@chhsiao1981/use-thunk 12.0.0 → 13.0.0

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

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,12 +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;
-    defaultID?: string | null;
     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,15 +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;
-    default?: Reducer<S>;
     defaultState: S;
-} & ThunkModuleBase<S>;
-export type ThunkModuleToFunc<T> = Omit<T, 'name' | '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,50 +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 getStateOrNullByModule = <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 getStateByModule = <S extends State>(moduleState: ModuleState<S>, myID?: string): S => {
-  return getStateOrNullByModule(moduleState, myID) || moduleState.defaultState
-}
-
-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 = getStateByModule(moduleState, theID)
-  return [state, theDo, theID]
-}

package/src/thunkModule/defaultThunkModuleFuncMap.ts

@@ -1,15 +0,0 @@
-import type { ActionFunc } from '../action'
-import { init } from '../init'
-import { remove } from '../remove'
-import { update } from '../update'
-
-export const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap = {
-  init,
-  update,
-  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 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/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;