@chhsiao1981/use-thunk 9.0.2 → 9.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chhsiao1981/use-thunk",
-  "version": "9.0.2",
+  "version": "9.0.3",
   "type": "module",
   "description": "A framework easily using useThunk to manage the data-state.",
   "homepage": "https://github.com/chhsiao1981/use-thunk",

package/src/addChild.ts

@@ -8,6 +8,9 @@ export const addChild = (myID: string, child: NodeMeta): AddRelationAction => ({
   relaton: child,
 })
 
-export const reduceAddChild = <S extends State>(state: ClassState<S>, action: AddRelationAction): ClassState<S> => {
-  return reduceAddRelation(state, action, Relation.CHILDREN)
+export const reduceAddChild = <S extends State>(
+  classState: ClassState<S>,
+  action: AddRelationAction,
+): ClassState<S> => {
+  return reduceAddRelation(classState, action, Relation.CHILDREN)
 }

package/src/addLink.ts

@@ -22,6 +22,6 @@ const addLinkCore = (myID: string, link: NodeMeta): AddRelationAction => ({
   relaton: link,
 })
 
-export const reduceAddLink = <S extends State>(state: ClassState<S>, action: AddRelationAction): ClassState<S> => {
-  return reduceAddRelation(state, action, Relation.LINKS)
+export const reduceAddLink = <S extends State>(classState: ClassState<S>, action: AddRelationAction): ClassState<S> => {
+  return reduceAddRelation(classState, action, Relation.LINKS)
 }

package/src/addRelation.ts

@@ -6,27 +6,27 @@ export interface AddRelationAction extends BaseAction {
 }
 
 export const reduceAddRelation = <S extends State>(
-  state: ClassState<S>,
+  classState: ClassState<S>,
   action: AddRelationAction,
   relationName: Relation,
 ): ClassState<S> => {
   const { myID, relaton: relation } = action
-  const me = state.nodes[myID]
-  if (!me) {
-    return state
+  const myNode = classState.nodes[myID]
+  if (!myNode) {
+    return classState
   }
 
   const { theClass, id: theID, do: theDo } = relation
 
-  const relations = me[relationName] ?? {}
+  const relations = myNode[relationName] ?? {}
   const relationsByClass = relations[theClass] ?? { list: [] }
   const relationIDs = relationsByClass.list ?? []
   const newIDs = theID ? relationIDs.concat([theID]) : relationIDs
 
-  const newRelations = Object.assign({}, me[relationName], { [theClass]: { list: newIDs, do: theDo } })
-  const newMe = Object.assign({}, me, { [relationName]: newRelations })
-  const newNodes = Object.assign({}, state.nodes, { [myID]: newMe })
-  const newState = Object.assign({}, state, { nodes: newNodes })
+  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 newState
+  return newClassState
 }

package/src/createReducer.ts

@@ -5,20 +5,20 @@ import type { Reducer } from './reducer'
 import type { ClassState, State } from './stateTypes'
 
 export const createReducer = <S extends State>(reduceMap?: ReduceMap<S>): Reducer<S> => {
-  return (state: ClassState<S>, action: BaseAction): ClassState<S> => {
+  return (classState: ClassState<S>, action: BaseAction): ClassState<S> => {
     if (!action) {
-      return state
+      return classState
     }
 
     if (reduceMap?.[action.type]) {
-      return reduceMap[action.type](state, action)
+      return reduceMap[action.type](classState, action)
     }
 
     const defaultReduceMap = DEFAULT_REDUCE_MAP<S>()
     if (defaultReduceMap?.[action.type]) {
-      return defaultReduceMap[action.type](state, action)
+      return defaultReduceMap[action.type](classState, action)
     }
 
-    return state
+    return classState
   }
 }

package/src/getRelation.ts

@@ -1,23 +1,27 @@
 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 getChildIDs = <S extends State>(myNode: NodeState<S>, childClass: string): string[] => {
+  return getRelationIDs(myNode, childClass, Relation.CHILDREN)
 }
 
-export const getChildID = <S extends State>(me: NodeState<S>, childClass: string): string => {
-  return getRelationID(me, 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>(me: NodeState<S>, linkClass: string): string[] => {
-  return getRelationIDs(me, linkClass, Relation.LINKS)
+export const getLinkIDs = <S extends State>(myNode: NodeState<S>, linkClass: string): string[] => {
+  return getRelationIDs(myNode, linkClass, Relation.LINKS)
 }
 
-export const getLinkID = <S extends State>(me: NodeState<S>, linkClass: string): string => {
-  return getRelationID(me, 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>(me: NodeState<S>, relationClass: string, relationName: Relation): string[] => {
-  const relations = me[relationName]
+const getRelationIDs = <S extends State>(
+  myNode: NodeState<S>,
+  relationClass: string,
+  relationName: Relation,
+): string[] => {
+  const relations = myNode[relationName]
   if (!relations) {
     return []
   }
@@ -29,7 +33,11 @@ const getRelationIDs = <S extends State>(me: NodeState<S>, relationClass: string
   return relationsByClass.list
 }
 
-const getRelationID = <S extends State>(me: NodeState<S>, relationClass: string, relationName: Relation): string => {
-  const ids = getRelationIDs(me, relationClass, relationName)
+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/init.ts

@@ -62,21 +62,21 @@ const initCore = <S extends State>(
   }
 }
 
-export const reduceInit = <S extends State>(state: ClassState<S>, action: InitAction<S>): ClassState<S> => {
+export const reduceInit = <S extends State>(classState: ClassState<S>, action: InitAction<S>): ClassState<S> => {
   const { myID, parentID, doParent, parentClass, state: initState } = action
 
-  const me: NodeState<S> = {
+  const myNode: NodeState<S> = {
     id: myID,
     state: initState,
     [Relation.CHILDREN]: {},
     [Relation.LINKS]: {},
   }
   if (parentID && doParent) {
-    me[PARENT] = { id: parentID, do: doParent, theClass: parentClass ?? '' }
+    myNode[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 })
+  const newNodes: NodeStateMap<S> = Object.assign({}, classState.nodes, { [myID]: myNode })
+  const newClassState: ClassState<S> = Object.assign({}, classState, { nodes: newNodes })
 
-  return newState
+  return newClassState
 }

package/src/reducer.ts

@@ -1,5 +1,5 @@
 import type { Reducer as rReducer } from 'react'
-import type { ActionFunc, BaseAction } from './action'
+import type { BaseAction } from './action'
 import type { ClassState, State } from './stateTypes'
 
 // Reducer

package/src/remove.ts

@@ -51,23 +51,23 @@ const removeCore = (myID: string): BaseAction => ({
   type: REMOVE,
 })
 
-export const reduceRemove = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+export const reduceRemove = <S extends State>(classState: ClassState<S>, action: BaseAction): ClassState<S> => {
   const { myID } = action
 
-  const me = state.nodes[myID]
-  if (!me) {
-    return state
+  const myNode = classState.nodes[myID]
+  if (!myNode) {
+    return classState
   }
 
-  const newNodes = Object.keys(state.nodes)
+  const newNodes = Object.keys(classState.nodes)
     .filter((each) => each !== myID)
     .reduce((r: NodeStateMap<S>, x) => {
-      r[x] = state.nodes[x]
+      r[x] = classState.nodes[x]
       return r
     }, {})
 
   // root
-  const newState = Object.assign({}, state, { nodes: newNodes })
+  const newState = Object.assign({}, classState, { nodes: newNodes })
   if (newState.root === myID) {
     newState.root = null
   }

package/src/removeChild.ts

@@ -37,10 +37,10 @@ const removeChildCore = (myID: string, childID: string, childClass: string): Rem
 })
 
 export const reduceRemoveChild = <S extends State>(
-  state: ClassState<S>,
+  classState: ClassState<S>,
   action: RemoveRelationAction,
 ): ClassState<S> => {
   const { myID, relationID, relationClass } = action
 
-  return reduceRemoveRelation(state, myID, relationID, relationClass, Relation.CHILDREN)
+  return reduceRemoveRelation(classState, myID, relationID, relationClass, Relation.CHILDREN)
 }

package/src/removeLink.ts

@@ -38,10 +38,10 @@ const removeLinkCore = (myID: string, linkID: string, linkClass: string): Remove
 })
 
 export const reduceRemoveLink = <S extends State>(
-  state: ClassState<S>,
+  classState: ClassState<S>,
   action: RemoveRelationAction,
 ): ClassState<S> => {
   const { myID, relationID, relationClass } = action
 
-  return reduceRemoveRelation(state, myID, relationID, relationClass, Relation.LINKS)
+  return reduceRemoveRelation(classState, myID, relationID, relationClass, Relation.LINKS)
 }

package/src/removeRelation.ts

@@ -22,14 +22,14 @@ export const removeRelation = <S extends State>(
   removeRelationCore: RemoveRelationCore,
   relationName: Relation,
 ) => {
-  const state = getClassState()
+  const classState = getClassState()
 
-  const me = state.nodes[myID]
-  if (!me) {
+  const myNode = classState.nodes[myID]
+  if (!myNode) {
     return
   }
 
-  const relation = me[relationName]
+  const relation = myNode[relationName]
   if (!relation) {
     return
   }
@@ -49,24 +49,24 @@ export const removeRelation = <S extends State>(
 }
 
 export const reduceRemoveRelation = <S extends State>(
-  state: ClassState<S>,
+  classState: 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 myNode = classState.nodes[myID]
+  if (!myNode) return classState
 
-  const relation = me[relationName]
-  if (!relation) return state
+  const relation = myNode[relationName]
+  if (!relation) return classState
 
   const relationByClass = relation[relationClass]
-  if (!relationByClass) return state
+  if (!relationByClass) return classState
 
   const relationIDs = relationByClass.list || []
   const newIDs = relationIDs.filter((eachID: string) => eachID !== relationID)
-  if (relationIDs.length === newIDs.length) return state
+  if (relationIDs.length === newIDs.length) return classState
 
   const newRelation = Object.assign({}, relation)
   if (newIDs.length === 0) {
@@ -76,9 +76,9 @@ export const reduceRemoveRelation = <S extends State>(
     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 })
+  const newMyNode = Object.assign({}, myNode, { [relationName]: newRelation })
+  const newNodes = Object.assign({}, classState.nodes, { [myID]: newMyNode })
+  const newClassState = Object.assign({}, classState, { nodes: newNodes })
 
-  return newState
+  return newClassState
 }

package/src/setData.ts

@@ -8,16 +8,16 @@ export const setData = <S extends State>(myID: string, data: S): BaseAction => (
   data,
 })
 
-export const reduceSetData = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+export const reduceSetData = <S extends State>(classState: ClassState<S>, action: BaseAction): ClassState<S> => {
   const { myID, data } = action
 
-  const me = state.nodes[myID]
-  if (!me) return state
+  const myNode = classState.nodes[myID]
+  if (!myNode) return classState
 
-  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 })
+  const newMyState = Object.assign({}, myNode.state, data)
+  const newMyNode = Object.assign({}, myNode, { state: newMyState })
+  const newNodes = Object.assign({}, classState.nodes, { [myID]: newMyNode })
+  const newClassState = Object.assign({}, classState, { nodes: newNodes })
 
-  return newState
+  return newClassState
 }

package/src/setRoot.ts

@@ -7,8 +7,8 @@ export const setRoot = (myID: string): BaseAction => ({
   type: SET_ROOT,
 })
 
-export const reduceSetRoot = <S extends State>(state: ClassState<S>, action: BaseAction): ClassState<S> => {
+export const reduceSetRoot = <S extends State>(classState: ClassState<S>, action: BaseAction): ClassState<S> => {
   const { myID } = action
 
-  return Object.assign({}, state, { root: myID })
+  return Object.assign({}, classState, { root: myID })
 }

package/src/stateTypes.ts

@@ -8,6 +8,9 @@ export enum Relation {
   LINKS = '_links',
 }
 
+// XXX PARENT is considered as a special relation
+//     and is not part of the enum Relation.
+//     The relation-ops does not apply to PARENT.
 export const PARENT = '_parent'
 
 //State

package/src/states.ts

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

package/src/useThunk.ts

@@ -2,7 +2,7 @@ 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 { ClassState, NodeStateMap, State } from './stateTypes'
 import type { ThunkModule, ThunkModuleFunc } from './thunk'
 import { DEFAULT_THUNK_MODULE_FUNC_MAP } from './thunkModuleFuncMap'
 import useThunkReducer from './thunkReducer'

package/types/addChild.d.ts

@@ -2,4 +2,4 @@ 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>;
+export declare const reduceAddChild: <S extends State>(classState: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addLink.d.ts

@@ -3,4 +3,4 @@ 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>;
+export declare const reduceAddLink: <S extends State>(classState: ClassState<S>, action: AddRelationAction) => ClassState<S>;

package/types/addRelation.d.ts

@@ -3,4 +3,4 @@ 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>;
+export declare const reduceAddRelation: <S extends State>(classState: ClassState<S>, action: AddRelationAction, relationName: Relation) => ClassState<S>;

package/types/getRelation.d.ts

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

@@ -15,5 +15,5 @@ interface InitAction<S extends State> extends BaseAction {
     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 declare const reduceInit: <S extends State>(classState: ClassState<S>, action: InitAction<S>) => ClassState<S>;
 export {};

package/types/remove.d.ts

@@ -2,4 +2,4 @@ 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>;
+export declare const reduceRemove: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/removeChild.d.ts

@@ -6,4 +6,4 @@ import { type ClassState, type State } from './stateTypes';
  */
 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>;
+export declare const reduceRemoveChild: <S extends State>(classState: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeLink.d.ts

@@ -6,4 +6,4 @@ import { type ClassState, type State } from './stateTypes';
  */
 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>;
+export declare const reduceRemoveLink: <S extends State>(classState: ClassState<S>, action: RemoveRelationAction) => ClassState<S>;

package/types/removeRelation.d.ts

@@ -8,5 +8,5 @@ export interface RemoveRelationAction extends BaseAction {
 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 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/setData.d.ts

@@ -2,4 +2,4 @@ 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>;
+export declare const reduceSetData: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/setRoot.d.ts

@@ -2,4 +2,4 @@ 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>;
+export declare const reduceSetRoot: <S extends State>(classState: ClassState<S>, action: BaseAction) => ClassState<S>;

package/types/states.d.ts

@@ -1,6 +1,4 @@
 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;
+export declare const getRootID: <S extends State>(classState: ClassState<S>) => string;
+export declare const getNode: <S extends State>(classState: ClassState<S>, myID?: string) => NodeState<S> | null;
+export declare const getState: <S extends State>(classState: ClassState<S>, myID?: string) => S | null;