@chhsiao1981/use-thunk 9.0.0

package/src/genUUID.ts

@@ -0,0 +1,38 @@
+import { v4 as uuidv4 } from 'uuid'
+
+const _GLOBAL_IDS = new Set()
+
+const _GEN_UUID_COUNT = 3
+
+const _GEN_UUID_STATE = {
+  iterate: 1,
+}
+
+export const genUUID = (myuuidv4?: () => string): string => {
+  let theID = ''
+  let isAdd = false
+  for (let i = 0; i < _GEN_UUID_COUNT; i++) {
+    theID = genUUIDCore(myuuidv4)
+    if (_GLOBAL_IDS.has(theID)) {
+      continue
+    }
+    _GLOBAL_IDS.add(theID)
+    isAdd = true
+    break
+  }
+  if (isAdd) {
+    return theID
+  }
+
+  _GEN_UUID_STATE.iterate += 1
+  theID = genUUIDCore(myuuidv4)
+  return theID
+}
+
+const genUUIDCore = (myuuid: () => string = uuidv4): string => {
+  let theID = ''
+  for (let j = 0; j < _GEN_UUID_STATE.iterate; j++) {
+    theID += myuuid()
+  }
+  return theID
+}

package/src/getRelation.ts

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

package/src/index.ts

@@ -0,0 +1,62 @@
+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,
+  // StateType, // XXX for global state
+  type State,
+  type NodeState,
+  type NodeMeta,
+  type NodeStateMap,
+  // type NodeStateMapByClass, // XXX for global state
+  type ClassState,
+  type GetClassState,
+  // type BaseAction, // XXX deemphasize action
+  type Thunk,
+  // type ActionOrThunk, // XXX deemphasize action
+  // type ActionFunc, // XXX deemphasize action
+  // type Reducer, // XXX deemphasize reducer
+  type ThunkModule,
+  type ThunkModuleToFunc,
+  // type ReduceFunc, // XXX deemphasize reducer
+  type Dispatch,
+  type DispatchFuncMap,
+  // type DefaultDispatchFuncMap, // XXX deemphasize default
+  getRootID,
+  getNode,
+  getState,
+  getChildIDs,
+  getChildID,
+  getLinkIDs,
+  getLinkID,
+  init,
+  type InitParams,
+  setData,
+  remove,
+  addChild,
+  removeChild,
+  addLink,
+  removeLink,
+  type AddRelationAction,
+  type RemoveRelationAction,
+  // type DefaultThunkModuleFuncMap as DefaultReducerModuleFuncMap, // XXX deemphasize default
+  // type ReduceMap, // XXX deemphasize reducer
+  // createReducer, // XXX deemphasize reducer
+  genUUID,
+}

package/src/init.ts

@@ -0,0 +1,82 @@
+import type { BaseAction, Thunk } from './action'
+import { genUUID } from './genUUID'
+import { setRoot } from './setRoot'
+import { type ClassState, type NodeState, type NodeStateMap, PARENT, Relation, type State } from './stateTypes'
+
+// InitParams
+export interface InitParams<S extends State> {
+  myID?: string
+  parentID?: string
+  // @ts-expect-error doParent can be any type.
+  doParent?: DispatchFuncMap
+  parentClass?: string
+
+  state: S
+}
+
+export const init = <S extends State>(params: InitParams<S>, myuuidv4?: () => string): Thunk<S> => {
+  return (dispatch, getClassState) => {
+    const myID = params.myID ?? genUUID(myuuidv4)
+
+    const { parentID, doParent, parentClass, state } = params
+    dispatch(initCore(myID, state, parentID, doParent, parentClass))
+
+    // @ts-expect-error XXX doMe is a hidden variable for children.
+    const { myClass, doMe, root } = getClassState()
+
+    // parent or root
+    if (parentID && doParent) {
+      doParent.addChild(parentID, { id: myID, theClass: myClass, do: doMe })
+    } else if (!root) {
+      dispatch(setRoot(myID))
+    }
+  }
+}
+
+interface InitAction<S extends State> extends BaseAction {
+  parentID?: string
+  // @ts-expect-error doParent can be any type
+  doParent?: DispatchFuncMap
+  parentClass?: string
+
+  state: S
+}
+
+export const INIT = '@chhsiao1981/use-thunk/INIT'
+const initCore = <S extends State>(
+  myID: string,
+  state: S,
+  parentID?: string,
+  // @ts-expect-error doParent can be any type
+  doParent?: DispatchFuncMap,
+  parentClass?: string,
+): InitAction<S> => {
+  return {
+    myID,
+    type: INIT,
+    parentID,
+    doParent,
+    parentClass,
+
+    state,
+  }
+}
+
+export const reduceInit = <S extends State>(state: ClassState<S>, action: InitAction<S>): ClassState<S> => {
+  const { myID, parentID, doParent, parentClass, state: initState } = action
+
+  const me: NodeState<S> = {
+    id: myID,
+    state: initState,
+    [Relation.CHILDREN]: {},
+    [Relation.LINKS]: {},
+  }
+  if (parentID && doParent) {
+    me[PARENT] = { id: parentID, do: doParent, theClass: parentClass ?? '' }
+  }
+
+  const newNodes: NodeStateMap<S> = Object.assign({}, state.nodes, { [myID]: me })
+  const newState: ClassState<S> = Object.assign({}, state, { nodes: newNodes })
+
+  return newState
+}

package/src/reduceMap.ts

@@ -0,0 +1,37 @@
+import { ADD_CHILD, reduceAddChild } from './addChild'
+import { ADD_LINK, reduceAddLink } from './addLink'
+import { INIT, reduceInit } from './init'
+import type { ReduceFunc } from './reducer'
+import { REMOVE, reduceRemove } from './remove'
+import { REMOVE_CHILD, reduceRemoveChild } from './removeChild'
+import { REMOVE_LINK, reduceRemoveLink } from './removeLink'
+import { reduceSetData, SET_DATA } from './setData'
+import { reduceSetRoot, SET_ROOT } from './setRoot'
+import type { State } from './stateTypes'
+
+export interface ReduceMap<S extends State> {
+  [type: string]: ReduceFunc<S>
+}
+
+// default reduceMap
+export const DEFAULT_REDUCE_MAP: <S extends State>() => ReduceMap<S> = () => ({
+  // @ts-expect-error baseAction in ReduceMap
+  [INIT]: reduceInit,
+  [SET_DATA]: reduceSetData,
+  [REMOVE]: reduceRemove,
+
+  // @ts-expect-error baseAction in ReduceMap
+  [ADD_CHILD]: reduceAddChild,
+  // @ts-expect-error baseAction in ReduceMap
+  [REMOVE_CHILD]: reduceRemoveChild,
+
+  // @ts-expect-error baseAction in ReduceMap
+  [ADD_LINK]: reduceAddLink,
+  // @ts-expect-error baseAction in ReduceMap
+  [REMOVE_LINK]: reduceRemoveLink,
+
+  // setRoot.
+  // Typically we don't need this in programming.
+  // The root is automatically determined if root is not set.
+  [SET_ROOT]: reduceSetRoot,
+})

package/src/reducer.ts

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

package/src/remove.ts

@@ -0,0 +1,76 @@
+import type { BaseAction, Thunk } from './action'
+import { removeChild } from './removeChild'
+import { removeLink } from './removeLink'
+import { type ClassState, type NodeStateMap, PARENT, Relation, type State } from './stateTypes'
+
+export const remove = <S extends State>(myID: string, isFromParent = false): Thunk<S> => {
+  return (dispatch, getClassState) => {
+    const state = getClassState()
+    const {
+      myClass,
+      nodes: { [myID]: me },
+    } = state
+    if (!me) {
+      return
+    }
+
+    // parent removes me
+    const parent = me[PARENT]
+    if (!isFromParent && parent) {
+      const { id: parentID, do: doParent } = parent
+      if (parentID) {
+        doParent.removeChild(parentID, myID, myClass, true)
+      }
+    }
+
+    // remove children
+    const children = me[Relation.CHILDREN]
+    if (children) {
+      const realChildren = children
+      Object.keys(realChildren).map((eachClass) => {
+        const child = realChildren[eachClass]
+        child.list.map((eachID) => dispatch(removeChild(myID, eachID, eachClass, false)))
+      })
+    }
+
+    // remove links
+    const links = me[Relation.LINKS] ?? {}
+    Object.keys(links).map((eachClass) => {
+      const link = links[eachClass]
+      link.list.map((eachID) => dispatch(removeLink(myID, eachID, eachClass, false)))
+    })
+
+    // remove me from myClass list
+    dispatch(removeCore(myID))
+  }
+}
+
+export const REMOVE = '@chhsiao1981/use-thunk/REMOVE'
+const removeCore = (myID: string): BaseAction => ({
+  myID,
+  type: REMOVE,
+})
+
+export const reduceRemove = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+  const { myID } = action
+
+  const me = state.nodes[myID]
+  if (!me) {
+    return state
+  }
+
+  const newNodes = Object.keys(state.nodes)
+    .filter((each) => each !== myID)
+    .reduce((r: NodeStateMap<S>, x) => {
+      r[x] = state.nodes[x]
+      return r
+    }, {})
+
+  // root
+  const newState = Object.assign({}, state, { nodes: newNodes })
+  if (newState.root === myID) {
+    newState.root = null
+  }
+
+  return newState
+}

package/src/removeChild.ts

@@ -0,0 +1,46 @@
+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>(
+  state: ClassState<S>,
+  action: RemoveRelationAction,
+): ClassState<S> => {
+  const { myID, relationID, relationClass } = action
+
+  return reduceRemoveRelation(state, myID, relationID, relationClass, Relation.CHILDREN)
+}

package/src/removeLink.ts

@@ -0,0 +1,47 @@
+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>(
+  state: ClassState<S>,
+  action: RemoveRelationAction,
+): ClassState<S> => {
+  const { myID, relationID, relationClass } = action
+
+  return reduceRemoveRelation(state, myID, relationID, relationClass, Relation.LINKS)
+}

package/src/removeRelation.ts

@@ -0,0 +1,84 @@
+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
+}
+
+// @ts-expect-error DispatchFuncMap can be any type
+type RelationRemove = (theDo: DispatchFuncMap) => void
+type RemoveRelationCore = (myID: string, relationID: string, relationClass: string) => BaseAction
+
+export 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,
+) => {
+  const state = getClassState()
+
+  const me = state.nodes[myID]
+  if (!me) {
+    return
+  }
+
+  const relation = me[relationName]
+  if (!relation) {
+    return
+  }
+  const relationByClass = relation[relationClass]
+  if (!relationByClass) {
+    return
+  }
+
+  const newIDs = relationByClass.list.filter((eachID: string) => eachID !== relationID)
+  if (relationByClass.list.length === newIDs.length) return
+
+  if (!isFromRelation) {
+    relationRemove(relationByClass.do)
+  }
+
+  dispatch(removeRelationCore(myID, relationID, relationClass))
+}
+
+export const reduceRemoveRelation = <S extends State>(
+  state: ClassState<S>,
+  myID: string,
+  relationID: string,
+  relationClass: string,
+  relationName: Relation.LINKS | Relation.CHILDREN,
+): ClassState<S> => {
+  const me = state.nodes[myID]
+  if (!me) return state
+
+  const relation = me[relationName]
+  if (!relation) return state
+
+  const relationByClass = relation[relationClass]
+  if (!relationByClass) return state
+
+  const relationIDs = relationByClass.list || []
+  const newIDs = relationIDs.filter((eachID: string) => eachID !== relationID)
+  if (relationIDs.length === newIDs.length) return state
+
+  const newRelation = Object.assign({}, relation)
+  if (newIDs.length === 0) {
+    delete newRelation[relationClass]
+  } else {
+    const newRelationByClass = Object.assign({}, relationByClass, { list: newIDs })
+    newRelation[relationClass] = newRelationByClass
+  }
+
+  const newMe = Object.assign({}, me, { [relationName]: newRelation })
+  const newNodes = Object.assign({}, state.nodes, { [myID]: newMe })
+  const newState = Object.assign({}, state, { nodes: newNodes })
+
+  return newState
+}

package/src/setData.ts

@@ -0,0 +1,23 @@
+import type { BaseAction } from './action'
+import type { ClassState, State } from './stateTypes'
+
+export const SET_DATA = '@chhsiao1981/use-thunk/SET_DATA'
+export const setData = <S extends State>(myID: string, data: S): BaseAction => ({
+  myID,
+  type: SET_DATA,
+  data,
+})
+
+export const reduceSetData = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+  const { myID, data } = action
+
+  const me = state.nodes[myID]
+  if (!me) return state
+
+  const newMyState = Object.assign({}, me.state, data)
+  const newMe = Object.assign({}, me, { state: newMyState })
+  const newNodes = Object.assign({}, state.nodes, { [myID]: newMe })
+  const newState = Object.assign({}, state, { nodes: newNodes })
+
+  return newState
+}

package/src/setRoot.ts

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

package/src/stateTypes.ts

@@ -0,0 +1,62 @@
+export enum StateType {
+  // SHARED = 'shared',
+  LOCAL = 'local',
+}
+
+export enum Relation {
+  CHILDREN = '_children',
+  LINKS = '_links',
+}
+
+export const PARENT = '_parent'
+
+//State
+export interface State {
+  [key: string]: unknown
+}
+
+// NodeState
+export type NodeState<S extends State> = {
+  id: string
+  state: S
+  [Relation.CHILDREN]?: NodeStateRelationMap | null
+  [PARENT]?: NodeMeta | null
+  [Relation.LINKS]?: NodeStateRelationMap | null
+}
+
+// NodeStateRelation
+type NodeStateRelationMap = {
+  [relationClass: string]: NodeStateRelation
+}
+
+type NodeStateRelation = {
+  list: string[]
+  // @ts-expect-error do can be any type.
+  do: DispatchFuncMap
+}
+
+export type NodeStateMap<S extends State> = {
+  [key: string]: NodeState<S>
+}
+
+export type NodeStateMapByClass<S extends State> = {
+  [className: string]: NodeStateMap<S>
+}
+
+// ClassState
+export type ClassState<S extends State> = {
+  myClass: string
+  root?: string | null
+  // XXX doMe is a hidden variable for ClassState
+  //     used only for parents / children / links.
+  // doMe: DispatchFuncMap
+  nodes: NodeStateMap<S>
+}
+
+// Node
+export type NodeMeta = {
+  id: string
+  theClass: string
+  // @ts-expect-error do can be any type.
+  do: DispatchFuncMap
+}

package/src/states.ts

@@ -0,0 +1,45 @@
+import type { ClassState, NodeState, State } from './stateTypes'
+
+export const getRootNode = <S extends State>(state: ClassState<S>): NodeState<S> | null => {
+  const root = state.root
+  if (!root) {
+    return null
+  }
+  return state.nodes[root] || null
+}
+
+export const getRootID = <S extends State>(state: ClassState<S>): string => {
+  return state.root ?? ''
+}
+
+export const getRoot = <S extends State>(state: ClassState<S>): S | null => {
+  const root = state.root
+  if (!root) {
+    return null
+  }
+  const me = state.nodes[root]
+  if (!me) {
+    return null
+  }
+  return me.state
+}
+
+export const getNode = <S extends State>(state: ClassState<S>, myID?: string): NodeState<S> | null => {
+  if (!myID) {
+    return getRootNode(state)
+  }
+
+  return state.nodes[myID] || null
+}
+
+export const getState = <S extends State>(state: ClassState<S>, myID?: string): S | null => {
+  if (!myID) {
+    return getRoot(state)
+  }
+
+  const me = state.nodes[myID]
+  if (!me) {
+    return null
+  }
+  return me.state
+}

package/src/thunk.ts

@@ -0,0 +1,16 @@
+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>
+}
+
+// This is used as the parameter for useThunk.
+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'>