@chhsiao1981/use-thunk 9.0.5 → 10.0.1

package/src/removeRelation.ts

@@ -1,84 +0,0 @@
-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 classState = getClassState()
-
-  const myNode = classState.nodes[myID]
-  if (!myNode) {
-    return
-  }
-
-  const relation = myNode[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>(
-  classState: ClassState<S>,
-  myID: string,
-  relationID: string,
-  relationClass: string,
-  relationName: Relation.LINKS | Relation.CHILDREN,
-): ClassState<S> => {
-  const myNode = classState.nodes[myID]
-  if (!myNode) return classState
-
-  const relation = myNode[relationName]
-  if (!relation) return classState
-
-  const relationByClass = relation[relationClass]
-  if (!relationByClass) return classState
-
-  const relationIDs = relationByClass.list || []
-  const newIDs = relationIDs.filter((eachID: string) => eachID !== relationID)
-  if (relationIDs.length === newIDs.length) return classState
-
-  const newRelation = Object.assign({}, relation)
-  if (newIDs.length === 0) {
-    delete newRelation[relationClass]
-  } else {
-    const newRelationByClass = Object.assign({}, relationByClass, { list: newIDs })
-    newRelation[relationClass] = newRelationByClass
-  }
-
-  const newMyNode = Object.assign({}, myNode, { [relationName]: newRelation })
-  const newNodes = Object.assign({}, classState.nodes, { [myID]: newMyNode })
-  const newClassState = Object.assign({}, classState, { nodes: newNodes })
-
-  return newClassState
-}

package/types/addChild.d.ts

@@ -1,5 +0,0 @@
-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>(classState: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addLink.d.ts

@@ -1,6 +0,0 @@
-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>(classState: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addRelation.d.ts

@@ -1,6 +0,0 @@
-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>(classState: ClassState<S>, action: AddRelationAction, relationName: Relation) => ClassState<S>;

package/types/getRelation.d.ts

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

package/types/reducerModuleFuncMap.d.ts

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

@@ -1,9 +0,0 @@
-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>(classState: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeLink.d.ts

@@ -1,9 +0,0 @@
-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>(classState: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeRelation.d.ts

@@ -1,12 +0,0 @@
-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>(classState: ClassState<S>, myID: string, relationID: string, relationClass: string, relationName: Relation.LINKS | Relation.CHILDREN) => ClassState<S>;
-export {};

package/types/thunk-reducer.d.ts

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

@@ -1,18 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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;