ele-admin-plus 1.1.4-beta.3 → 1.1.5-beta.1

package/lib/ele-virtual-table/components/body-row.js

@@ -0,0 +1,205 @@
+"use strict";
+const vue = require("vue");
+const BodyCell = require("./body-cell");
+const _sfc_main = vue.defineComponent({
+  name: "BodyRow",
+  components: { BodyCell },
+  props: {
+    /** 主体列配置 */
+    bodyCols: Array,
+    /** 表格主体列宽 */
+    colSizes: Array,
+    /** 当前行索引 */
+    rowIndex: Number,
+    /** 当前行数据 */
+    rowData: Object,
+    /** 表格多选选中的值 */
+    selectedRowKeys: Set,
+    /** 是否禁用表头选择框 */
+    tableSize: String,
+    /** 单元格类名自定义 */
+    bodyCellClass: [String, Function],
+    /** 单元格样式自定义 */
+    bodyCellStyle: [Object, Function],
+    /** 单元格合并行列方法 */
+    spanMethod: Function,
+    /** 溢出提示组件全局属性 */
+    tableTooltipProps: [Boolean, Object],
+    /** 序号列起始编号 */
+    pageIndex: Number,
+    /** 表格行高 */
+    rowHeight: Number,
+    /** 树表格展开图标的列 */
+    expandColumnKey: String,
+    /** 表格展开行的值 */
+    expandedRowKeys: Array,
+    /** 嵌套数据是否有子级字段名称 */
+    hasChildrenName: String,
+    /** 树表格是否懒加载子级 */
+    lazy: Boolean,
+    /** 树表格懒加载方法 */
+    load: Function,
+    /** 树表格行数据级别 */
+    level: Number,
+    /** 树表格行缩进 */
+    indent: Number,
+    /** 是否需要固定单元格高度 */
+    fixedCellHeight: Boolean,
+    /** 表格是否是自适应行高 */
+    autoRowHeight: Boolean
+  },
+  emits: {
+    /** 多选框选中改变事件 */
+    cellCheckedChange: (_row, _checked) => true,
+    /** 展开状态改变事件 */
+    cellExpandChange: (_row, _expanded, _data) => true,
+    /** 单元格点击事件 */
+    cellClick: (_row, _col, _e) => true,
+    /** 单元格双击事件 */
+    cellDblclick: (_row, _col, _e) => true,
+    /** 单元格右键事件 */
+    cellContextmenu: (_row, _col, _e) => true,
+    /** 单元格鼠标移入事件 */
+    cellMouseenter: (_row, _col, _e) => true,
+    /** 单元格鼠标移出事件 */
+    cellMouseleave: (_row, _col, _e) => true
+  },
+  setup(props, { emit }) {
+    const loading = vue.ref(false);
+    const rowDataKey = vue.computed(() => {
+      return props.rowData ? props.rowData._rowKey : void 0;
+    });
+    const isChecked = vue.computed(() => {
+      if (!props.selectedRowKeys || !rowDataKey.value) {
+        return false;
+      }
+      return props.selectedRowKeys.has(rowDataKey.value);
+    });
+    const hasChildren = vue.computed(() => {
+      if (props.rowData) {
+        if (props.rowData.children) {
+          return !!props.rowData.children.length;
+        }
+        if (props.lazy && props.hasChildrenName && props.rowData[props.hasChildrenName] === true) {
+          return true;
+        }
+      }
+      return false;
+    });
+    const rowIndent = vue.computed(() => {
+      if (!props.level || !props.indent) {
+        return;
+      }
+      return props.level * props.indent + "px";
+    });
+    const isCollapse = vue.computed(() => {
+      if (!props.expandedRowKeys || rowDataKey.value == null) {
+        return true;
+      }
+      return !props.expandedRowKeys.includes(rowDataKey.value);
+    });
+    const getKey = (column, columnIndex) => {
+      const key = rowDataKey.value ?? props.rowIndex;
+      return key + "-" + (column.key ?? columnIndex);
+    };
+    const onCellCheckedChange = (row, checked) => {
+      emit("cellCheckedChange", row, checked);
+    };
+    const onCellExpandChange = (row, expanded) => {
+      if (expanded && props.lazy && !row.children) {
+        if (props.load) {
+          loading.value = true;
+          props.load(row, null, (data) => {
+            loading.value = false;
+            emit("cellExpandChange", row, expanded, data);
+          });
+        }
+        return;
+      }
+      emit("cellExpandChange", row, expanded);
+    };
+    const onCellClick = (row, col, e) => {
+      emit("cellClick", row, col, e);
+    };
+    const onCellDblclick = (row, col, e) => {
+      emit("cellDblclick", row, col, e);
+    };
+    const onCellContextmenu = (row, col, e) => {
+      emit("cellContextmenu", row, col, e);
+    };
+    const onCellMouseenter = (row, col, e) => {
+      emit("cellMouseenter", row, col, e);
+    };
+    const onCellMouseleave = (row, col, e) => {
+      emit("cellMouseleave", row, col, e);
+    };
+    return {
+      loading,
+      isChecked,
+      hasChildren,
+      rowIndent,
+      isCollapse,
+      getKey,
+      onCellCheckedChange,
+      onCellExpandChange,
+      onCellClick,
+      onCellDblclick,
+      onCellContextmenu,
+      onCellMouseenter,
+      onCellMouseleave
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_BodyCell = vue.resolveComponent("BodyCell");
+  return vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.bodyCols, (column, index) => {
+    return vue.openBlock(), vue.createBlock(_component_BodyCell, {
+      key: _ctx.getKey(column, index),
+      column,
+      columnIndex: index,
+      rowIndex: _ctx.rowIndex,
+      rowData: _ctx.rowData,
+      colSizes: _ctx.colSizes,
+      tableSize: _ctx.tableSize,
+      bodyCellClass: _ctx.bodyCellClass,
+      bodyCellStyle: _ctx.bodyCellStyle,
+      spanMethod: _ctx.spanMethod,
+      tableTooltipProps: _ctx.tableTooltipProps,
+      pageIndex: _ctx.pageIndex,
+      rowHeight: _ctx.rowHeight,
+      expandColumnKey: _ctx.expandColumnKey,
+      isChecked: _ctx.isChecked,
+      hasChildren: _ctx.hasChildren,
+      rowIndent: _ctx.rowIndent,
+      isCollapse: _ctx.isCollapse,
+      loading: _ctx.loading,
+      fixedCellHeight: _ctx.fixedCellHeight,
+      autoRowHeight: _ctx.autoRowHeight,
+      onCheckedChange: _ctx.onCellCheckedChange,
+      onExpandChange: _ctx.onCellExpandChange,
+      onClick: _ctx.onCellClick,
+      onDblclick: _ctx.onCellDblclick,
+      onContextmenu: _ctx.onCellContextmenu,
+      onMouseenter: _ctx.onCellMouseenter,
+      onMouseleave: _ctx.onCellMouseleave
+    }, vue.createSlots({ _: 2 }, [
+      vue.renderList(Object.keys(_ctx.$slots), (name) => {
+        return {
+          name,
+          fn: vue.withCtx((slotProps) => [
+            vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+          ])
+        };
+      })
+    ]), 1032, ["column", "columnIndex", "rowIndex", "rowData", "colSizes", "tableSize", "bodyCellClass", "bodyCellStyle", "spanMethod", "tableTooltipProps", "pageIndex", "rowHeight", "expandColumnKey", "isChecked", "hasChildren", "rowIndent", "isCollapse", "loading", "fixedCellHeight", "autoRowHeight", "onCheckedChange", "onExpandChange", "onClick", "onDblclick", "onContextmenu", "onMouseenter", "onMouseleave"]);
+  }), 128);
+}
+const bodyRow = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = bodyRow;

package/lib/ele-virtual-table/components/cell-checkbox.d.ts

@@ -0,0 +1,32 @@
+import type { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    /** 是否是选中状态 */
+    checked: BooleanConstructor;
+    /** 是否是半选状态 */
+    indeterminate: BooleanConstructor;
+    /** 是否是禁用状态 */
+    disabled: BooleanConstructor;
+    /** 尺寸 */
+    size: PropType<"" | "default" | "small" | "large" | undefined>;
+}, {
+    onUpdateModelValue: (modelValue: boolean) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    /** 选中改变事件 */
+    change: (_checked: boolean) => true;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 是否是选中状态 */
+    checked: BooleanConstructor;
+    /** 是否是半选状态 */
+    indeterminate: BooleanConstructor;
+    /** 是否是禁用状态 */
+    disabled: BooleanConstructor;
+    /** 尺寸 */
+    size: PropType<"" | "default" | "small" | "large" | undefined>;
+}>> & {
+    onChange?: ((_checked: boolean) => any) | undefined;
+}, {
+    disabled: boolean;
+    indeterminate: boolean;
+    checked: boolean;
+}, {}>;
+export default _default;

package/lib/ele-virtual-table/components/cell-checkbox.js

@@ -0,0 +1,48 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const _sfc_main = vue.defineComponent({
+  name: "CellCheckbox",
+  components: { ElCheckbox: elementPlus.ElCheckbox },
+  props: {
+    /** 是否是选中状态 */
+    checked: Boolean,
+    /** 是否是半选状态 */
+    indeterminate: Boolean,
+    /** 是否是禁用状态 */
+    disabled: Boolean,
+    /** 尺寸 */
+    size: String
+  },
+  emits: {
+    /** 选中改变事件 */
+    change: (_checked) => true
+  },
+  setup(props, { emit }) {
+    const onUpdateModelValue = (modelValue) => {
+      if (props.checked !== modelValue) {
+        emit("change", modelValue);
+      }
+    };
+    return { onUpdateModelValue };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElCheckbox = vue.resolveComponent("ElCheckbox");
+  return vue.openBlock(), vue.createBlock(_component_ElCheckbox, {
+    modelValue: _ctx.checked,
+    indeterminate: _ctx.indeterminate,
+    disabled: _ctx.disabled,
+    size: _ctx.size,
+    "onUpdate:modelValue": _ctx.onUpdateModelValue
+  }, null, 8, ["modelValue", "indeterminate", "disabled", "size", "onUpdate:modelValue"]);
+}
+const cellCheckbox = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = cellCheckbox;

package/lib/ele-virtual-table/components/cell-filter.d.ts

@@ -0,0 +1,48 @@
+import type { PropType } from 'vue';
+import type { FilterValue } from '../../ele-data-table/types';
+declare const _default: import("vue").DefineComponent<{
+    /** 选中项 */
+    filtered: PropType<FilterValue>;
+    /** 是否多选 */
+    filterMultiple: BooleanConstructor;
+    /** 数据项 */
+    filters: PropType<import("element-plus/es/components/table/src/table-column/defaults").Filters | undefined>;
+    /** 弹出框定位 */
+    filterPlacement: {
+        type: PropType<any>;
+        default: string;
+    };
+}, {
+    tooltipRef: EleTooltipInstance;
+    checkedValue: import("vue").Ref<string[]>;
+    clearFilterText: import("vue").ComputedRef<string>;
+    filteredValue: import("vue").ComputedRef<string | undefined>;
+    confirmText: import("vue").ComputedRef<string>;
+    resetText: import("vue").ComputedRef<string>;
+    onItemClick: (value?: string) => void;
+    onFilterChange: (filtered: FilterValue) => void;
+    onConfirm: () => void;
+    onReset: () => void;
+    onBeforeEnter: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    /** 选中改变事件 */
+    change: (_filtered: FilterValue) => true;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 选中项 */
+    filtered: PropType<FilterValue>;
+    /** 是否多选 */
+    filterMultiple: BooleanConstructor;
+    /** 数据项 */
+    filters: PropType<import("element-plus/es/components/table/src/table-column/defaults").Filters | undefined>;
+    /** 弹出框定位 */
+    filterPlacement: {
+        type: PropType<any>;
+        default: string;
+    };
+}>> & {
+    onChange?: ((_filtered: FilterValue) => any) | undefined;
+}, {
+    filterPlacement: any;
+    filterMultiple: boolean;
+}, {}>;
+export default _default;

package/lib/ele-virtual-table/components/cell-filter.js

@@ -0,0 +1,210 @@
+"use strict";
+const vue = require("vue");
+const elementPlus = require("element-plus");
+const EleTooltip = require("../../ele-tooltip/index");
+const icons = require("../../icons");
+const _sfc_main = vue.defineComponent({
+  name: "CellFilter",
+  components: {
+    ElIcon: elementPlus.ElIcon,
+    ElButton: elementPlus.ElButton,
+    ElScrollbar: elementPlus.ElScrollbar,
+    EleTooltip,
+    FilterFilled: icons.FilterFilled
+  },
+  props: {
+    /** 选中项 */
+    filtered: Array,
+    /** 是否多选 */
+    filterMultiple: Boolean,
+    /** 数据项 */
+    filters: Array,
+    /** 弹出框定位 */
+    filterPlacement: {
+      type: String,
+      default: "bottom-start"
+    }
+  },
+  emits: {
+    /** 选中改变事件 */
+    change: (_filtered) => true
+  },
+  setup(props, { emit }) {
+    const { t } = elementPlus.useLocale();
+    const tooltipRef = vue.ref(null);
+    const checkedValue = vue.ref([]);
+    const clearFilterText = vue.computed(() => {
+      return t("el.table.clearFilter");
+    });
+    const filteredValue = vue.computed(() => {
+      if (!props.filtered || !props.filtered.length) {
+        return;
+      }
+      return props.filtered[0];
+    });
+    const confirmText = vue.computed(() => {
+      return t("el.table.confirmFilter");
+    });
+    const resetText = vue.computed(() => {
+      return t("el.table.resetFilter");
+    });
+    const hidePopper = () => {
+      tooltipRef.value && tooltipRef.value.hide();
+    };
+    const onBeforeEnter = () => {
+      checkedValue.value = props.filtered ?? [];
+    };
+    const onItemClick = (value) => {
+      onFilterChange(value == null ? [] : [value]);
+      hidePopper();
+    };
+    const onFilterChange = (filtered) => {
+      emit("change", filtered);
+    };
+    const onConfirm = () => {
+      onFilterChange(checkedValue.value);
+      hidePopper();
+    };
+    const onReset = () => {
+      checkedValue.value = [];
+      onFilterChange([]);
+      hidePopper();
+    };
+    return {
+      tooltipRef,
+      checkedValue,
+      clearFilterText,
+      filteredValue,
+      confirmText,
+      resetText,
+      onItemClick,
+      onFilterChange,
+      onConfirm,
+      onReset,
+      onBeforeEnter
+    };
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "ele-table-filter-footer" };
+const _hoisted_2 = {
+  key: 1,
+  class: "ele-table-filter-list"
+};
+const _hoisted_3 = ["onClick"];
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_FilterFilled = vue.resolveComponent("FilterFilled");
+  const _component_ElIcon = vue.resolveComponent("ElIcon");
+  const _component_ElCheckbox = vue.resolveComponent("ElCheckbox");
+  const _component_ElCheckboxGroup = vue.resolveComponent("ElCheckboxGroup");
+  const _component_ElScrollbar = vue.resolveComponent("ElScrollbar");
+  const _component_ElButton = vue.resolveComponent("ElButton");
+  const _component_EleTooltip = vue.resolveComponent("EleTooltip");
+  return vue.openBlock(), vue.createElementBlock("div", {
+    class: "ele-table-filter",
+    onClick: _cache[2] || (_cache[2] = vue.withModifiers(() => {
+    }, ["stop"]))
+  }, [
+    vue.createVNode(_component_EleTooltip, {
+      ref: "tooltipRef",
+      trigger: "click",
+      showArrow: false,
+      placement: _ctx.filterPlacement,
+      popperClass: "ele-table-filter-popper",
+      gpuAcceleration: true,
+      effect: "light",
+      isPopover: true,
+      popperOptions: {
+        modifiers: [{ name: "offset", options: { offset: [0, 4] } }]
+      },
+      onBeforeShow: _ctx.onBeforeEnter
+    }, {
+      body: vue.withCtx(() => [
+        _ctx.filterMultiple ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+          vue.createVNode(_component_ElScrollbar, { class: "ele-table-filter-body" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_ElCheckboxGroup, {
+                modelValue: _ctx.checkedValue,
+                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.checkedValue = $event)
+              }, {
+                default: vue.withCtx(() => [
+                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.filters, (item) => {
+                    return vue.openBlock(), vue.createBlock(_component_ElCheckbox, {
+                      key: item.value,
+                      label: item.value
+                    }, {
+                      default: vue.withCtx(() => [
+                        vue.createTextVNode(vue.toDisplayString(item.text), 1)
+                      ]),
+                      _: 2
+                    }, 1032, ["label"]);
+                  }), 128))
+                ]),
+                _: 1
+              }, 8, ["modelValue"])
+            ]),
+            _: 1
+          }),
+          vue.createElementVNode("div", _hoisted_1, [
+            vue.createVNode(_component_ElButton, {
+              size: "small",
+              text: true,
+              onClick: _ctx.onReset
+            }, {
+              default: vue.withCtx(() => [
+                vue.createTextVNode(vue.toDisplayString(_ctx.resetText), 1)
+              ]),
+              _: 1
+            }, 8, ["onClick"]),
+            vue.createVNode(_component_ElButton, {
+              size: "small",
+              type: "primary",
+              disabled: !_ctx.checkedValue.length,
+              onClick: _ctx.onConfirm
+            }, {
+              default: vue.withCtx(() => [
+                vue.createTextVNode(vue.toDisplayString(_ctx.confirmText), 1)
+              ]),
+              _: 1
+            }, 8, ["disabled", "onClick"])
+          ])
+        ], 64)) : (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+          vue.createElementVNode("div", {
+            class: vue.normalizeClass([
+              "ele-table-filter-item",
+              { "is-active": _ctx.filteredValue == null }
+            ]),
+            onClick: _cache[1] || (_cache[1] = ($event) => _ctx.onItemClick())
+          }, vue.toDisplayString(_ctx.clearFilterText), 3),
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.filters, (d) => {
+            return vue.openBlock(), vue.createElementBlock("div", {
+              key: d.value,
+              class: vue.normalizeClass([
+                "ele-table-filter-item",
+                { "is-active": _ctx.filteredValue === d.value }
+              ]),
+              onClick: ($event) => _ctx.onItemClick(d.value)
+            }, vue.toDisplayString(d.text), 11, _hoisted_3);
+          }), 128))
+        ]))
+      ]),
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_ElIcon, null, {
+          default: vue.withCtx(() => [
+            vue.createVNode(_component_FilterFilled)
+          ]),
+          _: 1
+        })
+      ]),
+      _: 1
+    }, 8, ["placement", "onBeforeShow"])
+  ]);
+}
+const cellFilter = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = cellFilter;

package/lib/ele-virtual-table/components/expand-row.d.ts

@@ -0,0 +1,18 @@
+import type { PropType } from 'vue';
+import type { DataItem } from '../../ele-data-table/types';
+declare const _default: import("vue").DefineComponent<{
+    /** 列配置 */
+    column: PropType<Partial<import("element-plus").Column<DataItem>>>;
+    /** 行索引 */
+    rowIndex: NumberConstructor;
+    /** 行数据 */
+    rowData: PropType<DataItem>;
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 列配置 */
+    column: PropType<Partial<import("element-plus").Column<DataItem>>>;
+    /** 行索引 */
+    rowIndex: NumberConstructor;
+    /** 行数据 */
+    rowData: PropType<DataItem>;
+}>>, {}, {}>;
+export default _default;

package/lib/ele-virtual-table/components/expand-row.js

@@ -0,0 +1,28 @@
+"use strict";
+const vue = require("vue");
+const _sfc_main = vue.defineComponent({
+  name: "ExpandRow",
+  props: {
+    /** 列配置 */
+    column: Object,
+    /** 行索引 */
+    rowIndex: Number,
+    /** 行数据 */
+    rowData: Object
+  }
+});
+const _export_sfc = (sfc, props) => {
+  const target = sfc.__vccOpts || sfc;
+  for (const [key, val] of props) {
+    target[key] = val;
+  }
+  return target;
+};
+const _hoisted_1 = { class: "el-table-v2__row-cell ele-table-td" };
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  return vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+    _ctx.column && _ctx.column.originalCol && _ctx.column.originalCol.slot ? vue.renderSlot(_ctx.$slots, _ctx.column.originalCol.slot, vue.normalizeProps(vue.mergeProps({ key: 0 }, { row: _ctx.rowData, column: _ctx.column.originalCol, $index: _ctx.rowIndex }))) : vue.createCommentVNode("", true)
+  ]);
+}
+const expandRow = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
+module.exports = expandRow;

package/lib/ele-virtual-table/components/footer-row.d.ts

@@ -0,0 +1,43 @@
+import type { PropType } from 'vue';
+import type { DataItem } from '../../ele-data-table/types';
+import type { BodyColumns, SumCol, ColSize } from '../types';
+declare const _default: import("vue").DefineComponent<{
+    /** 表格主体列配置 */
+    bodyCols: PropType<BodyColumns>;
+    /** 表格主体列宽 */
+    colSizes: PropType<ColSize[]>;
+    /** 表格主体所有列合计宽度 */
+    sumWidth: NumberConstructor;
+    /** 表格数据 */
+    tableData: PropType<DataItem[]>;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+    /** 合计行文本 */
+    sumText: StringConstructor;
+    /** 合计行自定义方法 */
+    summaryMethod: FunctionConstructor;
+}, {
+    sumCols: import("vue").ComputedRef<SumCol[]>;
+    onMouseenter: (e: MouseEvent) => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    /** 单元格鼠标移入事件 */
+    mouseenter: (_e: MouseEvent) => true;
+}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    /** 表格主体列配置 */
+    bodyCols: PropType<BodyColumns>;
+    /** 表格主体列宽 */
+    colSizes: PropType<ColSize[]>;
+    /** 表格主体所有列合计宽度 */
+    sumWidth: NumberConstructor;
+    /** 表格数据 */
+    tableData: PropType<DataItem[]>;
+    /** 表格行高 */
+    rowHeight: NumberConstructor;
+    /** 合计行文本 */
+    sumText: StringConstructor;
+    /** 合计行自定义方法 */
+    summaryMethod: FunctionConstructor;
+}>> & {
+    onMouseenter?: ((_e: MouseEvent) => any) | undefined;
+}, {}, {}>;
+export default _default;