vap1 0.0.1

package/hooks/useEffectOnce.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEffectOnce = void 0;
+const react_1 = require("react");
+const lodash_1 = __importDefault(require("lodash"));
+/**
+ * 仅使用一次的Effect
+*/
+const useEffectOnce = (fn) => {
+    (0, react_1.useEffect)(() => {
+        const result = fn();
+        if (typeof result == 'function') {
+            if (lodash_1.default.has(result, 'then')) {
+                return;
+            }
+            return result;
+        }
+    }, []);
+};
+exports.useEffectOnce = useEffectOnce;

package/hooks/useError.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useError.md
+*/
+export declare const useError: () => (err: Error) => void;

package/hooks/useError.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useError = void 0;
+const react_1 = require("react");
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useError.md
+*/
+const useError = () => {
+    const [error, setError] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        if (error) {
+            throw error;
+        }
+    }, [error]);
+    const dispatchError = (0, react_1.useCallback)((err) => {
+        setError(err);
+    }, []);
+    return dispatchError;
+};
+exports.useError = useError;

package/hooks/useFirstMountState.d.ts

@@ -0,0 +1,6 @@
+/**
+ * 判断一个组件是否是首次渲染
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useFirstMountState.md
+*/
+export declare const useFirstMountState: () => boolean;

package/hooks/useFirstMountState.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFirstMountState = void 0;
+const react_1 = require("react");
+/**
+ * 判断一个组件是否是首次渲染
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useFirstMountState.md
+*/
+const useFirstMountState = () => {
+    const isFirst = (0, react_1.useRef)(true);
+    if (isFirst.current) {
+        isFirst.current = false;
+        return true;
+    }
+    return isFirst.current;
+};
+exports.useFirstMountState = useFirstMountState;

package/hooks/useGenkey.d.ts

@@ -0,0 +1,2 @@
+import type { DependencyList } from 'react';
+export declare const useGenKey: (deps: DependencyList) => string;

package/hooks/useGenkey.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGenKey = void 0;
+const useUpdate_1 = require("./useUpdate");
+const react_1 = require("react");
+const utils_1 = require("../utils");
+const useGenKey = (deps) => {
+    const update = (0, useUpdate_1.useUpdate)();
+    const keyRef = (0, react_1.useRef)(utils_1.StringUtil.genKey());
+    (0, react_1.useEffect)(() => {
+        keyRef.current = utils_1.StringUtil.genKey();
+        update();
+    }, deps);
+    return keyRef.current;
+};
+exports.useGenKey = useGenKey;

package/hooks/useGetSet.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch } from 'react';
+type IHookStateInitialSetter<S> = () => S;
+type IHookStateInitAction<S> = S | IHookStateInitialSetter<S>;
+type IHookStateSetter<S> = ((prevState: S) => S) | (() => S);
+type IHookStateSetAction<S> = S | IHookStateSetter<S>;
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useGetSet.md
+*/
+export declare const useGetSet: <S>(initialState: IHookStateInitAction<S>) => [get: () => S, set: Dispatch<IHookStateSetAction<S>>];
+export {};

package/hooks/useGetSet.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGetSet = void 0;
+const react_1 = require("react");
+const useUpdate_1 = require("./useUpdate");
+function resolveHookState(nextState, currentState) {
+    if (typeof nextState === 'function') {
+        return nextState.length ? nextState(currentState) : nextState();
+    }
+    return nextState;
+}
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useGetSet.md
+*/
+const useGetSet = (initialState) => {
+    const state = (0, react_1.useRef)(resolveHookState(initialState));
+    const update = (0, useUpdate_1.useUpdate)();
+    return (0, react_1.useMemo)(() => [
+        () => state.current,
+        (newState) => {
+            state.current = resolveHookState(newState, state.current);
+            update();
+        },
+    ], []);
+};
+exports.useGetSet = useGetSet;

package/hooks/useGlobal.d.ts

@@ -0,0 +1,19 @@
+import { Dispatch, SetStateAction } from 'react';
+export type UseGStateOptions = {
+    /**
+     * 共享此模型, 默认不共享，说明 ：
+     *
+     *  1. 不设置 share 时，共享模型，
+     *      共享模型在所有 app-xxx 不得有 namespace 重名，否则会出BUG
+     *  2. 设置 share : false 时，不共享
+     *      没有共享的模型仅在 本 app-xx 有效
+    */
+    share?: true;
+};
+/**
+ * 参数 1，2 相当于 state,setState
+ * 参数 3 : loaded  首次返回 false, 其次返回true
+ * 参数 4 : 如果 shrare  = true ，则和其它应用共享数据
+ *
+*/
+export declare const useGlobal: <T extends object>(nameSpace: string, initValue: T, options?: UseGStateOptions) => [T, Dispatch<SetStateAction<T>>, boolean, (string: any) => any];

package/hooks/useGlobal.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useGlobal = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const react_1 = require("react");
+const _Support_1 = require("../utils/_Support");
+const PageUtil_1 = require("../utils/PageUtil");
+const _V_STATE = (0, _Support_1.globalDefault)('_V_STATE', {});
+const SHARE_SPACE = '_SHARE';
+// import type { Dispatch, SetStateAction } from 'react';
+const useUpdate_1 = require("./useUpdate");
+/**
+ * 参数 1，2 相当于 state,setState
+ * 参数 3 : loaded  首次返回 false, 其次返回true
+ * 参数 4 : 如果 shrare  = true ，则和其它应用共享数据
+ *
+*/
+const useGlobal = (nameSpace, initValue, options) => {
+    let loaded = true;
+    let appSpace;
+    if (options && options.share) {
+        appSpace = SHARE_SPACE;
+    }
+    else {
+        appSpace = (0, PageUtil_1.currentApp)();
+    }
+    if (!lodash_1.default.has(_V_STATE, appSpace)) {
+        loaded = false;
+        _V_STATE[appSpace] = {};
+    }
+    if (!lodash_1.default.has(_V_STATE[appSpace], nameSpace)) {
+        loaded = false;
+        _V_STATE[appSpace][nameSpace] = initValue;
+    }
+    const stateRef = (0, react_1.useRef)(_V_STATE[appSpace][nameSpace]);
+    const update = (0, useUpdate_1.useUpdate)();
+    const setState = (patch) => {
+        const prev = stateRef.current;
+        let newData = Object.assign({}, prev, patch instanceof Function ? patch(prev) : patch);
+        _V_STATE[appSpace][nameSpace] = newData;
+        stateRef.current = newData;
+        update();
+    };
+    return [
+        stateRef.current,
+        setState,
+        loaded,
+        (path) => {
+            if (lodash_1.default.has(_V_STATE[appSpace], path)) {
+                return lodash_1.default.get(_V_STATE[appSpace], path);
+            }
+            if (appSpace != SHARE_SPACE) {
+                return lodash_1.default.get(_V_STATE[SHARE_SPACE], path);
+            }
+            return null;
+        }
+    ];
+};
+exports.useGlobal = useGlobal;

package/hooks/useGlobal_back.d.ts

@@ -0,0 +1 @@
+export {};

package/hooks/useGlobal_back.js

@@ -0,0 +1,11 @@
+"use strict";
+// 说明： 此文件将用于1.5版本的 Global
+// import _ from 'lodash';
+// import { useRef } from 'react';
+// import { globalDefault } from '../utils/_Support';
+// import { currentApp } from '../utils/PageUtil'
+Object.defineProperty(exports, "__esModule", { value: true });
+const setData = () => { };
+const u = () => {
+    // const s = useReducer()
+};

package/hooks/useHover.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const noop: () => void;
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useHover.md
+*/
+export type Element = ((state: boolean) => React.ReactElement<any>) | React.ReactElement<any>;
+export declare const useHover: (element: Element) => [React.ReactElement<any>, boolean];

package/hooks/useHover.js

@@ -0,0 +1,49 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHover = exports.noop = void 0;
+const react_1 = __importStar(require("react"));
+const noop = () => { };
+exports.noop = noop;
+const useHover = (element) => {
+    const [state, setState] = (0, react_1.useState)(false);
+    const onMouseEnter = (originalOnMouseEnter) => (event) => {
+        (originalOnMouseEnter || exports.noop)(event);
+        setState(true);
+    };
+    const onMouseLeave = (originalOnMouseLeave) => (event) => {
+        (originalOnMouseLeave || exports.noop)(event);
+        setState(false);
+    };
+    if (typeof element === 'function') {
+        element = element(state);
+    }
+    const el = react_1.default.cloneElement(element, {
+        onMouseEnter: onMouseEnter(element.props.onMouseEnter),
+        onMouseLeave: onMouseLeave(element.props.onMouseLeave),
+    });
+    return [el, state];
+};
+exports.useHover = useHover;

package/hooks/useMemoPromise.d.ts

@@ -0,0 +1,6 @@
+import type { DependencyList } from 'react';
+/**
+ * 说明， useMemoPromise 在值没有返回时， value 是 null 如用于解构则报错 ，
+ * 如 const [loading,{a,b}] = useMemoPromise<{a:boolen,b:string}>();
+*/
+export declare const useMemoPromise: <T>(factory: () => Promise<T>, deps: DependencyList) => [boolean, T, any];

package/hooks/useMemoPromise.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMemoPromise = void 0;
+const react_1 = require("react");
+const useUpdate_1 = require("./useUpdate");
+const useEffectFunction_1 = require("./useEffectFunction");
+/**
+ * 说明， useMemoPromise 在值没有返回时， value 是 null 如用于解构则报错 ，
+ * 如 const [loading,{a,b}] = useMemoPromise<{a:boolen,b:string}>();
+*/
+const useMemoPromise = (factory, deps) => {
+    const ref = (0, react_1.useRef)([true, null, null]);
+    const update = (0, useUpdate_1.useUpdate)();
+    (0, useEffectFunction_1.useEffectFunction)(() => __awaiter(void 0, void 0, void 0, function* () {
+        ref.current[0] = true;
+        update();
+        try {
+            const result = yield factory();
+            ;
+            ref.current[1] = result;
+            ref.current[2] = null;
+        }
+        catch (e) {
+            // ref.current[1] = null;
+            ref.current[2] = e;
+        }
+        ref.current[0] = false;
+        update();
+    }), deps);
+    return ref.current;
+    ;
+};
+exports.useMemoPromise = useMemoPromise;

package/hooks/useModals.d.ts

@@ -0,0 +1,40 @@
+import type { UModalProps } from '../components/UForm';
+import type { PlainObject } from "../basetype";
+type ModalsState = {
+    modalProps: Pick<UModalProps, 'open' | 'onCancel' | 'data' | 'isEdit'>;
+    open: boolean;
+    isEdit: boolean;
+    data: PlainObject;
+    /**
+     * 仅仅是一个boolean值，通常用于页面有 UploadModal 时使用， 也可自定义于其它Modal
+     * 对应方法 ：showUpload
+     * */
+    openUpload: boolean;
+    /**
+     * 仅仅是一个boolean值，通常用于页面有 ApiTableModal 时使用， 也可自定义于其它Modal
+     * 对应方法 ：showDetail
+     * */
+    openDetail: boolean;
+    /**
+     * 说明
+     * extra 是用于自行扩展的对象
+    */
+    extra?: any;
+};
+/**
+ * useModals 提供了常用页面处理弹框的一个快捷封装
+ * 用于 添加、编辑 数据 ，及查看数据详情的 UModal
+ * 及 导入 UploadModal 的显示/隐藏控制参数 UploadModal
+ *
+ * 此Hook 没有提供任何数据操作，通常与 useApi返回的模型结合使用。
+*/
+export declare const useModals: () => {
+    modalState: ModalsState;
+    hide: (extra?: any) => void;
+    showInfo: (data: PlainObject, extra?: any) => void;
+    showAdd: (extra?: any) => void;
+    showEdit: (data: PlainObject, extra?: any) => void;
+    showUpload: (extra?: any) => void;
+    showDetail: (data?: PlainObject, extra?: any) => void;
+};
+export {};

package/hooks/useModals.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useModals = void 0;
+const react_1 = require("react");
+/**
+ * useModals 提供了常用页面处理弹框的一个快捷封装
+ * 用于 添加、编辑 数据 ，及查看数据详情的 UModal
+ * 及 导入 UploadModal 的显示/隐藏控制参数 UploadModal
+ *
+ * 此Hook 没有提供任何数据操作，通常与 useApi返回的模型结合使用。
+*/
+const useModals = () => {
+    const [modalState, setState] = (0, react_1.useState)({
+        modalProps: {
+            open: false, data: null, isEdit: false,
+            onCancel: (extra) => {
+                setState(prev => {
+                    let result = {
+                        open: false, openDetail: false, openUpload: false, isEdit: false, data: prev.data,
+                        modalProps: Object.assign(Object.assign({}, prev.modalProps), { open: false })
+                    };
+                    if (extra !== undefined)
+                        result.extra = extra;
+                    return result;
+                });
+            }
+        },
+        open: false,
+        openUpload: false,
+        openDetail: false,
+        isEdit: false,
+        data: {},
+        extra: null,
+    });
+    const hide = (extra) => setState(prev => {
+        let result = {
+            open: false, openDetail: false, openUpload: false, isEdit: false, data: prev.data,
+            modalProps: Object.assign(Object.assign({}, prev.modalProps), { open: false, isEdit: false, data: null })
+        };
+        if (extra !== undefined)
+            result.extra = extra;
+        return result;
+    });
+    const showInfo = (data, extra) => setState(prev => {
+        let result = {
+            open: true, openDetail: false, openUpload: false, isEdit: false, data,
+            modalProps: Object.assign(Object.assign({}, prev.modalProps), { open: true, data, isEdit: false })
+        };
+        if (extra !== undefined)
+            result.extra = extra;
+        return result;
+    });
+    const showAdd = (extra) => setState(prev => {
+        let result = {
+            open: true, openDetail: false, openUpload: false, data: null, isEdit: false,
+            modalProps: Object.assign(Object.assign({}, prev.modalProps), { open: true, data: null, isEdit: false })
+        };
+        if (extra !== undefined)
+            result.extra = extra;
+        return result;
+    });
+    const showEdit = (data, extra) => setState(prev => {
+        let result = {
+            open: true, openDetail: false, openUpload: false, data, isEdit: true,
+            modalProps: Object.assign(Object.assign({}, prev.modalProps), { open: true, data, isEdit: true })
+        };
+        if (data !== undefined)
+            result.data = data;
+        if (extra !== undefined)
+            result.extra = extra;
+        return result;
+    });
+    const showUpload = (extra) => setState(prev => {
+        let result = {
+            open: false, openDetail: false, openUpload: true, data: prev.data, isEdit: false,
+            modalProps: Object.assign(Object.assign({}, prev.modalProps), { open: false })
+        };
+        if (extra !== undefined)
+            result.extra = extra;
+        return result;
+    });
+    const showDetail = (data, extra) => setState(prev => {
+        let result = {
+            open: false, openDetail: true, openUpload: false, data: prev.data, isEdit: false,
+            modalProps: Object.assign(Object.assign({}, prev.modalProps), { open: false })
+        };
+        if (data !== undefined)
+            result.data = data;
+        if (extra !== undefined)
+            result.extra = extra;
+        return result;
+    });
+    return {
+        modalState,
+        hide, showInfo, showAdd, showEdit, showUpload, showDetail,
+    };
+};
+exports.useModals = useModals;

package/hooks/useMountedState.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useMountedState.md
+*/
+export declare const useMountedState: () => (() => boolean);

package/hooks/useMountedState.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMountedState = void 0;
+const react_1 = require("react");
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useMountedState.md
+*/
+const useMountedState = () => {
+    const mountedRef = (0, react_1.useRef)(false);
+    const get = (0, react_1.useCallback)(() => mountedRef.current, []);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+        };
+    }, []);
+    return get;
+};
+exports.useMountedState = useMountedState;

package/hooks/useOpenState.d.ts

@@ -0,0 +1,28 @@
+export type OpenState = {
+    /**
+     * 打开/关闭 状态
+    */
+    open: boolean;
+    /**
+     * 打开时顺代的参数，
+    */
+    data: any;
+    /**
+     * 打开时顺代的扩展参数
+    */
+    extra: any;
+    /**
+     * 打开
+    */
+    show: (data: any, extra?: any) => void;
+    /**
+     * 关闭
+    */
+    hide: () => void;
+};
+/**
+ * 一个打开，关闭的 hook
+ * 通用用于 Modal, Drawer, PopHover, DrowDown 等组件
+ * 除了 open属性外，可额外携带两个数据
+*/
+export declare const useOpenState: () => OpenState;

package/hooks/useOpenState.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenState = void 0;
+const react_1 = require("react");
+/**
+ * 一个打开，关闭的 hook
+ * 通用用于 Modal, Drawer, PopHover, DrowDown 等组件
+ * 除了 open属性外，可额外携带两个数据
+*/
+const useOpenState = () => {
+    const [[open, data, extra], setState] = (0, react_1.useState)([false, {}, null]);
+    return {
+        open,
+        data,
+        extra,
+        show: (data, extra) => setState(prev => {
+            let ext = extra === undefined ? prev[2] : extra;
+            return [true, data, ext];
+        }),
+        hide: () => setState(prev => [false, prev[1], prev[2]]),
+    };
+};
+exports.useOpenState = useOpenState;

package/hooks/usePromise.d.ts

@@ -0,0 +1,7 @@
+type UsePromise = () => <T>(promise: Promise<T>) => Promise<T>;
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/usePromise.md
+*/
+export declare const usePromise: UsePromise;
+export {};

package/hooks/usePromise.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePromise = void 0;
+const react_1 = require("react");
+const useMountedState_1 = require("./useMountedState");
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/usePromise.md
+*/
+const usePromise = () => {
+    const isMounted = (0, useMountedState_1.useMountedState)();
+    return (0, react_1.useCallback)((promise) => new Promise((resolve, reject) => {
+        const onValue = (value) => {
+            isMounted() && resolve(value);
+        };
+        const onError = (error) => {
+            isMounted() && reject(error);
+        };
+        promise.then(onValue, onError);
+    }), []);
+};
+exports.usePromise = usePromise;

package/hooks/useQueue.d.ts

@@ -0,0 +1,12 @@
+export interface QueueMethods<T> {
+    add: (item: T) => void;
+    remove: () => T;
+    first: T;
+    last: T;
+    size: number;
+}
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useQueue.md
+ * */
+export declare const useQueue: <T>(initialValue?: T[]) => QueueMethods<T>;

package/hooks/useQueue.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useQueue = void 0;
+const react_1 = require("react");
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useQueue.md
+ * */
+const useQueue = (initialValue = []) => {
+    const [state, set] = (0, react_1.useState)(initialValue);
+    return {
+        add: (value) => {
+            set((queue) => [...queue, value]);
+        },
+        remove: () => {
+            let result;
+            set(([first, ...rest]) => {
+                result = first;
+                return rest;
+            });
+            return result;
+        },
+        get first() {
+            return state[0];
+        },
+        get last() {
+            return state[state.length - 1];
+        },
+        get size() {
+            return state.length;
+        },
+    };
+};
+exports.useQueue = useQueue;

package/hooks/useSetState.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 使用方法参考
+ * https://github.com/streamich/react-use/blob/master/docs/useSetState.md
+ *
+ * 扩展点 1： 支持返回 null ，返回  null 不渲染，性能增加
+ * 扩展点 2： 支持 callBack
+ *
+*/
+export declare const useSetState: <T extends object>(initialState?: T) => [T, (patch: Partial<T> | ((prevState: T) => Partial<T>), cb?: (nextState: T) => void) => void];