@chhsiao1981/use-thunk 9.0.0

package/src/thunkModuleFuncMap.ts

@@ -0,0 +1,22 @@
+import { addChild } from './addChild'
+import { addLink } from './addLink'
+import { init } from './init'
+import { remove } from './remove'
+import { removeChild } from './removeChild'
+import { removeLink } from './removeLink'
+import { setData } from './setData'
+
+export const DEFAULT_THUNK_MODULE_FUNC_MAP = {
+  init,
+  setData,
+  remove,
+
+  addChild,
+
+  removeChild,
+
+  addLink,
+  removeLink,
+}
+
+export type DefaultThunkModuleFuncMap = typeof DEFAULT_THUNK_MODULE_FUNC_MAP

package/src/thunkReducer.ts

@@ -0,0 +1,73 @@
+//https://medium.com/solute-labs/configuring-thunk-action-creators-and-redux-dev-tools-with-reacts-usereducer-hook-5a1608476812
+//https://github.com/nathanbuchar/react-hook-thunk-reducer/blob/master/src/thunk-reducer.js
+
+import { type Dispatch, type Reducer, useCallback, useRef, useState } from 'react'
+import type { BaseAction } from './action'
+import type { State } from './stateTypes'
+
+export type Thunk<S extends State, A extends BaseAction> = (
+  dispatch: Dispatch<ActionOrThunk<S, A>>,
+  getState: () => 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 {State} initArg
+ * @param {Function} [init]
+ * @returns {[State, Dispatch]}
+ */
+export default <S extends State, A extends BaseAction>(
+  reducer: Reducer<S, A>,
+  initArg: S,
+  // biome-ignore lint/suspicious/noExplicitAny: params can by any types.
+  init?: (...params: any[]) => S,
+): [S, Dispatch<A | Thunk<S, A>>] => {
+  // 1. initState
+  const initState = init ? () => init(initArg) : initArg
+
+  // 2. renderState
+  const [renderState, setRenderState] = useState(initState)
+
+  // 3. hookState
+  const hookState = renderState
+
+  // 4. state management.
+  const state = useRef(hookState)
+  const getState = useCallback(() => state.current, [state])
+  const setState = useCallback(
+    (newState: S) => {
+      state.current = newState
+      setRenderState(newState)
+    },
+    [state, setRenderState],
+  )
+
+  // 5. reducer.
+  const reduce = useCallback(
+    (action: A): S => {
+      return reducer(getState(), action)
+    },
+    [reducer, getState],
+  )
+
+  // augmented dispatcher.
+  const dispatch = useCallback(
+    (action: A | Thunk<S, A>) => {
+      if (typeof action === 'function') {
+        action(dispatch, getState)
+        return
+      }
+
+      setState(reduce(action))
+    },
+    [getState, setState, reduce],
+  )
+
+  return [hookState, dispatch]
+}

package/src/useThunk.ts

@@ -0,0 +1,93 @@
+import { useRef, useState } from 'react'
+import type { ActionFunc } from './action'
+import { createReducer } from './createReducer'
+import type { DispatchFuncMap, DispatchFuncMapByClassMap, RefDispatchFuncMapByClassMap } from './dispatchFuncMap'
+import type { ClassState, NodeStateMap, State, StateType } from './stateTypes'
+import type { ThunkModule, ThunkModuleFunc } from './thunk'
+import { DEFAULT_THUNK_MODULE_FUNC_MAP } from './thunkModuleFuncMap'
+import useThunkReducer from './thunkReducer'
+
+/**********
+ * useThunk
+ **********/
+export default <S extends State, R extends ThunkModuleFunc<S>>(
+  theDo: ThunkModule<S, R>,
+  // biome-ignore lint/suspicious/noExplicitAny: params can by any types.
+  init?: (...params: any[]) => S,
+): [ClassState<S>, DispatchFuncMap<S, R>] => {
+  const { myClass } = theDo
+
+  // 1. dispatchMapByClass
+  const refDispatchMapByClass: RefDispatchFuncMapByClassMap<S, R> = useRef({})
+  const dispatchMapByClass: DispatchFuncMapByClassMap<S, R> = refDispatchMapByClass.current
+
+  // 2. It requires shared nodes for the same class to have the same dispatchMap.
+  // We don't optimize the dispatchMap in this PR.
+  const isFirstTime = !dispatchMapByClass[myClass]
+  if (isFirstTime) {
+    // @ts-expect-error {} is a kind of DispatchFuncMap<S, R>
+    dispatchMapByClass[myClass] = {}
+  }
+  const dispatchMap = dispatchMapByClass[myClass]
+
+  // 3. local nodes
+  const nodes: NodeStateMap<S> = {}
+
+  // 4. reducer.
+  //    using useState to have theDo.default as optional.
+  //    theReducer won't be changed.
+  //
+  //    theReducer is different for different reducers,
+  //    even within the same class.
+  //    However, because theReducer is a pure function
+  //    having ClassState as the input. It is ok to have
+  //    different reducers within the same class.
+  const [theReducer, _] = useState(() => theDo.default ?? createReducer<S>())
+
+  // 5. useThunkReducer
+  const [state, dispatch] = useThunkReducer(
+    theReducer,
+    {
+      myClass,
+      // @ts-expect-error doMe is a hidden variable for ClassState
+      doMe: dispatchMap,
+      nodes,
+    },
+    init,
+  )
+
+  // 7. the dispatchMap is always the same.
+  //    we can do early return if not first time.
+  if (!isFirstTime) {
+    return [state, dispatchMap]
+  }
+
+  // 8. setup dispatchMap
+  Object.keys(theDo)
+    // default and myClass are reserved words.
+    // functions starting reduce are included in default and not exported.
+    .filter((each) => typeof theDo[each] === 'function')
+    .reduce((val, eachAction) => {
+      const action: ActionFunc<S> = theDo[eachAction]
+      // @ts-expect-error eachAction is in DispatchFuncMap<S, R>
+      // biome-ignore lint/suspicious/noExplicitAny: action parameters can be any types.
+      val[eachAction] = (...params: any[]) => dispatch(action(...params))
+      return val
+    }, dispatchMap)
+
+  // 9. default functions for disapatchMap
+  Object.keys(DEFAULT_THUNK_MODULE_FUNC_MAP).reduce((val, eachAction) => {
+    if (val[eachAction]) {
+      return val
+    }
+    // @ts-expect-error DEFAULT_REDUCER_MODULE_FUNCS are all ActionFunc<S>
+    const action: ActionFunc<S> = DEFAULT_THUNK_MODULE_FUNC_MAP[eachAction]
+
+    // @ts-expect-error eachAction is in DispatchFuncMap<S, R>
+    // biome-ignore lint/suspicious/noExplicitAny: action parameters can be any types.
+    val[eachAction] = (...params: any[]) => dispatch(action(...params))
+    return val
+  }, dispatchMap)
+
+  return [state, dispatchMap]
+}

package/types/action.d.ts

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

package/types/addChild.d.ts

@@ -0,0 +1,5 @@
+import { type AddRelationAction } from './addRelation';
+import { type ClassState, type NodeMeta, type State } from './stateTypes';
+export declare const ADD_CHILD = "@chhsiao1981/use-thunk/ADD_CHILD";
+export declare const addChild: (myID: string, child: NodeMeta) => AddRelationAction;
+export declare const reduceAddChild: <S extends State>(state: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addLink.d.ts

@@ -0,0 +1,6 @@
+import type { Thunk } from './action';
+import { type AddRelationAction } from './addRelation';
+import { type ClassState, type NodeMeta, type State } from './stateTypes';
+export declare const addLink: <S extends State>(myID: string, link: NodeMeta, isFromLink?: boolean) => Thunk<S>;
+export declare const ADD_LINK = "@chhsiao1981/use-thunk/ADD_LINK";
+export declare const reduceAddLink: <S extends State>(state: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addRelation.d.ts

@@ -0,0 +1,6 @@
+import type { BaseAction } from './action';
+import type { ClassState, NodeMeta, Relation, State } from './stateTypes';
+export interface AddRelationAction extends BaseAction {
+    relaton: NodeMeta;
+}
+export declare const reduceAddRelation: <S extends State>(state: ClassState<S>, action: AddRelationAction, relationName: Relation) => ClassState<S>;

package/types/createReducer.d.ts

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

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

package/types/dispatchFuncMap.d.ts

@@ -0,0 +1,17 @@
+import type { State } from './stateTypes';
+import type { ThunkModuleFunc } from './thunk';
+import type { DefaultThunkModuleFuncMap } from './thunkModuleFuncMap';
+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 interface RefDispatchFuncMapByClassMap<S extends State, T extends ThunkModuleFunc<S>> {
+    current: DispatchFuncMapByClassMap<S, T>;
+}
+export {};

package/types/genUUID.d.ts

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

package/types/getRelation.d.ts

@@ -0,0 +1,5 @@
+import { type NodeState, type State } from './stateTypes';
+export declare const getChildIDs: <S extends State>(me: NodeState<S>, childClass: string) => string[];
+export declare const getChildID: <S extends State>(me: NodeState<S>, childClass: string) => string;
+export declare const getLinkIDs: <S extends State>(me: NodeState<S>, linkClass: string) => string[];
+export declare const getLinkID: <S extends State>(me: NodeState<S>, linkClass: string) => string;

package/types/index.d.ts

@@ -0,0 +1,19 @@
+import type { GetClassState, Thunk } from './action';
+import { addChild } from './addChild';
+import { addLink } from './addLink';
+import type { AddRelationAction } from './addRelation';
+import type { Dispatch } from './dispatch';
+import type { DispatchFuncMap } from './dispatchFuncMap';
+import { genUUID } from './genUUID';
+import { getChildID, getChildIDs, getLinkID, getLinkIDs } from './getRelation';
+import { type InitParams, init } from './init';
+import { remove } from './remove';
+import { removeChild } from './removeChild';
+import { removeLink } from './removeLink';
+import type { RemoveRelationAction } from './removeRelation';
+import { setData } from './setData';
+import { getNode, getRootID, getState } from './states';
+import type { ClassState, NodeMeta, NodeState, NodeStateMap, State } from './stateTypes';
+import type { ThunkModule, ThunkModuleToFunc } from './thunk';
+import useThunk from './useThunk';
+export { useThunk, type State, type NodeState, type NodeMeta, type NodeStateMap, type ClassState, type GetClassState, type Thunk, type ThunkModule, type ThunkModuleToFunc, type Dispatch, type DispatchFuncMap, getRootID, getNode, getState, getChildIDs, getChildID, getLinkIDs, getLinkID, init, type InitParams, setData, remove, addChild, removeChild, addLink, removeLink, type AddRelationAction, type RemoveRelationAction, genUUID, };

package/types/init.d.ts

@@ -0,0 +1,19 @@
+import type { BaseAction, Thunk } from './action';
+import { type ClassState, type State } from './stateTypes';
+export interface InitParams<S extends State> {
+    myID?: string;
+    parentID?: string;
+    doParent?: DispatchFuncMap;
+    parentClass?: 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>(state: ClassState<S>, action: InitAction<S>) => ClassState<S>;
+export {};

package/types/reduceMap.d.ts

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

@@ -0,0 +1,5 @@
+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/types/reducerModuleFuncMap.d.ts

@@ -0,0 +1,10 @@
+export declare const DEFAULT_REDUCER_MODULE_FUNC_MAP: {
+    init: <S extends import("./stateTypes").State>(params: import("./init").InitParams<S>, myuuidv4?: () => string) => import("./action").Thunk<S>;
+    setData: <S extends import("./stateTypes").State>(myID: string, data: S) => import("./action").BaseAction;
+    remove: <S extends import("./stateTypes").State>(myID: string, isFromParent?: boolean) => import("./action").Thunk<S>;
+    addChild: (myID: string, child: import("./stateTypes").NodeMeta) => import("./addRelation").AddRelationAction;
+    removeChild: <S extends import("./stateTypes").State>(myID: string, childID: string, childClass: string, isFromChild?: boolean) => import("./action").Thunk<S>;
+    addLink: <S extends import("./stateTypes").State>(myID: string, link: import("./stateTypes").NodeMeta, isFromLink?: boolean) => import("./action").Thunk<S>;
+    removeLink: <S extends import("./stateTypes").State>(myID: string, linkID: string, linkClass: string, isFromLink?: boolean) => import("./action").Thunk<S>;
+};
+export type DefaultReducerModuleFuncMap = typeof DEFAULT_REDUCER_MODULE_FUNC_MAP;

package/types/remove.d.ts

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

package/types/removeChild.d.ts

@@ -0,0 +1,9 @@
+import type { Thunk } from './action';
+import { type RemoveRelationAction } from './removeRelation';
+import { type ClassState, type State } from './stateTypes';
+/***
+ * remove-child
+ */
+export declare const removeChild: <S extends State>(myID: string, childID: string, childClass: string, isFromChild?: boolean) => Thunk<S>;
+export declare const REMOVE_CHILD = "@chhsiao1981/use-thunk/REMOVE_CHILD";
+export declare const reduceRemoveChild: <S extends State>(state: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeLink.d.ts

@@ -0,0 +1,9 @@
+import type { Thunk } from './action';
+import { type RemoveRelationAction } from './removeRelation';
+import { type ClassState, type State } from './stateTypes';
+/***
+ * remove-link
+ */
+export declare const removeLink: <S extends State>(myID: string, linkID: string, linkClass: string, isFromLink?: boolean) => Thunk<S>;
+export declare const REMOVE_LINK = "@chhsiao1981/use-thunk/REMOVE_LINK";
+export declare const reduceRemoveLink: <S extends State>(state: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeRelation.d.ts

@@ -0,0 +1,12 @@
+import type { BaseAction, GetClassState } from './action';
+import type { Dispatch } from './dispatch';
+import type { ClassState, Relation, State } from './stateTypes';
+export interface RemoveRelationAction extends BaseAction {
+    relationID: string;
+    relationClass: string;
+}
+type RelationRemove = (theDo: DispatchFuncMap) => void;
+type RemoveRelationCore = (myID: string, relationID: string, relationClass: string) => BaseAction;
+export declare const removeRelation: <S extends State>(dispatch: Dispatch<S>, getClassState: GetClassState<S>, myID: string, relationID: string, relationClass: string, isFromRelation: boolean, relationRemove: RelationRemove, removeRelationCore: RemoveRelationCore, relationName: Relation) => void;
+export declare const reduceRemoveRelation: <S extends State>(state: ClassState<S>, myID: string, relationID: string, relationClass: string, relationName: Relation.LINKS | Relation.CHILDREN) => ClassState<S>;
+export {};

package/types/setData.d.ts

@@ -0,0 +1,5 @@
+import type { BaseAction } from './action';
+import type { ClassState, State } from './stateTypes';
+export declare const SET_DATA = "@chhsiao1981/use-thunk/SET_DATA";
+export declare const setData: <S extends State>(myID: string, data: S) => BaseAction;
+export declare const reduceSetData: <S extends State>(state: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/setRoot.d.ts

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

package/types/stateTypes.d.ts

@@ -0,0 +1,42 @@
+export declare enum StateType {
+    LOCAL = "local"
+}
+export declare enum Relation {
+    CHILDREN = "_children",
+    LINKS = "_links"
+}
+export declare const PARENT = "_parent";
+export interface State {
+    [key: string]: unknown;
+}
+export type NodeState<S extends State> = {
+    id: string;
+    state: S;
+    [Relation.CHILDREN]?: NodeStateRelationMap | null;
+    [PARENT]?: NodeMeta | null;
+    [Relation.LINKS]?: NodeStateRelationMap | null;
+};
+type NodeStateRelationMap = {
+    [relationClass: string]: NodeStateRelation;
+};
+type NodeStateRelation = {
+    list: string[];
+    do: DispatchFuncMap;
+};
+export type NodeStateMap<S extends State> = {
+    [key: string]: NodeState<S>;
+};
+export type NodeStateMapByClass<S extends State> = {
+    [className: string]: NodeStateMap<S>;
+};
+export type ClassState<S extends State> = {
+    myClass: string;
+    root?: string | null;
+    nodes: NodeStateMap<S>;
+};
+export type NodeMeta = {
+    id: string;
+    theClass: string;
+    do: DispatchFuncMap;
+};
+export {};

package/types/states.d.ts

@@ -0,0 +1,6 @@
+import type { ClassState, NodeState, State } from './stateTypes';
+export declare const getRootNode: <S extends State>(state: ClassState<S>) => NodeState<S> | null;
+export declare const getRootID: <S extends State>(state: ClassState<S>) => string;
+export declare const getRoot: <S extends State>(state: ClassState<S>) => S | null;
+export declare const getNode: <S extends State>(state: ClassState<S>, myID?: string) => NodeState<S> | null;
+export declare const getState: <S extends State>(state: ClassState<S>, myID?: string) => S | null;

package/types/thunk-reducer.d.ts

@@ -0,0 +1,16 @@
+import { type Dispatch, type Reducer } from 'react';
+export type Thunk<State, BaseAction> = (dispatch: Dispatch<ActionOrThunk<State, BaseAction>>, getState: () => State) => void;
+export type ActionOrThunk<State, BaseAction> = BaseAction | Thunk<State, BaseAction>;
+/**
+ * useThunkReducer
+ *
+ * Augments React's useReducer() hook so that the action
+ * dispatcher supports thunks.
+ *
+ * @param {Function} reducer
+ * @param {Sas} initArg
+ * @param {Function} [init]
+ * @returns {[Sas, Dispatch]}
+ */
+export declare const useThunkReducer: <State, BaseAction>(reducer: Reducer<State, BaseAction>, initArg: State, init?: (s: State) => State) => [State, Dispatch<BaseAction | Thunk<State, BaseAction>>];
+export default useThunkReducer;

package/types/thunk.d.ts

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

package/types/thunkModuleFuncMap.d.ts

@@ -0,0 +1,10 @@
+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>;
+    setData: <S extends import("./stateTypes").State>(myID: string, data: S) => import("./action").BaseAction;
+    remove: <S extends import("./stateTypes").State>(myID: string, isFromParent?: boolean) => import("./action").Thunk<S>;
+    addChild: (myID: string, child: import("./stateTypes").NodeMeta) => import("./addRelation").AddRelationAction;
+    removeChild: <S extends import("./stateTypes").State>(myID: string, childID: string, childClass: string, isFromChild?: boolean) => import("./action").Thunk<S>;
+    addLink: <S extends import("./stateTypes").State>(myID: string, link: import("./stateTypes").NodeMeta, isFromLink?: boolean) => import("./action").Thunk<S>;
+    removeLink: <S extends import("./stateTypes").State>(myID: string, linkID: string, linkClass: string, isFromLink?: boolean) => import("./action").Thunk<S>;
+};
+export type DefaultThunkModuleFuncMap = typeof DEFAULT_THUNK_MODULE_FUNC_MAP;

package/types/thunkReducer.d.ts

@@ -0,0 +1,18 @@
+import { type Dispatch, type Reducer } from 'react';
+import type { BaseAction } from './action';
+import type { State } from './stateTypes';
+export type Thunk<S extends State, A extends BaseAction> = (dispatch: Dispatch<ActionOrThunk<S, A>>, getState: () => 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 {State} initArg
+ * @param {Function} [init]
+ * @returns {[State, Dispatch]}
+ */
+declare const _default: <S extends State, A extends BaseAction>(reducer: Reducer<S, A>, initArg: S, init?: (...params: any[]) => S) => [S, Dispatch<A | Thunk<S, A>>];
+export default _default;

package/types/useReducer.d.ts

@@ -0,0 +1,8 @@
+import type { DispatchFuncMap } from './dispatchFuncMap';
+import type { ReducerModule, ReducerModuleFunc } from './reducer';
+import type { ClassState, State, StateType } from './stateTypes';
+/**********
+ * useReducer
+ **********/
+declare const _default: <S extends State, R extends ReducerModuleFunc<S>>(theDo: ReducerModule<S, R>, stateType: StateType, init?: (...params: any[]) => S) => [ClassState<S>, DispatchFuncMap<S, R>];
+export default _default;

package/types/useThunk.d.ts

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