ele-admin-plus 1.4.1-beta.1 → 1.5.0-beta.1

package/lib/ele-table-select/index.cjs

@@ -1,10 +1,10 @@
 "use strict";
 const vue = require("vue");
+const common = require("../utils/common");
 const util$1 = require("../ele-pro-layout/util");
 const EleBasicSelect = require("../ele-basic-select/index");
 const util = require("../ele-basic-select/util");
-const EleProTable = require("../ele-pro-table/index");
-const util$2 = require("../ele-data-table/util");
+const EleButtons = require("../ele-buttons/index");
 const props = require("./props");
 const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   ...{ name: "EleTableSelect" },
@@ -12,198 +12,183 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
   props: props.tableSelectProps,
   emits: props.tableSelectEmits,
   setup(__props, { expose: __expose, emit: __emit }) {
+    const ownSlots = ["popperTopExtra", "popperBottomExtra"];
     const props2 = __props;
     const emit = __emit;
     const { validateChange } = util.useFormValidate();
     const isResponsive = util$1.useResponsive(props2);
     const selectRef = vue.ref(null);
-    const tableRef = vue.ref(null);
+    const proTableRef = vue.ref(null);
     const selectVisible = vue.ref(false);
     const selectedItems = vue.ref([]);
+    const tempSelectedItems = vue.ref([]);
+    const tempSelectValue = vue.ref();
+    const isModalType = vue.computed(() => {
+      return props2.popperType === "modal" || props2.popperType === "drawer";
+    });
+    const selectPopperClass = vue.computed(() => {
+      const classes = ["ele-table-select-popper"];
+      if (isResponsive.value && !isModalType.value) {
+        classes.push("is-responsive");
+      }
+      if (props2.popperClass) {
+        classes.push(props2.popperClass);
+      }
+      return classes.join(" ");
+    });
     const selectedLabel = vue.computed(() => {
       const selected = selectedItems.value;
       return !props2.multiple && selected.length ? selected[0].label : "";
     });
-    const currentRowKey = vue.computed(() => {
+    const tableCurrentRowKey = vue.computed(() => {
+      if (isModalType.value) {
+        if (props2.multiple || util.isEmptyValue(tempSelectValue.value)) {
+          return;
+        }
+        return tempSelectValue.value;
+      }
       if (props2.multiple || util.isEmptyValue(props2.modelValue)) {
         return;
       }
       return props2.modelValue;
     });
-    const selectedRowKeys = vue.computed(() => {
+    const tableSelectedRowKeys = vue.computed(() => {
+      if (isModalType.value) {
+        if (!props2.multiple || util.isEmptyValue(tempSelectValue.value)) {
+          return;
+        }
+        return tempSelectValue.value;
+      }
       if (!props2.multiple || util.isEmptyValue(props2.modelValue)) {
         return;
       }
       return props2.modelValue;
     });
-    const selectPopperClass = vue.computed(() => {
-      const classes = ["ele-table-select-popper"];
-      if (isResponsive.value) {
-        classes.push("is-responsive");
-      }
-      if (props2.popperClass) {
-        classes.push(props2.popperClass);
-      }
-      return classes.join(" ");
-    });
     const updatePopover = () => {
       selectRef.value && selectRef.value.updatePopper();
     };
-    const getItemByValue = (value) => {
-      if (util.isEmptyValue(value)) {
-        return;
-      }
-      if (props2.cacheData != null) {
-        const temp = props2.cacheData.find((d) => d[props2.valueKey] === value);
-        if (temp != null) {
-          return temp;
-        }
-      }
-      if (!util.isEmptyValue(props2.initValue)) {
-        if (!props2.multiple) {
-          return props2.initValue;
-        }
-        return props2.initValue.find(
-          (d) => d[props2.valueKey] === value
-        );
-      }
+    const focusSearchInput = () => {
+      selectRef.value && selectRef.value.focusSearchInput();
     };
-    const getCacheItemByValue = (value, cacheKeys, cacheData, tKeys, initValue) => {
-      if (cacheData != null) {
-        const index = cacheKeys.indexOf(value);
-        if (index !== -1) {
-          return cacheData[index];
-        }
-      }
-      if (initValue != null) {
-        const i = tKeys.indexOf(value);
-        if (i !== -1) {
-          return initValue[i];
+    const updateModelValue = (modelValue) => {
+      if (util.valueIsChanged(modelValue, props2.modelValue, props2.multiple)) {
+        emit("update:modelValue", modelValue);
+        if (props2.validateEvent) {
+          validateChange();
         }
+        emit("change", modelValue);
       }
     };
-    const getMultipleItems = () => {
-      const modelValue = props2.modelValue;
-      if (util.isEmptyValue(modelValue, true)) {
-        return [];
-      }
-      const selected = [];
-      const keys = [];
-      if (tableRef.value) {
-        const data = tableRef.value.getSelectionRows() || [];
-        data.forEach((item) => {
-          if (!item._isMock) {
-            const value = item[props2.valueKey];
-            const index = modelValue.indexOf(value);
-            if (index !== -1) {
-              selected.push({ value, label: item[props2.labelKey], index });
-              keys.push(value);
+    const updateVisible = (visible) => {
+      if (selectVisible.value !== visible) {
+        selectVisible.value = visible;
+        if (visible) {
+          if (isModalType.value) {
+            if (util.isEmptyValue(props2.modelValue)) {
+              tempSelectedItems.value = [];
+              tempSelectValue.value = void 0;
+            } else {
+              tempSelectedItems.value = [...selectedItems.value];
+              tempSelectValue.value = props2.multiple ? [...props2.modelValue] : props2.modelValue;
             }
           }
-        });
-      }
-      if (keys.length !== modelValue.length) {
-        const { valueKey, cacheData, initValue } = props2;
-        const cacheKeys = cacheData ? cacheData.map((d) => d[valueKey]) : [];
-        const tKeys = initValue ? initValue.map((d) => d[valueKey]) : [];
-        modelValue.forEach((value) => {
-          if (!keys.includes(value)) {
-            const item = getCacheItemByValue(
-              value,
-              cacheKeys,
-              cacheData,
-              tKeys,
-              initValue
-            );
-            const label = item ? item[props2.labelKey] : String(value);
-            const index = modelValue.indexOf(value);
-            selected.push({ value, label, index });
+          if (props2.tableProps?.virtual && proTableRef.value) {
+            const virtualTableRef = proTableRef.value.getTableRef();
+            if (virtualTableRef && !virtualTableRef.wrapWidth) {
+              vue.nextTick(() => {
+                virtualTableRef.updateWrapSize();
+                vue.nextTick(() => {
+                  updatePopover();
+                });
+              });
+            }
           }
-        });
+        }
+        if (props2.visible !== visible) {
+          emit("update:visible", visible);
+        }
+        emit("visibleChange", visible);
       }
-      selected.sort((a, b) => a.index - b.index);
-      return selected;
     };
-    const updateSelectedItems = (force) => {
+    const getChangedSelectedItems = (selectValue, selectedItems2, force) => {
+      const tableData = [
+        ...props2.cacheData || [],
+        ...(props2.multiple ? props2.initValue : props2.initValue ? [props2.initValue] : void 0) || [],
+        // 已废弃属性兼容
+        ...(props2.multiple && proTableRef.value ? proTableRef.value.getSelectionRows() : void 0) || []
+      ];
+      if (!props2.multiple) {
+        const temp = proTableRef.value ? proTableRef.value.getCurrentRow() : null;
+        if (temp) {
+          tableData.push(temp);
+        }
+      }
       if (!props2.multiple) {
-        const value = props2.modelValue;
-        const d = selectedItems.value.length ? selectedItems.value[0] : null;
+        const value = selectValue;
+        const d = selectedItems2.length ? selectedItems2[0] : null;
         if (util.isEmptyValue(value)) {
           if (d != null) {
-            selectedItems.value = [];
+            return [];
           }
           return;
         }
         if (force || !d || d.value !== value) {
-          const temp = tableRef.value ? tableRef.value.getCurrentRow() : null;
-          const t = temp && temp[props2.valueKey] === value ? temp : void 0;
-          const item = t || getItemByValue(value);
-          const label = item ? item[props2.labelKey] : String(value);
-          selectedItems.value = [{ label, value }];
+          const item = tableData ? tableData.find((d2) => common.getValue(d2, props2.valueKey) === value) : void 0;
+          let label = common.getValue(item, props2.labelKey);
+          if (label == null && (!item || item._isMock)) {
+            label = String(value);
+          }
+          return [{ value, label, data: item }];
         }
         return;
       }
-      if (util.isEmptyValue(props2.modelValue, true)) {
-        if (selectedItems.value.length) {
-          selectedItems.value = [];
-          vue.nextTick(() => {
-            updatePopover();
-          });
+      if (util.isEmptyValue(selectValue, true)) {
+        if (selectedItems2.length) {
+          return [];
         }
         return;
       }
-      const keys = selectedItems.value.map((d) => d.value);
-      if (force || util.valueIsChanged(props2.modelValue, keys, true)) {
-        selectedItems.value = getMultipleItems();
-        vue.nextTick(() => {
-          updatePopover();
-        });
-      }
-    };
-    const focusSearchInput = () => {
-      selectRef.value && selectRef.value.focusSearchInput();
-    };
-    const handleInitValueChange = (initValue) => {
-      const valueKey = props2.valueKey;
-      if (!props2.multiple) {
-        const key = initValue[valueKey];
-        if (key === props2.modelValue) {
-          updateSelectedItems();
-        } else {
-          updateModelValue(key);
-        }
+      if (!force && !util.valueIsChanged(
+        selectValue,
+        selectedItems2.map((d) => d.value),
+        true
+      )) {
         return;
       }
-      const keys = initValue.map((d) => d[valueKey]);
-      if (!util.valueIsChanged(props2.modelValue, keys, true)) {
-        updateSelectedItems();
-      } else {
-        updateModelValue(keys);
-      }
+      const selected = [];
+      const dataKeys = tableData ? tableData.map((d) => common.getValue(d, props2.valueKey)) : [];
+      selectValue.forEach((value, index) => {
+        const dataIndex = dataKeys.indexOf(value);
+        const item = dataIndex === -1 ? void 0 : tableData[dataIndex];
+        let label = common.getValue(item, props2.labelKey);
+        if (label == null && (!item || item._isMock)) {
+          label = String(value);
+        }
+        selected.push({ value, label, index, data: item });
+      });
+      return selected;
     };
-    const updateModelValue = (modelValue) => {
-      if (util.valueIsChanged(modelValue, props2.modelValue, props2.multiple)) {
-        emit("update:modelValue", modelValue);
-        validateChange();
-        emit("change", modelValue);
+    const checkUpdateSelectedItems = (force) => {
+      const items = getChangedSelectedItems(
+        props2.modelValue,
+        selectedItems.value,
+        force
+      );
+      if (items) {
+        selectedItems.value = items;
+        vue.nextTick(() => {
+          updatePopover();
+        });
       }
     };
-    const updateVisible = (visible) => {
-      var _a;
-      if (selectVisible.value !== visible) {
-        selectVisible.value = visible;
-        if (visible && ((_a = props2.tableProps) == null ? void 0 : _a.virtual) && tableRef.value) {
-          const virtualTableRef = tableRef.value.getTableRef();
-          if (virtualTableRef != null && !virtualTableRef.wrapWidth) {
-            vue.nextTick(() => {
-              virtualTableRef.updateWrapSize();
-              vue.nextTick(() => {
-                updatePopover();
-              });
-            });
-          }
-        }
-        emit("visibleChange", visible);
+    const checkUpdateTempSelectedItems = (force) => {
+      const items = getChangedSelectedItems(
+        tempSelectValue.value,
+        tempSelectedItems.value,
+        force
+      );
+      if (items) {
+        tempSelectedItems.value = items;
       }
     };
     const handleSelectRemove = (item) => {
@@ -225,62 +210,149 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
     const handleSelectFilter = (keywords) => {
       emit("filterChange", keywords);
     };
-    const updateSelectedRowKeys = (rowKeys) => {
-      if (props2.multiple) {
-        updateModelValue(rowKeys);
+    const handleUpdateModelValue = (modelValue) => {
+      if (isModalType.value) {
+        tempSelectValue.value = modelValue;
+      } else {
+        updateModelValue(modelValue);
       }
     };
-    const updateCurrentRowKey = (rowKey) => {
-      if (!props2.multiple) {
-        updateModelValue(rowKey);
+    const handleCheckUpdateSelectedItems = (force) => {
+      if (isModalType.value) {
+        checkUpdateTempSelectedItems(force);
+      } else {
+        checkUpdateSelectedItems(force);
       }
     };
-    const handleTableCurrentChange = (row) => {
-      if (!props2.multiple && row != null) {
-        updateSelectedItems(true);
+    const handleDataSelect = (data) => {
+      if (!isModalType.value) {
+        if (!props2.multiple) {
+          updateVisible(false);
+        }
+        emit("select", data);
+      }
+    };
+    const handleUpdateTableSelectedRowKeys = (rowKeys) => {
+      if (props2.multiple) {
+        const oldValues = props2.modelValue || [];
+        const values = [...rowKeys];
+        values.sort((a, b) => {
+          const aOldIndex = oldValues.indexOf(a);
+          const bOldIndex = oldValues.indexOf(b);
+          const aIndex = aOldIndex === -1 ? values.length : aOldIndex;
+          const bIndex = bOldIndex === -1 ? values.length : bOldIndex;
+          return aIndex - bIndex;
+        });
+        handleUpdateModelValue(values);
+      }
+    };
+    const handleUpdateTableCurrentRowKey = (rowKey) => {
+      if (!props2.multiple) {
+        handleUpdateModelValue(rowKey);
       }
     };
     const handleTableSelectionChange = () => {
       if (props2.multiple) {
-        updateSelectedItems(true);
+        handleCheckUpdateSelectedItems(true);
+      }
+    };
+    const handleTableCurrentChange = (row) => {
+      if (!props2.multiple && row != null) {
+        handleCheckUpdateSelectedItems(true);
       }
     };
-    const handleTableRowClick = (row) => {
-      var _a;
+    const handleTableRowClick = (row, _column, _e, disabled, selection) => {
       if (!props2.multiple) {
-        updateVisible(false);
-        emit("select", row);
-      } else if (((_a = props2.tableProps) == null ? void 0 : _a.rowClickChecked) && tableRef.value && !util$2.isDisableRow(
-        row,
-        tableRef.value.getData().indexOf(row),
-        tableRef.value.tableProps.columns
-      )) {
-        emit("select", tableRef.value.getSelectionRows() || []);
+        handleDataSelect(row);
+      } else if (props2.tableProps?.rowClickChecked && !disabled) {
+        handleDataSelect(selection || []);
       }
     };
     const handleTableSelect = (selection) => {
-      emit("select", selection);
+      handleDataSelect(selection);
     };
     const handleTableSelectAll = (selection) => {
-      emit("select", selection);
+      handleDataSelect(selection);
     };
     const handleTableDone = () => {
       vue.nextTick(() => {
         updatePopover();
       });
     };
+    const handleConfirm = () => {
+      const selected = tempSelectedItems.value.map((item) => item.data);
+      const selectedData = props2.multiple ? selected : selected[0];
+      if (props2.beforeConfirm && props2.beforeConfirm(selectedData) === false) {
+        return;
+      }
+      const values = tempSelectedItems.value.map((item) => item.value);
+      if (!props2.multiple) {
+        updateModelValue(values[0]);
+        emit("select", selectedData);
+        updateVisible(false);
+        return;
+      }
+      updateModelValue(values);
+      emit("select", selectedData);
+      updateVisible(false);
+    };
+    const handleInitValueChange = (initValue) => {
+      if (!props2.multiple) {
+        const value = common.getValue(initValue, props2.valueKey);
+        if (value === props2.modelValue) {
+          checkUpdateSelectedItems();
+        } else {
+          updateModelValue(value);
+        }
+        return;
+      }
+      const values = initValue.map(
+        (d) => common.getValue(d, props2.valueKey)
+      );
+      if (!util.valueIsChanged(props2.modelValue, values, true)) {
+        checkUpdateSelectedItems();
+      } else {
+        updateModelValue(values);
+      }
+    };
+    vue.watch(
+      () => props2.disabled,
+      (disabled) => {
+        if (disabled) {
+          updateVisible(false);
+        }
+      }
+    );
+    vue.watch(
+      () => props2.visible,
+      (visible) => {
+        updateVisible(visible);
+      }
+    );
+    vue.watch(
+      () => props2.cacheData,
+      () => {
+        checkUpdateSelectedItems(true);
+        if (isModalType.value && selectVisible.value) {
+          checkUpdateTempSelectedItems(true);
+        }
+      }
+    );
     vue.watch(
       () => props2.modelValue,
       () => {
-        updateSelectedItems();
+        checkUpdateSelectedItems();
       },
       { deep: true }
     );
     vue.watch(
-      () => props2.cacheData,
+      tempSelectValue,
       () => {
-        updateSelectedItems(true);
-      }
+        if (isModalType.value && selectVisible.value) {
+          checkUpdateTempSelectedItems();
+        }
+      },
+      { deep: true }
     );
     vue.watch(
       () => props2.initValue,
@@ -291,39 +363,64 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
       },
       { deep: true }
     );
-    vue.watch(
-      () => props2.disabled,
-      (disabled) => {
-        if (disabled) {
-          updateVisible(false);
-        }
-      }
-    );
     vue.onMounted(() => {
       if (!util.isEmptyValue(props2.initValue, props2.multiple)) {
         handleInitValueChange(props2.initValue);
       } else if (!util.isEmptyValue(props2.modelValue, props2.multiple)) {
-        updateSelectedItems();
+        checkUpdateSelectedItems();
       }
     });
+    const provideMethods = {
+      clearSelectedItems: handleSelectClear,
+      removeSelectedItem: (item) => {
+        if (props2.multiple) {
+          handleSelectRemove(item);
+        } else if (props2.modelValue === item.value) {
+          handleSelectClear();
+        }
+      },
+      updateSelectedItems: (items) => {
+        const values = items.map((item) => item.value);
+        updateModelValue(props2.multiple ? values : values[0]);
+      },
+      clearTempSelectedItems: () => {
+        tempSelectedItems.value = [];
+        tempSelectValue.value = null;
+      },
+      removeTempSelectedItem: (item) => {
+        const index = tempSelectedItems.value.indexOf(item);
+        tempSelectedItems.value.splice(index, 1);
+        const values = tempSelectedItems.value.map((item2) => item2.value);
+        tempSelectValue.value = props2.multiple ? values : values[0];
+      },
+      updateTempSelectedItems: (items) => {
+        tempSelectedItems.value = items;
+        const values = tempSelectedItems.value.map((item) => item.value);
+        tempSelectValue.value = props2.multiple ? values : values[0];
+      }
+    };
+    vue.provide(util.SELECT_DATA_KEY, {
+      selectedItems,
+      tempSelectedItems,
+      ...provideMethods
+    });
     __expose({
       selectRef,
-      tableRef,
-      selectVisible,
-      selectedItems,
-      selectedLabel,
-      currentRowKey,
-      selectedRowKeys,
+      tableRef: proTableRef,
       updatePopover,
-      updateSelectedItems,
       updateVisible,
-      focusSearchInput
+      focusSearchInput,
+      ...provideMethods
     });
     return (_ctx, _cache) => {
+      const _component_EleProTable = vue.resolveComponent("EleProTable");
       return vue.openBlock(), vue.createBlock(EleBasicSelect, {
         ref_key: "selectRef",
         ref: selectRef,
         value: _ctx.modelValue,
+        selectedLabel: selectedLabel.value,
+        selected: selectedItems.value,
+        visible: selectVisible.value,
         multiple: _ctx.multiple,
         disabled: _ctx.disabled,
         size: _ctx.size,
@@ -334,19 +431,22 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         tagType: _ctx.tagType,
         automaticDropdown: _ctx.automaticDropdown,
         filterable: _ctx.filterable,
+        selectClass: _ctx.selectClass,
+        selectStyle: _ctx.selectStyle,
+        inputStyle: _ctx.inputStyle,
+        selectTagsStyle: _ctx.selectTagsStyle,
+        popperClass: selectPopperClass.value,
+        popperWidth: _ctx.popperWidth,
+        popperHeight: _ctx.popperHeight,
+        popperType: _ctx.popperType,
+        popperProps: _ctx.popperProps,
+        popperSlots: { footer: "modalFooter", ..._ctx.popperSlots || {} },
+        popperTitle: _ctx.popperTitle,
         teleported: _ctx.teleported,
         persistent: _ctx.persistent,
         placement: _ctx.placement,
         transition: _ctx.transition,
-        popperWidth: _ctx.popperWidth,
         popperOptions: _ctx.popperOptions,
-        popperClass: selectPopperClass.value,
-        selectStyle: _ctx.selectStyle,
-        inputStyle: _ctx.inputStyle,
-        selectTagsStyle: _ctx.selectTagsStyle,
-        selectedLabel: selectedLabel.value,
-        selected: selectedItems.value,
-        visible: selectVisible.value,
         "onUpdate:visible": updateVisible,
         onFilterChange: handleSelectFilter,
         onRemoveTag: handleSelectRemove,
@@ -355,52 +455,108 @@ const _sfc_main = /* @__PURE__ */ vue.defineComponent({
         onBlur: handleSelectBlur
       }, vue.createSlots({
         default: vue.withCtx(() => [
-          vue.renderSlot(_ctx.$slots, "popperTopExtra"),
-          vue.createVNode(EleProTable, vue.mergeProps({
-            "onUpdate:selectedRowKeys": updateSelectedRowKeys,
-            "onUpdate:currentRowKey": updateCurrentRowKey,
-            onSelectionChange: handleTableSelectionChange,
-            onCurrentChange: handleTableCurrentChange,
-            onRowClick: handleTableRowClick,
-            onSelect: handleTableSelect,
-            onSelectAll: handleTableSelectAll,
-            onDone: handleTableDone
-          }, _ctx.tableProps || {}, {
-            ref_key: "tableRef",
-            ref: tableRef,
-            rowKey: _ctx.valueKey,
-            reserveCurrent: true,
-            highlightCurrentRow: !_ctx.multiple,
-            currentRowKey: currentRowKey.value,
-            selectedRowKeys: selectedRowKeys.value
-          }), vue.createSlots({ _: 2 }, [
-            vue.renderList(Object.keys(_ctx.$slots).filter(
-              (k) => ![
-                "popperTopExtra",
-                "popperBottomExtra",
-                "maxTagPlaceholder"
-              ].includes(k)
-            ), (name) => {
-              return {
-                name,
-                fn: vue.withCtx((slotProps) => [
-                  vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
-                ])
-              };
-            })
-          ]), 1040, ["rowKey", "highlightCurrentRow", "currentRowKey", "selectedRowKeys"]),
-          vue.renderSlot(_ctx.$slots, "popperBottomExtra")
+          _ctx.wrapperComponent ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.wrapperComponent), vue.normalizeProps(vue.mergeProps({ key: 0 }, _ctx.wrapperComponentProps || {})), {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "popperTopExtra"),
+              vue.createVNode(_component_EleProTable, vue.mergeProps({
+                "onUpdate:selectedRowKeys": handleUpdateTableSelectedRowKeys,
+                "onUpdate:currentRowKey": handleUpdateTableCurrentRowKey,
+                onSelectionChange: handleTableSelectionChange,
+                onCurrentChange: handleTableCurrentChange,
+                onRowClick: handleTableRowClick,
+                onSelect: handleTableSelect,
+                onSelectAll: handleTableSelectAll,
+                onDone: handleTableDone
+              }, _ctx.tableProps || {}, {
+                ref_key: "proTableRef",
+                ref: proTableRef,
+                rowKey: _ctx.valueKey,
+                reserveCurrent: true,
+                highlightCurrentRow: !_ctx.multiple,
+                currentRowKey: tableCurrentRowKey.value,
+                selectedRowKeys: tableSelectedRowKeys.value
+              }), vue.createSlots({ _: 2 }, [
+                vue.renderList(vue.unref(common.getSlotsMap)(
+                  _ctx.$slots,
+                  _ctx.tableSlots,
+                  [],
+                  ownSlots,
+                  !_ctx.tableSlots
+                ), (slotName, compSlotName) => {
+                  return {
+                    name: compSlotName,
+                    fn: vue.withCtx((slotProps) => [
+                      vue.renderSlot(_ctx.$slots, slotName, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+                    ])
+                  };
+                })
+              ]), 1040, ["rowKey", "highlightCurrentRow", "currentRowKey", "selectedRowKeys"]),
+              vue.renderSlot(_ctx.$slots, "popperBottomExtra")
+            ]),
+            _: 3
+          }, 16)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+            vue.renderSlot(_ctx.$slots, "popperTopExtra"),
+            vue.createVNode(_component_EleProTable, vue.mergeProps({
+              "onUpdate:selectedRowKeys": handleUpdateTableSelectedRowKeys,
+              "onUpdate:currentRowKey": handleUpdateTableCurrentRowKey,
+              onSelectionChange: handleTableSelectionChange,
+              onCurrentChange: handleTableCurrentChange,
+              onRowClick: handleTableRowClick,
+              onSelect: handleTableSelect,
+              onSelectAll: handleTableSelectAll,
+              onDone: handleTableDone
+            }, _ctx.tableProps || {}, {
+              ref_key: "proTableRef",
+              ref: proTableRef,
+              rowKey: _ctx.valueKey,
+              reserveCurrent: true,
+              highlightCurrentRow: !_ctx.multiple,
+              currentRowKey: tableCurrentRowKey.value,
+              selectedRowKeys: tableSelectedRowKeys.value
+            }), vue.createSlots({ _: 2 }, [
+              vue.renderList(vue.unref(common.getSlotsMap)(
+                _ctx.$slots,
+                _ctx.tableSlots,
+                [],
+                ownSlots,
+                !_ctx.tableSlots
+              ), (slotName, compSlotName) => {
+                return {
+                  name: compSlotName,
+                  fn: vue.withCtx((slotProps) => [
+                    vue.renderSlot(_ctx.$slots, slotName, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+                  ])
+                };
+              })
+            ]), 1040, ["rowKey", "highlightCurrentRow", "currentRowKey", "selectedRowKeys"]),
+            vue.renderSlot(_ctx.$slots, "popperBottomExtra")
+          ], 64))
         ]),
         _: 2
       }, [
-        _ctx.$slots.maxTagPlaceholder ? {
-          name: "maxTagPlaceholder",
-          fn: vue.withCtx((slotProps) => [
-            vue.renderSlot(_ctx.$slots, "maxTagPlaceholder", vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+        vue.renderList(Object.keys(_ctx.$slots).filter(
+          (k) => k !== "default" && !ownSlots.includes(k)
+        ), (name) => {
+          return {
+            name,
+            fn: vue.withCtx((slotProps) => [
+              vue.renderSlot(_ctx.$slots, name, vue.normalizeProps(vue.guardReactiveProps(slotProps || {})))
+            ])
+          };
+        }),
+        isModalType.value && !_ctx.$slots.modalFooter ? {
+          name: "modalFooter",
+          fn: vue.withCtx(() => [
+            vue.createVNode(EleButtons, {
+              items: [
+                { preset: "cancel", onClick: () => updateVisible(false) },
+                { preset: "confirm", onClick: () => handleConfirm() }
+              ]
+            }, null, 8, ["items"])
           ]),
           key: "0"
         } : void 0
-      ]), 1032, ["value", "multiple", "disabled", "size", "clearable", "placeholder", "maxTagCount", "maxTagTextLength", "tagType", "automaticDropdown", "filterable", "teleported", "persistent", "placement", "transition", "popperWidth", "popperOptions", "popperClass", "selectStyle", "inputStyle", "selectTagsStyle", "selectedLabel", "selected", "visible"]);
+      ]), 1032, ["value", "selectedLabel", "selected", "visible", "multiple", "disabled", "size", "clearable", "placeholder", "maxTagCount", "maxTagTextLength", "tagType", "automaticDropdown", "filterable", "selectClass", "selectStyle", "inputStyle", "selectTagsStyle", "popperClass", "popperWidth", "popperHeight", "popperType", "popperProps", "popperSlots", "popperTitle", "teleported", "persistent", "placement", "transition", "popperOptions"]);
     };
   }
 });