ele-admin-plus 1.1.6-beta.1 → 1.1.6-beta.3

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

@@ -2,6 +2,7 @@
 const vue = require("vue");
 const receiver = require("../ele-config-provider/receiver");
 const EleBasicSelect = require("../ele-basic-select/index");
+const util = require("../ele-basic-select/util");
 const EleProTable = require("../ele-pro-table/index");
 const props = require("./props");
 const _sfc_main = vue.defineComponent({
@@ -13,12 +14,24 @@ const _sfc_main = vue.defineComponent({
     const isResponsive = receiver.useResponsive(props2);
     const selectRef = vue.ref(null);
     const tableRef = vue.ref(null);
-    const visible = vue.ref(false);
-    const selectedLabel = vue.ref("");
-    const selectedData = vue.ref([]);
-    const current = vue.ref(null);
-    const selections = vue.ref([]);
-    const innerUpdate = vue.ref(false);
+    const selectVisible = vue.ref(false);
+    const selectedItems = vue.ref([]);
+    const selectedLabel = vue.computed(() => {
+      const selected = selectedItems.value;
+      return !props2.multiple && selected.length ? selected[0].label : "";
+    });
+    const currentRowKey = vue.computed(() => {
+      if (props2.multiple || util.isEmptyValue(props2.modelValue)) {
+        return;
+      }
+      return props2.modelValue;
+    });
+    const selectedRowKeys = vue.computed(() => {
+      if (!props2.multiple || util.isEmptyValue(props2.modelValue)) {
+        return;
+      }
+      return props2.modelValue;
+    });
     const selectPopperClass = vue.computed(() => {
       const classes = ["ele-table-select-popper"];
       if (isResponsive.value) {
@@ -29,278 +42,288 @@ const _sfc_main = vue.defineComponent({
       }
       return classes.join(" ");
     });
-    const updateVisible = (value) => {
-      if (visible.value !== value) {
-        visible.value = value;
-        emit("visibleChange", value);
+    const updatePopover = () => {
+      selectRef.value && selectRef.value.updatePopper();
+    };
+    const getItemByValue = (value) => {
+      if (util.isEmptyValue(value)) {
+        return;
       }
-      if (value) {
-        pageToSeleted();
+      if (props2.cacheData != null) {
+        const temp = props2.cacheData.find((d) => d[props2.valueKey] === value);
+        if (temp != null) {
+          return temp;
+        }
       }
-    };
-    const onRemoveTag = (item) => {
-      const values = props2.modelValue ?? [];
-      updateModelValue(values.filter((v) => v !== item.value));
-      emit("removeTag", item.value);
-    };
-    const onClear = () => {
-      updateModelValue(props2.multiple ? [] : null);
-      updateVisible(false);
-      emit("clear");
-    };
-    const onFocus = (e) => {
-      emit("focus", e);
-    };
-    const onBlur = (e) => {
-      emit("blur", e);
-    };
-    const valueIsChanged = (value) => {
-      const isEmpty = isEmptyValue(props2.modelValue);
-      if (!props2.multiple) {
-        if (isEmptyValue(value) && isEmpty) {
-          return false;
+      if (!util.isEmptyValue(props2.initValue)) {
+        if (!props2.multiple) {
+          return props2.initValue;
         }
-        return value !== props2.modelValue;
+        return props2.initValue.find(
+          (d) => d[props2.valueKey] === value
+        );
       }
-      const values = value;
-      const selected = props2.modelValue;
-      if (isEmpty || !selected.length) {
-        return !!values.length;
+    };
+    const getCacheItemByValue = (value, cacheKeys, cacheData, tKeys, initValue) => {
+      if (cacheData != null) {
+        const index2 = cacheKeys.indexOf(value);
+        if (index2 !== -1) {
+          return cacheData[index2];
+        }
       }
-      if (values.length !== selected.length) {
-        return true;
+      if (initValue != null) {
+        const i = tKeys.indexOf(value);
+        if (i !== -1) {
+          return initValue[i];
+        }
       }
-      return values.some((v) => !selected.includes(v));
     };
-    const updateModelValue = (value) => {
-      if (valueIsChanged(value)) {
-        emit("update:modelValue", value);
-        emit("change", value);
+    const getMultipleItems = () => {
+      const modelValue = props2.modelValue;
+      if (util.isEmptyValue(modelValue, true)) {
+        return [];
       }
-    };
-    const onUpdateCurrent = (value) => {
-      current.value = value;
-      if (!innerUpdate.value && !props2.multiple && value != null) {
-        updateModelValue(value[props2.valueKey]);
-        emit("select", value);
+      const selected = [];
+      const keys = [];
+      if (tableRef.value) {
+        const data = tableRef.value.getSelectionRows() || [];
+        data.forEach((item) => {
+          if (!item._isMock) {
+            const value = item[props2.valueKey];
+            const index2 = modelValue.indexOf(value);
+            if (index2 !== -1) {
+              selected.push({ value, label: item[props2.labelKey], index: index2 });
+              keys.push(value);
+            }
+          }
+        });
       }
-    };
-    const onUpdateSelections = (values) => {
-      selections.value = values;
-      if (!innerUpdate.value && props2.multiple && values != null) {
-        updateModelValue(values.map((d) => d[props2.valueKey]));
-        if (values.length) {
-          emit("select", values);
-        }
+      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 index2 = modelValue.indexOf(value);
+            selected.push({ value, label, index: index2 });
+          }
+        });
       }
+      selected.sort((a, b) => a.index - b.index);
+      return selected;
     };
-    const onValueChange = (value) => {
-      if (props2.multiple) {
-        const values = value;
-        if (values == null || !values.length) {
-          selectedData.value = [];
-          updateSelectedRows([]);
+    const updateSelectedItems = (force) => {
+      if (!props2.multiple) {
+        const value = props2.modelValue;
+        const d = selectedItems.value.length ? selectedItems.value[0] : null;
+        if (util.isEmptyValue(value)) {
+          if (d != null) {
+            selectedItems.value = [];
+          }
           return;
         }
-        const { checked, selectedRows } = getMultipleResult(values);
-        selectedData.value = checked;
-        updateSelectedRows(selectedRows);
-        return;
-      }
-      if (isEmptyValue(value)) {
-        selectedLabel.value = "";
-        updateCurrentRow(null);
+        if (force || !d || d.value !== value) {
+          const temp = tableRef.value ? tableRef.value.getCurrentRow() : null;
+          const item = temp || getItemByValue(value);
+          const label = item ? item[props2.labelKey] : String(value);
+          selectedItems.value = [{ label, value }];
+        }
         return;
       }
-      const row = getRowByValue(value);
-      if (row) {
-        selectedLabel.value = row[props2.labelKey] ?? "";
-        if (current.value !== row) {
-          updateCurrentRow(row);
+      if (util.isEmptyValue(props2.modelValue, true)) {
+        if (selectedItems.value.length) {
+          selectedItems.value = [];
+          vue.nextTick(() => {
+            updatePopover();
+          });
         }
         return;
       }
-      updateCurrentRow(null);
-      if (isEmptyValue(props2.initValue)) {
-        selectedLabel.value = value;
-        return;
+      const keys = selectedItems.value.map((d) => d.value);
+      if (force || util.valueIsChanged(props2.modelValue, keys, true)) {
+        selectedItems.value = getMultipleItems();
+        vue.nextTick(() => {
+          updatePopover();
+        });
       }
-      const label = props2.initValue[props2.labelKey];
-      selectedLabel.value = label ?? "";
     };
-    const updateCurrentRow = (row) => {
-      if (tableRef.value) {
-        innerUpdate.value = true;
-        tableRef.value.setCurrentRow(row);
-        innerUpdate.value = false;
+    const focusSearchInput = () => {
+      selectRef.value && selectRef.value.focusSearchInput();
+    };
+    const onInitValueChange = (initValue) => {
+      const valueKey = props2.valueKey;
+      if (!props2.multiple) {
+        const key = initValue[valueKey];
+        if (key === props2.modelValue) {
+          updateSelectedItems();
+        } else {
+          updateModelValue(key);
+        }
+        return;
+      }
+      const keys = initValue.map((d) => d[valueKey]);
+      if (!util.valueIsChanged(props2.modelValue, keys, true)) {
+        updateSelectedItems();
+      } else {
+        updateModelValue(keys);
       }
     };
-    const updateSelectedRows = (rows) => {
-      if (tableRef.value) {
-        innerUpdate.value = true;
-        tableRef.value.setSelectedRows(rows);
-        innerUpdate.value = false;
+    const updateModelValue = (modelValue) => {
+      if (util.valueIsChanged(modelValue, props2.modelValue, props2.multiple)) {
+        emit("update:modelValue", modelValue);
+        emit("change", modelValue);
       }
     };
-    const getMultipleResult = (values) => {
-      const checked = [];
-      const extras = [];
-      values.forEach((value) => {
-        const item = getRowByValue(value, selections.value);
-        if (item) {
-          checked.push({ value, label: item[props2.labelKey] });
-          return;
-        }
-        const row = getRowByValue(value);
-        if (row) {
-          checked.push({ value, label: row[props2.labelKey] });
-          extras.push(row);
-          return;
+    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();
+              });
+            });
+          }
         }
-        const label = getLabelFromInit(value);
-        checked.push({ value, label });
-        extras.push({ [props2.valueKey]: value, [props2.labelKey]: label });
-      });
-      const selectedRows = selections.value.filter((d) => values.includes(d[props2.valueKey])).concat(extras);
-      return { checked, selectedRows };
-    };
-    const getLabelFromInit = (value) => {
-      if (isEmptyValue(props2.initValue)) {
-        return value;
+        emit("visibleChange", visible);
       }
-      const list = props2.initValue;
-      const temp = list.find((d) => d[props2.valueKey] === value);
-      return temp ? temp[props2.labelKey] : value;
     };
-    const isEmptyValue = (value) => {
-      return value == null || value === "";
+    const onSelectRemove = (item) => {
+      const values = props2.modelValue || [];
+      updateModelValue(values.filter((v) => v !== item.value));
+      emit("removeTag", item.value);
     };
-    const isArrayDatasource = () => {
-      const tableProps = props2.tableProps;
-      return tableProps != null && Array.isArray(tableProps.datasource);
+    const onSelectClear = () => {
+      updateModelValue(props2.multiple ? [] : null);
+      updateVisible(false);
+      emit("clear");
     };
-    const getTablePageData = () => {
-      return tableRef.value ? tableRef.value.getData() : [];
+    const onSelectFocus = (e) => {
+      emit("focus", e);
     };
-    const getTableData = () => {
-      if (isArrayDatasource()) {
-        return props2.tableProps.datasource;
-      }
-      return getTablePageData();
+    const onSelectBlur = (e) => {
+      emit("blur", e);
     };
-    const getRowByValue = (value, data) => {
-      const list = data ?? getTableData();
-      return list.find((d) => d[props2.valueKey] === value);
+    const onSelectFilter = (keywords) => {
+      emit("filterChange", keywords);
     };
-    const pageToSeleted = () => {
-      if (!tableRef.value || isEmptyValue(props2.modelValue)) {
-        return;
+    const updateSelectedRowKeys = (rowKeys) => {
+      if (props2.multiple) {
+        updateModelValue(rowKeys);
       }
-      const data = getTablePageData();
+    };
+    const updateCurrentRowKey = (rowKey) => {
       if (!props2.multiple) {
-        if (data.some((d) => d[props2.valueKey] === props2.modelValue)) {
-          return;
-        }
-        tableRef.value.goPageByRowKey(props2.modelValue);
-        return;
+        updateModelValue(rowKey);
       }
-      if (!Array.isArray(props2.modelValue) || !props2.modelValue.length) {
-        return;
+    };
+    const onTableCurrentChange = (row, old) => {
+      if (!props2.multiple && row != null) {
+        updateSelectedItems(true);
+        emit("select", row);
       }
-      const selected = props2.modelValue;
-      if (data.some((d) => selected.includes(d[props2.valueKey]))) {
-        return;
+      if (props2.tableProps != null && typeof props2.tableProps.onCurrentChange === "function") {
+        props2.tableProps.onCurrentChange(row, old);
       }
-      tableRef.value.goPageByRowKey(selected[selected.length - 1]);
     };
-    const onTableDone = () => {
-      vue.nextTick(() => {
-        updatePopover();
-      });
-      if (!props2.multiple) {
-        if (!isEmptyValue(props2.modelValue)) {
-          const row = getRowByValue(props2.modelValue);
-          if (row) {
-            selectedLabel.value = row[props2.labelKey] ?? "";
-            updateCurrentRow(row);
-          }
-        }
-        return;
+    const onTableSelectionChange = (selection) => {
+      if (props2.multiple) {
+        updateSelectedItems(true);
+        emit("select", selection);
       }
-      const values = props2.modelValue;
-      if (values != null && values.length) {
-        const rows = [];
-        const data = getTablePageData();
-        selections.value.forEach((d) => {
-          rows.push(getRowByValue(d[props2.valueKey], data) ?? d);
-        });
-        updateSelectedRows(rows);
-        const { checked } = getMultipleResult(values);
-        selectedData.value = checked;
+      if (props2.tableProps != null && typeof props2.tableProps.onSelectionChange === "function") {
+        props2.tableProps.onSelectionChange(selection);
       }
     };
-    const onTableRowClick = () => {
+    const onTableRowClick = (row, column, e) => {
       if (!props2.multiple) {
         updateVisible(false);
       }
-    };
-    const onInitValueChange = (init) => {
-      if (!isEmptyValue(init)) {
-        if (!props2.multiple) {
-          updateModelValue(init[props2.valueKey]);
-          return;
-        }
-        const key = props2.valueKey;
-        updateModelValue(init.map((d) => d[key]));
+      if (props2.tableProps != null && typeof props2.tableProps.onRowClick === "function") {
+        props2.tableProps.onRowClick(row, column, e);
       }
     };
-    const updatePopover = () => {
-      selectRef.value && selectRef.value.updatePopper();
-    };
-    vue.onMounted(() => {
-      var _a;
-      if (props2.multiple) {
-        if (!isEmptyValue(props2.initValue)) {
-          onInitValueChange(props2.initValue);
-        } else if ((_a = props2.modelValue) == null ? void 0 : _a.length) {
-          onValueChange(props2.modelValue);
-        }
-      } else if (!isEmptyValue(props2.initValue)) {
-        onInitValueChange(props2.initValue);
-      } else if (!isEmptyValue(props2.modelValue)) {
-        onValueChange(props2.modelValue);
+    const onTableDone = (result, parent) => {
+      vue.nextTick(() => {
+        updatePopover();
+      });
+      if (props2.tableProps != null && typeof props2.tableProps.onDone === "function") {
+        props2.tableProps.onDone(result, parent);
       }
-    });
+    };
     vue.watch(
       () => props2.modelValue,
-      (value) => {
-        onValueChange(value);
+      () => {
+        updateSelectedItems();
+      },
+      { deep: true }
+    );
+    vue.watch(
+      () => props2.cacheData,
+      () => {
+        updateSelectedItems(true);
       }
     );
     vue.watch(
       () => props2.initValue,
       (initValue) => {
-        onInitValueChange(initValue);
+        if (!util.isEmptyValue(initValue)) {
+          onInitValueChange(initValue);
+        }
+      },
+      { deep: true }
+    );
+    vue.watch(
+      () => props2.disabled,
+      (disabled) => {
+        if (disabled) {
+          updateVisible(false);
+        }
       }
     );
+    vue.onMounted(() => {
+      if (!util.isEmptyValue(props2.initValue, props2.multiple)) {
+        onInitValueChange(props2.initValue);
+      } else if (!util.isEmptyValue(props2.modelValue, props2.multiple)) {
+        updateSelectedItems();
+      }
+    });
     return {
       selectRef,
       tableRef,
-      visible,
+      selectVisible,
+      selectedItems,
       selectedLabel,
-      selectedData,
-      current,
-      selections,
+      currentRowKey,
+      selectedRowKeys,
       selectPopperClass,
+      updatePopover,
+      updateSelectedItems,
+      focusSearchInput,
       updateVisible,
-      onRemoveTag,
-      onClear,
-      onFocus,
-      onBlur,
-      onUpdateCurrent,
-      onUpdateSelections,
-      onTableDone,
-      onTableRowClick
+      onSelectRemove,
+      onSelectClear,
+      onSelectFocus,
+      onSelectBlur,
+      onSelectFilter,
+      updateSelectedRowKeys,
+      updateCurrentRowKey,
+      onTableCurrentChange,
+      onTableSelectionChange,
+      onTableRowClick,
+      onTableDone
     };
   }
 });
@@ -322,41 +345,46 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     size: _ctx.size,
     clearable: _ctx.clearable,
     placeholder: _ctx.placeholder,
-    name: _ctx.name,
-    autocomplete: _ctx.autocomplete,
     maxTagCount: _ctx.maxTagCount,
     maxTagTextLength: _ctx.maxTagTextLength,
+    tagType: _ctx.tagType,
+    automaticDropdown: _ctx.automaticDropdown,
+    filterable: _ctx.filterable,
     teleported: _ctx.teleported,
     persistent: _ctx.persistent,
-    automaticDropdown: _ctx.automaticDropdown,
-    tagType: _ctx.tagType,
     placement: _ctx.placement,
+    transition: _ctx.transition,
     popperWidth: _ctx.popperWidth,
     popperOptions: _ctx.popperOptions,
     popperClass: _ctx.selectPopperClass,
     selectedLabel: _ctx.selectedLabel,
-    selected: _ctx.selectedData,
-    visible: _ctx.visible,
+    selected: _ctx.selectedItems,
+    visible: _ctx.selectVisible,
     "onUpdate:visible": _ctx.updateVisible,
-    onRemoveTag: _ctx.onRemoveTag,
-    onClear: _ctx.onClear,
-    onFocus: _ctx.onFocus,
-    onBlur: _ctx.onBlur
+    onFilterChange: _ctx.onSelectFilter,
+    onRemoveTag: _ctx.onSelectRemove,
+    onClear: _ctx.onSelectClear,
+    onFocus: _ctx.onSelectFocus,
+    onBlur: _ctx.onSelectBlur
   }, vue.createSlots({
     default: vue.withCtx(() => [
-      vue.createVNode(_component_EleProTable, vue.mergeProps(_ctx.tableProps, {
+      vue.renderSlot(_ctx.$slots, "topExtra"),
+      vue.createVNode(_component_EleProTable, vue.mergeProps(_ctx.tableProps || {}, {
         ref: "tableRef",
         rowKey: _ctx.valueKey,
-        current: _ctx.current,
-        selections: _ctx.selections,
+        reserveCurrent: true,
         highlightCurrentRow: !_ctx.multiple,
-        onDone: _ctx.onTableDone,
+        currentRowKey: _ctx.currentRowKey,
+        selectedRowKeys: _ctx.selectedRowKeys,
+        "onUpdate:selectedRowKeys": _ctx.updateSelectedRowKeys,
+        "onUpdate:currentRowKey": _ctx.updateCurrentRowKey,
+        onSelectionChange: _ctx.onTableSelectionChange,
+        onCurrentChange: _ctx.onTableCurrentChange,
         onRowClick: _ctx.onTableRowClick,
-        "onUpdate:current": _ctx.onUpdateCurrent,
-        "onUpdate:selections": _ctx.onUpdateSelections
+        onDone: _ctx.onTableDone
       }), vue.createSlots({ _: 2 }, [
         vue.renderList(Object.keys(_ctx.$slots).filter(
-          (k) => "maxTagPlaceholder" !== k
+          (k) => !["topExtra", "bottomExtra", "maxTagPlaceholder"].includes(k)
         ), (name) => {
           return {
             name,
@@ -365,7 +393,8 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
             ])
           };
         })
-      ]), 1040, ["rowKey", "current", "selections", "highlightCurrentRow", "onDone", "onRowClick", "onUpdate:current", "onUpdate:selections"])
+      ]), 1040, ["rowKey", "highlightCurrentRow", "currentRowKey", "selectedRowKeys", "onUpdate:selectedRowKeys", "onUpdate:currentRowKey", "onSelectionChange", "onCurrentChange", "onRowClick", "onDone"]),
+      vue.renderSlot(_ctx.$slots, "bottomExtra")
     ]),
     _: 2
   }, [
@@ -376,7 +405,7 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
       ]),
       key: "0"
     } : void 0
-  ]), 1032, ["value", "multiple", "disabled", "size", "clearable", "placeholder", "name", "autocomplete", "maxTagCount", "maxTagTextLength", "teleported", "persistent", "automaticDropdown", "tagType", "placement", "popperWidth", "popperOptions", "popperClass", "selectedLabel", "selected", "visible", "onUpdate:visible", "onRemoveTag", "onClear", "onFocus", "onBlur"]);
+  ]), 1032, ["value", "multiple", "disabled", "size", "clearable", "placeholder", "maxTagCount", "maxTagTextLength", "tagType", "automaticDropdown", "filterable", "teleported", "persistent", "placement", "transition", "popperWidth", "popperOptions", "popperClass", "selectedLabel", "selected", "visible", "onUpdate:visible", "onFilterChange", "onRemoveTag", "onClear", "onFocus", "onBlur"]);
 }
 const index = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
 module.exports = index;