@qsxy/element-plus-react 1.0.0-next.1

package/dist/Switch/Switch.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { SwitchProps } from './typings';
+declare const Switch: React.ForwardRefExoticComponent<SwitchProps<import("./typings").ValueType> & React.RefAttributes<HTMLDivElement>>;
+export default Switch;

package/dist/Switch/Switch.js

@@ -0,0 +1,167 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Switch/Switch.tsx
+var Switch_exports = {};
+__export(Switch_exports, {
+  default: () => Switch_default
+});
+module.exports = __toCommonJS(Switch_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_isBoolean = __toESM(require("lodash/isBoolean"));
+var import_react = __toESM(require("react"));
+var import_Icon = require("../Icon");
+var import_Util = require("../Util");
+var import_hooks = require("../hooks");
+var Switch = (0, import_react.forwardRef)((props, ref) => {
+  const {
+    defaultValue,
+    name,
+    width,
+    activeText,
+    inactiveText,
+    activeColor,
+    inactiveColor,
+    activeValue,
+    inactiveValue,
+    activeIcon,
+    inactiveIcon,
+    loading,
+    className,
+    style,
+    inlinePrompt,
+    classPrefix = "switch",
+    onClick,
+    onMouseEnter,
+    onMouseLeave,
+    onContextMenu,
+    beforeChange,
+    onChange
+  } = props;
+  const inputRef = (0, import_react.useRef)();
+  const { b, e, m, em, is } = (0, import_hooks.useClassNames)(classPrefix);
+  const [value, setValue] = (0, import_hooks.useControlled)(props.value, defaultValue);
+  const disabled = (0, import_hooks.useDisabled)(props.disabled || loading);
+  const size = (0, import_hooks.useSize)(props.size);
+  const active = (0, import_react.useMemo)(() => {
+    return value === activeValue;
+  }, [value, activeValue]);
+  const currentColor = (0, import_react.useMemo)(() => {
+    return active ? activeColor : inactiveColor;
+  }, [active, activeColor, inactiveColor]);
+  const borderColor = (0, import_react.useMemo)(() => {
+    return active ? props.borderColor || currentColor : currentColor;
+  }, [active, props.borderColor, currentColor]);
+  const handleChange = (0, import_react.useCallback)(() => {
+    const val = active ? inactiveValue : activeValue;
+    setValue(val);
+    onChange == null ? void 0 : onChange(val, !active);
+  }, [active, activeValue, inactiveValue, onChange, setValue]);
+  const switchValue = (0, import_react.useCallback)(
+    (event) => {
+      event.preventDefault();
+      if (disabled) {
+        return;
+      }
+      if (!beforeChange) {
+        handleChange();
+        onClick == null ? void 0 : onClick();
+        return;
+      }
+      const shouldChange = beforeChange();
+      const isExpectType = [shouldChange instanceof Promise, (0, import_isBoolean.default)(shouldChange)].some((i) => i);
+      if (!isExpectType) {
+        return;
+      }
+      if (shouldChange instanceof Promise) {
+        shouldChange.then((result) => {
+          if (result) {
+            handleChange();
+            onClick == null ? void 0 : onClick();
+          }
+        }).catch((event1) => {
+          (0, import_Util.warning)(false, event1);
+        });
+      } else if (shouldChange) {
+        handleChange();
+        onClick == null ? void 0 : onClick();
+      }
+    },
+    [beforeChange, disabled, handleChange, onClick]
+  );
+  const falseLabel = (0, import_react.useMemo)(() => {
+    if (inactiveIcon || inactiveText) {
+      return /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(e`label`, em("label", "left"), is({ active: !active })) }, (0, import_react.isValidElement)(inactiveIcon) && inactiveIcon, typeof inactiveIcon === "string" && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: inactiveIcon }), !inactiveIcon && inactiveText ? /* @__PURE__ */ import_react.default.createElement("span", null, inactiveText) : null);
+    }
+  }, [active, e, em, inactiveIcon, inactiveText, is]);
+  const trueLabel = (0, import_react.useMemo)(() => {
+    if (activeIcon || activeText) {
+      return /* @__PURE__ */ import_react.default.createElement("span", { className: (0, import_classnames.default)(e`label`, em("label", "right"), is({ active })) }, (0, import_react.isValidElement)(activeIcon) && activeIcon, typeof activeIcon === "string" && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: activeIcon }), !activeIcon && activeText ? /* @__PURE__ */ import_react.default.createElement("span", null, activeText) : null);
+    }
+    return null;
+  }, [active, activeIcon, activeText, e, em, is]);
+  return /* @__PURE__ */ import_react.default.createElement(
+    "div",
+    {
+      className: (0, import_classnames.default)(b(), m({ [size]: size }), is({ disabled, checked: active }), className),
+      style,
+      onClick: switchValue,
+      ref,
+      onMouseEnter,
+      onMouseLeave,
+      onContextMenu
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      "input",
+      {
+        ref: inputRef,
+        className: e`input`,
+        type: "checkbox",
+        name,
+        disabled,
+        onKeyDown: (event) => {
+          (event.keyCode || event.which || event.charCode) === 13 ? switchValue : null;
+        }
+      }
+    ),
+    !inlinePrompt && falseLabel,
+    /* @__PURE__ */ import_react.default.createElement("span", { className: e`core`, style: { background: currentColor, borderColor, width } }, inlinePrompt && /* @__PURE__ */ import_react.default.createElement("div", { className: e`inner` }, !active ? activeText && /* @__PURE__ */ import_react.default.createElement("span", { className: "is-text" }, activeText) : typeof activeIcon === "string" && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { className: "is-icon", name: activeIcon }), active ? inactiveText && /* @__PURE__ */ import_react.default.createElement("span", { className: "is-text" }, inactiveText) : typeof inactiveIcon === "string" && /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { className: "is-icon", name: inactiveIcon })), /* @__PURE__ */ import_react.default.createElement("div", { className: e`action`, style: { color: currentColor } }, loading ? /* @__PURE__ */ import_react.default.createElement(import_Icon.Icon, { name: "spinner", spin: true }) : null)),
+    !inlinePrompt && trueLabel
+  );
+});
+Switch.defaultProps = {
+  disabled: false,
+  activeText: "",
+  inactiveText: "",
+  activeColor: "",
+  inactiveColor: "",
+  activeValue: true,
+  inactiveValue: false,
+  loading: false
+};
+var Switch_default = Switch;

package/dist/Switch/index.d.ts

@@ -0,0 +1,2 @@
+export { default as Switch } from './Switch';
+export type { ChangeValue, SwitchProps as ISwitchProps, ValueType } from './typings';

package/dist/Switch/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Switch/index.ts
+var Switch_exports = {};
+__export(Switch_exports, {
+  Switch: () => import_Switch.default
+});
+module.exports = __toCommonJS(Switch_exports);
+var import_Switch = __toESM(require("./Switch"));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Switch
+});

package/dist/Switch/typings.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { IconName } from '../Icon';
+import { BaseProps, FormControlBaseProps, NativeProps, TooltipBaseProps } from '../types/common';
+export type ValueType = boolean | string | number;
+export type ChangeValue = {
+    checked: boolean;
+    value: ValueType;
+};
+export interface SwitchProps<V = ValueType> extends Omit<FormControlBaseProps<V>, 'onChange'>, BaseProps, NativeProps<'--el-switch-on-color' | '--el-switch-off-color'>, TooltipBaseProps<HTMLDivElement> {
+    width?: number;
+    activeText?: string;
+    inactiveText?: string;
+    activeIcon?: IconName | React.ReactElement<any>;
+    inactiveIcon?: IconName | React.ReactElement<any>;
+    activeColor?: string;
+    inactiveColor?: string;
+    borderColor?: string;
+    activeValue?: V;
+    inactiveValue?: V;
+    validateEvent?: boolean;
+    loading?: boolean;
+    inlinePrompt?: boolean;
+    beforeChange?: () => Promise<boolean> | boolean;
+    onChange?: (value?: ValueType, checked?: boolean, e?: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+}

package/dist/Switch/typings.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Switch/typings.ts
+var typings_exports = {};
+module.exports = __toCommonJS(typings_exports);

package/dist/Table/Colgroup.d.ts

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+import { TableColumnCtx } from './typings';
+interface Props<T> {
+    columns: TableColumnCtx<T>[];
+    tableLayout?: 'fixed' | 'auto';
+}
+declare const Colgroup: FC<Props<any>>;
+export default Colgroup;

package/dist/Table/Colgroup.js

@@ -0,0 +1,56 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Table/Colgroup.tsx
+var Colgroup_exports = {};
+__export(Colgroup_exports, {
+  default: () => Colgroup_default
+});
+module.exports = __toCommonJS(Colgroup_exports);
+var import_react = require("react");
+var Colgroup = (props) => {
+  const isAuto = props.tableLayout === "auto";
+  let columns = props.columns || [];
+  if (isAuto) {
+    if (columns.every((column) => column.width === void 0)) {
+      columns = [];
+    }
+  }
+  const getPropsData = (column) => {
+    const propsData = {
+      key: `${props.tableLayout}_${column.id}`,
+      style: {},
+      name: "",
+      width: column.realWidth || column.width
+    };
+    if (isAuto) {
+      propsData.style = {
+        width: `${column.width}px`
+      };
+    } else {
+      propsData.name = column.id || "";
+    }
+    return propsData;
+  };
+  return (0, import_react.createElement)(
+    "colgroup",
+    {},
+    columns.map((column) => (0, import_react.createElement)("col", getPropsData(column)))
+  );
+};
+var Colgroup_default = Colgroup;

package/dist/Table/Table.d.ts

@@ -0,0 +1,12 @@
+import React, { Ref } from 'react';
+import { TableProps, TableRef } from './typings';
+declare const ForwardTable: <RecordType extends object = any>(props: TableProps<RecordType> & {
+    ref?: React.Ref<TableRef<RecordType>>;
+}) => React.ReactElement;
+type InternalTableType = typeof ForwardTable;
+interface TableInterface extends InternalTableType {
+    displayName?: string;
+    defaultProps?: Partial<TableProps<any>>;
+}
+declare const Table: TableInterface;
+export default Table;

package/dist/Table/Table.js

@@ -0,0 +1,189 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Table/Table.tsx
+var Table_exports = {};
+__export(Table_exports, {
+  default: () => Table_default
+});
+module.exports = __toCommonJS(Table_exports);
+var import_classnames = __toESM(require("classnames"));
+var import_react = __toESM(require("react"));
+var import_Loading = require("../Loading");
+var import_Scrollbar = require("../Scrollbar");
+var import_hooks = require("../hooks");
+var import_Colgroup = __toESM(require("./Colgroup"));
+var import_TableBody = __toESM(require("./TableBody"));
+var import_TableContext = require("./TableContext");
+var import_TableHeader = __toESM(require("./TableHeader"));
+var import_useScroll = require("./hooks/useScroll");
+var import_useSelection = require("./hooks/useSelection");
+var import_useTable = require("./hooks/useTable");
+var import_util = require("./util");
+function InternalTable(props, ref) {
+  const { height, maxHeight, size, stripe = false, fit, border, tableLayout, showHeader, showSummary, emptyText, append, loading } = props;
+  const { b, e, m } = (0, import_hooks.useClassNames)("table");
+  const refs = {
+    tableWrapper: (0, import_react.useRef)(null),
+    innerWrpper: (0, import_react.useRef)(null),
+    headerWrapper: (0, import_react.useRef)(null),
+    footerWrapper: (0, import_react.useRef)(null),
+    scrollBarRef: (0, import_react.useRef)(null),
+    resizeHelper: (0, import_react.useRef)(null),
+    tableHeader: (0, import_react.useRef)(null),
+    tableBody: (0, import_react.useRef)(null),
+    emptyBlock: (0, import_react.useRef)(null)
+  };
+  const tableId = (0, import_react.useMemo)(() => import_util.TableIdManager.nextTableId(), []);
+  const {
+    data,
+    setData,
+    _children,
+    columns,
+    flattenColumns,
+    fixedLeftColumns,
+    fixedRightColumns,
+    isGroup,
+    bodyWidth,
+    scheduleLayout,
+    setScrollClass,
+    initialData,
+    sortedData,
+    treeNodes,
+    treeProps,
+    isTreeTable,
+    isTreeExpandCell
+  } = (0, import_useTable.useTable)(props, refs, tableId);
+  const { state, dispatch, oldActiveRow, setCurrentRow, toggleRowSelection, toggleAllSelection, getSelectionRows, clearSelection, disabledRows } = (0, import_useSelection.useSelection)(props, data);
+  const { setHeight, scrollTo, setScrollLeft, setScrollTop } = (0, import_useScroll.useScroll)(props, data, refs, m);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    refs,
+    clearSelection,
+    getSelectionRows,
+    toggleRowSelection,
+    toggleAllSelection,
+    setCurrentRow,
+    setHeight,
+    doLayout: scheduleLayout,
+    scrollTo,
+    setScrollLeft,
+    setScrollTop
+  }));
+  return /* @__PURE__ */ import_react.default.createElement(
+    import_TableContext.TableContext.Provider,
+    {
+      value: {
+        props,
+        tableId,
+        columns,
+        flattenColumns,
+        fixedLeftColumns,
+        fixedRightColumns,
+        tableRefs: refs,
+        data,
+        setData
+      }
+    },
+    /* @__PURE__ */ import_react.default.createElement(
+      "div",
+      {
+        className: (0, import_classnames.default)(
+          {
+            [m`fit`]: fit,
+            [m`striped`]: stripe,
+            [m`border`]: border || isGroup,
+            // [ns.m('hidden')]: isHidden,
+            [m`group`]: isGroup,
+            [m`fluid-height`]: maxHeight,
+            // [ns.m('scrollable-x')]: layout.scrollX.value,
+            // [ns.m('scrollable-y')]: layout.scrollY.value,
+            [m`enable-row-hover`]: true,
+            [m("enable-row-transition")]: (data || []).length !== 0 && (data || []).length < 100,
+            "has-footer": showSummary
+          },
+          b(),
+          m(size),
+          props.className,
+          m`layout${tableLayout}`
+        ),
+        style: { ...props.style, height, maxHeight },
+        ref: refs.tableWrapper
+      },
+      /* @__PURE__ */ import_react.default.createElement("div", { ref: refs.innerWrpper, className: e`inner-wrapper`, style: { height, maxHeight } }, /* @__PURE__ */ import_react.default.createElement("div", { className: "hidden-columns" }, _children), showHeader && tableLayout === "fixed" && /* @__PURE__ */ import_react.default.createElement("div", { className: e`header-wrapper`, ref: refs.headerWrapper }, /* @__PURE__ */ import_react.default.createElement("table", { ref: refs.tableHeader, className: e`header`, border: 0, cellPadding: 0, cellSpacing: 0 }, /* @__PURE__ */ import_react.default.createElement(import_Colgroup.default, { columns: flattenColumns, tableLayout }), /* @__PURE__ */ import_react.default.createElement(
+        import_TableContext.TableBodyContext.Provider,
+        {
+          value: { oldActiveRow, state, dispatch, initialData, sortedData, disabledRows, treeProps, isTreeTable, isTreeExpandCell, treeNodes }
+        },
+        /* @__PURE__ */ import_react.default.createElement(import_TableHeader.default, { scheduleLayout })
+      ))), /* @__PURE__ */ import_react.default.createElement("div", { className: e`body-wrapper` }, /* @__PURE__ */ import_react.default.createElement(
+        import_Scrollbar.Scrollbar,
+        {
+          ref: refs.scrollBarRef,
+          viewStyle: { display: "inline-block", verticalAlign: "middle" },
+          onScroll: ({ scrollLeft }) => {
+            var _a;
+            if (refs.headerWrapper.current) {
+              refs.headerWrapper.current.scrollLeft = scrollLeft;
+            }
+            if (scrollLeft === 0) {
+              setScrollClass("is-scrolling-left");
+            } else if (refs.tableWrapper.current && scrollLeft > 0 && scrollLeft + ((_a = refs.tableWrapper.current) == null ? void 0 : _a.clientWidth) + 2 < bodyWidth.current) {
+              setScrollClass("is-scrolling-middle");
+            } else {
+              setScrollClass("is-scrolling-right");
+            }
+          }
+        },
+        /* @__PURE__ */ import_react.default.createElement("table", { ref: refs.tableBody, className: e`body`, border: 0, cellPadding: 0, cellSpacing: 0, style: { tableLayout } }, /* @__PURE__ */ import_react.default.createElement(import_Colgroup.default, { columns: flattenColumns, tableLayout }), /* @__PURE__ */ import_react.default.createElement(
+          import_TableContext.TableBodyContext.Provider,
+          {
+            value: { oldActiveRow, state, dispatch, initialData, sortedData, disabledRows, treeProps, isTreeTable, isTreeExpandCell, treeNodes }
+          },
+          tableLayout === "auto" && /* @__PURE__ */ import_react.default.createElement(import_TableHeader.default, { scheduleLayout }),
+          /* @__PURE__ */ import_react.default.createElement(import_TableBody.default, null)
+        )),
+        append && /* @__PURE__ */ import_react.default.createElement("div", { className: e`append-wrapper` }, append)
+      ), !loading && data.length === 0 && // @ts-ignore
+      /* @__PURE__ */ import_react.default.createElement("div", { ref: refs.emptyBlock, className: e`empty-block`, style: { height: "100%", position: tableLayout === "auto" ? "unset" : "" } }, /* @__PURE__ */ import_react.default.createElement("span", { className: e`empty-text` }, emptyText)), /* @__PURE__ */ import_react.default.createElement(import_Loading.Loading, { className: e`loading`, fullscreen: false, background: "rgba(255, 255, 255, 0.6)", text: "正在加载中...", visible: loading })), showSummary && /* @__PURE__ */ import_react.default.createElement("div", { className: e`footer-wrapper`, ref: refs.footerWrapper })),
+      /* @__PURE__ */ import_react.default.createElement("div", { className: e`column-resize-proxy`, ref: refs.resizeHelper, style: { display: "none" } })
+    )
+  );
+}
+var ForwardTable = (0, import_react.forwardRef)(InternalTable);
+var Table = ForwardTable;
+Table.defaultProps = {
+  data: [],
+  fit: true,
+  showHeader: true,
+  tableLayout: "fixed",
+  style: {},
+  emptyText: "暂无数据",
+  selectOnIndeterminate: true
+};
+Table.displayName = "Table";
+var Table_default = Table;

package/dist/Table/TableBody.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+declare const TableBody: {
+    (): React.JSX.Element;
+    displayName: string;
+};
+export default TableBody;