@qsxy/element-plus-react 1.0.1 → 1.0.3

package/dist/Util/base.js

@@ -5,6 +5,8 @@ function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol"
 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); }
 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); }
 import is_empty from 'lodash/isEmpty';
+import isNil from 'lodash/isNil';
+import noop from 'lodash/noop';
 
 /**
  * 判断对象是否为空
@@ -130,6 +132,12 @@ export var isNumber = function isNumber(val) {
 export var isString = function isString(val) {
   return typeof val === 'string';
 };
+export var isFunction = function isFunction(val) {
+  return typeof val === 'function';
+};
+export var isPropAbsent = function isPropAbsent(prop) {
+  return isNil(prop);
+};
 export var isStringNumber = function isStringNumber(val) {
   if (!isString(val)) {
     return false;
@@ -165,4 +173,135 @@ export function mergeDefaultProps() {
     }
   }
   return props;
-}
+}
+var isIOS = /iPhone|iPad|iPod/i.test(navigator.userAgent);
+function isNative(Ctor) {
+  return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
+}
+//  上面三行与核心代码关系不大，了解即可
+//  noop 表示一个无操作空函数，用作函数默认值，防止传入 undefined 导致报错
+//  handleError 错误处理函数
+//  isIE, isIOS, isNative 环境判断函数，
+//  isNative 判断某个属性或方法是否原生支持，如果不支持或通过第三方实现支持都会返回 false
+
+export var isUsingMicroTask = false; // 标记 nextTick 最终是否以微任务执行
+
+var callbacks = []; // 存放调用 nextTick 时传入的回调函数
+var pending = false; // 标记是否已经向任务队列中添加了一个任务，如果已经添加了就不能再添加了
+// 当向任务队列中添加了任务时，将 pending 置为 true，当任务被执行时将 pending 置为 false
+//
+
+// 声明 nextTick 函数，接收一个回调函数和一个执行上下文作为参数
+// 回调的 this 自动绑定到调用它的实例上
+export function nextTick(cb, ctx) {
+  var _resolve;
+  // 将传入的回调函数存放到数组中，后面会遍历执行其中的回调
+  callbacks.push(function () {
+    if (cb) {
+      // 对传入的回调进行 try catch 错误捕获
+      try {
+        cb.call(ctx);
+      } catch (e) {
+        // 进行统一的错误处理
+        // handleError(e, ctx, 'nextTick');
+      }
+    } else if (_resolve) {
+      _resolve(ctx);
+    }
+  });
+
+  // 如果当前没有在 pending 的回调，
+  // 就执行 timeFunc 函数选择当前环境优先支持的异步方法
+  if (!pending) {
+    pending = true;
+    timerFunc();
+  }
+
+  // 如果没有传入回调，并且当前环境支持 promise，就返回一个 promise
+  // 在返回的这个 promise.then 中 DOM 已经更新好了，
+  if (!cb && typeof Promise !== 'undefined') {
+    return new Promise(function (resolve) {
+      _resolve = resolve;
+    });
+  }
+}
+
+// 判断当前环境优先支持的异步方法，优先选择微任务
+// 优先级：Promise---> MutationObserver---> setImmediate---> setTimeout
+// setTimeout 可能产生一个 4ms 的延迟，而 setImmediate 会在主线程执行完后立刻执行
+// setImmediate 在 IE10 和 node 中支持
+
+// 当在同一轮事件循环中多次调用 nextTick 时 ,timerFunc 只会执行一次
+
+var timerFunc;
+// 判断当前环境是否原生支持 promise
+if (typeof Promise !== 'undefined' && isNative(Promise)) {
+  // 支持 promise
+  var p = Promise.resolve();
+  timerFunc = function timerFunc() {
+    // 用 promise.then 把 flushCallbacks 函数包裹成一个异步微任务
+    p.then(flushCallbacks);
+    if (isIOS) {
+      setTimeout(noop);
+    }
+    // 这里的 setTimeout 是用来强制刷新微任务队列的
+    // 因为在 ios 下 promise.then 后面没有宏任务的话，微任务队列不会刷新
+  };
+  // 标记当前 nextTick 使用的微任务
+  isUsingMicroTask = true;
+
+  // 如果不支持 promise，就判断是否支持 MutationObserver
+  // 不是IE环境，并且原生支持 MutationObserver，那也是一个微任务
+} else if (typeof MutationObserver !== 'undefined' && (isNative(MutationObserver) || MutationObserver.toString() === '[object MutationObserverConstructor]')) {
+  var counter = 1;
+  // new 一个 MutationObserver 类
+  var observer = new MutationObserver(flushCallbacks);
+  // 创建一个文本节点
+  var textNode = document.createTextNode(String(counter));
+  // 监听这个文本节点，当数据发生变化就执行 flushCallbacks
+  observer.observe(textNode, {
+    characterData: true
+  });
+  timerFunc = function timerFunc() {
+    counter = (counter + 1) % 2;
+    textNode.data = String(counter); // 数据更新
+  };
+  isUsingMicroTask = true; // 标记当前 nextTick 使用的微任务
+
+  // 判断当前环境是否原生支持 setImmediate
+} else if (typeof setImmediate !== 'undefined' && isNative(setImmediate)) {
+  timerFunc = function timerFunc() {
+    setImmediate(flushCallbacks);
+  };
+} else {
+  // 以上三种都不支持就选择 setTimeout
+  timerFunc = function timerFunc() {
+    setTimeout(flushCallbacks, 0);
+  };
+}
+
+// 如果多次调用 nextTick，会依次执行上面的方法，将 nextTick 的回调放在 callbacks 数组中
+// 最后通过 flushCallbacks 函数遍历 callbacks 数组的拷贝并执行其中的回调
+function flushCallbacks() {
+  pending = false;
+  var copies = callbacks.slice(0); // 拷贝一份 callbacks
+  callbacks.length = 0; // 清空 callbacks
+  for (var i = 0; i < copies.length; i++) {
+    // 遍历执行传入的回调
+    copies[i]();
+  }
+}
+
+// 为什么要拷贝一份 callbacks
+
+// 用 callbacks.slice(0) 将 callbacks 拷贝出来一份，
+// 是因为考虑到在 nextTick 回调中可能还会调用 nextTick 的情况,
+// 如果在 nextTick 回调中又调用了一次 nextTick，则又会向 callbacks 中添加回调，
+// 而 nextTick 回调中的 nextTick 应该放在下一轮执行，
+// 否则就可能出现一直循环的情况，
+// 所以需要将 callbacks 复制一份出来然后清空，再遍历备份列表执行回调
+
+export var escapeStringRegexp = function escapeStringRegexp() {
+  var string = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return string.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&').replace(/-/g, '\\x2d');
+};

package/dist/config/Constants.d.ts

@@ -1,9 +1,12 @@
+import { IconName } from '../Icon';
 export declare const TypeMap: {
+    primary: string;
     success: string;
     info: string;
     warning: string;
     error: string;
 };
+export declare const TypeComponentsMap: Record<string, IconName>;
 export declare const EVENT_CODE: {
     tab: string;
     enter: string;

package/dist/config/Constants.js

@@ -1,9 +1,17 @@
 export var TypeMap = {
+  primary: 'primary',
   success: 'success',
   info: 'info',
   warning: 'warning',
   error: 'error'
 };
+export var TypeComponentsMap = {
+  primary: 'info-circle',
+  success: 'circle-check',
+  info: 'info-circle',
+  warning: 'circle-exclamation',
+  error: 'circle-xmark'
+};
 export var EVENT_CODE = {
   tab: 'Tab',
   enter: 'Enter',

package/dist/hooks/index.d.ts

@@ -9,5 +9,6 @@ export { default as prefix } from './prefix';
 export { partitionTreePropsUtils } from './treePropsUtils';
 export { default as useChildrenInstance } from './useChildrenInstance';
 export * from './useCommonProps';
+export { useConfigProvider } from './useConfigProvider';
 export { useForceUpdate } from './useForceUpdate';
 export { default as useUpdateEffect } from './useUpdateEffect';

package/dist/hooks/index.js

@@ -11,5 +11,6 @@ export { default as prefix } from "./prefix";
 export { partitionTreePropsUtils } from "./treePropsUtils";
 export { default as useChildrenInstance } from "./useChildrenInstance";
 export * from "./useCommonProps";
+export { useConfigProvider } from "./useConfigProvider";
 export { useForceUpdate } from "./useForceUpdate";
 export { default as useUpdateEffect } from "./useUpdateEffect";

package/dist/hooks/popperPropsUtils.js

@@ -1,7 +1,7 @@
 import forEach from 'lodash/forEach';
 import includes from 'lodash/includes';
 // @ts-ignore
-export var popperAllProps = ['popperInstRef', 'offset', 'placement', 'arrowOffset', 'showArrow', 'popperClass', 'popperStyle', 'name', 'display', 'unmountOnExit', 'transitionAppear', 'duration', 'gpuAcceleration', 'strategy', 'appendToBody', 'appendTo', 'popperOptions', 'fallbackPlacements'];
+export var popperAllProps = ['popperInstRef', 'offset', 'placement', 'arrowOffset', 'showArrow', 'popperClass', 'popperStyle', 'name', 'display', 'unmountOnExit', 'transitionAppear', 'duration', 'gpuAcceleration', 'strategy', 'appendToBody', 'appendTo', 'popperOptions', 'fallbackPlacements', 'effect'];
 
 /**
  * Returns an array of objects consisting of: props of html input element and rest.

package/dist/hooks/treePropsUtils.d.ts

@@ -1,15 +1,15 @@
-import { DirectoryTreeProps } from '../Tree';
+import { TreeProps } from '../Tree';
 export declare const treeAllProps: string[];
 /**
  * Returns an array of objects consisting of: props of html input element and rest.
  * @author	Parker
  * @CreateTime	2022/4/8 17:46:40
  * @LastEditor	Parker
- * @ModifyTime	2022/4/21 10:06:19
+ * @ModifyTime	2026/2/7 14:37:37
  * @param {object} props A ReactElement props object
  * @param {Object} [options={}]
  * @param {Array} [options.htmlProps] An array of html input props
  * @param {boolean} [options.includeAria] Includes all input props that starts with "aria-"
  * @returns {[{}, {}]} An array of objects
  */
-export declare const partitionTreePropsUtils: (props: any, options?: any) => [DirectoryTreeProps<any>, any];
+export declare const partitionTreePropsUtils: (props: any, options?: any) => [TreeProps, any];

package/dist/hooks/treePropsUtils.js

@@ -1,13 +1,13 @@
 import forEach from 'lodash/forEach';
 import includes from 'lodash/includes';
-export var treeAllProps = ['showLine', 'multiple', 'selectedKeys', 'filterAntTreeNode', 'showIcon', 'switcherIcon', 'children', 'blockNode', 'prefixCls', 'focusable', 'activeKey', 'tabIndex', 'treeData', 'fieldNames', 'icon', 'selectable', 'disabled', 'checkable', 'checkStrictly', 'draggable', 'defaultExpandParent', 'autoExpandParent', 'defaultExpandAll', 'defaultExpandedKeys', 'expandedKeys', 'defaultCheckedKeys', 'checkedKeys', 'defaultSelectedKeys', 'allowDrop', 'titleRender', 'dropIndicatorRender', 'onFocus', 'onBlur', 'onKeyDown', 'onContextMenu', 'onClick', 'onDoubleClick', 'onScroll', 'onExpand', 'onCheck', 'onSelect', 'onLoad', 'loadData', 'loadedKeys', 'onMouseEnter', 'onMouseLeave', 'onRightClick', 'onDragStart', 'onDragEnter', 'onDragOver', 'onDragLeave', 'onDragEnd', 'onDrop'];
+export var treeAllProps = ['data', 'emptyText', 'renderAfterExpand', 'nodeKey', 'checkStrictly', 'expandOnClickNode', 'defaultExpandAll', 'checkOnClickNode', 'checkOnClickLeaf', 'checkDescendants', 'autoExpandParent', 'defaultCheckedKeys', 'defaultExpandedKeys', 'currentNodeKey', 'renderContent', 'showCheckbox', 'draggable', 'allowDrag', 'allowDrop', 'props', 'lazy', 'highlightCurrent', 'load', 'filterNodeMethod', 'accordion', 'indent', 'icon', 'renderEmpty', 'onNodeClick', 'onNodeContextmenu', 'onCheckChange', 'onNodeExpandAll', 'onCheck', 'onCurrentChange', 'onNodeExpand', 'onNodeCollapse', 'onNodeDragStart', 'onNodeDragOver', 'onNodeDragLeave', 'onNodeDragEnter', 'onNodeDragEnd', 'onNodeDrop'];
 
 /**
  * Returns an array of objects consisting of: props of html input element and rest.
  * @author	Parker
  * @CreateTime	2022/4/8 17:46:40
  * @LastEditor	Parker
- * @ModifyTime	2022/4/21 10:06:19
+ * @ModifyTime	2026/2/7 14:37:37
  * @param {object} props A ReactElement props object
  * @param {Object} [options={}]
  * @param {Array} [options.htmlProps] An array of html input props

package/dist/hooks/useCalcInputWidth.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+export declare function useCalcInputWidth(): {
+    calculatorRef: import("react").MutableRefObject<HTMLElement>;
+    calculatorWidth: number;
+    inputStyle: {
+        minWidth: string;
+    };
+};

package/dist/{Tree/useUnmount.js → hooks/useCalcInputWidth.js}

@@ -4,31 +4,27 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 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 useLayoutEffect from 'rc-util/lib/hooks/useLayoutEffect';
-import * as React from 'react';
-
-/**
- * Trigger only when component unmount
- */
-function useUnmount(triggerStart, triggerEnd) {
-  var _React$useState = React.useState(false),
-    _React$useState2 = _slicedToArray(_React$useState, 2),
-    firstMount = _React$useState2[0],
-    setFirstMount = _React$useState2[1];
-  useLayoutEffect(function () {
-    if (firstMount) {
-      triggerStart();
-      return function () {
-        triggerEnd();
-      };
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [firstMount]);
-  useLayoutEffect(function () {
-    setFirstMount(true);
-    return function () {
-      setFirstMount(false);
+import { useMemo, useRef, useState } from 'react';
+import { useResizeObserver } from "./useResizeObserver";
+export function useCalcInputWidth() {
+  var calculatorRef = useRef();
+  var _useState = useState(0),
+    _useState2 = _slicedToArray(_useState, 2),
+    calculatorWidth = _useState2[0],
+    setCalculatorWidth = _useState2[1];
+  var inputStyle = useMemo(function () {
+    return {
+      minWidth: "".concat(Math.max(calculatorWidth, 11), "px")
     };
-  }, []);
-}
-export default useUnmount;
+  }, [calculatorWidth]);
+  var resetCalculatorWidth = function resetCalculatorWidth() {
+    var _calculatorRef$curren, _calculatorRef$curren2;
+    setCalculatorWidth((_calculatorRef$curren = (_calculatorRef$curren2 = calculatorRef.current) === null || _calculatorRef$curren2 === void 0 ? void 0 : _calculatorRef$curren2.getBoundingClientRect().width) !== null && _calculatorRef$curren !== void 0 ? _calculatorRef$curren : 0);
+  };
+  useResizeObserver(calculatorRef, resetCalculatorWidth);
+  return {
+    calculatorRef: calculatorRef,
+    calculatorWidth: calculatorWidth,
+    inputStyle: inputStyle
+  };
+}

package/dist/hooks/useComposition.d.ts

@@ -0,0 +1,16 @@
+import { CompositionEvent } from 'react';
+interface UseCompositionOptions {
+    afterComposition: (event: CompositionEvent<HTMLInputElement>) => void;
+    compositionstart?: (evt: CompositionEvent<HTMLInputElement>) => void;
+    compositionupdate?: (evt: CompositionEvent<HTMLInputElement>) => void;
+    compositionend?: (evt: CompositionEvent<HTMLInputElement>) => void;
+}
+export declare function useComposition({ afterComposition, compositionstart, compositionupdate, compositionend }: UseCompositionOptions): {
+    isComposing: import("react").MutableRefObject<boolean>;
+    handleComposition: (event: CompositionEvent<HTMLInputElement>) => void;
+    handleCompositionStart: (event: CompositionEvent<HTMLInputElement>) => void;
+    handleCompositionUpdate: (event: CompositionEvent<HTMLInputElement>) => void;
+    handleCompositionEnd: (event: CompositionEvent<HTMLInputElement>) => void;
+};
+export declare const isKorean: (text: string) => boolean;
+export {};

package/dist/hooks/useComposition.js

@@ -0,0 +1,39 @@
+import { useRef } from 'react';
+export function useComposition(_ref) {
+  var afterComposition = _ref.afterComposition,
+    compositionstart = _ref.compositionstart,
+    compositionupdate = _ref.compositionupdate,
+    compositionend = _ref.compositionend;
+  var isComposing = useRef(false);
+  var handleCompositionStart = function handleCompositionStart(event) {
+    compositionstart === null || compositionstart === void 0 || compositionstart(event);
+    isComposing.current = true;
+  };
+  var handleCompositionUpdate = function handleCompositionUpdate(event) {
+    var _event$target;
+    compositionupdate === null || compositionupdate === void 0 || compositionupdate(event);
+    var text = (_event$target = event.target) === null || _event$target === void 0 ? void 0 : _event$target.value;
+    var lastCharacter = text[text.length - 1] || '';
+    isComposing.current = !isKorean(lastCharacter);
+  };
+  var handleCompositionEnd = function handleCompositionEnd(event) {
+    compositionend === null || compositionend === void 0 || compositionend(event);
+    if (isComposing.current) {
+      isComposing.current = false;
+      afterComposition(event);
+    }
+  };
+  var handleComposition = function handleComposition(event) {
+    event.type === 'compositionend' ? handleCompositionEnd(event) : handleCompositionUpdate(event);
+  };
+  return {
+    isComposing: isComposing,
+    handleComposition: handleComposition,
+    handleCompositionStart: handleCompositionStart,
+    handleCompositionUpdate: handleCompositionUpdate,
+    handleCompositionEnd: handleCompositionEnd
+  };
+}
+export var isKorean = function isKorean(text) {
+  return /([\uAC00-\uD7AF\u3130-\u318F])+/gi.test(text);
+};

package/dist/hooks/useConfigProvider.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+import { MessageMethod } from '../Message/typings';
+import { MessageBoxProps } from '../MessageBox';
+import { Action, MessageBoxInputData } from '../MessageBox/typings';
+export declare const useConfigProvider: () => {
+    ElMessage: MessageMethod;
+    ElMessageBox: {
+        (options?: MessageBoxProps): Promise<Action>;
+        /**
+         * 消息弹窗提示
+         * @param message 消息内容
+         * @param title 标题
+         * @param options 其他设置项
+         * @returns
+         */
+        alert: (message: string | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, title?: string | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | MessageBoxProps, options?: MessageBoxProps) => Promise<Action>;
+        /**
+         * 确认消息
+         * @param message 消息内容
+         * @param title 标题
+         * @param options 其他设置项
+         * @returns
+         */
+        confirm: (message: string | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, title?: string | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | MessageBoxProps, options?: MessageBoxProps) => Promise<Action>;
+        prompt: (message: string | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>, title?: string | import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>> | MessageBoxProps, options?: MessageBoxProps) => Promise<MessageBoxInputData>;
+    };
+};

package/dist/hooks/useConfigProvider.js

@@ -0,0 +1,78 @@
+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 { isValidElement, useContext } from 'react';
+import ConfigProviderContext from "../ConfigProvider/ConfigProviderContext";
+import { Message } from "../Message";
+import { MessageBox, instanceFactory } from "../MessageBox";
+import { isEmpty } from "../Util";
+export var useConfigProvider = function useConfigProvider() {
+  var _useContext = useContext(ConfigProviderContext),
+    messageConfig = _useContext.message,
+    locale = _useContext.locale;
+  var ElMessage = function ElMessage() {
+    var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (typeof opts === 'string' || /*#__PURE__*/isValidElement(opts)) {
+      opts = _objectSpread(_objectSpread({}, messageConfig), {}, {
+        message: opts
+      });
+    }
+    if (isEmpty(opts)) {
+      opts = _objectSpread(_objectSpread({}, messageConfig), {}, {
+        message: ''
+      });
+    } else {
+      opts = _objectSpread(_objectSpread({}, messageConfig), opts);
+    }
+    var options = opts;
+    Message(options);
+  };
+  ['primary', 'success', 'warning', 'info', 'error'].forEach(function (type) {
+    ElMessage[type] = function (options) {
+      if (typeof options === 'string' || /*#__PURE__*/isValidElement(options)) {
+        options = _objectSpread(_objectSpread({}, messageConfig), {}, {
+          message: options,
+          type: type
+        });
+      } else {
+        options = _objectSpread(_objectSpread(_objectSpread({}, messageConfig), options), {}, {
+          type: type
+        });
+      }
+      return Message(options);
+    };
+  });
+  ElMessage.closeAll = Message.closeAll;
+  var ElMessageBox = function ElMessageBox() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return MessageBox(_objectSpread({
+      locale: locale
+    }, options));
+  };
+
+  /**
+   * 消息弹窗提示
+   * @param message 消息内容
+   * @param title 标题
+   * @param options 其他设置项
+   * @returns
+   */
+  ElMessageBox.alert = instanceFactory('alert', locale);
+
+  /**
+   * 确认消息
+   * @param message 消息内容
+   * @param title 标题
+   * @param options 其他设置项
+   * @returns
+   */
+  ElMessageBox.confirm = instanceFactory('confirm', locale);
+  ElMessageBox.prompt = instanceFactory('prompt', locale);
+  return {
+    ElMessage: ElMessage,
+    ElMessageBox: ElMessageBox
+  };
+};

package/dist/hooks/useCursor.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useCursor(input: RefObject<HTMLInputElement | undefined>): [() => void, () => void];

package/dist/hooks/useCursor.js

@@ -0,0 +1,52 @@
+// Keep input cursor in the correct position when we use formatter.
+export function useCursor(input) {
+  var selectionInfo;
+  function recordCursor() {
+    if (input.current == undefined) {
+      return;
+    }
+    var _input$current = input.current,
+      selectionStart = _input$current.selectionStart,
+      selectionEnd = _input$current.selectionEnd,
+      value = _input$current.value;
+    if (selectionStart == null || selectionEnd == null) {
+      return;
+    }
+    var beforeTxt = value.slice(0, Math.max(0, selectionStart));
+    var afterTxt = value.slice(Math.max(0, selectionEnd));
+    selectionInfo = {
+      selectionStart: selectionStart,
+      selectionEnd: selectionEnd,
+      value: value,
+      beforeTxt: beforeTxt,
+      afterTxt: afterTxt
+    };
+  }
+  function setCursor() {
+    if (input.current == undefined || selectionInfo == undefined) {
+      return;
+    }
+    var value = input.current.value;
+    var _selectionInfo = selectionInfo,
+      beforeTxt = _selectionInfo.beforeTxt,
+      afterTxt = _selectionInfo.afterTxt,
+      selectionStart = _selectionInfo.selectionStart;
+    if (beforeTxt == undefined || afterTxt == undefined || selectionStart == undefined) {
+      return;
+    }
+    var startPos = value.length;
+    if (value.endsWith(afterTxt)) {
+      startPos = value.length - afterTxt.length;
+    } else if (value.startsWith(beforeTxt)) {
+      startPos = beforeTxt.length;
+    } else {
+      var beforeLastChar = beforeTxt[selectionStart - 1];
+      var newIndex = value.indexOf(beforeLastChar, selectionStart - 1);
+      if (newIndex !== -1) {
+        startPos = newIndex + 1;
+      }
+    }
+    input.current.setSelectionRange(startPos, startPos);
+  }
+  return [recordCursor, setCursor];
+}

package/dist/hooks/useFocusController.d.ts

@@ -0,0 +1,27 @@
+import { RefObject } from 'react';
+interface UseFocusControllerOptions {
+    disabled?: boolean;
+    /**
+     * return true to cancel focus
+     * @param event FocusEvent
+     */
+    beforeFocus?: (event: FocusEvent) => boolean | undefined;
+    afterFocus?: () => void;
+    /**
+     * return true to cancel blur
+     * @param event FocusEvent
+     */
+    beforeBlur?: (event: FocusEvent) => boolean | undefined;
+    afterBlur?: () => void;
+}
+export declare function useFocusController<T extends {
+    focus: () => void;
+}>(target: RefObject<HTMLElement | undefined>, { disabled, beforeFocus, afterFocus, beforeBlur, afterBlur }?: UseFocusControllerOptions): {
+    isFocused: boolean;
+    /** Avoid using wrapperRef and handleFocus/handleBlur together */
+    wrapperRef: import("react").MutableRefObject<HTMLInputElement>;
+    handleFocus: (event: FocusEvent) => void;
+    handleBlur: (event: FocusEvent) => void;
+    handleClick: (event: Event) => void;
+};
+export {};

package/dist/hooks/useFocusController.js

@@ -0,0 +1,72 @@
+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 isFunction from 'lodash/isFunction';
+import { useRef, useState } from 'react';
+import { isFocusable } from "../Util/aria";
+export function useFocusController(target) {
+  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    disabled = _ref.disabled,
+    beforeFocus = _ref.beforeFocus,
+    afterFocus = _ref.afterFocus,
+    beforeBlur = _ref.beforeBlur,
+    afterBlur = _ref.afterBlur;
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    isFocused = _useState2[0],
+    setIsFocused = _useState2[1];
+  var wrapperRef = useRef(null);
+  var handleFocus = function handleFocus(event) {
+    var cancelFocus = isFunction(beforeFocus) ? beforeFocus(event) : false;
+    if (disabled || isFocused || cancelFocus) {
+      return;
+    }
+    setIsFocused(true);
+    // emit('focus', event);
+    afterFocus === null || afterFocus === void 0 || afterFocus();
+  };
+  var handleBlur = function handleBlur(event) {
+    var _wrapperRef$current;
+    var cancelBlur = isFunction(beforeBlur) ? beforeBlur(event) : false;
+    if (disabled || event.relatedTarget && (_wrapperRef$current = wrapperRef.current) !== null && _wrapperRef$current !== void 0 && _wrapperRef$current.contains(event.relatedTarget) || cancelBlur) {
+      return;
+    }
+    setIsFocused(false);
+
+    // emit('blur', event);
+    afterBlur === null || afterBlur === void 0 || afterBlur();
+  };
+  var handleClick = function handleClick(event) {
+    var _wrapperRef$current2, _target$current;
+    if (disabled || isFocusable(event.target) || (_wrapperRef$current2 = wrapperRef.current) !== null && _wrapperRef$current2 !== void 0 && _wrapperRef$current2.contains(document.activeElement) && wrapperRef.current !== document.activeElement) {
+      return;
+    }
+    (_target$current = target.current) === null || _target$current === void 0 || _target$current.focus();
+  };
+
+  // useMount(() => {
+  //     if (!wrapperRef.current) {
+  //         return;
+  //     }
+  //     wrapperRef.current.addEventListener('focus', handleFocus, true);
+  //     wrapperRef.current.addEventListener('blur', handleBlur, true);
+  //     wrapperRef.current.addEventListener('click', handleClick, true);
+  //     return () => {
+  //         wrapperRef.current?.removeEventListener('focus', handleFocus, true);
+  //         wrapperRef.current?.removeEventListener('blur', handleBlur, true);
+  //         wrapperRef.current?.removeEventListener('click', handleClick, true);
+  //     };
+  // });
+
+  return {
+    isFocused: isFocused,
+    /** Avoid using wrapperRef and handleFocus/handleBlur together */
+    wrapperRef: wrapperRef,
+    handleFocus: handleFocus,
+    handleBlur: handleBlur,
+    handleClick: handleClick
+  };
+}