ele-admin-plus 1.3.0-beta.3 → 1.3.0-beta.4

package/es/ele-virtual-table/index.js

@@ -1,5 +1,5 @@
-import { defineComponent, ref, reactive, computed, onActivated, onDeactivated, watch, nextTick, resolveComponent, openBlock, createElementBlock, normalizeClass, createBlock, mergeProps, createSlots, withCtx, renderList, renderSlot, normalizeProps, guardReactiveProps, createCommentVNode, toDisplayString, createVNode } from "vue";
-import { ElTableV2, ElEmpty, useLocale } from "element-plus";
+import { defineComponent, ref, reactive, computed, onActivated, onDeactivated, watch, nextTick, openBlock, createElementBlock, normalizeClass, unref, createBlock, mergeProps, createSlots, withCtx, renderList, renderSlot, normalizeProps, guardReactiveProps, createCommentVNode, toDisplayString, createVNode } from "vue";
+import { useLocale, ElTableV2, ElEmpty } from "element-plus";
 import { eachTree, queryChild, findTree, getValue } from "../utils/core";
 import EleTooltip from "../ele-tooltip/index";
 import { useEmits, useStickyHeader, isReserveChecked, valueIsChanged, arrayIsChanged, getRowKeys, mergeTooltipProps, getGlobalTooltipProps } from "../ele-data-table/util";
@@ -9,21 +9,19 @@ import BodyRow from "./components/body-row";
 import ExpandRow from "./components/expand-row";
 import FooterRow from "./components/footer-row";
 import { virtualTableProps, virtualTableEmits } from "./props";
-const ownSlots = ["default", "empty", "append"];
-const _sfc_main = defineComponent({
-  name: "EleVirtualTable",
-  components: {
-    ElTableV2,
-    ElEmpty,
-    EleTooltip,
-    HeaderRow,
-    BodyRow,
-    ExpandRow,
-    FooterRow
-  },
+const _hoisted_1 = {
+  key: 0,
+  class: "ele-table-empty-text"
+};
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{ name: "EleVirtualTable" },
+  __name: "index",
   props: virtualTableProps,
   emits: virtualTableEmits,
-  setup(props, { emit }) {
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const ownSlots = ["default", "empty", "append"];
+    const props = __props;
+    const emit = __emit;
     const { t } = useLocale();
     const events = useEmits(emit);
     const { wrapWidth, wrapHeight, updateWrapSize } = useAutoResize(
@@ -57,9 +55,7 @@ const _sfc_main = defineComponent({
     const sortBy = ref(
       getDefaultSort(props.defaultSort)
     );
-    const filtered = reactive(
-      getDefaultFiltered(props.columns)
-    );
+    const filtered = reactive(getDefaultFiltered(props.columns));
     const tableTooltipProps = reactive({
       placement: "top",
       trigger: "click",
@@ -286,16 +282,16 @@ const _sfc_main = defineComponent({
           props.rowKey,
           getSelectableFunction(bodyCols.value)
         );
-        let index2 = -1;
+        let index = -1;
         eachTree(tableData.value, (d) => {
-          index2++;
+          index++;
           if (d.rowId === row.rowId) {
             d.children = childs;
             if (!childs.length) {
               d.hasChildren = false;
             }
           }
-          d.rowIndex = index2;
+          d.rowIndex = index;
         });
         if (!childs.length) {
           return;
@@ -475,9 +471,9 @@ const _sfc_main = defineComponent({
           treeChildrenName.value
         );
         checkedRowKeys.value.forEach((key2) => {
-          const index2 = dataKeys.indexOf(key2);
-          if (index2 !== -1) {
-            const row = list[index2].rowData;
+          const index = dataKeys.indexOf(key2);
+          if (index !== -1) {
+            const row = list[index].rowData;
             if (tableState.checked.get(key2) !== row) {
               tableState.checked.set(key2, row);
             }
@@ -572,9 +568,9 @@ const _sfc_main = defineComponent({
         checkedRowKeys.value = new Set(keys);
         tableState.checked.clear();
         keys.forEach((key) => {
-          const index2 = dataKeys.indexOf(key);
-          if (index2 !== -1) {
-            tableState.checked.set(key, list[index2].rowData);
+          const index = dataKeys.indexOf(key);
+          if (index !== -1) {
+            tableState.checked.set(key, list[index].rowData);
           } else if (props.cacheData != null) {
             const i = cacheKeys.indexOf(key);
             if (i !== -1) {
@@ -694,8 +690,8 @@ const _sfc_main = defineComponent({
       if (spread) {
         expandedRowKeys.value.push(dataKey);
       } else {
-        const index2 = expandedRowKeys.value.findIndex((t2) => t2 === dataKey);
-        expandedRowKeys.value.splice(index2, 1);
+        const index = expandedRowKeys.value.findIndex((t2) => t2 === dataKey);
+        expandedRowKeys.value.splice(index, 1);
       }
       events.onExpandChange(row.rowData, spread);
     };
@@ -738,10 +734,7 @@ const _sfc_main = defineComponent({
       headerRowSizes.value = rowSizes;
       if (force || isSizesChanged) {
         bodyColSizes.value = colSizes;
-        tableColumns.value = getTableColumns(
-          bodyCols.value,
-          bodyColSizes.value
-        );
+        tableColumns.value = getTableColumns(bodyCols.value, bodyColSizes.value);
       }
       if (isUpdate) {
         tableKey.value++;
@@ -900,56 +893,8 @@ const _sfc_main = defineComponent({
         }
       }
     );
-    return {
-      ownSlots,
-      rootRef,
+    __expose({
       tableRef,
-      tableKey,
-      wrapWidth,
-      headerRows,
-      bodyCols,
-      headerRowSizes,
-      bodyColSizes,
-      colsSumWidth,
-      tableWidth,
-      tableData,
-      isCheckAll,
-      isIndeterminate,
-      checkedRowKeys,
-      expandedRowKeys,
-      sortBy,
-      filtered,
-      tableTooltipProps,
-      tableExpandCol,
-      hasExpandCol,
-      tableExpandColumnKey,
-      tableRowHeight,
-      autoRowHeight,
-      hasFooter,
-      tableProps,
-      isPingLeft,
-      isPingRight,
-      tableSumText,
-      tableEmptyText,
-      isLayoutFixedHead,
-      isLayoutMaximized,
-      handleTableFilterChange,
-      handleCellCheckedChange,
-      handleCellExpandChange,
-      handleCellClick,
-      handleCellDblclick,
-      handleCellContextmenu,
-      handleCellMouseenter,
-      handleCellMouseleave,
-      handleHeaderCellClick,
-      handleHeaderCellContextmenu,
-      handleHeaderCellMouseenter,
-      handleFooterCellMouseenter,
-      handleExpandCellMouseenter,
-      handleTableMouseleave,
-      handleTableScroll,
-      handleEndEeached,
-      handleRowsRendered,
       updateWrapSize,
       updateTableData,
       updateSelectedAndChecked,
@@ -973,190 +918,173 @@ const _sfc_main = defineComponent({
       setScrollLeft,
       scrollToRow,
       hideTooltip
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createElementBlock("div", {
+        ref_key: "rootRef",
+        ref: rootRef,
+        class: normalizeClass([
+          "ele-virtual-table",
+          { "is-border": _ctx.border || headerRows.value.length > 1 },
+          { "is-stripe": _ctx.stripe },
+          { "is-sticky": _ctx.sticky },
+          { "is-layout-fixed-head": _ctx.sticky && unref(isLayoutFixedHead) },
+          { "is-layout-maximized": _ctx.sticky && unref(isLayoutMaximized) },
+          { "has-footer": hasFooter.value },
+          { "hide-header": !_ctx.showHeader },
+          { "hide-bottom-line": !_ctx.bottomLine },
+          { "is-ping-left": isPingLeft.value },
+          { "is-ping-right": isPingRight.value },
+          { "is-auto-width": unref(wrapWidth) === tableWidth.value },
+          { "is-small": _ctx.size === "small" },
+          { "is-large": _ctx.size === "large" }
+        ]),
+        onMouseleave: handleTableMouseleave
+      }, [
+        tableProps.value.width ? (openBlock(), createBlock(unref(ElTableV2), mergeProps({ key: 0 }, tableProps.value, {
+          key: tableKey.value,
+          ref_key: "tableRef",
+          ref: tableRef,
+          onScroll: handleTableScroll,
+          onEndEeached: handleEndEeached,
+          onRowsRendered: handleRowsRendered
+        }), createSlots({
+          header: withCtx((headerProps) => [
+            headerProps && headerRows.value[headerProps.headerIndex] ? (openBlock(), createBlock(HeaderRow, {
+              key: 0,
+              headerCols: headerRows.value[headerProps.headerIndex],
+              headerColSizes: headerRowSizes.value[headerProps.headerIndex],
+              headerIndex: headerProps.headerIndex,
+              sortBy: sortBy.value,
+              filtered,
+              isCheckAll: isCheckAll.value,
+              isIndeterminate: isIndeterminate.value,
+              disabledCheckbox: !tableData.value.length,
+              tableSize: _ctx.size,
+              headerCellClass: _ctx.headerCellClassName,
+              headerCellStyle: _ctx.headerCellStyle,
+              headerEllipsis: true,
+              rowHeight: tableRowHeight.value,
+              onCheckedChange: _cache[0] || (_cache[0] = ($event) => toggleAllSelection()),
+              onFilterChange: handleTableFilterChange,
+              onCellClick: handleHeaderCellClick,
+              onCellContextmenu: handleHeaderCellContextmenu,
+              onCellMouseenter: handleHeaderCellMouseenter
+            }, createSlots({ _: 2 }, [
+              renderList(Object.keys(_ctx.$slots).filter(
+                (k) => !ownSlots.includes(k)
+              ), (name) => {
+                return {
+                  name,
+                  fn: withCtx((slotProps) => [
+                    renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
+                  ])
+                };
+              })
+            ]), 1032, ["headerCols", "headerColSizes", "headerIndex", "sortBy", "filtered", "isCheckAll", "isIndeterminate", "disabledCheckbox", "tableSize", "headerCellClass", "headerCellStyle", "rowHeight"])) : createCommentVNode("", true)
+          ]),
+          row: withCtx((rowProps) => {
+            var _a;
+            return [
+              rowProps && rowProps.rowData && rowProps.rowData.isExpandRow ? (openBlock(), createBlock(ExpandRow, {
+                key: 0,
+                column: (_a = tableExpandCol.value) == null ? void 0 : _a.originalCol,
+                rowIndex: rowProps.rowData.rowIndex,
+                rowData: rowProps.rowData.rowData,
+                onMouseenter: handleExpandCellMouseenter
+              }, createSlots({ _: 2 }, [
+                renderList(Object.keys(_ctx.$slots).filter(
+                  (k) => !ownSlots.includes(k)
+                ), (name) => {
+                  return {
+                    name,
+                    fn: withCtx((slotProps) => [
+                      renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
+                    ])
+                  };
+                })
+              ]), 1032, ["column", "rowIndex", "rowData"])) : rowProps && rowProps.rowData && rowProps.rowData.rowData ? (openBlock(), createBlock(BodyRow, {
+                key: 1,
+                bodyCols: bodyCols.value,
+                colSizes: bodyColSizes.value,
+                rowIndex: rowProps.rowData.rowIndex,
+                rowItem: rowProps.rowData,
+                rowId: rowProps.rowData.rowId,
+                checkedRowKeys: checkedRowKeys.value,
+                bodyCellClass: _ctx.cellClassName,
+                bodyCellStyle: _ctx.cellStyle,
+                spanMethod: _ctx.spanMethod,
+                tableTooltipProps: _ctx.showOverflowTooltip,
+                pageIndex: _ctx.pageIndex,
+                rowHeight: tableRowHeight.value,
+                tableSize: _ctx.size,
+                expandColumnKey: tableExpandColumnKey.value,
+                expandedRowKeys: expandedRowKeys.value,
+                lazy: _ctx.lazy,
+                load: _ctx.load,
+                level: rowProps.depth,
+                indent: _ctx.indent,
+                fixedCellHeight: hasExpandCol.value,
+                autoRowHeight: autoRowHeight.value,
+                onCellCheckedChange: handleCellCheckedChange,
+                onCellExpandChange: handleCellExpandChange,
+                onCellClick: handleCellClick,
+                onCellDblclick: handleCellDblclick,
+                onCellContextmenu: handleCellContextmenu,
+                onCellMouseenter: handleCellMouseenter,
+                onCellMouseleave: handleCellMouseleave
+              }, createSlots({ _: 2 }, [
+                renderList(Object.keys(_ctx.$slots).filter(
+                  (k) => !ownSlots.includes(k)
+                ), (name) => {
+                  return {
+                    name,
+                    fn: withCtx((slotProps) => [
+                      renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
+                    ])
+                  };
+                })
+              ]), 1032, ["bodyCols", "colSizes", "rowIndex", "rowItem", "rowId", "checkedRowKeys", "bodyCellClass", "bodyCellStyle", "spanMethod", "tableTooltipProps", "pageIndex", "rowHeight", "tableSize", "expandColumnKey", "expandedRowKeys", "lazy", "load", "level", "indent", "fixedCellHeight", "autoRowHeight"])) : createCommentVNode("", true)
+            ];
+          }),
+          empty: withCtx(() => [
+            renderSlot(_ctx.$slots, "empty", {
+              text: _ctx.emptyText,
+              error: _ctx.errorText
+            }, () => [
+              _ctx.emptyProps === false ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(tableEmptyText.value), 1)) : (openBlock(), createBlock(unref(ElEmpty), mergeProps({
+                key: 1,
+                imageSize: 68
+              }, !_ctx.emptyProps || _ctx.emptyProps === true ? {} : _ctx.emptyProps, {
+                description: tableEmptyText.value,
+                class: "ele-table-empty"
+              }), null, 16, ["description"]))
+            ])
+          ]),
+          _: 2
+        }, [
+          hasFooter.value ? {
+            name: "footer",
+            fn: withCtx(() => [
+              createVNode(FooterRow, {
+                bodyCols: bodyCols.value,
+                colSizes: bodyColSizes.value,
+                sumWidth: colsSumWidth.value,
+                tableData: tableData.value,
+                rowHeight: tableRowHeight.value,
+                sumText: tableSumText.value,
+                summaryMethod: _ctx.summaryMethod,
+                onMouseenter: handleFooterCellMouseenter
+              }, null, 8, ["bodyCols", "colSizes", "sumWidth", "tableData", "rowHeight", "sumText", "summaryMethod"])
+            ]),
+            key: "0"
+          } : void 0
+        ]), 1040)) : createCommentVNode("", true),
+        createVNode(EleTooltip, normalizeProps(guardReactiveProps(tableTooltipProps)), null, 16)
+      ], 34);
     };
   }
 });
-const _export_sfc = (sfc, props) => {
-  const target = sfc.__vccOpts || sfc;
-  for (const [key, val] of props) {
-    target[key] = val;
-  }
-  return target;
-};
-const _hoisted_1 = {
-  key: 0,
-  class: "ele-table-empty-text"
-};
-function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
-  const _component_HeaderRow = resolveComponent("HeaderRow");
-  const _component_ExpandRow = resolveComponent("ExpandRow");
-  const _component_BodyRow = resolveComponent("BodyRow");
-  const _component_FooterRow = resolveComponent("FooterRow");
-  const _component_ElEmpty = resolveComponent("ElEmpty");
-  const _component_ElTableV2 = resolveComponent("ElTableV2");
-  const _component_EleTooltip = resolveComponent("EleTooltip");
-  return openBlock(), createElementBlock("div", {
-    ref: "rootRef",
-    class: normalizeClass([
-      "ele-virtual-table",
-      { "is-border": _ctx.border || _ctx.headerRows.length > 1 },
-      { "is-stripe": _ctx.stripe },
-      { "is-sticky": _ctx.sticky },
-      { "is-layout-fixed-head": _ctx.sticky && _ctx.isLayoutFixedHead },
-      { "is-layout-maximized": _ctx.sticky && _ctx.isLayoutMaximized },
-      { "has-footer": _ctx.hasFooter },
-      { "hide-header": !_ctx.showHeader },
-      { "hide-bottom-line": !_ctx.bottomLine },
-      { "is-ping-left": _ctx.isPingLeft },
-      { "is-ping-right": _ctx.isPingRight },
-      { "is-auto-width": _ctx.wrapWidth === _ctx.tableWidth },
-      { "is-small": _ctx.size === "small" },
-      { "is-large": _ctx.size === "large" }
-    ]),
-    onMouseleave: _cache[1] || (_cache[1] = (...args) => _ctx.handleTableMouseleave && _ctx.handleTableMouseleave(...args))
-  }, [
-    _ctx.tableProps.width ? (openBlock(), createBlock(_component_ElTableV2, mergeProps({ key: 0 }, _ctx.tableProps, {
-      key: _ctx.tableKey,
-      ref: "tableRef",
-      onScroll: _ctx.handleTableScroll,
-      onEndEeached: _ctx.handleEndEeached,
-      onRowsRendered: _ctx.handleRowsRendered
-    }), createSlots({
-      header: withCtx((headerProps) => [
-        headerProps && _ctx.headerRows[headerProps.headerIndex] ? (openBlock(), createBlock(_component_HeaderRow, {
-          key: 0,
-          headerCols: _ctx.headerRows[headerProps.headerIndex],
-          headerColSizes: _ctx.headerRowSizes[headerProps.headerIndex],
-          headerIndex: headerProps.headerIndex,
-          sortBy: _ctx.sortBy,
-          filtered: _ctx.filtered,
-          isCheckAll: _ctx.isCheckAll,
-          isIndeterminate: _ctx.isIndeterminate,
-          disabledCheckbox: !_ctx.tableData.length,
-          tableSize: _ctx.size,
-          headerCellClass: _ctx.headerCellClassName,
-          headerCellStyle: _ctx.headerCellStyle,
-          headerEllipsis: true,
-          rowHeight: _ctx.tableRowHeight,
-          onCheckedChange: _cache[0] || (_cache[0] = ($event) => _ctx.toggleAllSelection()),
-          onFilterChange: _ctx.handleTableFilterChange,
-          onCellClick: _ctx.handleHeaderCellClick,
-          onCellContextmenu: _ctx.handleHeaderCellContextmenu,
-          onCellMouseenter: _ctx.handleHeaderCellMouseenter
-        }, createSlots({ _: 2 }, [
-          renderList(Object.keys(_ctx.$slots).filter(
-            (k) => !_ctx.ownSlots.includes(k)
-          ), (name) => {
-            return {
-              name,
-              fn: withCtx((slotProps) => [
-                renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
-              ])
-            };
-          })
-        ]), 1032, ["headerCols", "headerColSizes", "headerIndex", "sortBy", "filtered", "isCheckAll", "isIndeterminate", "disabledCheckbox", "tableSize", "headerCellClass", "headerCellStyle", "rowHeight", "onFilterChange", "onCellClick", "onCellContextmenu", "onCellMouseenter"])) : createCommentVNode("", true)
-      ]),
-      row: withCtx((rowProps) => {
-        var _a;
-        return [
-          rowProps && rowProps.rowData && rowProps.rowData.isExpandRow ? (openBlock(), createBlock(_component_ExpandRow, {
-            key: 0,
-            column: (_a = _ctx.tableExpandCol) == null ? void 0 : _a.originalCol,
-            rowIndex: rowProps.rowData.rowIndex,
-            rowData: rowProps.rowData.rowData,
-            onMouseenter: _ctx.handleExpandCellMouseenter
-          }, createSlots({ _: 2 }, [
-            renderList(Object.keys(_ctx.$slots).filter(
-              (k) => !_ctx.ownSlots.includes(k)
-            ), (name) => {
-              return {
-                name,
-                fn: withCtx((slotProps) => [
-                  renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
-                ])
-              };
-            })
-          ]), 1032, ["column", "rowIndex", "rowData", "onMouseenter"])) : rowProps && rowProps.rowData && rowProps.rowData.rowData ? (openBlock(), createBlock(_component_BodyRow, {
-            key: 1,
-            bodyCols: _ctx.bodyCols,
-            colSizes: _ctx.bodyColSizes,
-            rowIndex: rowProps.rowData.rowIndex,
-            rowItem: rowProps.rowData,
-            rowId: rowProps.rowData.rowId,
-            checkedRowKeys: _ctx.checkedRowKeys,
-            bodyCellClass: _ctx.cellClassName,
-            bodyCellStyle: _ctx.cellStyle,
-            spanMethod: _ctx.spanMethod,
-            tableTooltipProps: _ctx.showOverflowTooltip,
-            pageIndex: _ctx.pageIndex,
-            rowHeight: _ctx.tableRowHeight,
-            tableSize: _ctx.size,
-            expandColumnKey: _ctx.tableExpandColumnKey,
-            expandedRowKeys: _ctx.expandedRowKeys,
-            lazy: _ctx.lazy,
-            load: _ctx.load,
-            level: rowProps.depth,
-            indent: _ctx.indent,
-            fixedCellHeight: _ctx.hasExpandCol,
-            autoRowHeight: _ctx.autoRowHeight,
-            onCellCheckedChange: _ctx.handleCellCheckedChange,
-            onCellExpandChange: _ctx.handleCellExpandChange,
-            onCellClick: _ctx.handleCellClick,
-            onCellDblclick: _ctx.handleCellDblclick,
-            onCellContextmenu: _ctx.handleCellContextmenu,
-            onCellMouseenter: _ctx.handleCellMouseenter,
-            onCellMouseleave: _ctx.handleCellMouseleave
-          }, createSlots({ _: 2 }, [
-            renderList(Object.keys(_ctx.$slots).filter(
-              (k) => !_ctx.ownSlots.includes(k)
-            ), (name) => {
-              return {
-                name,
-                fn: withCtx((slotProps) => [
-                  renderSlot(_ctx.$slots, name, normalizeProps(guardReactiveProps(slotProps || {})))
-                ])
-              };
-            })
-          ]), 1032, ["bodyCols", "colSizes", "rowIndex", "rowItem", "rowId", "checkedRowKeys", "bodyCellClass", "bodyCellStyle", "spanMethod", "tableTooltipProps", "pageIndex", "rowHeight", "tableSize", "expandColumnKey", "expandedRowKeys", "lazy", "load", "level", "indent", "fixedCellHeight", "autoRowHeight", "onCellCheckedChange", "onCellExpandChange", "onCellClick", "onCellDblclick", "onCellContextmenu", "onCellMouseenter", "onCellMouseleave"])) : createCommentVNode("", true)
-        ];
-      }),
-      empty: withCtx(() => [
-        renderSlot(_ctx.$slots, "empty", {
-          text: _ctx.emptyText,
-          error: _ctx.errorText
-        }, () => [
-          _ctx.emptyProps === false ? (openBlock(), createElementBlock("div", _hoisted_1, toDisplayString(_ctx.tableEmptyText), 1)) : (openBlock(), createBlock(_component_ElEmpty, mergeProps({
-            key: 1,
-            imageSize: 68
-          }, !_ctx.emptyProps || _ctx.emptyProps === true ? {} : _ctx.emptyProps, {
-            description: _ctx.tableEmptyText,
-            class: "ele-table-empty"
-          }), null, 16, ["description"]))
-        ])
-      ]),
-      _: 2
-    }, [
-      _ctx.hasFooter ? {
-        name: "footer",
-        fn: withCtx(() => [
-          createVNode(_component_FooterRow, {
-            bodyCols: _ctx.bodyCols,
-            colSizes: _ctx.bodyColSizes,
-            sumWidth: _ctx.colsSumWidth,
-            tableData: _ctx.tableData,
-            rowHeight: _ctx.tableRowHeight,
-            sumText: _ctx.tableSumText,
-            summaryMethod: _ctx.summaryMethod,
-            onMouseenter: _ctx.handleFooterCellMouseenter
-          }, null, 8, ["bodyCols", "colSizes", "sumWidth", "tableData", "rowHeight", "sumText", "summaryMethod", "onMouseenter"])
-        ]),
-        key: "0"
-      } : void 0
-    ]), 1040, ["onScroll", "onEndEeached", "onRowsRendered"])) : createCommentVNode("", true),
-    createVNode(_component_EleTooltip, normalizeProps(guardReactiveProps(_ctx.tableTooltipProps)), null, 16)
-  ], 34);
-}
-const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 export {
-  index as default
+  _sfc_main as default
 };

package/es/ele-virtual-table/props.d.ts

@@ -49,7 +49,7 @@ export declare const virtualTableProps: {
     width: (NumberConstructor | StringConstructor)[];
     height: (NumberConstructor | StringConstructor)[];
     data: {
-        type: import('vue').PropType<any[]>;
+        type: import('vue').PropType<import('element-plus/es/components/table/src/table/defaults').DefaultRow[]>;
         default: () => never[];
     };
     size: {
@@ -68,38 +68,30 @@ export declare const virtualTableProps: {
         type: StringConstructor;
         default: string;
     };
+    emptyText: StringConstructor;
     showHeader: {
         type: BooleanConstructor;
         default: boolean;
     };
     showSummary: BooleanConstructor;
     sumText: StringConstructor;
-    summaryMethod: import('vue').PropType<import('element-plus').SummaryMethod<any> | undefined>;
-    rowClassName: import('vue').PropType<import('element-plus').ColumnCls<any> | undefined>;
-    rowStyle: import('vue').PropType<import('element-plus').ColumnStyle<any> | undefined>;
-    cellClassName: import('vue').PropType<import('element-plus').CellCls<any> | undefined>;
-    cellStyle: import('vue').PropType<import('element-plus').CellStyle<any> | undefined>;
-    headerRowClassName: import('vue').PropType<import('element-plus').ColumnCls<any> | undefined>;
-    headerRowStyle: import('vue').PropType<import('element-plus').ColumnStyle<any> | undefined>;
-    headerCellClassName: import('vue').PropType<import('element-plus').CellCls<any> | undefined>;
-    headerCellStyle: import('vue').PropType<import('element-plus').CellStyle<any> | undefined>;
+    summaryMethod: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["summaryMethod"]>;
+    rowClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["rowClassName"]>;
+    rowStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["rowStyle"]>;
+    cellClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["cellClassName"]>;
+    cellStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["cellStyle"]>;
+    headerRowClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["headerRowClassName"]>;
+    headerRowStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["headerRowStyle"]>;
+    headerCellClassName: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["headerCellClassName"]>;
+    headerCellStyle: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["headerCellStyle"]>;
     highlightCurrentRow: BooleanConstructor;
     currentRowKey: (NumberConstructor | StringConstructor)[];
-    emptyText: StringConstructor;
-    expandRowKeys: import('vue').PropType<string[] | undefined>;
+    expandRowKeys: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["expandRowKeys"]>;
     defaultExpandAll: BooleanConstructor;
-    defaultSort: import('vue').PropType<import('element-plus').Sort | undefined>;
+    defaultSort: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["defaultSort"]>;
     tooltipEffect: StringConstructor;
-    tooltipOptions: import('vue').PropType<Partial<Pick<import('element-plus').ElTooltipProps, "offset" | "transition" | "placement" | "effect" | "showAfter" | "hideAfter" | "popperOptions" | "enterable" | "popperClass" | "appendTo" | "showArrow">> | undefined>;
-    spanMethod: import('vue').PropType<((data: {
-        row: any;
-        rowIndex: number;
-        column: import('element-plus').TableColumnCtx<any>;
-        columnIndex: number;
-    }) => number[] | {
-        rowspan: number;
-        colspan: number;
-    } | undefined) | undefined>;
+    tooltipOptions: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["tooltipOptions"]>;
+    spanMethod: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["spanMethod"]>;
     selectOnIndeterminate: {
         type: BooleanConstructor;
         default: boolean;
@@ -109,21 +101,30 @@ export declare const virtualTableProps: {
         default: number;
     };
     treeProps: {
-        type: import('vue').PropType<import('element-plus/es/components/table/src/table/defaults').TreeProps | undefined>;
+        type: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["treeProps"]>;
         default: () => {
             hasChildren: string;
             children: string;
             checkStrictly: boolean;
         };
     };
-    load: import('vue').PropType<((row: any, treeNode: import('element-plus').TreeNode, resolve: (data: any[]) => void) => void) | undefined>;
+    load: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["load"]>;
     tableLayout: {
         type: import('vue').PropType<"fixed" | "auto">;
         default: string;
     };
     scrollbarAlwaysOn: BooleanConstructor;
     flexible: BooleanConstructor;
-    showOverflowTooltip: import('vue').PropType<boolean | Partial<Pick<import('element-plus').ElTooltipProps, "offset" | "transition" | "placement" | "effect" | "showAfter" | "hideAfter" | "popperOptions" | "enterable" | "popperClass" | "appendTo" | "showArrow">> | undefined>;
+    showOverflowTooltip: import('vue').PropType<import('element-plus').TableProps<import('element-plus/es/components/table/src/table/defaults').DefaultRow>["showOverflowTooltip"]>;
+    appendFilterPanelTo: StringConstructor;
+    scrollbarTabindex: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: undefined;
+    };
+    allowDragLastColumn: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
 };
 export type VirtualTableProps = ExtractPropTypes<typeof virtualTableProps>;
 /**
@@ -133,6 +134,8 @@ export declare const virtualTableEmits: {
     endEeached: (_params: any) => boolean;
     scroll: (_params: ScrollPos) => boolean;
     rowsRendered: (_params: any) => boolean;
+    'update:currentRowKey': (_currentRowKey?: import('../ele-data-table/types').DataKey) => boolean;
+    'update:selectedRowKeys': (_selectedRowKeys?: import('../ele-data-table/types').DataKey[]) => boolean;
     select: (_selection: import('../ele-data-table/types').DataItem[], _row: import('../ele-data-table/types').DataItem) => boolean;
     selectAll: (_selection: import('../ele-data-table/types').DataItem[]) => boolean;
     selectionChange: (_selection: import('../ele-data-table/types').DataItem[]) => boolean;
@@ -151,6 +154,4 @@ export declare const virtualTableEmits: {
     currentChange: (_current?: import('../ele-data-table/types').DataItem | null, _old?: import('../ele-data-table/types').DataItem | null) => boolean;
     headerDragend: (_width: number, _old: number, _column: import('../ele-data-table/types').Column, _e: MouseEvent) => boolean;
     expandChange: (_row: import('../ele-data-table/types').DataItem, _expanded: boolean) => boolean;
-    'update:currentRowKey': (_currentRowKey?: import('../ele-data-table/types').DataKey) => boolean;
-    'update:selectedRowKeys': (_selectedRowKeys?: import('../ele-data-table/types').DataKey[]) => boolean;
 };

package/es/ele-virtual-table/util.d.ts

@@ -221,7 +221,7 @@ export declare function cellIsOverflow(cell: HTMLElement): boolean;
  * @param getEl 获取根节点的方法
  */
 export declare function useAutoResize(getEl: () => HTMLElement | null): {
-    wrapWidth: import('vue').Ref<number>;
-    wrapHeight: import('vue').Ref<number>;
+    wrapWidth: import('vue').Ref<number, number>;
+    wrapHeight: import('vue').Ref<number, number>;
     updateWrapSize: () => void;
 };