@chhsiao1981/use-thunk 12.0.0 → 14.0.0

package/dist/thunkModuleFuncMap.d.ts

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

package/dist/update.d.ts

@@ -1,6 +0,0 @@
-import type { BaseAction } from './action';
-import type { ClassState, State } from './stateTypes';
-export declare const UPDATE = "@chhsiao1981/use-thunk/UPDATE";
-export declare const update: <S extends State>(myID: string, data: Partial<S>) => BaseAction;
-export declare const setData: <S extends State>(myID: string, data: Partial<S>) => BaseAction;
-export declare const reduceUpdate: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/dist/useThunk.d.ts

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

package/dist/useThunkReducer.d.ts

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

package/src/ThunkContext.tsx

@@ -1,46 +0,0 @@
-import { type ReactNode, useMemo, useState } from 'react'
-import { THUNK_CONTEXT_MAP } from './thunkContextMap'
-
-type Props = {
-  modules?: string[]
-  children?: ReactNode
-}
-
-const ThunkContext = (props: Props): ReactNode => {
-  const { modules: propsModules, children } = props
-  const modules = propsModules || THUNK_CONTEXT_MAP.theList
-  // 0. if there is no Thunk modules (no createThunk): return children.
-  if (modules.length === 0) {
-    return children
-  }
-
-  // render the 0th module.
-  const theModule = modules[0]
-
-  // 1. get the context and moduleState from context map.
-  const { context: Context_m, refModuleState } = THUNK_CONTEXT_MAP.theMap[theModule]
-
-  // 2. setup moduleState.
-  // biome-ignore lint/correctness/useHookAtTopLevel: the order is fixed.
-  const [moduleState, setModuleState] = useState(refModuleState.current)
-  refModuleState.current = moduleState
-
-  // 3. value reset only if moduleState is changed.
-  // biome-ignore lint/correctness/useHookAtTopLevel: the order is fixed.
-  const value = useMemo(
-    () => ({
-      refModuleState: refModuleState,
-      setModuleState: setModuleState,
-    }),
-    [moduleState],
-  )
-
-  // 4. get theChildren
-  const theChildren =
-    modules.length === 1 ? children : ThunkContext({ modules: modules.slice(1), children })
-
-  // 5. return context.
-  return <Context_m.Provider value={value}>{theChildren}</Context_m.Provider>
-}
-
-export default ThunkContext

package/src/action/ActionOrThunk.ts

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

package/src/action/baseAction.ts

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

package/src/action/index.ts

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

package/src/action/thunk.ts

@@ -1,9 +0,0 @@
-import type { set } from '../set'
-import type { ModuleState, State } from '../stateTypes'
-
-// Thunk
-export type Thunk<S extends State> = (
-  set: set<S>,
-  get: (id?: string) => S | null,
-  getModuleState: () => ModuleState<S>,
-) => void

package/src/createReducer.ts

@@ -1,24 +0,0 @@
-import type BaseAction from './action/baseAction'
-import { DEFAULT_REDUCE_MAP, type ReduceMap } from './reduceMap'
-import type { Reducer } from './reducer'
-
-import type { ModuleState, State } from './stateTypes'
-
-export const createReducer = <S extends State>(reduceMap?: ReduceMap<S>): Reducer<S> => {
-  return (moduleState: ModuleState<S>, action: BaseAction): ModuleState<S> => {
-    if (!action) {
-      return moduleState
-    }
-
-    if (reduceMap?.[action.type]) {
-      return reduceMap[action.type](moduleState, action)
-    }
-
-    const defaultReduceMap = DEFAULT_REDUCE_MAP<S>()
-    if (defaultReduceMap?.[action.type]) {
-      return defaultReduceMap[action.type](moduleState, action)
-    }
-
-    return moduleState
-  }
-}

package/src/createThunk.ts

@@ -1,24 +0,0 @@
-import { createContext, type Dispatch, type SetStateAction } from 'react'
-import type { ModuleState, State } from './stateTypes'
-import { THUNK_CONTEXT_MAP } from './thunkContextMap'
-import type { ThunkModule } from './thunkModule'
-
-export default <S extends State>(theDo: ThunkModule<S>) => {
-  const { name, defaultState } = theDo
-
-  if (THUNK_CONTEXT_MAP.theMap[name]) {
-    console.warn('createThunk: already init:', name)
-    return
-  }
-
-  const moduleState: ModuleState<S> = { name, nodes: {}, defaultState }
-  const setModuleState: Dispatch<SetStateAction<ModuleState<S>>> = () => {}
-  const refModuleState = { current: moduleState }
-  const context = createContext({ refModuleState: refModuleState, setModuleState })
-
-  THUNK_CONTEXT_MAP.theMap[name] = { context, refModuleState }
-  const theList = Object.keys(THUNK_CONTEXT_MAP.theMap).sort()
-  THUNK_CONTEXT_MAP.theList = theList
-
-  console.info('createThunk: done:', name)
-}

package/src/genUUID.ts

@@ -1,38 +0,0 @@
-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/get.ts

@@ -1,3 +0,0 @@
-import type { State } from './stateTypes'
-
-export type get = <S extends State>(id: string) => S

package/src/index.ts

@@ -1,42 +0,0 @@
-import type { GetModuleState, Thunk } from './action'
-import createThunk from './createThunk'
-import { genUUID } from './genUUID'
-import type { get } from './get'
-import { type InitParams, init } from './init'
-import { remove } from './remove'
-import type { set } from './set'
-import { setDefaultID } from './setDefaultID'
-import type { setMap } from './setMap'
-import { getDefaultID, getNode, getState, getStateByModule, getStateOrNullByModule } from './states'
-import type { ModuleState, State } from './stateTypes'
-import ThunkContext from './ThunkContext'
-import type { ThunkModule, ThunkModuleToFunc } from './thunkModule'
-import { update } from './update'
-import useThunk, { type UseThunk } from './useThunk'
-
-export {
-  createThunk,
-  useThunk,
-  type UseThunk,
-  ThunkContext,
-  type State,
-  type ModuleState,
-  type GetModuleState,
-  type Thunk,
-  type ThunkModule,
-  type ThunkModuleToFunc,
-  type set,
-  type setMap,
-  type get,
-  getNode,
-  getDefaultID,
-  getStateOrNullByModule,
-  getStateByModule,
-  getState,
-  init,
-  type InitParams,
-  update,
-  remove,
-  setDefaultID,
-  genUUID,
-}

package/src/init/index.ts

@@ -1,26 +0,0 @@
-import type { Thunk } from '../action'
-import { genUUID } from '../genUUID'
-import { setDefaultID } from '../setDefaultID'
-import type { State } from '../stateTypes'
-import initCore from './initCore'
-
-// InitParams
-export interface InitParams<S extends State> {
-  myID?: string
-  state: S
-}
-
-export const init = <S extends State>(params: InitParams<S>, myuuidv4?: () => string): Thunk<S> => {
-  return (set, _, getModuleState) => {
-    const myID = params.myID ?? genUUID(myuuidv4)
-
-    const { state } = params
-    set(initCore(myID, state))
-
-    const { defaultID } = getModuleState()
-
-    if (!defaultID) {
-      set(setDefaultID(myID))
-    }
-  }
-}

package/src/init/initCore.ts

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

package/src/reduceMap.ts

@@ -1,22 +0,0 @@
-import { INIT, reduceInit } from './init/initCore'
-import type { ReduceFunc } from './reducer'
-import { REMOVE, reduceRemove } from './remove'
-import { reduceSetDefaultID, SET_DEFAULT_ID } from './setDefaultID'
-import type { State } from './stateTypes'
-import { reduceUpdate, UPDATE } from './update'
-
-export interface ReduceMap<S extends State> {
-  [type: string]: ReduceFunc<S>
-}
-
-// default reduceMap
-export const DEFAULT_REDUCE_MAP: <S extends State>() => ReduceMap<S> = () => ({
-  [INIT]: reduceInit,
-  [UPDATE]: reduceUpdate,
-  [REMOVE]: reduceRemove,
-
-  // setDefaultID.
-  // Typically we don't need this in programming.
-  // The defaultID is automatically determined if defaultID is not set.
-  [SET_DEFAULT_ID]: reduceSetDefaultID,
-})

package/src/reducer.ts

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

package/src/remove.ts

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

package/src/set.ts

@@ -1,7 +0,0 @@
-import type { Dispatch } from 'react'
-// XXX requiring to import directly from action/ActionOrThunk, or it will cause looping.
-import type { ActionOrThunk } from './action/ActionOrThunk'
-import type { State } from './stateTypes'
-
-// set
-export type set<S extends State> = Dispatch<ActionOrThunk<S>>

package/src/setDefaultID.ts

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

package/src/setMap.ts

@@ -1,65 +0,0 @@
-import type { ActionFunc } from './action'
-import type { set } from './set'
-import type { State } from './stateTypes'
-import type { ThunkModule, ThunkModuleFunc } from './thunkModule'
-import {
-  DEFAULT_THUNK_MODULE_FUNC_MAP,
-  type DefaultThunkModuleFuncMap,
-} from './thunkModule/defaultThunkModuleFuncMap'
-
-// biome-ignore lint/suspicious/noExplicitAny: unknown requires same type in list, use any for possible different types.
-type VoidReturnType<T extends (...params: any[]) => unknown> = (...params: Parameters<T>) => void
-
-export type setMap<S extends State, T extends ThunkModuleFunc<S>> = {
-  [action in keyof T]: VoidReturnType<T[action]>
-} & Omit<DefaultSetMap, keyof T>
-
-export type DefaultSetMap = {
-  [action in keyof DefaultThunkModuleFuncMap]: VoidReturnType<DefaultThunkModuleFuncMap[action]>
-}
-
-export interface setMapByModuleMap<S extends State, T extends ThunkModuleFunc<S>> {
-  [name: string]: setMap<S, T>
-}
-
-// biome-ignore lint/suspicious/noExplicitAny: set map by module map can be any.
-export const SET_MAP_BY_MODULE_MAP: setMapByModuleMap<any, any> = {}
-
-export const constructSetMap = <S extends State, T extends ThunkModuleFunc<S>>(
-  theDo: ThunkModule<S>,
-  set: set<S>,
-  setMap: setMap<S, T>,
-) => {
-  Object.keys(theDo)
-    // default and name are reserved words.
-    // functions starting reduce are included in default and not exported.
-    .filter((each) => typeof theDo[each] === 'function')
-    .reduce((val, eachAction) => {
-      if (val[eachAction]) {
-        return val
-      }
-
-      // because action is a function.
-      const action = theDo[eachAction] as ActionFunc<S>
-
-      // @ts-expect-error eachAction is in setMap<S, R>
-      // biome-ignore lint/suspicious/noExplicitAny: action parameters can be any types.
-      val[eachAction] = (...params: any[]) => set(action(...params))
-      return val
-    }, setMap)
-
-  Object.keys(DEFAULT_THUNK_MODULE_FUNC_MAP).reduce((val, eachAction) => {
-    if (val[eachAction]) {
-      return val
-    }
-
-    const action = DEFAULT_THUNK_MODULE_FUNC_MAP[eachAction]
-
-    // @ts-expect-error eachAction is in setMap<S, R>
-    // biome-ignore lint/suspicious/noExplicitAny: action parameters can be any types.
-    val[eachAction] = (...params: any[]) => set(action(...params))
-    return val
-  }, setMap)
-
-  return setMap
-}

package/src/stateTypes.ts

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

package/src/states.ts

@@ -1,50 +0,0 @@
-import type { setMap } from './setMap'
-import type { ModuleState, NodeState, State } from './stateTypes'
-import type { ThunkModuleFunc } from './thunkModule'
-import type { UseThunk } from './useThunk'
-
-export const getDefaultID = <S extends State>(moduleState: ModuleState<S>): string => {
-  return moduleState.defaultID ?? ''
-}
-
-export const getNode = <S extends State>(
-  moduleState: ModuleState<S>,
-  myID?: string,
-): NodeState<S> | null => {
-  const theID = myID ? myID : getDefaultID(moduleState)
-  if (!theID) {
-    return null
-  }
-
-  return moduleState.nodes[theID] || null
-}
-
-export const getStateOrNullByModule = <S extends State>(
-  moduleState: ModuleState<S>,
-  myID?: string,
-): S | null => {
-  const theID = myID ? myID : getDefaultID(moduleState)
-  if (!theID) {
-    return null
-  }
-
-  const me = moduleState.nodes[theID]
-  if (!me) {
-    return null
-  }
-  return me.state
-}
-
-export const getStateByModule = <S extends State>(moduleState: ModuleState<S>, myID?: string): S => {
-  return getStateOrNullByModule(moduleState, myID) || moduleState.defaultState
-}
-
-export const getState = <S extends State, R extends ThunkModuleFunc<S>>(
-  theUseThunk: UseThunk<S, R>,
-  myID?: string,
-): [S, setMap<S, R>, string] => {
-  const [moduleState, theDo] = theUseThunk
-  const theID = myID ? myID : getDefaultID(moduleState)
-  const state = getStateByModule(moduleState, theID)
-  return [state, theDo, theID]
-}

package/src/thunkContextMap.ts

@@ -1,22 +0,0 @@
-import type { Context as rContext } from 'react'
-import type { ModuleState } from './stateTypes'
-import type { Context } from './thunkContextTypes'
-
-export type ThunkContextMap = {
-  theMap: {
-    [moduleName: string]: {
-      // biome-ignore lint/suspicious/noExplicitAny: ThunkContextMap can be any type
-      context: rContext<Context<any>>
-
-      // we need to use refModuleState to sync all the moduleState in all ops.
-      // biome-ignore lint/suspicious/noExplicitAny: ThunkContextMap can be any type
-      refModuleState: { current: ModuleState<any> }
-    }
-  }
-  theList: string[]
-}
-
-export const THUNK_CONTEXT_MAP: ThunkContextMap = {
-  theMap: {},
-  theList: [],
-}

package/src/thunkContextTypes.ts

@@ -1,8 +0,0 @@
-import type { Dispatch, SetStateAction } from 'react'
-import type { ModuleState, State } from './stateTypes'
-
-export type Context<S extends State> = {
-  // INFO: we use refModuleState to reference across all the useThunk of the same module in different ops.
-  refModuleState: { current: ModuleState<S> }
-  setModuleState: Dispatch<SetStateAction<ModuleState<S>>>
-}

package/src/thunkModule/defaultThunkModuleFuncMap.ts

@@ -1,15 +0,0 @@
-import type { ActionFunc } from '../action'
-import { init } from '../init'
-import { remove } from '../remove'
-import { update } from '../update'
-
-export const DEFAULT_THUNK_MODULE_FUNC_MAP: DefaultThunkModuleFuncMap = {
-  init,
-  update,
-  remove,
-}
-
-export type DefaultThunkModuleFuncMap = {
-  // biome-ignore lint/suspicious/noExplicitAny: DefaultThunkModuleFuncMap can be any type.
-  [action: string]: ActionFunc<any>
-}

package/src/thunkModule/index.ts

@@ -1,20 +0,0 @@
-import type { ThunkFunc } from '../action'
-import type { Reducer } from '../reducer'
-import type { State } from '../stateTypes'
-
-export interface ThunkModuleBase<S extends State> {
-  [idx: string]: ThunkFunc<S> | string | Reducer<S> | S | undefined
-}
-
-export interface ThunkModuleFunc<S extends State> extends ThunkModuleBase<S> {
-  [action: string]: ThunkFunc<S>
-}
-
-// This is used as the parameter for useThunk.
-export type ThunkModule<S extends State> = {
-  name: string
-  default?: Reducer<S>
-  defaultState: S
-} & ThunkModuleBase<S>
-
-export type ThunkModuleToFunc<T> = Omit<T, 'name' | 'default' | 'defaultState'>