ele-admin-plus 1.1.6-beta.2 → 1.1.6-beta.4

package/lib/ele-cropper/index.d.ts

@@ -27,11 +27,12 @@ declare const _default: import("vue").DefineComponent<{
     };
     toBlob: BooleanConstructor;
     options: import("vue").PropType<CropperOptions>;
-    croppedOptions: import("vue").PropType<import("./types").CroppedOptions>;
+    /** 是否开启布局响应 */
+    croppedOptions: import("vue").PropType<import("./types").CroppedOptions>; /** 图片节点 */
     tooltip: {
         type: BooleanConstructor;
         default: boolean;
-    };
+    }; /** 预览组件 */
     tooltipProps: import("vue").PropType<Partial<import("../ele-tooltip/props").TooltipProps>>;
     responsive: {
         type: BooleanConstructor;
@@ -85,11 +86,12 @@ declare const _default: import("vue").DefineComponent<{
     };
     toBlob: BooleanConstructor;
     options: import("vue").PropType<CropperOptions>;
-    croppedOptions: import("vue").PropType<import("./types").CroppedOptions>;
+    /** 是否开启布局响应 */
+    croppedOptions: import("vue").PropType<import("./types").CroppedOptions>; /** 图片节点 */
     tooltip: {
         type: BooleanConstructor;
         default: boolean;
-    };
+    }; /** 预览组件 */
     tooltipProps: import("vue").PropType<Partial<import("../ele-tooltip/props").TooltipProps>>;
     responsive: {
         type: BooleanConstructor;
@@ -100,12 +102,12 @@ declare const _default: import("vue").DefineComponent<{
     onDone?: ((_result?: string | Blob | null | undefined) => any) | undefined;
 }, {
     tooltip: boolean;
-    tools: string;
-    responsive: boolean;
-    previewWidth: number;
-    accept: string;
     preview: boolean;
+    responsive: boolean;
     imageType: string;
+    accept: string;
+    tools: string;
+    previewWidth: number;
     toBlob: boolean;
 }, {}>;
 export default _default;

package/lib/ele-cropper-modal/index.d.ts

@@ -1,7 +1,7 @@
 import type { CropperLocale } from '../ele-cropper/types';
 declare const _default: import("vue").DefineComponent<{
     modelValue: BooleanConstructor;
-    modalProps: import("vue").PropType<Partial<Omit<import("../ele-modal/props").ModalProps, "modelValue">>>;
+    modalProps: import("vue").PropType<Partial<Omit<import("../ele-app/types").EleModalProps, "modelValue">>>;
     height: StringConstructor;
     src: StringConstructor;
     imageType: {
@@ -43,10 +43,10 @@ declare const _default: import("vue").DefineComponent<{
     onDone: (result: Blob | string | null) => void;
 }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     done: (_result: string | Blob | null) => boolean;
-    'update:modelValue': (_value: boolean) => boolean;
+    'update:modelValue': (_value: boolean) => boolean; /** 更新绑定值 */
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     modelValue: BooleanConstructor;
-    modalProps: import("vue").PropType<Partial<Omit<import("../ele-modal/props").ModalProps, "modelValue">>>;
+    modalProps: import("vue").PropType<Partial<Omit<import("../ele-app/types").EleModalProps, "modelValue">>>;
     height: StringConstructor;
     src: StringConstructor;
     imageType: {
@@ -88,12 +88,12 @@ declare const _default: import("vue").DefineComponent<{
 }, {
     modelValue: boolean;
     tooltip: boolean;
-    tools: string;
-    responsive: boolean;
-    previewWidth: number;
-    accept: string;
     preview: boolean;
+    responsive: boolean;
     imageType: string;
+    accept: string;
+    tools: string;
+    previewWidth: number;
     toBlob: boolean;
 }, {}>;
 export default _default;

package/lib/ele-cropper-modal/props.d.ts

@@ -1,5 +1,5 @@
 import type { PropType, ExtractPropTypes } from 'vue';
-import type { ModalProps } from '../ele-modal/props';
+import type { EleModalProps } from '../ele-app/types';
 /**
  * 属性
  */
@@ -7,7 +7,7 @@ export declare const cropperModalProps: {
     /** 弹窗是否显示 */
     modelValue: BooleanConstructor;
     /** 弹窗参数 */
-    modalProps: PropType<Partial<Omit<ModalProps, "modelValue">>>;
+    modalProps: PropType<Partial<Omit<EleModalProps, "modelValue">>>;
     height: StringConstructor;
     src: StringConstructor;
     imageType: {
@@ -16,6 +16,9 @@ export declare const cropperModalProps: {
     };
     accept: {
         type: StringConstructor;
+        /**
+         * 事件
+         */
         default: string;
     };
     tools: {

package/lib/ele-data-table/index.d.ts

@@ -1,5 +1,5 @@
 import type { ElTableInstance } from '../ele-app/types';
-import type { DataItem, Column, Columns, Sorter, Filter } from './types';
+import type { DataKey, DataItem, Column, Columns, Sorter, Filter } from './types';
 declare const _default: import("vue").DefineComponent<{
     stripe: {
         type: BooleanConstructor;
@@ -33,8 +33,11 @@ declare const _default: import("vue").DefineComponent<{
         default: () => null;
     };
     rowClickChecked: import("vue").PropType<import("./types").RowClickChecked>;
+    reserveCurrent: BooleanConstructor;
+    selectedRowKeys: import("vue").PropType<DataKey[]>;
+    cacheData: import("vue").PropType<DataItem[]>;
     size: {
-        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly type: import("vue").PropType<import("element-plus/es/utils/index").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -119,17 +122,20 @@ declare const _default: import("vue").DefineComponent<{
     flexible: BooleanConstructor;
 }, {
     clearSort: () => void;
+    clearSelection: () => void;
+    toggleRowSelection: (row: DataItem, selected?: boolean) => void;
+    setCurrentRow: (row?: DataItem | null) => void;
+    setCurrentRowKey: (key?: DataKey | null) => void;
+    getCurrentRow: () => DataItem | undefined;
     setSelectedRows: (rows?: DataItem[]) => void;
-    setSelectedRowKeys: (keys?: string[] | number[]) => void;
+    setSelectedRowKeys: (keys?: DataKey[]) => void;
     toggleRowExpansionAll: (expanded?: boolean) => void;
+    updateSelectedAndChecked: () => void;
     tableRef: import("vue").Ref<ElTableInstance>;
-    clearSelection: () => void;
     getSelectionRows: () => DataItem[] | undefined;
-    toggleRowSelection: (row: DataItem, selected?: boolean | undefined) => void;
     toggleAllSelection: () => void;
     toggleRowExpansion: (row: DataItem, expanded?: boolean | undefined) => void;
-    setCurrentRow: (row?: DataItem | null | undefined) => void;
-    clearFilter: (columnKeys?: string[] | undefined) => void;
+    clearFilter: (columnKeys?: string[] | undefined) => void; /** 设置单选选中值 */
     doLayout: () => void;
     sort: (prop: string, order: string) => void;
     scrollTo: (options: number | ScrollToOptions, yCoord?: number | undefined) => void;
@@ -153,7 +159,9 @@ declare const _default: import("vue").DefineComponent<{
     filterChange: (_filter: Filter) => boolean;
     currentChange: (_current?: DataItem | null | undefined, _old?: DataItem | null | undefined) => boolean;
     headerDragend: (_width: number, _old: number, _column: Column, _e: MouseEvent) => boolean;
-    expandChange: (_row: DataItem, _expanded: boolean) => boolean; /** 切换所有行的展开状态 */
+    expandChange: (_row: DataItem, _expanded: boolean) => boolean;
+    'update:currentRowKey': (_currentRowKey?: DataKey | undefined) => boolean;
+    'update:selectedRowKeys': (_selectedRowKeys?: DataKey[] | undefined) => boolean;
 }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     stripe: {
         type: BooleanConstructor;
@@ -187,8 +195,11 @@ declare const _default: import("vue").DefineComponent<{
         default: () => null;
     };
     rowClickChecked: import("vue").PropType<import("./types").RowClickChecked>;
+    reserveCurrent: BooleanConstructor;
+    selectedRowKeys: import("vue").PropType<DataKey[]>;
+    cacheData: import("vue").PropType<DataItem[]>;
     size: {
-        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly type: import("vue").PropType<import("element-plus/es/utils/index").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -290,6 +301,8 @@ declare const _default: import("vue").DefineComponent<{
     onCurrentChange?: ((_current?: DataItem | null | undefined, _old?: DataItem | null | undefined) => any) | undefined;
     onHeaderDragend?: ((_width: number, _old: number, _column: Column, _e: MouseEvent) => any) | undefined;
     onExpandChange?: ((_row: DataItem, _expanded: boolean) => any) | undefined;
+    "onUpdate:currentRowKey"?: ((_currentRowKey?: DataKey | undefined) => any) | undefined;
+    "onUpdate:selectedRowKeys"?: ((_selectedRowKeys?: DataKey[] | undefined) => any) | undefined;
 }, {
     fit: boolean;
     className: string;
@@ -315,5 +328,6 @@ declare const _default: import("vue").DefineComponent<{
     sticky: boolean;
     bottomLine: boolean;
     emptyProps: import("./types").TableEmptyProps;
+    reserveCurrent: boolean;
 }, {}>;
 export default _default;

package/lib/ele-data-table/index.js

@@ -11,14 +11,13 @@ const index = vue.defineComponent({
   setup(props$1, { emit, slots, expose }) {
     const events = util.useEmits(emit);
     const methods = util.useMethods(() => tableRef.value);
-    const {
-      getSorter,
-      setSorter,
-      getFilter,
-      setFilter,
-      getSelectionNoChange,
-      setSelectionNoChange
-    } = util.useState(props$1.defaultSort);
+    const tableState = {
+      sorter: props$1.defaultSort,
+      key: null,
+      checkedKeys: [],
+      checked: [],
+      reserveChecked: util.isReserveChecked(props$1.columns)
+    };
     const tableRef = vue.ref(null);
     const tableCols = vue.ref(props$1.columns ?? []);
     const tableOverflowTooltip = vue.computed(() => {
@@ -28,73 +27,252 @@ const index = vue.defineComponent({
         props$1.tooltipOptions
       );
     });
-    vue.watch(
-      () => props$1.columns,
-      (columns) => {
-        if (!columns) {
-          tableCols.value = [];
-          return;
-        }
-        const { cols, sorter } = util.getStateCols(
-          columns,
-          getSorter(),
-          getFilter()
-        );
-        tableCols.value = cols;
-        vue.nextTick(() => {
-          methods.doLayout();
-          if (sorter) {
-            methods.sort(sorter.prop, sorter.order || "ascending");
-          }
-        });
-      },
-      { deep: true }
-    );
+    const childKey = vue.computed(() => {
+      var _a;
+      return ((_a = props$1.treeProps) == null ? void 0 : _a.children) || "children";
+    });
     const clearSort = () => {
       methods.clearSort();
-      setSorter({});
+      tableState.sorter = {};
+    };
+    const clearSelection = () => {
+      updateCheckedState([]);
+    };
+    const toggleRowSelection = (row, selected) => {
+      methods.toggleRowSelection(row, selected);
+      const selection = methods.getSelectionRows() || [];
+      updateCheckedState(util.getRowKeys(selection, props$1.rowKey), selection);
+    };
+    const setCurrentRow = (row) => {
+      updateSelectedState(util.getValue(row, props$1.rowKey), row);
+    };
+    const setCurrentRowKey = (key) => {
+      updateSelectedState(key);
+    };
+    const getCurrentRow = () => {
+      return tableState.row;
     };
     const setSelectedRows = (rows) => {
-      if (rows == null) {
-        return;
+      if (rows) {
+        updateCheckedState(util.getRowKeys(rows, props$1.rowKey), rows, !!rows.length);
       }
-      setSelectionNoChange(true);
-      methods.clearSelection();
-      rows.forEach((d) => {
-        methods.toggleRowSelection(d, true);
-      });
-      setSelectionNoChange(false);
-      events.onSelectionChange(rows);
     };
     const setSelectedRowKeys = (keys) => {
-      if (!keys || !props$1.rowKey) {
-        return;
+      if (keys) {
+        updateCheckedState(keys);
       }
-      const rows = props$1.data.filter(
-        (d) => keys.some((v) => v === util.getValue(d, props$1.rowKey))
-      );
-      setSelectedRows(rows);
     };
     const toggleRowExpansionAll = (expanded) => {
-      var _a;
-      const childKey = ((_a = props$1.treeProps) == null ? void 0 : _a.children) || "children";
       core.eachTree(
         props$1.data,
-        (d) => {
-          var _a2;
-          if ((_a2 = d[childKey]) == null ? void 0 : _a2.length) {
-            methods.toggleRowExpansion(d, expanded);
+        (row) => {
+          var _a;
+          if ((_a = row[childKey.value]) == null ? void 0 : _a.length) {
+            methods.toggleRowExpansion(row, expanded);
           }
         },
-        childKey
+        childKey.value
       );
     };
+    const updateSelectedState = (key, item) => {
+      if (!util.valueIsChanged(tableState.key, key)) {
+        if (key != null && item != null) {
+          if (tableState.row !== item) {
+            tableState.row = item;
+            events.onCurrentChange(item, tableState.oldRow);
+          }
+          methods.setCurrentRow(item);
+        }
+        return;
+      }
+      if (key != null) {
+        const row = util.getRowByKey(key, props$1.data, props$1.rowKey, childKey.value);
+        if (row != null || props$1.reserveCurrent) {
+          tableState.oldRow = tableState.row;
+          tableState.row = row || item || void 0;
+          if (tableState.row == null && props$1.cacheData != null) {
+            tableState.row = util.getRowByKey(
+              key,
+              props$1.cacheData,
+              props$1.rowKey,
+              childKey.value
+            );
+          }
+          tableState.key = key;
+          methods.setCurrentRow(row);
+          updateCurrentRowKey(key);
+          events.onCurrentChange(tableState.row, tableState.oldRow);
+          return;
+        }
+      }
+      if (tableState.key != null) {
+        tableState.oldRow = tableState.row;
+        tableState.row = void 0;
+        tableState.key = null;
+        methods.setCurrentRow(null);
+        updateCurrentRowKey();
+        events.onCurrentChange(void 0, tableState.oldRow);
+      }
+    };
+    const updateCheckedState = (keys, items, force) => {
+      if (!force && !util.arrayIsChanged(tableState.checkedKeys, keys)) {
+        return;
+      }
+      const [dataKeys, list] = util.getKeysAndList(
+        props$1.data,
+        props$1.rowKey,
+        childKey.value
+      );
+      const [cacheKeys, cacheList] = util.getKeysAndList(
+        props$1.cacheData,
+        props$1.rowKey,
+        childKey.value
+      );
+      const itemKeys = items ? items.map((d) => util.getValue(d, props$1.rowKey)) : [];
+      const oldKeys = tableState.checked.map((d) => util.getValue(d, props$1.rowKey));
+      const checkedKeys = [];
+      const checked = [];
+      keys.forEach((key) => {
+        const index2 = dataKeys.indexOf(key);
+        if (index2 !== -1) {
+          checkedKeys.push(key);
+          checked.push(list[index2]);
+        } else if (tableState.reserveChecked) {
+          checkedKeys.push(key);
+          if (items != null) {
+            const tIndex = itemKeys.indexOf(key);
+            if (tIndex !== -1 && !items[tIndex]._isMock) {
+              checked.push(items[tIndex]);
+              return;
+            }
+          }
+          if (props$1.cacheData != null) {
+            const i = cacheKeys.indexOf(key);
+            if (i !== -1) {
+              checked.push(cacheList[i]);
+              return;
+            }
+          }
+          const oIndex = oldKeys.indexOf(key);
+          if (oIndex !== -1) {
+            checked.push(tableState.checked[oIndex]);
+            return;
+          }
+          if (typeof props$1.rowKey === "string") {
+            checked.push({ [props$1.rowKey]: key, _isMock: true });
+          }
+        }
+      });
+      const isChanged = util.arrayIsChanged(tableState.checked, checked);
+      tableState.checked = checked;
+      tableState.checkedKeys = checkedKeys;
+      if (isChanged) {
+        methods.clearSelection();
+        checked.forEach((row) => {
+          methods.toggleRowSelection(row, true);
+        });
+      }
+      updateSelectedRowKeys(checkedKeys);
+      if (isChanged) {
+        events.onSelectionChange(checked);
+      }
+    };
+    const updateSelectedAndChecked = () => {
+      const key = tableState.key;
+      if (key != null) {
+        const row = util.getRowByKey(key, props$1.data, props$1.rowKey, childKey.value);
+        if (row != null) {
+          updateSelectedState(key, row);
+        } else if (!props$1.reserveCurrent) {
+          updateSelectedState(null);
+        } else if (props$1.cacheData != null) {
+          const temp = util.getRowByKey(
+            key,
+            props$1.cacheData,
+            props$1.rowKey,
+            childKey.value
+          );
+          if (temp != null) {
+            updateSelectedState(key, temp);
+          }
+        }
+      }
+      if (tableState.checkedKeys.length) {
+        updateCheckedState(tableState.checkedKeys, void 0, true);
+      }
+    };
+    const updateCurrentRowKey = (key) => {
+      if (util.valueIsChanged(props$1.currentRowKey, key)) {
+        events["onUpdate:currentRowKey"](key);
+      }
+    };
+    const updateSelectedRowKeys = (keys) => {
+      const selected = props$1.selectedRowKeys || [];
+      if (util.arrayIsChanged(selected, keys)) {
+        events["onUpdate:selectedRowKeys"](keys);
+      }
+    };
+    vue.watch(
+      () => props$1.columns,
+      (columns) => {
+        tableState.reserveChecked = util.isReserveChecked(columns);
+        if (!columns) {
+          tableCols.value = [];
+        } else {
+          const { cols, sorter } = util.getStateCols(
+            columns,
+            tableState.sorter,
+            tableState.filter
+          );
+          tableCols.value = cols;
+          vue.nextTick(() => {
+            methods.doLayout();
+            if (sorter) {
+              methods.sort(sorter.prop, sorter.order || "ascending");
+            }
+          });
+        }
+      },
+      { deep: true }
+    );
+    vue.watch([() => props$1.data, () => props$1.cacheData], () => {
+      vue.nextTick(() => {
+        updateSelectedAndChecked();
+      });
+    });
+    vue.watch(
+      () => props$1.currentRowKey,
+      (key) => {
+        updateSelectedState(key);
+      }
+    );
+    vue.watch(
+      () => props$1.selectedRowKeys,
+      (selectedRowKeys) => {
+        updateCheckedState(selectedRowKeys || []);
+      },
+      { deep: true }
+    );
+    vue.onMounted(() => {
+      if (props$1.currentRowKey != null) {
+        updateSelectedState(props$1.currentRowKey);
+      }
+      if (props$1.selectedRowKeys != null && props$1.selectedRowKeys.length) {
+        updateCheckedState(props$1.selectedRowKeys);
+      }
+    });
     const exposeValue = {
       ...methods,
       clearSort,
+      clearSelection,
+      toggleRowSelection,
+      setCurrentRow,
+      setCurrentRowKey,
+      getCurrentRow,
       setSelectedRows,
       setSelectedRowKeys,
       toggleRowExpansionAll,
+      updateSelectedAndChecked,
       tableRef
     };
     expose(exposeValue);
@@ -103,13 +281,17 @@ const index = vue.defineComponent({
         elementPlus.ElTable,
         {
           ...core.pick(props$1, props.tablePropKeys),
-          ...events,
+          ...core.omit(events, [
+            "onUpdate:currentRowKey",
+            "onUpdate:selectedRowKeys"
+          ]),
           ref: tableRef,
           class: [
             "ele-data-table",
             { "is-sticky": props$1.sticky },
             { "hide-bottom-line": !props$1.bottomLine }
           ],
+          currentRowKey: void 0,
           emptyText: props$1.errorText || props$1.emptyText,
           rowClassName: (param) => {
             return util.getBodyRowClass(props$1.rowClassName, param);
@@ -124,10 +306,11 @@ const index = vue.defineComponent({
           onRowClick: (row, column, event) => {
             if (props$1.rowClickChecked && !util.isDisableRow(row, props$1.data.indexOf(row), props$1.columns)) {
               const selections = methods.getSelectionRows();
-              if (props$1.rowClickChecked === "smart" && selections != null && selections.length === 1) {
-                setSelectedRows([row]);
+              if (props$1.rowClickChecked === "smart" && (!selections || !selections.length || selections.length === 1)) {
+                const key = util.getValue(row, props$1.rowKey);
+                updateCheckedState(key == null ? [] : [key]);
               } else {
-                methods.toggleRowSelection(row);
+                toggleRowSelection(row);
               }
             }
             events.onRowClick(row, column, event);
@@ -137,29 +320,38 @@ const index = vue.defineComponent({
               const el = e.currentTarget;
               if (el) {
                 const caretEl = el.querySelector(".caret-wrapper");
-                if (caretEl) {
-                  caretEl.dispatchEvent(new MouseEvent("click"));
-                }
+                caretEl && caretEl.dispatchEvent(new MouseEvent("click"));
               }
             }
             events.onHeaderClick(column, e);
           },
-          onSelectionChange: (selection) => {
-            if (!getSelectionNoChange()) {
-              events.onSelectionChange(selection);
-            }
-          },
           onSortChange: (sorter) => {
-            const currentSorter = getSorter();
+            const currentSorter = tableState.sorter;
             if (currentSorter && sorter.prop === currentSorter.prop && sorter.order === currentSorter.order) {
               return;
             }
-            setSorter(sorter);
-            events.onSortChange(getSorter());
+            tableState.sorter = sorter;
+            events.onSortChange(sorter);
           },
           onFilterChange: (filter) => {
-            setFilter(util.getTableFilter(tableRef.value) ?? filter);
-            events.onFilterChange(getFilter());
+            tableState.filter = util.getTableFilter(tableRef.value) ?? filter;
+            events.onFilterChange(tableState.filter);
+          },
+          // 重写选中逻辑
+          onCurrentChange: (row, old) => {
+            if (row != null && row !== old) {
+              updateSelectedState(util.getValue(row, props$1.rowKey), row);
+            }
+          },
+          onSelect: (selection, row) => {
+            events.onSelect(selection, row);
+            updateCheckedState(util.getRowKeys(selection, props$1.rowKey), selection);
+          },
+          onSelectAll: (selection) => {
+            updateCheckedState(util.getRowKeys(selection, props$1.rowKey), selection);
+            events.onSelectAll(selection);
+          },
+          onSelectionChange: () => {
           },
           // 移除提示组件相关属性
           showOverflowTooltip: void 0,

package/lib/ele-data-table/props.d.ts

@@ -1,12 +1,12 @@
 import type { PropType, ExtractPropTypes } from 'vue';
-import type { DataItem, Column, Columns, Sorter, Filter, TableEmptyProps, RowClickChecked } from './types';
+import type { DataKey, DataItem, Column, Columns, Sorter, Filter, TableEmptyProps, RowClickChecked } from './types';
 declare const normalizeProps: Omit<{
     data: {
         type: PropType<any[]>;
         default: () => never[];
     };
     size: {
-        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly type: PropType<import("element-plus/es/utils/index").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -137,8 +137,14 @@ export declare const dataTableProps: {
     };
     /** 多选时行点击选中 */
     rowClickChecked: PropType<RowClickChecked>;
+    /** 单选选中是否保留不存在的数据 */
+    reserveCurrent: BooleanConstructor;
+    /** 多选选中行的值 */
+    selectedRowKeys: PropType<DataKey[]>;
+    /** 缓存数据 */
+    cacheData: PropType<DataItem[]>;
     size: {
-        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly type: PropType<import("element-plus/es/utils/index").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
         readonly required: false;
         readonly validator: ((val: unknown) => boolean) | undefined;
         __epPropKey: true;
@@ -245,6 +251,10 @@ export declare const dataTableEmits: {
     currentChange: (_current?: DataItem | null, _old?: DataItem | null) => boolean;
     headerDragend: (_width: number, _old: number, _column: Column, _e: MouseEvent) => boolean;
     expandChange: (_row: DataItem, _expanded: boolean) => boolean;
+    /** 更新单选选中行的值 */
+    'update:currentRowKey': (_currentRowKey?: DataKey) => boolean;
+    /** 更新多选选中行的值 */
+    'update:selectedRowKeys': (_selectedRowKeys?: DataKey[]) => boolean;
 };
 /**
  * 表格组件属性名

package/lib/ele-data-table/props.js

@@ -47,7 +47,13 @@ const dataTableProps = {
     }
   },
   /** 多选时行点击选中 */
-  rowClickChecked: [Boolean, String]
+  rowClickChecked: [Boolean, String],
+  /** 单选选中是否保留不存在的数据 */
+  reserveCurrent: Boolean,
+  /** 多选选中行的值 */
+  selectedRowKeys: Array,
+  /** 缓存数据 */
+  cacheData: Array
 };
 const dataTableEmits = {
   select: (_selection, _row) => true,
@@ -67,7 +73,11 @@ const dataTableEmits = {
   filterChange: (_filter) => true,
   currentChange: (_current, _old) => true,
   headerDragend: (_width, _old, _column, _e) => true,
-  expandChange: (_row, _expanded) => true
+  expandChange: (_row, _expanded) => true,
+  /** 更新单选选中行的值 */
+  "update:currentRowKey": (_currentRowKey) => true,
+  /** 更新多选选中行的值 */
+  "update:selectedRowKeys": (_selectedRowKeys) => true
 };
 const tablePropKeys = Object.keys(normalizeProps);
 const dataTablePropKeys = Object.keys(