@qsxy/element-plus-react 1.0.2 → 2.0.0

package/dist/Steps/Step.js

@@ -0,0 +1,247 @@
+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); }
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14;
+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); }
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+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 classNames from 'classnames';
+import React, { memo, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { useClassNames } from "../hooks";
+import Icon from "../Icon/Icon";
+import { isNumber, mergeDefaultProps } from "../Util";
+import { StepsContext } from "./Steps";
+var getUid = function () {
+  var uid = 0;
+  return function () {
+    return ++uid;
+  };
+}();
+var Step = /*#__PURE__*/memo(function (props) {
+  props = mergeDefaultProps({
+    classPrefix: 'step',
+    title: '',
+    description: '',
+    icon: null,
+    status: ''
+  }, props);
+  var _props = props,
+    classPrefix = _props.classPrefix,
+    title = _props.title,
+    description = _props.description,
+    icon = _props.icon,
+    status = _props.status,
+    className = _props.className,
+    styleProp = _props.style,
+    children = _props.children;
+  var _useClassNames = useClassNames(classPrefix),
+    b = _useClassNames.b,
+    e = _useClassNames.e,
+    is = _useClassNames.is;
+  var parent = useContext(StepsContext);
+  var uidRef = useRef(getUid());
+  var _useState = useState(-1),
+    _useState2 = _slicedToArray(_useState, 2),
+    index = _useState2[0],
+    setIndexState = _useState2[1];
+  var _useState3 = useState(''),
+    _useState4 = _slicedToArray(_useState3, 2),
+    internalStatus = _useState4[0],
+    setInternalStatus = _useState4[1];
+  var _useState5 = useState({}),
+    _useState6 = _slicedToArray(_useState5, 2),
+    lineStyle = _useState6[0],
+    setLineStyle = _useState6[1];
+  var stepDiffRef = useRef(0);
+  var beforeActiveRef = useRef(0);
+  var indexRef = useRef(index);
+  indexRef.current = index;
+  var currentStatus = useMemo(function () {
+    return status || internalStatus;
+  }, [status, internalStatus]);
+  var isCenter = useMemo(function () {
+    return parent.props.alignCenter;
+  }, [parent.props.alignCenter]);
+  var isVertical = useMemo(function () {
+    return parent.props.direction === 'vertical';
+  }, [parent.props.direction]);
+  var isSimple = useMemo(function () {
+    return parent.props.simple;
+  }, [parent.props.simple]);
+  var stepsCount = useMemo(function () {
+    return parent.steps.length;
+  }, [parent.steps]);
+  var isLast = useMemo(function () {
+    var _parent$steps;
+    return ((_parent$steps = parent.steps[stepsCount - 1]) === null || _parent$steps === void 0 ? void 0 : _parent$steps.uid) === uidRef.current;
+  }, [parent.steps, stepsCount]);
+  var space = useMemo(function () {
+    return isSimple ? '' : parent.props.space;
+  }, [isSimple, parent.props.space]);
+  var containerKls = useMemo(function () {
+    return classNames(b(), is(isSimple ? 'simple' : parent.props.direction), is({
+      flex: isLast && !space && !isCenter,
+      center: isCenter && !isVertical && !isSimple
+    }));
+  }, [b, is, isSimple, parent.props.direction, isLast, space, isCenter, isVertical]);
+  var containerStyle = useMemo(function () {
+    var sty = {
+      flexBasis: function () {
+        if (isNumber(space)) {
+          return "".concat(space, "px");
+        }
+        if (space) {
+          return space;
+        }
+        return "".concat(100 / (stepsCount - (isCenter ? 0 : 1)), "%");
+      }()
+    };
+    if (isVertical) {
+      return sty;
+    }
+    if (isLast) {
+      sty.maxWidth = "".concat(100 / stepsCount, "%");
+    }
+    return sty;
+  }, [space, stepsCount, isCenter, isVertical, isLast]);
+  var setIndex = useCallback(function (val) {
+    setIndexState(val);
+  }, []);
+  var calcProgress = useCallback(function (stat) {
+    var isWait = stat === 'wait';
+    var stepDiff = stepDiffRef.current;
+    var beforeActive = beforeActiveRef.current;
+    var idx = indexRef.current;
+    var _parent$props = parent.props,
+      active = _parent$props.active,
+      direction = _parent$props.direction,
+      processStatus = _parent$props.processStatus;
+    var delayTimer;
+    if (Math.abs(stepDiff) === 1) {
+      delayTimer = 0;
+    } else if (stepDiff > 0) {
+      delayTimer = (idx + 1 - beforeActive) * 150;
+    } else {
+      delayTimer = -(idx + 1 - active) * 150;
+    }
+    var sty = {
+      transitionDelay: "".concat(delayTimer, "ms")
+    };
+    var step = stat === processStatus || isWait ? 0 : 100;
+    sty.borderWidth = step && !isSimple ? '1px' : 0;
+    if (direction === 'vertical') {
+      sty.height = "".concat(step, "%");
+    } else {
+      sty.width = "".concat(step, "%");
+    }
+    setLineStyle(sty);
+  }, [isSimple, parent.props]);
+  var updateStatus = useCallback(function (activeIndex) {
+    var _parent$props2 = parent.props,
+      finishStatus = _parent$props2.finishStatus,
+      processStatus = _parent$props2.processStatus;
+    var newStatus;
+    var idx = indexRef.current;
+    var prevStep = parent.steps[idx - 1];
+    var prevInternalStatus = prevStep ? prevStep.internalStatus : 'wait';
+    if (activeIndex > idx) {
+      newStatus = finishStatus;
+    } else if (activeIndex === idx && prevInternalStatus !== 'error') {
+      newStatus = processStatus;
+    } else {
+      newStatus = 'wait';
+    }
+    setInternalStatus(newStatus);
+    if (prevStep) {
+      prevStep.calcProgress(newStatus);
+    }
+  }, [parent.props, parent.steps]);
+  var stepItemStateRef = useRef({
+    uid: uidRef.current,
+    currentStatus: currentStatus,
+    internalStatus: internalStatus,
+    indexRef: indexRef,
+    setIndex: setIndex,
+    calcProgress: calcProgress,
+    updateStatus: updateStatus
+  });
+  stepItemStateRef.current = {
+    uid: uidRef.current,
+    currentStatus: currentStatus,
+    internalStatus: internalStatus,
+    indexRef: indexRef,
+    setIndex: setIndex,
+    calcProgress: calcProgress,
+    updateStatus: updateStatus
+  };
+  useEffect(function () {
+    parent.addStep(stepItemStateRef.current);
+    return function () {
+      parent.removeStep(stepItemStateRef.current);
+    };
+  }, []);
+  useEffect(function () {
+    var _parent$props$active;
+    var activeIdx = (_parent$props$active = parent.props.active) !== null && _parent$props$active !== void 0 ? _parent$props$active : 0;
+    var oldActive = beforeActiveRef.current;
+    beforeActiveRef.current = activeIdx;
+    stepDiffRef.current = activeIdx - oldActive;
+    updateStatus(activeIdx);
+  }, [parent.props.active, parent.props.processStatus, parent.props.finishStatus]);
+  var renderIcon = function renderIcon() {
+    if (icon) {
+      return /*#__PURE__*/React.createElement(Icon, {
+        className: e(_templateObject || (_templateObject = _taggedTemplateLiteral(["icon-inner"]))),
+        name: icon
+      });
+    }
+    if (currentStatus === 'success') {
+      return /*#__PURE__*/React.createElement(Icon, {
+        className: classNames(e(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["icon-inner"]))), is(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["status"])))),
+        name: "check"
+      });
+    }
+    if (currentStatus === 'error') {
+      return /*#__PURE__*/React.createElement(Icon, {
+        className: classNames(e(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["icon-inner"]))), is(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["status"])))),
+        name: "close"
+      });
+    }
+    if (!isSimple) {
+      return /*#__PURE__*/React.createElement("span", {
+        className: e(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["icon-inner"])))
+      }, index + 1);
+    }
+    return null;
+  };
+  return /*#__PURE__*/React.createElement("div", {
+    style: _objectSpread(_objectSpread({}, containerStyle), styleProp),
+    className: classNames(containerKls, className)
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames(e(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["head"]))), is(currentStatus))
+  }, !isSimple && /*#__PURE__*/React.createElement("div", {
+    className: e(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["line"])))
+  }, /*#__PURE__*/React.createElement("i", {
+    className: e(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["line-inner"]))),
+    style: lineStyle
+  })), /*#__PURE__*/React.createElement("div", {
+    className: classNames(e(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["icon"]))), is(icon ? 'icon' : 'text'))
+  }, renderIcon())), /*#__PURE__*/React.createElement("div", {
+    className: e(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["main"])))
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames(e(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["title"]))), is(currentStatus))
+  }, title), isSimple ? /*#__PURE__*/React.createElement("div", {
+    className: e(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["arrow"])))
+  }) : /*#__PURE__*/React.createElement("div", {
+    className: classNames(e(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["description"]))), is(currentStatus))
+  }, description)));
+});
+Step.displayName = 'ElStep';
+export default Step;

package/dist/Steps/Steps.d.ts

@@ -0,0 +1,5 @@
+import React, { FC } from 'react';
+import { StepsContextProps, StepsProps } from './typings';
+declare const Steps: FC<StepsProps>;
+export default Steps;
+export declare const StepsContext: React.Context<StepsContextProps>;

package/dist/Steps/Steps.js

@@ -0,0 +1,116 @@
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+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 classNames from 'classnames';
+import React, { createContext, memo, useCallback, useEffect, useRef, useState } from 'react';
+import { useClassNames } from "../hooks";
+import { mergeDefaultProps } from "../Util";
+var Steps = /*#__PURE__*/memo(function (props) {
+  props = mergeDefaultProps({
+    classPrefix: 'steps',
+    space: '',
+    active: 0,
+    direction: 'horizontal',
+    alignCenter: false,
+    simple: false,
+    finishStatus: 'finish',
+    processStatus: 'process'
+  }, props);
+  var _props = props,
+    classPrefix = _props.classPrefix,
+    space = _props.space,
+    active = _props.active,
+    direction = _props.direction,
+    alignCenter = _props.alignCenter,
+    simple = _props.simple,
+    finishStatus = _props.finishStatus,
+    processStatus = _props.processStatus,
+    onChange = _props.onChange,
+    className = _props.className,
+    style = _props.style,
+    children = _props.children;
+  var _useClassNames = useClassNames(classPrefix),
+    b = _useClassNames.b,
+    m = _useClassNames.m;
+  var _useState = useState([]),
+    _useState2 = _slicedToArray(_useState, 2),
+    steps = _useState2[0],
+    setSteps = _useState2[1];
+  var prevActiveRef = useRef(active);
+  var _useState3 = useState(0),
+    _useState4 = _slicedToArray(_useState3, 2),
+    stepsVersion = _useState4[0],
+    setStepsVersion = _useState4[1];
+  var addStep = useCallback(function (item) {
+    setSteps(function (prev) {
+      return [].concat(_toConsumableArray(prev), [item]);
+    });
+    setStepsVersion(function (v) {
+      return v + 1;
+    });
+  }, []);
+  var removeStep = useCallback(function (item) {
+    var idx = steps.indexOf(item);
+    if (idx >= 0) {
+      setSteps(function (prev) {
+        return [].concat(_toConsumableArray(prev.slice(0, idx)), _toConsumableArray(prev.slice(idx + 1)));
+      });
+      setStepsVersion(function (v) {
+        return v + 1;
+      });
+    }
+  }, [steps]);
+  useEffect(function () {
+    steps.forEach(function (instance, idx) {
+      instance.setIndex(idx);
+      instance.indexRef.current = idx;
+      instance.updateStatus(active);
+    });
+  }, [steps]);
+  useEffect(function () {
+    if (onChange) {
+      onChange(active, prevActiveRef.current);
+    }
+    prevActiveRef.current = active;
+  }, [active, onChange]);
+  var contextValue = {
+    props: {
+      space: space,
+      active: active,
+      direction: direction,
+      alignCenter: alignCenter,
+      simple: simple,
+      finishStatus: finishStatus,
+      processStatus: processStatus,
+      classPrefix: 'step'
+    },
+    steps: steps,
+    addStep: addStep,
+    removeStep: removeStep
+  };
+  return /*#__PURE__*/React.createElement(StepsContext.Provider, {
+    value: contextValue
+  }, /*#__PURE__*/React.createElement("div", {
+    className: classNames(b(), m(simple ? 'simple' : direction), className),
+    style: style
+  }, children));
+});
+Steps.displayName = 'ElSteps';
+export default Steps;
+export var StepsContext = /*#__PURE__*/createContext({
+  props: {
+    space: '',
+    active: 0,
+    direction: 'horizontal'
+  },
+  steps: [],
+  addStep: function addStep() {},
+  removeStep: function removeStep() {}
+});

package/dist/Steps/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Steps } from './Steps';
+export { default as Step } from './Step';
+export type { StepItemState, StepProps, StepsContextProps, StepsProps, StepsStatus } from './typings';

package/dist/Steps/index.js

@@ -0,0 +1,2 @@
+export { default as Steps } from "./Steps";
+export { default as Step } from "./Step";

package/dist/Steps/typings.d.ts

@@ -0,0 +1,119 @@
+import React from 'react';
+import { IconName } from '../Icon';
+import type { BaseProps, NativeProps } from '../types/common';
+export type StepsStatus = '' | 'wait' | 'process' | 'finish' | 'error' | 'success';
+export interface StepsProps extends BaseProps, NativeProps {
+    /**
+     * 每个 step 的间距，不填写将自适应间距。支持百分比。
+     * @default ''
+     */
+    space?: number | string;
+    /**
+     * 设置当前激活步骤
+     * @default 0
+     */
+    active?: number;
+    /**
+     * 显示方向
+     * @default 'horizontal'
+     */
+    direction?: 'horizontal' | 'vertical';
+    /**
+     * 是否进行居中对齐
+     * @default false
+     */
+    alignCenter?: boolean;
+    /**
+     * 是否应用简洁风格
+     * @default false
+     */
+    simple?: boolean;
+    /**
+     * 设置结束步骤的状态
+     * @default 'finish'
+     */
+    finishStatus?: StepsStatus;
+    /**
+     * 设置当前步骤的状态
+     * @default 'process'
+     */
+    processStatus?: StepsStatus;
+    /**
+     * 步骤切换时触发
+     */
+    onChange?: (newVal: number, oldVal: number) => void;
+}
+export interface StepItemState {
+    /**
+     * 步骤唯一标识
+     */
+    uid: number;
+    /**
+     * 当前步骤状态
+     */
+    currentStatus: string;
+    /**
+     * 内部状态
+     */
+    internalStatus: string;
+    /**
+     * 步骤索引
+     */
+    indexRef: React.MutableRefObject<number>;
+    /**
+     * 设置步骤索引
+     */
+    setIndex: (val: number) => void;
+    /**
+     * 计算进度条动画
+     */
+    calcProgress: (status: string) => void;
+    /**
+     * 更新步骤状态
+     */
+    updateStatus: (activeIndex: number) => void;
+}
+export interface StepsContextProps {
+    /**
+     * Steps 组件的 props
+     */
+    props: StepsProps;
+    /**
+     * 所有步骤项的状态列表
+     */
+    steps: StepItemState[];
+    /**
+     * 注册步骤项
+     */
+    addStep: (item: StepItemState) => void;
+    /**
+     * 当前激活步骤
+     * @default 0
+     */
+    active?: number;
+    /**
+     * 移除步骤项
+     */
+    removeStep: (item: StepItemState) => void;
+}
+export interface StepProps extends BaseProps, NativeProps {
+    /**
+     * 标题
+     * @default ''
+     */
+    title?: string | React.ReactNode;
+    /**
+     * Step 组件的自定义图标
+     */
+    icon?: IconName;
+    /**
+     * 描述文案
+     * @default ''
+     */
+    description?: string | React.ReactNode;
+    /**
+     * 设置当前步骤的状态，不设置则根据 steps 确定状态
+     * @default ''
+     */
+    status?: StepsStatus;
+}

package/dist/Steps/typings.js

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

package/dist/Switch/Switch.js

@@ -189,7 +189,7 @@ var Switch = /*#__PURE__*/forwardRef(function (props, ref) {
     }
   }, inlinePrompt && /*#__PURE__*/React.createElement("div", {
     className: e(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["inner"])))
-  }, !active ? function () {
+  }, active ? function () {
     if (activeText) {
       return /*#__PURE__*/React.createElement("span", {
         className: "is-text"
@@ -204,7 +204,7 @@ var Switch = /*#__PURE__*/forwardRef(function (props, ref) {
         return activeIcon;
       }
     }
-  }() : null, active ? function () {
+  }() : null, !active ? function () {
     if (inactiveText) {
       return /*#__PURE__*/React.createElement("span", {
         className: "is-text"

package/dist/Switch/typings.d.ts

@@ -32,7 +32,6 @@ export interface SwitchProps<V = ValueType> extends Omit<FormControlBaseProps<V>
     /** switch的状态为 off 时的值 */
     inactiveValue?: V;
     /**  */
-    validateEvent?: boolean;
     /** 是否显示加载中 */
     loading?: boolean;
     /** 无论图标或文本是否显示在点内，只会呈现文本的第一个字符 */

package/dist/Table/Table.js

@@ -1,5 +1,5 @@
 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); }
-var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16, _templateObject17, _templateObject18;
+var _templateObject, _templateObject2, _templateObject3, _templateObject4, _templateObject5, _templateObject6, _templateObject7, _templateObject8, _templateObject9, _templateObject10, _templateObject11, _templateObject12, _templateObject13, _templateObject14, _templateObject15, _templateObject16, _templateObject17;
 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; }
@@ -28,7 +28,7 @@ function InternalTable(props, ref) {
   var _useTranslation = useTranslation(),
     t = _useTranslation.t;
   props = mergeDefaultProps({
-    data: [],
+    // data: [],
     fit: true,
     showHeader: true,
     tableLayout: 'fixed',
@@ -106,6 +106,9 @@ function InternalTable(props, ref) {
   useImperativeHandle(ref, function () {
     return {
       refs: refs,
+      get columns() {
+        return columns;
+      },
       clearSelection: clearSelection,
       getSelectionRows: getSelectionRows,
       toggleRowSelection: toggleRowSelection,
@@ -131,7 +134,7 @@ function InternalTable(props, ref) {
       setData: setData
     }
   }, /*#__PURE__*/React.createElement("div", {
-    className: classNames(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, m(_templateObject || (_templateObject = _taggedTemplateLiteral(["fit"]))), fit), m(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["striped"]))), stripe), m(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["border"]))), border || isGroup), m(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["group"]))), isGroup), m(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["fluid-height"]))), maxHeight), m(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["enable-row-hover"]))), true), m('enable-row-transition'), (data || []).length !== 0 && (data || []).length < 100), 'has-footer', showSummary), b(), m(size), props.className, m(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["layout", ""])), tableLayout)),
+    className: classNames(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, m(_templateObject || (_templateObject = _taggedTemplateLiteral(["fit"]))), fit), m(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["striped"]))), stripe), m(_templateObject3 || (_templateObject3 = _taggedTemplateLiteral(["border"]))), border || isGroup), m(_templateObject4 || (_templateObject4 = _taggedTemplateLiteral(["group"]))), isGroup), m(_templateObject5 || (_templateObject5 = _taggedTemplateLiteral(["fluid-height"]))), maxHeight), m(_templateObject6 || (_templateObject6 = _taggedTemplateLiteral(["enable-row-hover"]))), true), m('enable-row-transition'), (data || []).length !== 0 && (data || []).length < 100), 'has-footer', showSummary), b(), m(size), props.className, m("layout-".concat(tableLayout))),
     style: _objectSpread(_objectSpread({}, props.style), {}, {
       height: height,
       maxHeight: maxHeight
@@ -139,7 +142,7 @@ function InternalTable(props, ref) {
     ref: refs.tableWrapper
   }, /*#__PURE__*/React.createElement("div", {
     ref: refs.innerWrpper,
-    className: e(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["inner-wrapper"]))),
+    className: e(_templateObject7 || (_templateObject7 = _taggedTemplateLiteral(["inner-wrapper"]))),
     style: {
       height: height,
       maxHeight: maxHeight
@@ -147,11 +150,11 @@ function InternalTable(props, ref) {
   }, /*#__PURE__*/React.createElement("div", {
     className: "hidden-columns"
   }, _children), showHeader && tableLayout === 'fixed' && /*#__PURE__*/React.createElement("div", {
-    className: e(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["header-wrapper"]))),
+    className: e(_templateObject8 || (_templateObject8 = _taggedTemplateLiteral(["header-wrapper"]))),
     ref: refs.headerWrapper
   }, /*#__PURE__*/React.createElement("table", {
     ref: refs.tableHeader,
-    className: e(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["header"]))),
+    className: e(_templateObject9 || (_templateObject9 = _taggedTemplateLiteral(["header"]))),
     border: 0,
     cellPadding: 0,
     cellSpacing: 0
@@ -174,7 +177,7 @@ function InternalTable(props, ref) {
   }, /*#__PURE__*/React.createElement(TableHeader, {
     scheduleLayout: scheduleLayout
   })))), /*#__PURE__*/React.createElement("div", {
-    className: e(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["body-wrapper"])))
+    className: e(_templateObject10 || (_templateObject10 = _taggedTemplateLiteral(["body-wrapper"])))
   }, /*#__PURE__*/React.createElement(Scrollbar, {
     ref: refs.scrollBarRef,
     viewStyle: {
@@ -197,7 +200,7 @@ function InternalTable(props, ref) {
     }
   }, /*#__PURE__*/React.createElement("table", {
     ref: refs.tableBody,
-    className: e(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["body"]))),
+    className: e(_templateObject11 || (_templateObject11 = _taggedTemplateLiteral(["body"]))),
     border: 0,
     cellPadding: 0,
     cellSpacing: 0,
@@ -223,30 +226,30 @@ function InternalTable(props, ref) {
   }, tableLayout === 'auto' && /*#__PURE__*/React.createElement(TableHeader, {
     scheduleLayout: scheduleLayout
   }), /*#__PURE__*/React.createElement(TableBody, null))), append && /*#__PURE__*/React.createElement("div", {
-    className: e(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["append-wrapper"])))
+    className: e(_templateObject12 || (_templateObject12 = _taggedTemplateLiteral(["append-wrapper"])))
   }, append)), !loading && data.length === 0 &&
   /*#__PURE__*/
   // @ts-ignore
   React.createElement("div", {
     ref: refs.emptyBlock,
-    className: e(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["empty-block"]))),
+    className: e(_templateObject13 || (_templateObject13 = _taggedTemplateLiteral(["empty-block"]))),
     style: {
       height: '100%',
       position: tableLayout === 'auto' ? 'unset' : ''
     }
   }, /*#__PURE__*/React.createElement("span", {
-    className: e(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["empty-text"])))
+    className: e(_templateObject14 || (_templateObject14 = _taggedTemplateLiteral(["empty-text"])))
   }, emptyText)), /*#__PURE__*/React.createElement(Loading, {
-    className: e(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["loading"]))),
+    className: e(_templateObject15 || (_templateObject15 = _taggedTemplateLiteral(["loading"]))),
     fullscreen: false,
     background: "rgba(255, 255, 255, 0.6)",
     text: "\u6B63\u5728\u52A0\u8F7D\u4E2D...",
     visible: loading
   })), showSummary && /*#__PURE__*/React.createElement("div", {
-    className: e(_templateObject17 || (_templateObject17 = _taggedTemplateLiteral(["footer-wrapper"]))),
+    className: e(_templateObject16 || (_templateObject16 = _taggedTemplateLiteral(["footer-wrapper"]))),
     ref: refs.footerWrapper
   })), /*#__PURE__*/React.createElement("div", {
-    className: e(_templateObject18 || (_templateObject18 = _taggedTemplateLiteral(["column-resize-proxy"]))),
+    className: e(_templateObject17 || (_templateObject17 = _taggedTemplateLiteral(["column-resize-proxy"]))),
     ref: refs.resizeHelper,
     style: {
       display: 'none'