@chhsiao1981/use-thunk 9.0.4 → 10.0.0

package/src/useThunk.ts

@@ -1,40 +1,45 @@
-import { useRef, useState } from 'react'
-import type { ActionFunc } from './action'
+import { useMemo } from 'react'
 import { createReducer } from './createReducer'
-import type { DispatchFuncMap, DispatchFuncMapByClassMap, RefDispatchFuncMapByClassMap } from './dispatchFuncMap'
-import type { ClassState, NodeStateMap, State } from './stateTypes'
+import {
+  constructDispatchMap,
+  type DispatchFuncMap,
+  type DispatchFuncMapByClassMap,
+} from './dispatchFuncMap'
+import type { ClassState, State } from './stateTypes'
 import type { ThunkModule, ThunkModuleFunc } from './thunk'
-import { DEFAULT_THUNK_MODULE_FUNC_MAP } from './thunkModuleFuncMap'
 import useThunkReducer from './useThunkReducer'
 
-export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [ClassState<S>, DispatchFuncMap<S, R>]
+// biome-ignore lint/suspicious/noExplicitAny: DISPACH_MAP_BY_CLASS can by any type
+const DISPACH_MAP_BY_CLASS: DispatchFuncMapByClassMap<any, any> = {}
+
+export type UseThunk<S extends State, R extends ThunkModuleFunc<S>> = [
+  ClassState<S>,
+  DispatchFuncMap<S, R>,
+]
 
 /**********
  * 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,
 ): UseThunk<S, R> => {
   const { myClass } = theDo
 
   // 1. dispatchMapByClass
-  const refDispatchMapByClass: RefDispatchFuncMapByClassMap<S, R> = useRef({})
-  const dispatchMapByClass: DispatchFuncMapByClassMap<S, R> = refDispatchMapByClass.current
+  //
+  // INFO The reason why we need to useRef is because we don't want to
+  //        rebuild dispatchMap every time we call useThunk.
+  const dispatchMapByClass: DispatchFuncMapByClassMap<S, R> = DISPACH_MAP_BY_CLASS
 
   // 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>
+    // @ts-expect-error init dispatchMap
     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.
@@ -44,52 +49,23 @@ export default <S extends State, R extends ThunkModuleFunc<S>>(
   //    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>())
+  //
+  // INFO useMemo is to avoid accidental re-init createReducer every-time.
+  const theReducer = useMemo(() => theDo.default ?? createReducer<S>(), [])
 
   // 5. useThunkReducer
-  const [classState, dispatch] = useThunkReducer(
-    theReducer,
-    {
-      myClass,
-      // @ts-expect-error doMe is a hidden variable for ClassState
-      doMe: dispatchMap,
-      nodes,
-    },
-    init,
-  )
+  const [classState, dispatch] = useThunkReducer(theReducer, myClass)
 
-  // 7. the dispatchMap is always the same.
-  //    we can do early return if not first time.
-  if (!isFirstTime) {
+  // INFO useMemo is to avoid accidental included in useEffect.
+  const ret: UseThunk<S, R> = useMemo(() => {
     return [classState, 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)
+  }, [classState, 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]
+  if (!isFirstTime) {
+    return ret
+  }
 
-    // @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)
+  constructDispatchMap(theDo, dispatch, dispatchMap)
 
-  return [classState, dispatchMap]
+  return ret
 }

package/src/useThunkReducer.ts

@@ -1,9 +1,10 @@
 //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 Dispatch, type Reducer, useCallback, useContext } from 'react'
 import type { BaseAction } from './action'
 import type { ClassState, State } from './stateTypes'
+import { THUNK_CONTEXT_MAP } from './thunkContextMap'
 
 export type Thunk<S extends State, A extends BaseAction> = (
   dispatch: Dispatch<ActionOrThunk<S, A>>,
@@ -18,39 +19,34 @@ export type ActionOrThunk<S extends State, A extends BaseAction> = A | Thunk<S,
  * dispatcher supports thunks.
  *
  * @param {Function} reducer
- * @param {State} initArg
- * @param {Function} [init]
- * @returns {[State, Dispatch]}
+ * @param {string} className
+ * @returns {[ClassState<S>, Dispatch]}
  */
 export default <S extends State, A extends BaseAction>(
   reducer: Reducer<ClassState<S>, A>,
-  initArg: ClassState<S>,
-  init?: (initArg: ClassState<S>) => ClassState<S>,
+  className: string,
 ): [ClassState<S>, Dispatch<A | Thunk<S, A>>] => {
-  // 1. initState
-  const initClassState = init ? () => init(initArg) : initArg
+  const { context } = THUNK_CONTEXT_MAP.theMap[className]
 
-  // 2. renderState
-  const [renderClassState, setRenderClassState] = useState(initClassState)
+  const { refClassState, setClassState: setClassState_c } = useContext(context)
+  const getClassState = useCallback(() => {
+    return refClassState.current
+  }, [refClassState])
 
-  // 3. hookState
-  const hookClassState = renderClassState
-
-  // 4. state management.
-  const classState = useRef(hookClassState)
-  const getClassState = useCallback(() => classState.current, [classState])
   const setClassState = useCallback(
     (newClassState: ClassState<S>) => {
-      classState.current = newClassState
-      setRenderClassState(newClassState)
+      refClassState.current = newClassState
+      setClassState_c(newClassState)
     },
-    [classState, setRenderClassState],
+    [refClassState, setClassState_c],
   )
 
   // 5. reducer.
   const reduce = useCallback(
     (action: A): ClassState<S> => {
-      return reducer(getClassState(), action)
+      const classState = getClassState()
+      const newClassState = reducer(classState, action)
+      return newClassState
     },
     [reducer, getClassState],
   )
@@ -63,10 +59,11 @@ export default <S extends State, A extends BaseAction>(
         return
       }
 
-      setClassState(reduce(action))
+      const newClassState = reduce(action)
+      setClassState(newClassState)
     },
     [getClassState, setClassState, reduce],
   )
 
-  return [hookClassState, dispatch]
+  return [refClassState.current, dispatch]
 }

package/types/ThunkContext.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from 'react';
+type Props = {
+    classes?: string[];
+    children?: ReactNode;
+};
+declare const ThunkContext: (props: Props) => string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | Iterable<ReactNode> | null | undefined> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export default ThunkContext;

package/types/dispatchFuncMap.d.ts

@@ -1,6 +1,8 @@
+import type { BaseAction } from './action';
 import type { State } from './stateTypes';
-import type { ThunkModuleFunc } from './thunk';
-import type { DefaultThunkModuleFuncMap } from './thunkModuleFuncMap';
+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]>;
@@ -11,7 +13,6 @@ export type DefaultDispatchFuncMap = {
 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 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, T>, dispatch: (action: A | rThunk<S, A>) => void, dispatchMap: DispatchFuncMap<S, T>) => DispatchFuncMap<S, T>;
 export {};

package/types/index.d.ts

@@ -1,19 +1,14 @@
 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 registerThunk from './registerThunk';
 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 ThunkContext from './ThunkContext';
 import type { ThunkModule, ThunkModuleToFunc } from './thunk';
 import useThunk, { type UseThunk } from './useThunk';
-export { useThunk, type 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, };
+export { registerThunk, useThunk, ThunkContext, type 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, init, type InitParams, setData, remove, genUUID, };

package/types/init.d.ts

@@ -1,5 +1,5 @@
 import type { BaseAction, Thunk } from './action';
-import { type ClassState, type State } from './stateTypes';
+import type { ClassState, State } from './stateTypes';
 export interface InitParams<S extends State> {
     myID?: string;
     parentID?: string;

package/types/registerThunk.d.ts

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

package/types/remove.d.ts

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

@@ -1,5 +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 setData: <S extends State>(myID: string, data: Partial<S>) => BaseAction;
 export declare const reduceSetData: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/stateTypes.d.ts

@@ -1,27 +1,9 @@
-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>;
@@ -39,4 +21,3 @@ export type NodeMeta = {
     theClass: string;
     do: DispatchFuncMap;
 };
-export {};

package/types/thunk.d.ts

@@ -7,6 +7,6 @@ export interface ThunkModuleFunc<S extends State> {
 export type ThunkModule<S extends State, T extends ThunkModuleFunc<S>> = {
     myClass: string;
     default?: Reducer<S>;
-    defaultState?: S;
+    defaultState: S;
 } & T;
 export type ThunkModuleToFunc<T> = Omit<T, 'myClass' | 'default' | 'defaultState'>;

package/types/thunkContextMap.d.ts

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

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

@@ -1,10 +1,6 @@
 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>;
+    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/types/useThunk.d.ts

@@ -1,9 +1,12 @@
-import type { DispatchFuncMap } from './dispatchFuncMap';
+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>];
+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, R>, init?: (...params: any[]) => S) => UseThunk<S, R>;
+declare const _default: <S extends State, R extends ThunkModuleFunc<S>>(theDo: ThunkModule<S, R>) => UseThunk<S, R>;
 export default _default;

package/types/useThunkReducer.d.ts

@@ -10,9 +10,8 @@ export type ActionOrThunk<S extends State, A extends BaseAction> = A | Thunk<S,
  * dispatcher supports thunks.
  *
  * @param {Function} reducer
- * @param {State} initArg
- * @param {Function} [init]
- * @returns {[State, Dispatch]}
+ * @param {string} className
+ * @returns {[ClassState<S>, Dispatch]}
  */
-declare const _default: <S extends State, A extends BaseAction>(reducer: Reducer<ClassState<S>, A>, initArg: ClassState<S>, init?: (initArg: ClassState<S>) => ClassState<S>) => [ClassState<S>, Dispatch<A | Thunk<S, A>>];
+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/addChild.ts

@@ -1,16 +0,0 @@
-import { type AddRelationAction, reduceAddRelation } from './addRelation'
-import { type ClassState, type NodeMeta, Relation, type State } from './stateTypes'
-
-export const ADD_CHILD = '@chhsiao1981/use-thunk/ADD_CHILD'
-export const addChild = (myID: string, child: NodeMeta): AddRelationAction => ({
-  myID,
-  type: ADD_CHILD,
-  relaton: child,
-})
-
-export const reduceAddChild = <S extends State>(
-  classState: ClassState<S>,
-  action: AddRelationAction,
-): ClassState<S> => {
-  return reduceAddRelation(classState, action, Relation.CHILDREN)
-}

package/src/addLink.ts

@@ -1,27 +0,0 @@
-import type { Thunk } from './action'
-import { type AddRelationAction, reduceAddRelation } from './addRelation'
-import { type ClassState, type NodeMeta, Relation, type State } from './stateTypes'
-
-export const addLink = <S extends State>(myID: string, link: NodeMeta, isFromLink = false): Thunk<S> => {
-  return (dispatch, getClassState) => {
-    dispatch(addLinkCore(myID, link))
-
-    if (!isFromLink) {
-      // I connect to the other, would like the other to connect to me as well.
-      // @ts-expect-error XXX doMe is a hidden variable for links.
-      const { doMe, myClass } = getClassState()
-      link.do.addLink(link.id, { id: myID, theClass: myClass, do: doMe }, true)
-    }
-  }
-}
-
-export const ADD_LINK = '@chhsiao1981/use-thunk/ADD_LINK'
-const addLinkCore = (myID: string, link: NodeMeta): AddRelationAction => ({
-  myID,
-  type: ADD_LINK,
-  relaton: link,
-})
-
-export const reduceAddLink = <S extends State>(classState: ClassState<S>, action: AddRelationAction): ClassState<S> => {
-  return reduceAddRelation(classState, action, Relation.LINKS)
-}

package/src/addRelation.ts

@@ -1,32 +0,0 @@
-import type { BaseAction } from './action'
-import type { ClassState, NodeMeta, Relation, State } from './stateTypes'
-
-export interface AddRelationAction extends BaseAction {
-  relaton: NodeMeta
-}
-
-export const reduceAddRelation = <S extends State>(
-  classState: ClassState<S>,
-  action: AddRelationAction,
-  relationName: Relation,
-): ClassState<S> => {
-  const { myID, relaton: relation } = action
-  const myNode = classState.nodes[myID]
-  if (!myNode) {
-    return classState
-  }
-
-  const { theClass, id: theID, do: theDo } = relation
-
-  const relations = myNode[relationName] ?? {}
-  const relationsByClass = relations[theClass] ?? { list: [] }
-  const relationIDs = relationsByClass.list ?? []
-  const newIDs = theID ? relationIDs.concat([theID]) : relationIDs
-
-  const newRelations = Object.assign({}, myNode[relationName], { [theClass]: { list: newIDs, do: theDo } })
-  const newMyNode = Object.assign({}, myNode, { [relationName]: newRelations })
-  const newNodes = Object.assign({}, classState.nodes, { [myID]: newMyNode })
-  const newClassState = Object.assign({}, classState, { nodes: newNodes })
-
-  return newClassState
-}

package/src/getRelation.ts

@@ -1,43 +0,0 @@
-import { type NodeState, Relation, type State } from './stateTypes'
-
-export const getChildIDs = <S extends State>(myNode: NodeState<S>, childClass: string): string[] => {
-  return getRelationIDs(myNode, childClass, Relation.CHILDREN)
-}
-
-export const getChildID = <S extends State>(myNode: NodeState<S>, childClass: string): string => {
-  return getRelationID(myNode, childClass, Relation.CHILDREN)
-}
-
-export const getLinkIDs = <S extends State>(myNode: NodeState<S>, linkClass: string): string[] => {
-  return getRelationIDs(myNode, linkClass, Relation.LINKS)
-}
-
-export const getLinkID = <S extends State>(myNode: NodeState<S>, linkClass: string): string => {
-  return getRelationID(myNode, linkClass, Relation.LINKS)
-}
-
-const getRelationIDs = <S extends State>(
-  myNode: NodeState<S>,
-  relationClass: string,
-  relationName: Relation,
-): string[] => {
-  const relations = myNode[relationName]
-  if (!relations) {
-    return []
-  }
-  const relationsByClass = relations[relationClass]
-  if (!relationsByClass) {
-    return []
-  }
-
-  return relationsByClass.list
-}
-
-const getRelationID = <S extends State>(
-  myNode: NodeState<S>,
-  relationClass: string,
-  relationName: Relation,
-): string => {
-  const ids = getRelationIDs(myNode, relationClass, relationName)
-  return ids.length ? ids[0] : ''
-}

package/src/removeChild.ts

@@ -1,46 +0,0 @@
-import type { Thunk } from './action'
-import { type RemoveRelationAction, reduceRemoveRelation, removeRelation } from './removeRelation'
-import { type ClassState, Relation, type State } from './stateTypes'
-
-/***
- * remove-child
- */
-export const removeChild = <S extends State>(
-  myID: string,
-  childID: string,
-  childClass: string,
-  isFromChild = false,
-): Thunk<S> => {
-  return (dispatch, getClassState) => {
-    // @ts-expect-error theDo (from child) can by any type
-    const relationRemove = (theDo: DispatchFuncMap) => theDo.remove(childID, true)
-    removeRelation(
-      dispatch,
-      getClassState,
-      myID,
-      childID,
-      childClass,
-      isFromChild,
-      relationRemove,
-      removeChildCore,
-      Relation.CHILDREN,
-    )
-  }
-}
-
-export const REMOVE_CHILD = '@chhsiao1981/use-thunk/REMOVE_CHILD'
-const removeChildCore = (myID: string, childID: string, childClass: string): RemoveRelationAction => ({
-  myID,
-  type: REMOVE_CHILD,
-  relationID: childID,
-  relationClass: childClass,
-})
-
-export const reduceRemoveChild = <S extends State>(
-  classState: ClassState<S>,
-  action: RemoveRelationAction,
-): ClassState<S> => {
-  const { myID, relationID, relationClass } = action
-
-  return reduceRemoveRelation(classState, myID, relationID, relationClass, Relation.CHILDREN)
-}

package/src/removeLink.ts

@@ -1,47 +0,0 @@
-import type { Thunk } from './action'
-import { type RemoveRelationAction, reduceRemoveRelation, removeRelation } from './removeRelation'
-import { type ClassState, Relation, type State } from './stateTypes'
-
-/***
- * remove-link
- */
-export const removeLink = <S extends State>(
-  myID: string,
-  linkID: string,
-  linkClass: string,
-  isFromLink = false,
-): Thunk<S> => {
-  return (dispatch, getClassState) => {
-    const myClass = getClassState().myClass
-    // @ts-expect-error theDo (from link) can be any type
-    const relationRemove = (theDo: DispatchFuncMap) => theDo.removeLink(linkID, myID, myClass, true)
-    removeRelation(
-      dispatch,
-      getClassState,
-      myID,
-      linkID,
-      linkClass,
-      isFromLink,
-      relationRemove,
-      removeLinkCore,
-      Relation.LINKS,
-    )
-  }
-}
-
-export const REMOVE_LINK = '@chhsiao1981/use-thunk/REMOVE_LINK'
-const removeLinkCore = (myID: string, linkID: string, linkClass: string): RemoveRelationAction => ({
-  myID,
-  type: REMOVE_LINK,
-  relationID: linkID,
-  relationClass: linkClass,
-})
-
-export const reduceRemoveLink = <S extends State>(
-  classState: ClassState<S>,
-  action: RemoveRelationAction,
-): ClassState<S> => {
-  const { myID, relationID, relationClass } = action
-
-  return reduceRemoveRelation(classState, myID, relationID, relationClass, Relation.LINKS)
-}