@chhsiao1981/use-thunk 13.0.0 → 14.0.0

package/dist/action.d.ts

@@ -1,11 +0,0 @@
-import type { ClassState, State } from './stateTypes';
-import type { ActionOrThunk as rActionOrThunk, Thunk as rThunk } from './useThunkReducer';
-export interface BaseAction {
-    myID: string;
-    type: string;
-    [key: string]: unknown;
-}
-export type Thunk<S extends State> = rThunk<S, BaseAction>;
-export type ActionOrThunk<S extends State> = rActionOrThunk<S, BaseAction>;
-export type ActionFunc<S extends State> = (...params: any[]) => ActionOrThunk<S>;
-export type GetClassState<S extends State> = () => ClassState<S>;

package/dist/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/dist/createThunk.d.ts

@@ -1,4 +0,0 @@
-import type { State } from './stateTypes';
-import type { ThunkModule } from './thunk';
-export default function createThunk<S extends State>(theDo: ThunkModule<S>): void;
-export declare function registerThunk<S extends State>(theDo: ThunkModule<S>): void;

package/dist/dispatchFuncMap.d.ts

@@ -1,18 +0,0 @@
-import type { BaseAction } from './action';
-import type { State } from './stateTypes';
-import type { ThunkModule, ThunkModuleFunc } from './thunk';
-import { type DefaultThunkModuleFuncMap } from './thunkModuleFuncMap';
-import type { Thunk as rThunk } from './useThunkReducer';
-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>, A extends BaseAction>(theDo: ThunkModule<S>, dispatch: (action: A | rThunk<S, A>) => void, dispatchMap: DispatchFuncMap<S, T>) => DispatchFuncMap<S, T>;
-export {};

package/dist/genUUID.d.ts

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

package/dist/init.d.ts

@@ -1,16 +0,0 @@
-import type { BaseAction, Thunk } from './action';
-import type { ClassState, 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>;
-interface InitAction<S extends State> extends BaseAction {
-    parentID?: string;
-    doParent?: DispatchFuncMap;
-    parentClass?: string;
-    state: S;
-}
-export declare const INIT = "@chhsiao1981/use-thunk/INIT";
-export declare const reduceInit: <S extends State>(classState: ClassState<S>, action: InitAction<S>) => ClassState<S>;
-export {};

package/dist/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/dist/reducer.d.ts

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

package/dist/remove.d.ts

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

package/dist/setDefaultID.d.ts

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

package/dist/stateTypes.d.ts

@@ -1,16 +0,0 @@
-export interface State {
-    [key: string]: unknown;
-}
-export type NodeState<S extends State> = {
-    id: string;
-    state: S;
-};
-export type NodeStateMap<S extends State> = {
-    [key: string]: NodeState<S>;
-};
-export type ClassState<S extends State> = {
-    myClass: string;
-    defaultID?: string | null;
-    nodes: NodeStateMap<S>;
-    defaultState: S;
-};

package/dist/states.d.ts

@@ -1,9 +0,0 @@
-import type { DispatchFuncMap } from './dispatchFuncMap';
-import type { ClassState, NodeState, State } from './stateTypes';
-import type { ThunkModuleFunc } from './thunk';
-import type { UseThunk } from './useThunk';
-export declare const getDefaultID: <S extends State>(classState: ClassState<S>) => string;
-export declare const getNode: <S extends State>(classState: ClassState<S>, myID?: string) => NodeState<S> | null;
-export declare const getState: <S extends State>(classState: ClassState<S>, myID?: string) => S | null;
-export declare const mustGetState: <S extends State>(classState: ClassState<S>, myID?: string) => S;
-export declare const mustGetStateByThunk: <S extends State, R extends ThunkModuleFunc<S>>(theUseThunk: UseThunk<S, R>, myID?: string) => [S, DispatchFuncMap<S, R>, string];

package/dist/thunk.d.ts

@@ -1,15 +0,0 @@
-import type { ActionFunc } from './action';
-import type { Reducer } from './reducer';
-import type { State } from './stateTypes';
-export interface ThunkModuleBase<S extends State> {
-    [idx: string]: ActionFunc<S> | string | Reducer<S> | S | undefined;
-}
-export interface ThunkModuleFunc<S extends State> extends ThunkModuleBase<S> {
-    [action: string]: ActionFunc<S>;
-}
-export type ThunkModule<S extends State> = {
-    myClass: string;
-    default?: Reducer<S>;
-    defaultState: S;
-} & ThunkModuleBase<S>;
-export type ThunkModuleToFunc<T> = Omit<T, 'myClass' | 'default' | 'defaultState'>;

package/dist/thunkContextMap.d.ts

@@ -1,15 +0,0 @@
-import type { Context as rContext } from 'react';
-import type { ClassState } from './stateTypes';
-import type { Context } from './thunkContextTypes';
-export type ThunkContextMap = {
-    theMap: {
-        [classname: string]: {
-            context: rContext<Context<any>>;
-            refClassState: {
-                current: ClassState<any>;
-            };
-        };
-    };
-    theList: string[];
-};
-export declare const THUNK_CONTEXT_MAP: ThunkContextMap;

package/dist/thunkContextTypes.d.ts

@@ -1,8 +0,0 @@
-import type { Dispatch, SetStateAction } from 'react';
-import type { ClassState, State } from './stateTypes';
-export type Context<S extends State> = {
-    refClassState: {
-        current: ClassState<S>;
-    };
-    setClassState: Dispatch<SetStateAction<ClassState<S>>>;
-};

package/dist/thunkModuleFuncMap.d.ts

@@ -1,7 +0,0 @@
-export declare const DEFAULT_THUNK_MODULE_FUNC_MAP: {
-    init: <S extends import("./stateTypes").State>(params: import("./init").InitParams<S>, myuuidv4?: () => string) => import("./action").Thunk<S>;
-    update: <S extends import("./stateTypes").State>(myID: string, data: Partial<S>) => import("./action").BaseAction;
-    setData: <S extends import("./stateTypes").State>(myID: string, data: Partial<S>) => import("./action").BaseAction;
-    remove: <S extends import("./stateTypes").State>(myID: string) => import("./action").Thunk<S>;
-};
-export type DefaultThunkModuleFuncMap = typeof DEFAULT_THUNK_MODULE_FUNC_MAP;

package/dist/update.d.ts

@@ -1,6 +0,0 @@
-import type { BaseAction } from './action';
-import type { ClassState, 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>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/dist/useThunk.d.ts

@@ -1,12 +0,0 @@
-import { type DispatchFuncMap } from './dispatchFuncMap';
-import type { ClassState, State } from './stateTypes';
-import type { ThunkModule, ThunkModuleFunc } from './thunk';
-export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [
-    ClassState<S>,
-    DispatchFuncMap<S, R>
-];
-/**********
- * useThunk
- **********/
-declare const _default: <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModule<S>) => UseThunk<S, R>;
-export default _default;

package/dist/useThunkReducer.d.ts

@@ -1,17 +0,0 @@
-import { type Dispatch, type Reducer } from 'react';
-import type { BaseAction } from './action';
-import type { ClassState, State } from './stateTypes';
-export type Thunk<S extends State, A extends BaseAction> = (dispatch: Dispatch<ActionOrThunk<S, A>>, getClassState: () => ClassState<S>) => void;
-export type ActionOrThunk<S extends State, A extends BaseAction> = A | Thunk<S, A>;
-/**
- * useThunkReducer
- *
- * Augments React's useReducer() hook so that the action
- * dispatcher supports thunks.
- *
- * @param {Function} reducer
- * @param {string} className
- * @returns {[ClassState<S>, Dispatch]}
- */
-declare const _default: <S extends State, A extends BaseAction>(reducer: Reducer<ClassState<S>, A>, className: string) => [ClassState<S>, Dispatch<A | Thunk<S, A>>];
-export default _default;

package/src/action/ActionOrThunk.ts

@@ -1,5 +0,0 @@
-import type { State } from '../states'
-import type BaseAction from './baseAction'
-import type { Thunk } from './thunk'
-
-export type ActionOrThunk<S extends State> = BaseAction | Thunk<S>

package/src/action/baseAction.ts

@@ -1,6 +0,0 @@
-// BaseAction contains only object-based actions, no thunk-based actions.
-export default interface BaseAction {
-  myID: string
-  type: string
-  [key: string]: unknown
-}

package/src/action/index.ts

@@ -1,16 +0,0 @@
-import type { ModuleState, State } from '../states'
-import type { ActionOrThunk } from './ActionOrThunk'
-import type BaseAction from './baseAction'
-import type { Thunk } from './thunk'
-
-export type { Thunk, ActionOrThunk, BaseAction }
-
-// ActionFunc
-// biome-ignore lint/suspicious/noExplicitAny: params can be any type.
-export type ActionFunc<S extends State> = (...params: any[]) => ActionOrThunk<S>
-
-// biome-ignore lint/suspicious/noExplicitAny: params can by any type.
-export type ThunkFunc<S extends State> = (...params: any[]) => Thunk<S>
-
-// getModuleState
-export type getModuleState<S extends State> = () => ModuleState<S>

package/src/action/thunk.ts

@@ -1,13 +0,0 @@
-import type { dispatch } from '../dispatch'
-import type { get, getOrNull } from '../get'
-import type { set } from '../set'
-import type { ModuleState, State } from '../states'
-
-// Thunk
-export type Thunk<S extends State> = (
-  set: set<S>,
-  get: get<S>,
-  getOrNull: getOrNull<S>,
-  dispatch: dispatch<S>,
-  getModuleState: () => ModuleState<S>,
-) => void

package/src/defaultThunks/index.ts

@@ -1,15 +0,0 @@
-// default thunks will be used in thunkModule/defaultDoModule and defaultReduceMap
-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/src/defaultThunks/init/index.ts

@@ -1,27 +0,0 @@
-import type { Thunk } from '../../action'
-import type { State } from '../../states'
-import { genID } from '../../utils'
-import { setDefaultID } from '../setDefaultID'
-import initCore, { INIT, reduceInit } from './initCore'
-export { INIT, reduceInit }
-
-// InitParams
-export interface InitParams<S extends State> {
-  myID?: string
-  state: S
-}
-
-export const init = <S extends State>(params: InitParams<S>): Thunk<S> => {
-  return (set, _get, _getOrNull, _dispatch, getModuleState) => {
-    const myID = params.myID ?? genID()
-
-    const { state } = params
-    set(initCore(myID, state))
-
-    const { defaultID } = getModuleState()
-
-    if (!defaultID) {
-      set(setDefaultID(myID))
-    }
-  }
-}

package/src/defaultThunks/init/initCore.ts

@@ -1,31 +0,0 @@
-import type { BaseAction } from '../../action'
-import type { ModuleState, NodeState, NodeStateMap, State } from '../../states'
-
-export interface InitAction<S extends State> extends BaseAction {
-  state: S
-}
-
-export const INIT = '@chhsiao1981/use-thunk/INIT'
-export default <S extends State>(myID: string, state: S): InitAction<S> => {
-  return {
-    myID,
-    type: INIT,
-    state,
-  }
-}
-
-export const reduceInit = <S extends State>(
-  moduleState: ModuleState<S>,
-  action: BaseAction,
-): ModuleState<S> => {
-  const { myID, state } = action as InitAction<S>
-
-  const myNode: NodeState<S> = {
-    id: myID,
-    state: state,
-  }
-  const newNodes: NodeStateMap<S> = Object.assign({}, moduleState.nodes, { [myID]: myNode })
-  const newModuleState: ModuleState<S> = Object.assign({}, moduleState, { nodes: newNodes })
-
-  return newModuleState
-}

package/src/defaultThunks/remove.ts

@@ -1,35 +0,0 @@
-import type { BaseAction } from '../action'
-import type { ModuleState, NodeStateMap, State } from '../states'
-
-export const REMOVE = '@chhsiao1981/use-thunk/REMOVE'
-export const remove = (myID: string): BaseAction => ({
-  myID,
-  type: REMOVE,
-})
-
-export const reduceRemove = <S extends State>(
-  moduleState: ModuleState<S>,
-  action: BaseAction,
-): ModuleState<S> => {
-  const { myID } = action
-
-  const myNode = moduleState.nodes[myID]
-  if (!myNode) {
-    return moduleState
-  }
-
-  const newNodes = Object.keys(moduleState.nodes)
-    .filter((each) => each !== myID)
-    .reduce((r: NodeStateMap<S>, x) => {
-      r[x] = moduleState.nodes[x]
-      return r
-    }, {})
-
-  // defaultID
-  const newState = Object.assign({}, moduleState, { nodes: newNodes })
-  if (newState.defaultID === myID) {
-    newState.defaultID = null
-  }
-
-  return newState
-}

package/src/defaultThunks/setDefaultID.ts

@@ -1,18 +0,0 @@
-import type { BaseAction } from '../action'
-import type { ModuleState, State } from '../states'
-
-export const SET_DEFAULT_ID = '@chhsiao1981/use-thunk/SET_DEFAULT_ID'
-export const setDefaultID = (myID: string): BaseAction => ({
-  myID,
-  type: SET_DEFAULT_ID,
-})
-
-export const reduceSetDefaultID = <S extends State>(
-  moduleState: ModuleState<S>,
-  action: BaseAction,
-): ModuleState<S> => {
-  const { myID } = action
-
-  const toUpdate: Partial<ModuleState<S>> = { defaultID: myID, isInitDefaultID: true }
-  return Object.assign({}, moduleState, toUpdate)
-}

package/src/defaultThunks/update.ts

@@ -1,26 +0,0 @@
-import type { BaseAction } from '../action'
-import type { ModuleState, State } from '../states'
-
-export const UPDATE = '@chhsiao1981/use-thunk/UPDATE'
-export const update = <S extends State>(myID: string, data: Partial<S>): BaseAction => ({
-  myID,
-  type: UPDATE,
-  data,
-})
-
-export const reduceUpdate = <S extends State>(
-  moduleState: ModuleState<S>,
-  action: BaseAction,
-): ModuleState<S> => {
-  const { myID, data } = action
-
-  const myNode = moduleState.nodes[myID]
-  if (!myNode) return moduleState
-
-  const newMyState = Object.assign({}, myNode.state, data)
-  const newMyNode = Object.assign({}, myNode, { state: newMyState })
-  const newNodes = Object.assign({}, moduleState.nodes, { [myID]: newMyNode })
-  const newModuleState = Object.assign({}, moduleState, { nodes: newNodes })
-
-  return newModuleState
-}

package/src/defaultThunks/upsert.ts

@@ -1,27 +0,0 @@
-import type { BaseAction } from '../action'
-import type { ModuleState, NodeState, State } from '../states'
-import { deepCopy } from '../utils'
-
-export const UPSERT = '@chhsiao1981/use-thunk/UPSERT'
-export const upsert = <S extends State>(myID: string, data: Partial<S>): BaseAction => ({
-  myID,
-  type: UPSERT,
-  data,
-})
-
-export const reduceUpsert = <S extends State>(
-  moduleState: ModuleState<S>,
-  action: BaseAction,
-): ModuleState<S> => {
-  const { myID, data } = action
-
-  const myNode = moduleState.nodes[myID]
-  const node: NodeState<S> = myNode ?? { id: myID, state: deepCopy(moduleState.defaultState) }
-
-  const newState = Object.assign({}, node.state, data)
-  const newNode = Object.assign({}, node, { state: newState })
-  const newNodes = Object.assign({}, moduleState.nodes, { [myID]: newNode })
-  const newModuleState = Object.assign({}, moduleState, { nodes: newNodes })
-
-  return newModuleState
-}

package/src/dispatch.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'
-import type { State } from './states'
-
-// dispatch
-export type dispatch<S extends State> = Dispatch<ActionOrThunk<S>>

package/src/get.ts

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

@@ -1,58 +0,0 @@
-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'
-import { genID } from './utils'
-
-export {
-  // thunk definition.
-  type Thunk,
-  type set,
-  type get,
-  type getOrNull,
-  type dispatch,
-  type getModuleState,
-  // registerThunk / useThunk / ThunkContext
-  registerThunk,
-  useThunk,
-  type UseThunk,
-  ThunkContext,
-  // state related.
-  type State,
-  getState,
-  type ModuleState,
-  // module related.
-  type ThunkModule,
-  type toDoModule,
-  type doModule,
-  type ThunkFunc,
-  // default thunks.
-  init,
-  type InitParams,
-  update,
-  upsert,
-  remove,
-  // genID
-  genID,
-  // advanced usage.
-  type setMap,
-  setDefaultID,
-  getNodeOrNull,
-  getDefaultID,
-  getStateOrNullByModule,
-  getStateByModule,
-}

package/src/reducer/createReducer.ts

@@ -1,18 +0,0 @@
-import type { BaseAction } from '../action'
-import type { ModuleState, State } from '../states'
-import { DEFAULT_REDUCE_MAP } from './defaultReduceMap'
-import type { Reducer } from './index'
-
-export const createReducer = <S extends State>(): Reducer<S> => {
-  return (moduleState: ModuleState<S>, action: BaseAction): ModuleState<S> => {
-    if (!action) {
-      return moduleState
-    }
-
-    if (DEFAULT_REDUCE_MAP[action.type]) {
-      return DEFAULT_REDUCE_MAP[action.type](moduleState, action)
-    }
-
-    return moduleState
-  }
-}

package/src/reducer/defaultReduceMap.ts

@@ -1,26 +0,0 @@
-import {
-  INIT,
-  REMOVE,
-  reduceInit,
-  reduceRemove,
-  reduceSetDefaultID,
-  reduceUpdate,
-  reduceUpsert,
-  SET_DEFAULT_ID,
-  UPDATE,
-  UPSERT,
-} from '../defaultThunks'
-import type { ReduceMap } from './reduceMap'
-
-// biome-ignore lint/suspicious/noExplicitAny: DEFAULT_REDUCE_MAP can apply to any States.
-export const DEFAULT_REDUCE_MAP: ReduceMap<any> = {
-  [INIT]: reduceInit,
-  [UPDATE]: reduceUpdate,
-  [REMOVE]: reduceRemove,
-  [UPSERT]: reduceUpsert,
-
-  // 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/reducer/index.ts

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

package/src/reducer/reduceMap.ts

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

package/src/registerThunk.ts

@@ -1,29 +0,0 @@
-// Reason for registerThunk instead of createThunk:
-//   I feel that createThunk needs to return some object
-//   as the proof of successful creation.
-//   However, we register Thunks to the global state management
-//   system and return void.
-import { createContext, type Dispatch, type SetStateAction } from 'react'
-import type { ModuleState, State } from './states'
-import { THUNK_CONTEXT_MAP } from './thunkContext'
-import type { ThunkModule } from './thunkModule'
-
-export default <S extends State>(theDo: ThunkModule<S>) => {
-  const { name, defaultState } = theDo
-
-  if (THUNK_CONTEXT_MAP.theMap[name]) {
-    console.warn('registerThunk: already init:', name)
-    return
-  }
-
-  const moduleState: ModuleState<S> = { name, nodes: {}, defaultState }
-  const setModuleState: Dispatch<SetStateAction<ModuleState<S>>> = () => {}
-  const refModuleState = { current: moduleState }
-  const context = createContext({ refModuleState: refModuleState, setModuleState })
-
-  THUNK_CONTEXT_MAP.theMap[name] = { context, refModuleState }
-  const theList = Object.keys(THUNK_CONTEXT_MAP.theMap).sort()
-  THUNK_CONTEXT_MAP.theList = theList
-
-  console.info('registerThunk: done:', name)
-}

package/src/set/index.ts

@@ -1,9 +0,0 @@
-// XXX requiring to import directly from action/ActionOrThunk, or it will cause looping.
-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 }
-
-// set
-export type set<S extends State> = (actionOrID: ActionOrThunk<S> | string, data?: Partial<S>) => void