@chaomingd/hooks 0.0.34

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# @chaomingd/hooks
+
+[![NPM version](https://img.shields.io/npm/v/@chaomingd/hooks.svg?style=flat)](https://npmjs.com/package/@chaomingd/hooks)
+[![NPM downloads](http://img.shields.io/npm/dm/@chaomingd/hooks.svg?style=flat)](https://npmjs.com/package/@chaomingd/hooks)
+
+## Install
+
+```bash
+$ pnpm install
+```
+
+```bash
+$ npm run dev
+$ npm run build
+```
+
+## Options
+
+TODO
+
+## LICENSE
+
+MIT

package/dist/esm/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/esm/index.js

@@ -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/esm/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/esm/useDragAndDrop/index.js

@@ -0,0 +1,193 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { listen, EventEmitter } from '@chaomingd/utils';
+import { useEffect, useRef } from 'react';
+import "./index.less";
+var Signal = new EventEmitter();
+var 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;
+  var container = store.container;
+  if (container) {
+    container.setAttribute('effect', effect);
+  }
+}
+export function setDragData(data) {
+  Object.assign(store.data, data);
+}
+export function getDragData() {
+  return _objectSpread({}, store.data);
+}
+function initContainer(options) {
+  if (!store.container) {
+    store.container = document.createElement('div');
+  }
+  if (store.container.parentNode === document.body) return;
+  var className = 'laf-drag-item';
+  if (options.containerClassName) {
+    className += " ".concat(options.containerClassName);
+  }
+  store.container.className = className;
+  document.body.appendChild(store.container);
+}
+function addTargetCloneNode(dom) {
+  var node = dom.cloneNode(true);
+  node.style.position = 'static';
+  var 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) {
+  var container = store.container;
+  var offset = store.offset;
+  // container.style.left = e.clientX - offset.x + 'px';
+  // container.style.top = e.clientY - offset.y + 'px';
+  container.style.transform = "translate3d(".concat(e.clientX - offset.x, "px, ").concat(e.clientY - offset.y, "px, 0)");
+  if (isInDom(dom, e)) {
+    updateDragEffect('auto');
+  } else {
+    if (!store.enterDropArea) {
+      updateDragEffect('disabled');
+    }
+  }
+}
+function removeContainer() {
+  if (store.container) {
+    var _store$container$pare;
+    store.container.firstElementChild && store.container.removeChild(store.container.firstElementChild);
+    (_store$container$pare = store.container.parentNode) === null || _store$container$pare === void 0 || _store$container$pare.removeChild(store.container);
+    store.container = null;
+  }
+}
+function setOffset(e, dom) {
+  if (!dom) return;
+  var rect = dom.getBoundingClientRect();
+  store.offset = {
+    x: e.clientX - rect.left,
+    y: e.clientY - rect.top
+  };
+}
+export function handlerDragMouseDown(e, options, dom) {
+  if (!dom) return;
+  var move = false;
+  var cloneNode;
+  initContainer(options);
+  var SignalKey = options.key;
+  setOffset(e, dom);
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  var offMouseMove = listen(document, 'mousemove', function (e) {
+    e.preventDefault();
+    if (!move) {
+      var _options$onDragStart;
+      cloneNode = addTargetCloneNode(dom);
+      (_options$onDragStart = options.onDragStart) === null || _options$onDragStart === void 0 || _options$onDragStart.call(options, e, {
+        setDragData: setDragData,
+        updateDragEffect: updateDragEffect,
+        node: cloneNode
+      });
+      move = true;
+      store.draging = true;
+    } else {
+      Signal.emit("".concat(SignalKey, "-mousemove"), e);
+    }
+    updateContainerPosition(e, dom);
+  });
+  // eslint-disable-next-line @typescript-eslint/no-shadow
+  var offMouseUp = listen(document, 'mouseup', function (e) {
+    e.preventDefault();
+    offMouseMove();
+    offMouseUp();
+    if (move) {
+      var _options$onDragEnd;
+      (_options$onDragEnd = options.onDragEnd) === null || _options$onDragEnd === void 0 || _options$onDragEnd.call(options, e, {
+        node: cloneNode,
+        setDragData: setDragData,
+        updateDragEffect: updateDragEffect
+      });
+      Signal.emit("".concat(SignalKey, "-mouseup"), e);
+    }
+    updateDragEffect('auto');
+    removeContainer();
+    resetStore();
+  });
+}
+export function useDrop(domRef, options) {
+  var optionsRef = useRef(options);
+  useEffect(function () {
+    var SignalKey = optionsRef.current.key;
+    var isDragEnter = false;
+    var callbackOptions = {
+      updateDragEffect: updateDragEffect,
+      getDragData: getDragData
+    };
+    var onMouseMove = function onMouseMove(e) {
+      if (isInDom(domRef.current, e)) {
+        var _optionsRef$current$o2, _optionsRef$current2;
+        if (!isDragEnter) {
+          var _optionsRef$current$o, _optionsRef$current;
+          isDragEnter = true;
+          (_optionsRef$current$o = (_optionsRef$current = optionsRef.current).onDragEnter) === null || _optionsRef$current$o === void 0 || _optionsRef$current$o.call(_optionsRef$current, e, callbackOptions);
+          store.enterDropArea = true;
+          updateDragEffect('drop');
+        }
+        (_optionsRef$current$o2 = (_optionsRef$current2 = optionsRef.current).onDragMove) === null || _optionsRef$current$o2 === void 0 || _optionsRef$current$o2.call(_optionsRef$current2, e, callbackOptions);
+      } else {
+        if (isDragEnter) {
+          var _optionsRef$current$o3, _optionsRef$current3;
+          store.enterDropArea = false;
+          isDragEnter = false;
+          updateDragEffect('disabled');
+          (_optionsRef$current$o3 = (_optionsRef$current3 = optionsRef.current).onDragLeave) === null || _optionsRef$current$o3 === void 0 || _optionsRef$current$o3.call(_optionsRef$current3, e, callbackOptions);
+        }
+      }
+    };
+    var onMouseUp = function onMouseUp(e) {
+      if (isInDom(domRef.current, e)) {
+        var validate = true;
+        if (optionsRef.current.onValideDrop) {
+          validate = optionsRef.current.onValideDrop(e, callbackOptions);
+        }
+        if (validate) {
+          var _optionsRef$current$o4, _optionsRef$current4;
+          (_optionsRef$current$o4 = (_optionsRef$current4 = optionsRef.current).onDrop) === null || _optionsRef$current$o4 === void 0 || _optionsRef$current$o4.call(_optionsRef$current4, e, callbackOptions);
+        }
+      }
+      store.enterDropArea = false;
+    };
+    Signal.on("".concat(SignalKey, "-mousemove"), onMouseMove);
+    Signal.on("".concat(SignalKey, "-mouseup"), onMouseUp);
+  }, [domRef]);
+}
+function isInDom(dom, e) {
+  if (!dom) return false;
+  var rect = dom.getBoundingClientRect();
+  var clientX = e.clientX;
+  var 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/esm/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/esm/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 {};

package/dist/esm/useEditModal/index.js

@@ -0,0 +1,166 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { useRef } from 'react';
+import { useModel } from '@chaomingd/store';
+import { omit } from '@chaomingd/utils';
+function defaultHandler() {
+  return Promise.resolve({});
+}
+export function useEditModal() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$onAdd = _ref.onAdd,
+    onAdd = _ref$onAdd === void 0 ? defaultHandler : _ref$onAdd,
+    _ref$onEdit = _ref.onEdit,
+    onEdit = _ref$onEdit === void 0 ? defaultHandler : _ref$onEdit,
+    _ref$title = _ref.title,
+    title = _ref$title === void 0 ? 'Modal Title' : _ref$title,
+    _ref$saveService = _ref.saveService,
+    saveService = _ref$saveService === void 0 ? defaultHandler : _ref$saveService,
+    _ref$hasLoading = _ref.hasLoading,
+    hasLoading = _ref$hasLoading === void 0 ? true : _ref$hasLoading,
+    _ref$hasConfirmLoadin = _ref.hasConfirmLoading,
+    hasConfirmLoading = _ref$hasConfirmLoadin === void 0 ? true : _ref$hasConfirmLoadin,
+    _ref$onSaveClose = _ref.onSaveClose,
+    onSaveClose = _ref$onSaveClose === void 0 ? true : _ref$onSaveClose,
+    _ref$onCloseResetStat = _ref.onCloseResetState,
+    onCloseResetState = _ref$onCloseResetStat === void 0 ? true : _ref$onCloseResetStat,
+    onClose = _ref.onClose,
+    onSave = _ref.onSave,
+    defaultState = _ref.defaultState,
+    form = _ref.form;
+  var formRef = useRef(form || null);
+  var originDataRef = useRef({});
+  var defaultEditState = _objectSpread({
+    visible: false,
+    title: title,
+    loading: false,
+    isEdit: false,
+    confirmLoading: false
+  }, defaultState);
+  var model = useModel({
+    state: defaultEditState
+  });
+  var state = model.useGetState();
+  var createHandler = function createHandler(isEdit) {
+    return function (data) {
+      if (model.getState().visible) {
+        return;
+      }
+      originDataRef.current = data;
+      var handler = isEdit ? onEdit : onAdd;
+      var formValues = _objectSpread({}, data.formValue || {});
+      var openState = _objectSpread(_objectSpread({}, data.state || {}), {}, {
+        visible: true,
+        isEdit: isEdit
+      });
+      if (hasLoading) {
+        openState.loading = true;
+      }
+      model.setState(openState);
+      var newState = {
+        loading: false
+      };
+      Promise.resolve(handler(data)).then(function (returnValue) {
+        if (returnValue && returnValue.formValue) {
+          Object.assign(formValues, (returnValue === null || returnValue === void 0 ? void 0 : returnValue.formValue) || {});
+        }
+        if (returnValue && returnValue.state) {
+          Object.assign(newState, returnValue.state);
+        }
+      }).finally(function () {
+        var _formRef$current;
+        model.setState(newState);
+        (_formRef$current = formRef.current) === null || _formRef$current === void 0 || _formRef$current.setFieldsValue(formValues);
+      });
+    };
+  };
+  var add = createHandler(false);
+  var edit = createHandler(true);
+  var close = function close() {
+    if (onCloseResetState) {
+      model.setState(omit(defaultEditState, ['title']));
+    } else {
+      model.setState({
+        visible: false
+      });
+    }
+    onClose && onClose();
+  };
+  var afterOpenChange = function afterOpenChange(open) {
+    if (!open) {
+      if (formRef.current) {
+        formRef.current.resetFields();
+      }
+    }
+  };
+  var onSubmit = function onSubmit() {
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    var handleService = function handleService(values, state) {
+      return saveService === null || saveService === void 0 ? void 0 : saveService(values, state).then(function (res) {
+        var currentState = model.getState();
+        onSaveClose && close();
+        onSave && onSave(res, currentState);
+        originDataRef.current.onSave && originDataRef.current.onSave(res, currentState);
+        if (hasConfirmLoading) {
+          model.setState({
+            confirmLoading: false
+          });
+        }
+        return res;
+      });
+    };
+    if (hasConfirmLoading) {
+      model.setState({
+        confirmLoading: true
+      });
+    }
+    if (formRef.current) {
+      var _formRef$current2;
+      (_formRef$current2 = formRef.current) === null || _formRef$current2 === void 0 || _formRef$current2.validateFields().then(function (values) {
+        return handleService(values, model.getState());
+      }).catch(function (e) {
+        console.error(e);
+        originDataRef.current.onError && originDataRef.current.onError(e);
+        if (hasConfirmLoading) {
+          model.setState({
+            confirmLoading: false
+          });
+        }
+      });
+    } else {
+      handleService({}, model.getState()).catch(function (e) {
+        console.error(e);
+        originDataRef.current.onError && originDataRef.current.onError(e);
+        if (hasConfirmLoading) {
+          model.setState({
+            confirmLoading: false
+          });
+        }
+      });
+    }
+  };
+  var modalProps = {
+    open: state.visible,
+    title: state.title,
+    onCancel: close,
+    onOk: onSubmit,
+    confirmLoading: state.confirmLoading,
+    afterOpenChange: afterOpenChange
+  };
+  return {
+    modalProps: modalProps,
+    state: state,
+    originDataRef: originDataRef,
+    formRef: formRef,
+    add: add,
+    edit: edit,
+    close: close,
+    onSubmit: onSubmit,
+    submit: onSubmit,
+    model: model
+  };
+}

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

@@ -0,0 +1,2 @@
+import { MutableRefObject } from 'react';
+export declare function useEffectWithTarget(effect: () => any, targetRef?: MutableRefObject<any> | MutableRefObject<any>[] | null, deps?: any[], strict?: boolean): void;

package/dist/esm/useEffectWithTarget/index.js

@@ -0,0 +1,36 @@
+import { useUnmount } from 'ahooks';
+import { useEffect, useRef } from 'react';
+import { isSameArr, isDefined } from '@chaomingd/utils';
+export function useEffectWithTarget(effect, targetRef, deps) {
+  var strict = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var lastDepsRef = useRef();
+  var lastElementRef = useRef();
+  var lastEffectReturnRef = useRef();
+  var clearEffect = function clearEffect() {
+    if (lastEffectReturnRef.current && typeof lastEffectReturnRef.current === 'function') {
+      lastEffectReturnRef.current();
+    }
+  };
+  useEffect(function () {
+    var currentTarget = (Array.isArray(targetRef) ? targetRef.map(function (ref) {
+      return ref.current;
+    }) : targetRef ? [targetRef.current] : []).filter(function (el) {
+      return isDefined(el);
+    });
+    if (!isSameArr(lastElementRef.current, currentTarget) || lastDepsRef.current && deps && !isSameArr(lastDepsRef.current, deps)) {
+      lastElementRef.current = currentTarget;
+      lastDepsRef.current = deps;
+      clearEffect();
+      if (strict) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        currentTarget.length && (lastEffectReturnRef.current = effect());
+      } else {
+        lastEffectReturnRef.current = effect();
+      }
+    }
+  });
+  useUnmount(function () {
+    lastElementRef.current = undefined;
+    clearEffect();
+  });
+}

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

@@ -0,0 +1,8 @@
+import type { Dispatch, SetStateAction } from 'react';
+declare function useLatestState<T>(initialState: T | (() => T)): [T, Dispatch<SetStateAction<T>>, () => T];
+declare function useLatestState<T = undefined>(): [
+    T | undefined,
+    Dispatch<SetStateAction<T | undefined>>,
+    () => T | undefined
+];
+export default useLatestState;

package/dist/esm/useLatestState/index.js

@@ -0,0 +1,36 @@
+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 { useCallback, useRef, useState } from 'react';
+var isFunction = function isFunction(val) {
+  return typeof val === 'function';
+};
+
+// 获取新的状态值，兼容传值和传函数情况
+function getStateVal(preState, initVal) {
+  if (isFunction(initVal)) {
+    return initVal(preState);
+  }
+  return initVal;
+}
+function useLatestState(initVal) {
+  var initState = getStateVal(undefined, initVal);
+  var _useState = useState(initState),
+    _useState2 = _slicedToArray(_useState, 2),
+    val = _useState2[0],
+    setVal = _useState2[1];
+  var valRef = useRef(initState);
+  var setState = useCallback(function (newVal) {
+    var newState = getStateVal(valRef.current, newVal);
+    valRef.current = newState;
+    setVal(newState);
+  }, []);
+  var getRealState = useCallback(function () {
+    return valRef.current;
+  }, []);
+  return [val, setState, getRealState];
+}
+export default useLatestState;

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

@@ -0,0 +1,20 @@
+import { MutableRefObject } from 'react';
+import { px } from '@chaomingd/utils';
+export declare function setDefaultTransform(transform: typeof px): void;
+export interface UseListLayoutConfig {
+    containerRef?: MutableRefObject<HTMLElement | null>;
+    baseWidth: number;
+    baseHeight?: number;
+    gap?: number | [number, number];
+    onChange?: (state: IState) => any;
+    removeScrollBarWidth?: boolean;
+    pxTransform?: (base: number, width: number) => number;
+}
+interface IState {
+    col: number;
+    row: number;
+    width: number;
+    height: number;
+}
+export declare function useListLayout(config: UseListLayoutConfig): IState;
+export {};