@chhsiao1981/use-thunk 12.0.0 → 14.0.0

package/dist/index.js

@@ -0,0 +1,173 @@
+import { createContext as e, useCallback as t, useContext as n, useMemo as r, useState as i } from "react";
+import { jsx as a } from "react/jsx-runtime";
+//#region src/utils/deepCopy.ts
+var o = (e) => {
+	if (typeof e != "object" || !e) return e;
+	if (e instanceof Date) return new Date(e.getTime());
+	if (Array.isArray(e)) return e.map((e) => o(e));
+	let t = {};
+	for (let n in e) e.hasOwnProperty(n) && (t[n] = o(e[n]));
+	return t;
+}, s = 1, c = () => (s += 1, `${s}`), l = "@chhsiao1981/use-thunk/SET_DEFAULT_ID", u = (e) => ({
+	myID: e,
+	type: l
+}), d = (e, t) => {
+	let { myID: n } = t;
+	return Object.assign({}, e, {
+		defaultID: n,
+		isInitDefaultID: !0
+	});
+}, f = "@chhsiao1981/use-thunk/INIT", p = (e, t) => ({
+	myID: e,
+	type: f,
+	state: t
+}), m = (e, t) => {
+	let { myID: n, state: r } = t, i = {
+		id: n,
+		state: r
+	}, a = Object.assign({}, e.nodes, { [n]: i });
+	return Object.assign({}, e, { nodes: a });
+}, h = (e) => (t, n, r, i, a) => {
+	let o = e.myID ?? c(), { state: s } = e;
+	t(p(o, s));
+	let { defaultID: l } = a();
+	l || t(u(o));
+}, g = "@chhsiao1981/use-thunk/UPDATE", _ = (e, t) => ({
+	myID: e,
+	type: g,
+	data: t
+}), v = (e, t) => {
+	let { myID: n, data: r } = t, i = e.nodes[n];
+	if (!i) return e;
+	let a = Object.assign({}, i.state, r), o = Object.assign({}, i, { state: a }), s = Object.assign({}, e.nodes, { [n]: o });
+	return Object.assign({}, e, { nodes: s });
+}, y = "@chhsiao1981/use-thunk/REMOVE", b = (e) => ({
+	myID: e,
+	type: y
+}), x = (e, t) => {
+	let { myID: n } = t;
+	if (!e.nodes[n]) return e;
+	let r = Object.keys(e.nodes).filter((e) => e !== n).reduce((t, n) => (t[n] = e.nodes[n], t), {}), i = Object.assign({}, e, { nodes: r });
+	return i.defaultID === n && (i.defaultID = null), i;
+}, S = "@chhsiao1981/use-thunk/UPSERT", C = (e, t) => ({
+	myID: e,
+	type: S,
+	data: t
+}), w = (e, t) => {
+	let { myID: n, data: r } = t, i = e.nodes[n] ?? {
+		id: n,
+		state: o(e.defaultState)
+	}, a = Object.assign({}, i.state, r), s = Object.assign({}, i, { state: a }), c = Object.assign({}, e.nodes, { [n]: s });
+	return Object.assign({}, e, { nodes: c });
+}, T = {
+	theMap: {},
+	theList: []
+}, E = (e) => {
+	let { modules: t, children: n } = e, o = t || T.theList;
+	if (o.length === 0) return n;
+	let s = o[0], { context: c, refModuleState: l } = T.theMap[s], [u, d] = i(l.current);
+	l.current = u;
+	let f = r(() => ({
+		refModuleState: l,
+		setModuleState: d
+	}), [u]), p = o.length === 1 ? n : E({
+		modules: o.slice(1),
+		children: n
+	});
+	return /* @__PURE__ */ a(c.Provider, {
+		value: f,
+		children: p
+	});
+}, D = (t) => {
+	let { name: n, defaultState: r } = t;
+	if (T.theMap[n]) {
+		console.warn("registerThunk: already init:", n);
+		return;
+	}
+	let i = {
+		name: n,
+		nodes: {},
+		defaultState: r
+	}, a = () => {}, o = { current: i }, s = e({
+		refModuleState: o,
+		setModuleState: a
+	});
+	T.theMap[n] = {
+		context: s,
+		refModuleState: o
+	}, T.theList = Object.keys(T.theMap).sort(), console.info("registerThunk: done:", n);
+}, O = (e) => e.defaultID ?? "", k = (e, t) => {
+	let n = t || O(e);
+	return n && e.nodes[n] || null;
+}, A = (e, t) => {
+	let n = t || O(e);
+	if (!n) return null;
+	let r = e.nodes[n];
+	return r ? r.state : null;
+}, j = (e, t) => {
+	let n = t || O(e) || c(), r = A(e, n);
+	if (r) return r;
+	let i = o(e.defaultState), a = {
+		id: n,
+		state: i
+	};
+	return e.nodes[n] = a, e.isInitDefaultID || e.defaultID || (e.defaultID = n, e.isInitDefaultID = !0), i;
+}, M = (e, t) => {
+	let [n, r] = e, i = t || O(n);
+	return [
+		j(n, i),
+		r,
+		i
+	];
+}, N = {
+	[f]: m,
+	[g]: v,
+	[y]: x,
+	[S]: w,
+	[l]: d
+}, P = () => (e, t) => t && N[t.type] ? N[t.type](e, t) : e, F = {
+	init: h,
+	update: _,
+	remove: b
+}, I = (e, t, n) => (Object.keys(e).filter((t) => typeof e[t] == "function").reduce((n, r) => {
+	if (n[r]) return n;
+	let i = e[r];
+	return n[r] = (...e) => t(i(...e)), n;
+}, n), Object.keys(F).reduce((e, n) => {
+	if (e[n]) return e;
+	let r = F[n];
+	return e[n] = (...e) => t(r(...e)), e;
+}, n), n), L = (e, r) => {
+	let { context: i } = T.theMap[r], { refModuleState: a, setModuleState: o } = n(i), s = t(() => a.current, [a]), c = t((e) => {
+		a.current = e, o(e);
+	}, [a, o]), l = t((e) => A(s(), e), [s]), u = t((e) => j(s(), e), [s]), d = t((t) => e(s(), t), [e, s]), f = t((e) => {
+		if (typeof e == "function") {
+			e(p, u, l, f, s);
+			return;
+		}
+		c(d(e));
+	}, [
+		s,
+		c,
+		d
+	]), p = t((e, t) => {
+		if (typeof e == "string") {
+			if (!t) return;
+			c(d(C(e, t)));
+			return;
+		}
+		f(e);
+	}, [
+		s,
+		c,
+		d
+	]);
+	return [a.current, p];
+}, R = {}, z = (e) => {
+	let { name: t } = e, n = !R[t];
+	n && (R[t] = {});
+	let i = R[t], [a, o] = L(r(() => P(), []), t), s = r(() => [a, i], [a, i]);
+	return n && I(e, o, i), s;
+};
+//#endregion
+export { E as ThunkContext, c as genID, O as getDefaultID, k as getNodeOrNull, M as getState, j as getStateByModule, A as getStateOrNullByModule, h as init, D as registerThunk, b as remove, u as setDefaultID, _ as update, C as upsert, z as useThunk };

package/dist/index.umd.cjs

@@ -0,0 +1 @@
+(function(e,t){typeof exports==`object`&&typeof module<`u`?t(exports,require("react"),require("react/jsx-runtime")):typeof define==`function`&&define.amd?define([`exports`,`react`,`react/jsx-runtime`],t):(e=typeof globalThis<`u`?globalThis:e||self,t(e[`@chhsiao1981/use-thunk`]={},e.React,e.ReactJSXRuntime))})(this,function(e,t,n){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var r=e=>{if(typeof e!=`object`||!e)return e;if(e instanceof Date)return new Date(e.getTime());if(Array.isArray(e))return e.map(e=>r(e));let t={};for(let n in e)e.hasOwnProperty(n)&&(t[n]=r(e[n]));return t},i=1,a=()=>(i+=1,`${i}`),o=`@chhsiao1981/use-thunk/SET_DEFAULT_ID`,s=e=>({myID:e,type:o}),c=(e,t)=>{let{myID:n}=t;return Object.assign({},e,{defaultID:n,isInitDefaultID:!0})},l=`@chhsiao1981/use-thunk/INIT`,u=(e,t)=>({myID:e,type:l,state:t}),d=(e,t)=>{let{myID:n,state:r}=t,i={id:n,state:r},a=Object.assign({},e.nodes,{[n]:i});return Object.assign({},e,{nodes:a})},f=e=>(t,n,r,i,o)=>{let c=e.myID??a(),{state:l}=e;t(u(c,l));let{defaultID:d}=o();d||t(s(c))},p=`@chhsiao1981/use-thunk/UPDATE`,m=(e,t)=>({myID:e,type:p,data:t}),h=(e,t)=>{let{myID:n,data:r}=t,i=e.nodes[n];if(!i)return e;let a=Object.assign({},i.state,r),o=Object.assign({},i,{state:a}),s=Object.assign({},e.nodes,{[n]:o});return Object.assign({},e,{nodes:s})},g=`@chhsiao1981/use-thunk/REMOVE`,_=e=>({myID:e,type:g}),v=(e,t)=>{let{myID:n}=t;if(!e.nodes[n])return e;let r=Object.keys(e.nodes).filter(e=>e!==n).reduce((t,n)=>(t[n]=e.nodes[n],t),{}),i=Object.assign({},e,{nodes:r});return i.defaultID===n&&(i.defaultID=null),i},y=`@chhsiao1981/use-thunk/UPSERT`,b=(e,t)=>({myID:e,type:y,data:t}),x=(e,t)=>{let{myID:n,data:i}=t,a=e.nodes[n]??{id:n,state:r(e.defaultState)},o=Object.assign({},a.state,i),s=Object.assign({},a,{state:o}),c=Object.assign({},e.nodes,{[n]:s});return Object.assign({},e,{nodes:c})},S={theMap:{},theList:[]},C=e=>{let{modules:r,children:i}=e,a=r||S.theList;if(a.length===0)return i;let o=a[0],{context:s,refModuleState:c}=S.theMap[o],[l,u]=(0,t.useState)(c.current);c.current=l;let d=(0,t.useMemo)(()=>({refModuleState:c,setModuleState:u}),[l]),f=a.length===1?i:C({modules:a.slice(1),children:i});return(0,n.jsx)(s.Provider,{value:d,children:f})},w=e=>{let{name:n,defaultState:r}=e;if(S.theMap[n]){console.warn(`registerThunk: already init:`,n);return}let i={name:n,nodes:{},defaultState:r},a=()=>{},o={current:i},s=(0,t.createContext)({refModuleState:o,setModuleState:a});S.theMap[n]={context:s,refModuleState:o},S.theList=Object.keys(S.theMap).sort(),console.info(`registerThunk: done:`,n)},T=e=>e.defaultID??``,E=(e,t)=>{let n=t||T(e);return n&&e.nodes[n]||null},D=(e,t)=>{let n=t||T(e);if(!n)return null;let r=e.nodes[n];return r?r.state:null},O=(e,t)=>{let n=t||T(e)||a(),i=D(e,n);if(i)return i;let o=r(e.defaultState),s={id:n,state:o};return e.nodes[n]=s,e.isInitDefaultID||e.defaultID||(e.defaultID=n,e.isInitDefaultID=!0),o},k=(e,t)=>{let[n,r]=e,i=t||T(n);return[O(n,i),r,i]},A={[l]:d,[p]:h,[g]:v,[y]:x,[o]:c},j=()=>(e,t)=>t&&A[t.type]?A[t.type](e,t):e,M={init:f,update:m,remove:_},N=(e,t,n)=>(Object.keys(e).filter(t=>typeof e[t]==`function`).reduce((n,r)=>{if(n[r])return n;let i=e[r];return n[r]=(...e)=>t(i(...e)),n},n),Object.keys(M).reduce((e,n)=>{if(e[n])return e;let r=M[n];return e[n]=(...e)=>t(r(...e)),e},n),n),P=(e,n)=>{let{context:r}=S.theMap[n],{refModuleState:i,setModuleState:a}=(0,t.useContext)(r),o=(0,t.useCallback)(()=>i.current,[i]),s=(0,t.useCallback)(e=>{i.current=e,a(e)},[i,a]),c=(0,t.useCallback)(e=>D(o(),e),[o]),l=(0,t.useCallback)(e=>O(o(),e),[o]),u=(0,t.useCallback)(t=>e(o(),t),[e,o]),d=(0,t.useCallback)(e=>{if(typeof e==`function`){e(f,l,c,d,o);return}s(u(e))},[o,s,u]),f=(0,t.useCallback)((e,t)=>{if(typeof e==`string`){if(!t)return;s(u(b(e,t)));return}d(e)},[o,s,u]);return[i.current,f]},F={};e.ThunkContext=C,e.genID=a,e.getDefaultID=T,e.getNodeOrNull=E,e.getState=k,e.getStateByModule=O,e.getStateOrNullByModule=D,e.init=f,e.registerThunk=w,e.remove=_,e.setDefaultID=s,e.update=m,e.upsert=b,e.useThunk=e=>{let{name:n}=e,r=!F[n];r&&(F[n]={});let i=F[n],[a,o]=P((0,t.useMemo)(()=>j(),[]),n),s=(0,t.useMemo)(()=>[a,i],[a,i]);return r&&N(e,o,i),s}});

package/dist/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/dist/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 → dist/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/dist/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 → dist/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/dist/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/dist/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/dist/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 → dist/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/dist/thunkContext/ThunkContext.d.ts

@@ -0,0 +1,7 @@
+import { type JSX, type ReactNode } from 'react';
+type Props = {
+    modules?: string[];
+    children?: ReactNode;
+};
+declare const ThunkContext: (props: Props) => JSX.Element;
+export default ThunkContext;

package/dist/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 → dist/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 → dist/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/dist/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/dist/thunkModule/index.d.ts

@@ -0,0 +1,13 @@
+import type { ThunkFunc } from '../action';
+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;
+    defaultState: S;
+    [action: string]: ThunkFunc<S> | string | S;
+};
+export type toDoModule<T extends ThunkModule<any>> = Omit<T, 'name' | 'defaultState'>;

package/dist/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 → dist/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/dist/utils/deepCopy.d.ts

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

package/dist/utils/genID.d.ts

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

package/dist/utils/index.d.ts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chhsiao1981/use-thunk",
-  "version": "12.0.0",
+  "version": "14.0.0",
   "type": "module",
   "description": "A framework easily using useThunk to manage the data-state.",
   "homepage": "https://github.com/chhsiao1981/use-thunk",
@@ -8,12 +8,19 @@
     "type": "git",
     "url": "https://github.com/chhsiao1981/use-thunk"
   },
-  "main": "src/index.ts",
-  "types": "types/index.d.ts",
+  "main": "dist/index.umd.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.umd.cjs",
+      "default": "./dist/index.umd.cjs"
+    }
+  },
   "files": [
-    "src",
-    "dist",
-    "types"
+    "dist"
   ],
   "author": {
     "name": "Chuan-Heng Hsiao",
@@ -24,40 +31,38 @@
     "useThunk"
   ],
   "scripts": {
-    "clean:lib": "rimraf ./dist/* ./types/*",
     "compile:lib": "vite build",
-    "build:lib": "npm run clean:lib && npm run types && npm run compile:lib",
-    "build": "npm run build:lib",
+    "compile:types": "tsc -b",
+    "build": "npm run compile:lib && npm run compile:types",
+
     "lint": "biome lint --error-on-warnings",
     "test": "vitest run",
-    "types": "tsc -b",
-    "coverage": "vitest run --coverage --reporter=junit --outputFile=test-report.junit.xml",
-    "tsd": "npx -p typescript tsc src/*.ts --declaration --allowJs --emitDeclarationOnly --strict --jsx react-jsx --outDir types"
+    "coverage": "vitest run --coverage --reporter=junit --outputFile=test-report.junit.xml"
   },
   "license": "MIT",
   "devDependencies": {
-    "@codecov/vite-plugin": "^1.9.1",
-    "@eslint/js": "^9.39.4",
-    "@types/node": "^25.5.0",
-    "@types/react": ">=18.3.1",
+    "@babel/core": "^7.29.0",
+    "@biomejs/biome": "^2.5.1",
+    "@rolldown/plugin-babel": "^0.2.3",
+    "@types/babel__core": "^7.20.5",
+    "@types/node": "^25.9.3",
     "@types/react-dom": ">=18.3.1",
-    "@vitejs/plugin-react-swc": "^4.3.0",
-    "@vitest/coverage-v8": "^4.1.0",
-    "eslint": "^9.39.4",
-    "eslint-plugin-react-hooks": "^7.0.1",
-    "eslint-plugin-react-refresh": "^0.5.2",
-    "globals": "^17.4.0",
-    "happy-dom": "^20.8.4",
-    "jiti": "^2.6.1",
+    "@vitejs/plugin-react": "^6.0.1",
+    "@vitest/coverage-v8": "^4.1.8",
+    "babel-plugin-react-compiler": "^1.0.0",
+    "globals": "^17.6.0",
+    "happy-dom": "^20.10.2",
+    "jiti": "^2.7.0",
     "react-dom": ">=18.3.1",
-    "rimraf": "^6.1.3",
     "typescript": "~5.9.3",
-    "typescript-eslint": "^8.57.1",
-    "vite": "^6.4.1",
-    "vitest": "^4.1.0"
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8"
+  },
+  "dependencies": {
+    "react-compiler-runtime": "^1.0.0"
   },
   "peerDependencies": {
-    "react": ">=18.3.1",
-    "uuid": "^14.0.0"
+    "@types/react": ">=18.3.1",
+    "react": ">=18.3.1"
   }
 }

package/dist/ThunkContext.d.ts

@@ -1,7 +0,0 @@
-import { type ReactNode } from 'react';
-type Props = {
-    classes?: string[];
-    children?: ReactNode;
-};
-declare const ThunkContext: (props: Props) => ReactNode;
-export default ThunkContext;

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>>>;
-};