@chaomingd/hooks 0.0.34

package/dist/esm/useResponsive/index.d.ts

@@ -0,0 +1,44 @@
+import { MutableRefObject } from 'react';
+export interface IResponsiveConfigItem<TData = any> {
+    key: string;
+    val: number;
+    minWidth?: number;
+    maxWidth?: number;
+    data: TData;
+    [key: string]: any;
+}
+export interface IUseResponseParams<TData = any> {
+    mediaQuery?: IResponsiveConfigItem<TData>[];
+    onChange?: (item: IResponsiveConfigItem<TData>) => void;
+    enable?: boolean;
+    containerRef?: MutableRefObject<HTMLElement | null>;
+}
+/**
+ * @examples
+ * ```ts
+  // window resize
+  const { matchedItem } = useResponsive({
+    mediaQuery: [
+      { key: 'small', maxWidth: 760 },
+      { key: 'middle', minWidth: 761, maxWidth: 1440 },
+      { key: 'big', minWidth: 1441 }
+    ],
+    onChange: (matchedItem) => {}
+  });
+  // dom resize
+  const containerRef = useRef<HTMLDivElement | null>(null);
+  const { matchedItem } = useResponsive({
+    containerRef,
+    mediaQuery: [
+      { key: 'small', maxWidth: 760 },
+      { key: 'middle', minWidth: 761, maxWidth: 1440 },
+      { key: 'big', minWidth: 1441 }
+    ],
+    onChange: (matchedItem) => {}
+  });
+ * ```
+*/
+export declare function useResponsive<TData = any>(params: IUseResponseParams<TData>): {
+    mediaQueryMatchedItem: IResponsiveConfigItem<TData> | null;
+    matchMedia: (this: unknown) => void;
+};

package/dist/esm/useResponsive/index.js

@@ -0,0 +1,94 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { listen, isSameObject, resizeObserver } from '@chaomingd/utils';
+import { useLatest, useMemoizedFn } from 'ahooks';
+import { useRef, useState } from 'react';
+import { useEffectWithTarget } from "../useEffectWithTarget";
+/**
+ * @examples
+ * ```ts
+  // window resize
+  const { matchedItem } = useResponsive({
+    mediaQuery: [
+      { key: 'small', maxWidth: 760 },
+      { key: 'middle', minWidth: 761, maxWidth: 1440 },
+      { key: 'big', minWidth: 1441 }
+    ],
+    onChange: (matchedItem) => {}
+  });
+  // dom resize
+  const containerRef = useRef<HTMLDivElement | null>(null);
+  const { matchedItem } = useResponsive({
+    containerRef,
+    mediaQuery: [
+      { key: 'small', maxWidth: 760 },
+      { key: 'middle', minWidth: 761, maxWidth: 1440 },
+      { key: 'big', minWidth: 1441 }
+    ],
+    onChange: (matchedItem) => {}
+  });
+ * ```
+*/
+
+export function useResponsive(params) {
+  var _useState = useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    mediaQueryMatchedItem = _useState2[0],
+    setMatchedItem = _useState2[1];
+  var paramsRef = useLatest(params);
+  var currDataRef = useRef(null);
+  var matchMedia = useMemoizedFn(function () {
+    var _paramsRef$current, _params$containerRef;
+    if (!paramsRef.current.enable || !((_paramsRef$current = paramsRef.current) !== null && _paramsRef$current !== void 0 && _paramsRef$current.mediaQuery)) return;
+    var width;
+    if ((_params$containerRef = params.containerRef) !== null && _params$containerRef !== void 0 && _params$containerRef.current) {
+      width = params.containerRef.current.getBoundingClientRect().width;
+    } else {
+      width = window.innerWidth;
+    }
+    var mediaQuery = paramsRef.current.mediaQuery;
+    var matchItem = null;
+    if (mediaQuery) {
+      for (var i = 0; i < mediaQuery.length; i++) {
+        var _item = mediaQuery[i];
+        if (width >= (_item.minWidth || 0) && width <= (_item.maxWidth || Infinity)) {
+          matchItem = _item;
+          break;
+        }
+      }
+      if (!matchItem) {
+        matchItem = mediaQuery[0];
+      }
+      if (matchItem && !isSameObject(currDataRef.current, matchItem)) {
+        var _onChange, _ref;
+        currDataRef.current = matchItem;
+        setMatchedItem(matchItem);
+        (_onChange = (_ref = paramsRef.current).onChange) === null || _onChange === void 0 || _onChange.call(_ref, matchItem);
+      }
+    }
+  });
+  useEffectWithTarget(function () {
+    var _params$containerRef2;
+    matchMedia();
+    var offResize;
+    if ((_params$containerRef2 = params.containerRef) !== null && _params$containerRef2 !== void 0 && _params$containerRef2.current) {
+      offResize = resizeObserver({
+        el: params.containerRef.current,
+        onResize: matchMedia
+      });
+    } else {
+      offResize = listen(window, 'resize', matchMedia);
+    }
+    return function () {
+      offResize();
+    };
+  }, params.containerRef, [], true);
+  return {
+    mediaQueryMatchedItem: mediaQueryMatchedItem,
+    matchMedia: matchMedia
+  };
+}

package/dist/esm/useSelectionList/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="react" />
+interface IConfig<T = any> {
+    dataList?: T[];
+    listKey?: string;
+    getKey?: (item: T) => string;
+}
+export declare function useSelectionList<TData = any>({ dataList, listKey, getKey, }: IConfig<TData>): {
+    selectedKeys: string[];
+    selectedListKeys: string[];
+    selectedListItems: TData[];
+    changeSelectedListKeys: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+};
+export {};

package/dist/esm/useSelectionList/index.js

@@ -0,0 +1,49 @@
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+import { arrayToMap } from '@chaomingd/utils';
+import { useLatest } from 'ahooks';
+import { useMemo, useState } from 'react';
+var DEFAULT_LIST_KEY = 'key';
+export function useSelectionList(_ref) {
+  var dataList = _ref.dataList,
+    listKey = _ref.listKey,
+    getKey = _ref.getKey;
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    selectedKeys = _useState2[0],
+    changeSelectedListKeys = _useState2[1];
+  var getKeyRef = useLatest(getKey);
+  var selectedListData = useMemo(function () {
+    if (!dataList || !dataList.length) {
+      return {
+        selectedKeys: selectedKeys,
+        selectedListKeys: [],
+        selectedListItems: [],
+        changeSelectedListKeys: changeSelectedListKeys
+      };
+    }
+    var getKeyFunc = getKeyRef.current ? getKeyRef.current : function (item) {
+      return item && item[listKey || DEFAULT_LIST_KEY];
+    };
+    var listDatMap = arrayToMap(dataList, getKeyFunc);
+    var selectedListKeys = [];
+    var selectedListItems = [];
+    selectedKeys.forEach(function (key) {
+      if (listDatMap[key]) {
+        selectedListKeys.push(key);
+        selectedListItems.push(listDatMap[key]);
+      }
+    });
+    return {
+      selectedKeys: selectedKeys,
+      selectedListKeys: selectedListKeys,
+      selectedListItems: selectedListItems,
+      changeSelectedListKeys: changeSelectedListKeys
+    };
+  }, [dataList, listKey, getKeyRef, selectedKeys]);
+  return selectedListData;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,10 @@
+import useLatestState from './useLatestState';
+export * from './useDragAndDrop';
+export * from './usePagination';
+export * from './useResizer';
+export * from './useResponsive';
+export * from './useEffectWithTarget';
+export * from './useEditModal';
+export * from './useListLayout';
+export * from './useSelectionList';
+export { useLatestState };

package/dist/lib/index.js

@@ -0,0 +1,112 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  useLatestState: true
+};
+Object.defineProperty(exports, "useLatestState", {
+  enumerable: true,
+  get: function () {
+    return _useLatestState.default;
+  }
+});
+var _useLatestState = _interopRequireDefault(require("./useLatestState"));
+var _useDragAndDrop = require("./useDragAndDrop");
+Object.keys(_useDragAndDrop).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useDragAndDrop[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useDragAndDrop[key];
+    }
+  });
+});
+var _usePagination = require("./usePagination");
+Object.keys(_usePagination).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _usePagination[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _usePagination[key];
+    }
+  });
+});
+var _useResizer = require("./useResizer");
+Object.keys(_useResizer).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useResizer[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useResizer[key];
+    }
+  });
+});
+var _useResponsive = require("./useResponsive");
+Object.keys(_useResponsive).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useResponsive[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useResponsive[key];
+    }
+  });
+});
+var _useEffectWithTarget = require("./useEffectWithTarget");
+Object.keys(_useEffectWithTarget).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useEffectWithTarget[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useEffectWithTarget[key];
+    }
+  });
+});
+var _useEditModal = require("./useEditModal");
+Object.keys(_useEditModal).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useEditModal[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useEditModal[key];
+    }
+  });
+});
+var _useListLayout = require("./useListLayout");
+Object.keys(_useListLayout).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useListLayout[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useListLayout[key];
+    }
+  });
+});
+var _useSelectionList = require("./useSelectionList");
+Object.keys(_useSelectionList).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _useSelectionList[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _useSelectionList[key];
+    }
+  });
+});
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/dist/lib/useDragAndDrop/index.d.ts

@@ -0,0 +1,35 @@
+import { MutableRefObject } from 'react';
+import './index.less';
+type TEffect = 'disabled' | 'drop' | 'auto' | '';
+declare function updateDragEffect(effect: TEffect): void;
+export declare function setDragData(data: Record<string, any>): void;
+export declare function getDragData(): {
+    [x: string]: any;
+};
+type TDomRef = MutableRefObject<HTMLElement | null>;
+interface ICallbackOptions {
+    setDragData: typeof setDragData;
+    updateDragEffect: typeof updateDragEffect;
+    node: HTMLElement;
+}
+export interface IDragOptions {
+    onDragStart?: (e: MouseEvent, options: ICallbackOptions) => void;
+    onDragEnd?: (e: MouseEvent, options: ICallbackOptions) => void;
+    key: string;
+    containerClassName?: string;
+}
+export declare function handlerDragMouseDown(e: any, options: IDragOptions, dom: HTMLElement | null): void;
+interface IDropCallbackOptions {
+    updateDragEffect: typeof updateDragEffect;
+    getDragData: typeof getDragData;
+}
+export interface IDropOptions {
+    key: string;
+    onDragEnter?: (e: MouseEvent, options: IDropCallbackOptions) => void;
+    onDragLeave?: (e: MouseEvent, options: IDropCallbackOptions) => void;
+    onDragMove?: (e: MouseEvent, options: IDropCallbackOptions) => void;
+    onDrop?: (e: MouseEvent, options: IDropCallbackOptions) => void;
+    onValideDrop?: (e: MouseEvent, options: IDropCallbackOptions) => boolean;
+}
+export declare function useDrop(domRef: TDomRef, options: IDropOptions): void;
+export {};

package/dist/lib/useDragAndDrop/index.js

@@ -0,0 +1,191 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDragData = getDragData;
+exports.handlerDragMouseDown = handlerDragMouseDown;
+exports.setDragData = setDragData;
+exports.useDrop = useDrop;
+var _utils = require("@chaomingd/utils");
+var _react = require("react");
+require("./index.less");
+const Signal = new _utils.EventEmitter();
+const store = getInitialStore();
+function getInitialStore() {
+  return {
+    data: {},
+    container: null,
+    draging: false,
+    enterDropArea: false,
+    offset: {
+      x: 0,
+      y: 0
+    },
+    effect: ''
+  };
+}
+function resetStore() {
+  Object.assign(store, getInitialStore());
+}
+function updateDragEffect(effect) {
+  if (effect === store.effect) return;
+  store.effect = effect;
+  const container = store.container;
+  if (container) {
+    container.setAttribute('effect', effect);
+  }
+}
+function setDragData(data) {
+  Object.assign(store.data, data);
+}
+function getDragData() {
+  return {
+    ...store.data
+  };
+}
+function initContainer(options) {
+  if (!store.container) {
+    store.container = document.createElement('div');
+  }
+  if (store.container.parentNode === document.body) return;
+  let className = 'laf-drag-item';
+  if (options.containerClassName) {
+    className += ` ${options.containerClassName}`;
+  }
+  store.container.className = className;
+  document.body.appendChild(store.container);
+}
+function addTargetCloneNode(dom) {
+  const node = dom.cloneNode(true);
+  node.style.position = 'static';
+  const rect = dom.getBoundingClientRect();
+  store.container.style.width = rect.width + 'px';
+  store.container.style.height = rect.height + 'px';
+  store.container.appendChild(node);
+  return node;
+}
+function updateContainerPosition(e, dom) {
+  const container = store.container;
+  const offset = store.offset;
+  // container.style.left = e.clientX - offset.x + 'px';
+  // container.style.top = e.clientY - offset.y + 'px';
+  container.style.transform = `translate3d(${e.clientX - offset.x}px, ${e.clientY - offset.y}px, 0)`;
+  if (isInDom(dom, e)) {
+    updateDragEffect('auto');
+  } else {
+    if (!store.enterDropArea) {
+      updateDragEffect('disabled');
+    }
+  }
+}
+function removeContainer() {
+  if (store.container) {
+    store.container.firstElementChild && store.container.removeChild(store.container.firstElementChild);
+    store.container.parentNode?.removeChild(store.container);
+    store.container = null;
+  }
+}
+function setOffset(e, dom) {
+  if (!dom) return;
+  const rect = dom.getBoundingClientRect();
+  store.offset = {
+    x: e.clientX - rect.left,
+    y: e.clientY - rect.top
+  };
+}
+function handlerDragMouseDown(e, options, dom) {
+  if (!dom) return;
+  let move = false;
+  let cloneNode;
+  initContainer(options);
+  const SignalKey = options.key;
+  setOffset(e, dom);
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  const offMouseMove = (0, _utils.listen)(document, 'mousemove', e => {
+    e.preventDefault();
+    if (!move) {
+      cloneNode = addTargetCloneNode(dom);
+      options.onDragStart?.(e, {
+        setDragData,
+        updateDragEffect,
+        node: cloneNode
+      });
+      move = true;
+      store.draging = true;
+    } else {
+      Signal.emit(`${SignalKey}-mousemove`, e);
+    }
+    updateContainerPosition(e, dom);
+  });
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  const offMouseUp = (0, _utils.listen)(document, 'mouseup', e => {
+    e.preventDefault();
+    offMouseMove();
+    offMouseUp();
+    if (move) {
+      options.onDragEnd?.(e, {
+        node: cloneNode,
+        setDragData,
+        updateDragEffect
+      });
+      Signal.emit(`${SignalKey}-mouseup`, e);
+    }
+    updateDragEffect('auto');
+    removeContainer();
+    resetStore();
+  });
+}
+function useDrop(domRef, options) {
+  const optionsRef = (0, _react.useRef)(options);
+  (0, _react.useEffect)(() => {
+    const SignalKey = optionsRef.current.key;
+    let isDragEnter = false;
+    const callbackOptions = {
+      updateDragEffect,
+      getDragData
+    };
+    const onMouseMove = e => {
+      if (isInDom(domRef.current, e)) {
+        if (!isDragEnter) {
+          isDragEnter = true;
+          optionsRef.current.onDragEnter?.(e, callbackOptions);
+          store.enterDropArea = true;
+          updateDragEffect('drop');
+        }
+        optionsRef.current.onDragMove?.(e, callbackOptions);
+      } else {
+        if (isDragEnter) {
+          store.enterDropArea = false;
+          isDragEnter = false;
+          updateDragEffect('disabled');
+          optionsRef.current.onDragLeave?.(e, callbackOptions);
+        }
+      }
+    };
+    const onMouseUp = e => {
+      if (isInDom(domRef.current, e)) {
+        let validate = true;
+        if (optionsRef.current.onValideDrop) {
+          validate = optionsRef.current.onValideDrop(e, callbackOptions);
+        }
+        if (validate) {
+          optionsRef.current.onDrop?.(e, callbackOptions);
+        }
+      }
+      store.enterDropArea = false;
+    };
+    Signal.on(`${SignalKey}-mousemove`, onMouseMove);
+    Signal.on(`${SignalKey}-mouseup`, onMouseUp);
+  }, [domRef]);
+}
+function isInDom(dom, e) {
+  if (!dom) return false;
+  const rect = dom.getBoundingClientRect();
+  const clientX = e.clientX;
+  const clientY = e.clientY;
+  if (clientX < rect.left || clientX > rect.left + rect.width || clientY < rect.top || clientY > rect.top + rect.height) {
+    return false;
+  }
+  return true;
+}

package/dist/lib/useDragAndDrop/index.less

@@ -0,0 +1,29 @@
+.laf-drag-item {
+  position: fixed;
+  z-index: 10000;
+  opacity: 0.7;
+  top: 0;
+  left: 0;
+
+  &::after {
+    content: '';
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    width: 200%;
+    height: 200%;
+    transform: translate(-50%, -50%);
+  }
+
+  &[effect='disabled'] {
+    &::after {
+      cursor: not-allowed;
+    }
+  }
+
+  &[effect='drop'] {
+    &::after {
+      cursor: copy;
+    }
+  }
+}

package/dist/lib/useEditModal/index.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import { FormInstance } from 'antd';
+interface IState {
+    visible: boolean;
+    title: string;
+    loading: boolean;
+    confirmLoading: boolean;
+    isEdit: boolean;
+    [key: string]: any;
+}
+interface IHandlerReturnValue<IFormValues extends Record<string, any> = Record<string, any>, IUserState extends Record<string, any> = Record<string, any>> {
+    formValue?: Partial<IFormValues>;
+    state?: Partial<IState & IUserState>;
+}
+interface IHandlerData<IFormValues extends Record<string, any> = Record<string, any>, IUserState extends Record<string, any> = Record<string, any>> {
+    formValue?: Partial<IFormValues>;
+    state?: Partial<IState & IUserState>;
+    onSave?: (res: any, state: IState & IUserState) => void;
+    onError?: (e: Error) => void;
+    [key: string]: any;
+}
+type TPromiseValue<T> = T | Promise<T>;
+interface IConfig<IFormValues extends Record<string, any> = Record<string, any>, IUserState extends Record<string, any> = Record<string, any>> {
+    title?: string;
+    hasLoading?: boolean;
+    hasConfirmLoading?: boolean;
+    saveService?: (formValues: IFormValues, state: IState & IUserState) => Promise<any>;
+    onSaveClose?: boolean;
+    onCloseResetState?: boolean;
+    onClose?: () => void;
+    onSave?: (res: any, state: IState & IUserState) => void;
+    onAdd?: (data: IHandlerReturnValue<IFormValues, IUserState>) => TPromiseValue<void | undefined | IHandlerReturnValue<IFormValues, IUserState>>;
+    onEdit?: (data: IHandlerReturnValue<IFormValues, IUserState>) => TPromiseValue<void | undefined | IHandlerReturnValue<IFormValues, IUserState>>;
+    defaultState?: IUserState;
+    form?: FormInstance;
+}
+export declare function useEditModal<IFormValues extends Record<string, any> = Record<string, any>, IUserState extends Record<string, any> = Record<string, any>>({ onAdd, onEdit, title, saveService, hasLoading, hasConfirmLoading, onSaveClose, onCloseResetState, onClose, onSave, defaultState, form, }?: IConfig<IFormValues, IUserState>): {
+    modalProps: {
+        open: boolean;
+        title: string;
+        onCancel: () => void;
+        onOk: () => void;
+        confirmLoading: boolean;
+        afterOpenChange: (open: boolean) => void;
+    };
+    state: IState & IUserState;
+    originDataRef: import("react").MutableRefObject<IHandlerData<IFormValues, IUserState>>;
+    formRef: import("react").MutableRefObject<FormInstance<any> | null>;
+    add: (data: IHandlerData<IFormValues, IUserState>) => void;
+    edit: (data: IHandlerData<IFormValues, IUserState>) => void;
+    close: () => void;
+    onSubmit: () => void;
+    submit: () => void;
+    model: import("@chaomingd/store").Model<IState, object, Record<string, any>>;
+};
+export {};