ele-admin-plus 1.1.4 → 1.1.5-beta.2

package/lib/ele-pro-table/components/tool-column.js

@@ -1,51 +1,44 @@
 "use strict";
 const vue = require("vue");
-const VueDraggable = require("vuedraggable");
 const iconsVue = require("@element-plus/icons-vue");
 const elementPlus = require("element-plus");
+const core = require("../../utils/core");
 const EleTooltip = require("../../ele-tooltip/index");
-const ElePopover = require("../../ele-popover/index");
-const icons = require("../../icons");
 const EleTool = require("../../ele-tool/index");
 const util = require("../util");
+const ToolColumnList = require("./tool-column-list");
 const _sfc_main = vue.defineComponent({
   name: "ToolColumn",
   components: {
-    VueDraggable,
     ElCheckbox: elementPlus.ElCheckbox,
-    ElCheckboxGroup: elementPlus.ElCheckboxGroup,
     ElIcon: elementPlus.ElIcon,
-    ElLink: elementPlus.ElLink,
     EleTooltip,
-    ElePopover,
     Setting: iconsVue.Setting,
-    HolderOutlined: icons.HolderOutlined,
-    VerticalRightOutlined: icons.VerticalRightOutlined,
-    VerticalLeftOutlined: icons.VerticalLeftOutlined,
-    EleTool
+    EleTool,
+    ToolColumnList
   },
   props: {
-    // 提示文字
+    /** 提示文字 */
     title: String,
-    // 提示位置
+    /** 提示位置 */
     placement: String,
-    // 全选文字
+    /** 全选文字 */
     checkAllText: String,
-    // 重置文字
+    /** 重置文字 */
     resetText: String,
-    // 无标题列文字
+    /** 无标题列文字 */
     untitledText: String,
-    // 固定在左侧文字
+    /** 固定在左侧文字 */
     fixedLeftText: String,
-    // 固定在右侧文字
+    /** 固定在右侧文字 */
     fixedRightText: String,
-    // 列数据
+    /** 列数据 */
     columns: Array,
-    // 是否开启列拖拽排序
+    /** 是否开启列拖拽排序 */
     sortable: Boolean,
-    // 是否开启开关固定列
+    /** 是否开启开关固定列 */
     allowFixed: Boolean,
-    // 列配置缓存本地的名称
+    /** 列配置缓存本地的名称 */
     cacheKey: String
   },
   emits: {
@@ -53,96 +46,41 @@ const _sfc_main = vue.defineComponent({
   },
   setup(props, { emit }) {
     const data = vue.ref([]);
-    const checkedIds = vue.ref([]);
-    const isChecked = vue.ref(false);
+    const isCheckAll = vue.ref(false);
     const isIndeterminate = vue.ref(false);
     const tooltipContent = vue.ref("");
     const virtualRef = vue.ref();
-    const popperClass = vue.computed(() => {
-      const classes = ["ele-tool-column"];
-      if (props.sortable) {
-        classes.push("is-sortable");
-      }
-      return classes.join(" ");
-    });
-    const updateSortCols = (cols) => {
-      data.value = util.sortCols(cols);
-      onSortChange();
-    };
-    const onCheckedChange = () => {
-      data.value.forEach((d) => {
-        d.checked = checkedIds.value.includes(d.uid);
-      });
-      isChecked.value = data.value.length > 0 && data.value.length === checkedIds.value.length;
-      isIndeterminate.value = checkedIds.value.length !== 0 && data.value.length !== checkedIds.value.length;
-      const columns = util.getCheckedColumns(
+    const initData = () => {
+      const cols = util.getSettingCols(
         props.columns,
-        data.value,
-        checkedIds.value,
-        props.sortable
+        props.untitledText,
+        props.cacheKey
       );
-      cacheSettingCols();
-      emit("update:columns", columns);
-    };
-    const onCheckAllChange = () => {
-      if (isChecked.value) {
-        checkedIds.value = data.value.map((d) => d.uid);
-      } else {
-        checkedIds.value = [];
-      }
-      isIndeterminate.value = false;
-      data.value.forEach((d) => {
-        d.checked = checkedIds.value.includes(d.uid);
+      data.value = cols;
+      let checkAll = true;
+      let indeterminate = false;
+      core.eachTree(data.value, (d) => {
+        if (!d.checked && checkAll) {
+          checkAll = false;
+        }
+        if (d.checked && !indeterminate) {
+          indeterminate = true;
+        }
+        if (!checkAll && indeterminate) {
+          return false;
+        }
       });
-      const columns = util.getCheckedColumns(
-        props.columns,
-        data.value,
-        checkedIds.value,
-        props.sortable
-      );
-      cacheSettingCols();
-      emit("update:columns", columns);
+      isCheckAll.value = data.value.length > 0 && checkAll;
+      isIndeterminate.value = !checkAll && indeterminate;
     };
-    const onReset = () => {
-      const result = util.getSettingCols(props.columns, props.untitledText);
-      data.value = result.data;
-      checkedIds.value = result.checkedIds;
-      isChecked.value = result.isChecked;
-      isIndeterminate.value = result.isIndeterminate;
-      const columns = util.getCheckedColumns(
-        props.columns,
-        result.data,
-        result.checkedIds,
-        props.sortable
-      );
-      cleanSettingCols();
-      emit("update:columns", columns);
-    };
-    const onSortChange = () => {
+    const updateColumns = () => {
       const columns = util.getCheckedColumns(
         props.columns,
         data.value,
-        checkedIds.value,
         props.sortable
       );
-      cacheSettingCols();
       emit("update:columns", columns);
     };
-    const onItemFixedLeft = (col) => {
-      const cols = [...data.value];
-      const index = cols.findIndex((c) => c.uid === col.uid);
-      const isFixedLeft = col.fixed === true || col.fixed === "left";
-      cols[index].fixed = isFixedLeft ? false : "left";
-      data.value = util.sortCols(cols);
-      onSortChange();
-    };
-    const onItemFixedRight = (col) => {
-      const cols = [...data.value];
-      const index = cols.findIndex((c) => c.uid === col.uid);
-      cols[index].fixed = col.fixed === "right" ? false : "right";
-      data.value = util.sortCols(cols);
-      onSortChange();
-    };
     const cacheSettingCols = () => {
       if (props.cacheKey) {
         localStorage.setItem(
@@ -156,47 +94,107 @@ const _sfc_main = vue.defineComponent({
         localStorage.removeItem(util.getColsCacheKey(props.cacheKey));
       }
     };
-    const openTooltip = (e, content) => {
-      virtualRef.value = e.currentTarget;
-      tooltipContent.value = content ?? "";
+    const onCheckedChange = (item, checked) => {
+      let checkAll = true;
+      let indeterminate = false;
+      core.eachTree(data.value, (d) => {
+        if (d.uid === item.uid) {
+          d.checked = checked;
+        }
+        if (!d.checked && checkAll) {
+          checkAll = false;
+        }
+        if (d.checked && !indeterminate) {
+          indeterminate = true;
+        }
+        if (d.uid === item.uid && !checkAll && indeterminate) {
+          return false;
+        }
+      });
+      isCheckAll.value = data.value.length > 0 && checkAll;
+      isIndeterminate.value = !checkAll && indeterminate;
+      cacheSettingCols();
+      updateColumns();
     };
-    vue.watch(
-      () => props.columns,
-      (columns) => {
-        if (!columns) {
-          return;
+    const onCheckAllChange = (checked) => {
+      isCheckAll.value = checked;
+      isIndeterminate.value = false;
+      core.eachTree(data.value, (d) => {
+        if (d.checked !== checked) {
+          d.checked = checked;
         }
-        const result = util.getSettingCols(
-          columns,
-          props.untitledText,
-          props.cacheKey
-        );
-        data.value = result.data;
-        checkedIds.value = result.checkedIds;
-        isChecked.value = result.isChecked;
-        isIndeterminate.value = result.isIndeterminate;
-      },
-      {
-        immediate: true,
-        deep: true
+      });
+      cacheSettingCols();
+      updateColumns();
+    };
+    const onReset = () => {
+      cleanSettingCols();
+      initData();
+      updateColumns();
+    };
+    const onSortChange = (colItems, parent) => {
+      if (!parent) {
+        data.value = colItems;
+      } else {
+        core.eachTree(data.value, (d) => {
+          if (d.uid === parent.uid) {
+            d.children = colItems;
+            return false;
+          }
+        });
       }
+      cacheSettingCols();
+      updateColumns();
+    };
+    const onFixedLeft = (colItem) => {
+      core.eachTree(data.value, (d) => {
+        if (d.uid === colItem.uid) {
+          d.fixed = d.fixed === true || d.fixed === "left" ? false : "left";
+          return false;
+        }
+      });
+      cacheSettingCols();
+      updateColumns();
+    };
+    const onFixedRight = (colItem) => {
+      core.eachTree(data.value, (d) => {
+        if (d.uid === colItem.uid) {
+          d.fixed = d.fixed === "right" ? false : "right";
+          return false;
+        }
+      });
+      cacheSettingCols();
+      updateColumns();
+    };
+    const onFixedLeftTooltip = (el) => {
+      virtualRef.value = el;
+      tooltipContent.value = props.fixedLeftText ?? "";
+    };
+    const onFixedRightTooltip = (el) => {
+      virtualRef.value = el;
+      tooltipContent.value = props.fixedRightText ?? "";
+    };
+    vue.watch(
+      [() => props.columns, () => props.untitledText],
+      () => {
+        initData();
+      },
+      { immediate: true, deep: true }
     );
     return {
       data,
-      checkedIds,
-      isChecked,
+      isCheckAll,
       isIndeterminate,
       tooltipContent,
       virtualRef,
-      popperClass,
-      updateSortCols,
       onCheckedChange,
       onCheckAllChange,
       onReset,
       onSortChange,
-      onItemFixedLeft,
-      onItemFixedRight,
-      openTooltip
+      onFixedLeft,
+      onFixedRight,
+      onFixedLeftTooltip,
+      onFixedRightTooltip
     };
   }
 });
@@ -207,29 +205,13 @@ const _export_sfc = (sfc, props) => {
   }
   return target;
 };
-const _hoisted_1 = { class: "ele-tool-column-label" };
-const _hoisted_2 = {
-  key: 0,
-  class: "ele-tool-column-handle"
-};
-const _hoisted_3 = { class: "ele-tool-column-label" };
-const _hoisted_4 = {
-  key: 1,
-  class: "ele-tool-column-fixed"
-};
-const _hoisted_5 = ["onClick"];
-const _hoisted_6 = ["onClick"];
+const _hoisted_1 = { class: "ele-tool-column-header" };
+const _hoisted_2 = { class: "ele-tool-column-label" };
 function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
   const _component_Setting = vue.resolveComponent("Setting");
   const _component_ElIcon = vue.resolveComponent("ElIcon");
   const _component_ElCheckbox = vue.resolveComponent("ElCheckbox");
-  const _component_ElLink = vue.resolveComponent("ElLink");
-  const _component_HolderOutlined = vue.resolveComponent("HolderOutlined");
-  const _component_VerticalRightOutlined = vue.resolveComponent("VerticalRightOutlined");
-  const _component_VerticalLeftOutlined = vue.resolveComponent("VerticalLeftOutlined");
-  const _component_VueDraggable = vue.resolveComponent("VueDraggable");
-  const _component_ElCheckboxGroup = vue.resolveComponent("ElCheckboxGroup");
-  const _component_ElePopover = vue.resolveComponent("ElePopover");
+  const _component_ToolColumnList = vue.resolveComponent("ToolColumnList");
   const _component_EleTooltip = vue.resolveComponent("EleTooltip");
   const _component_EleTool = vue.resolveComponent("EleTool");
   return vue.openBlock(), vue.createBlock(_component_EleTool, {
@@ -237,140 +219,73 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
     placement: _ctx.placement
   }, {
     default: vue.withCtx(() => [
-      vue.createVNode(_component_ElePopover, {
+      vue.createVNode(_component_EleTooltip, {
         trigger: "click",
         placement: "bottom-end",
+        popperClass: "ele-tool-column",
         transition: "el-zoom-in-top",
-        popperClass: _ctx.popperClass,
+        gpuAcceleration: false,
+        effect: "light",
+        isPopover: true,
         popperOptions: {
           modifiers: [{ name: "offset", options: { offset: [20, 10] } }]
         }
       }, {
-        reference: vue.withCtx(() => [
-          vue.createVNode(_component_ElIcon, null, {
-            default: vue.withCtx(() => [
-              vue.createVNode(_component_Setting, { style: { "transform": "scale(1.08)" } })
-            ]),
-            _: 1
-          })
-        ]),
-        default: vue.withCtx(() => [
+        body: vue.withCtx(() => [
           vue.createElementVNode("div", {
-            class: "ele-tool-column-header",
-            onClick: _cache[1] || (_cache[1] = vue.withModifiers(() => {
-            }, ["stop"]))
+            class: vue.normalizeClass(["ele-popover-body", { "is-sortable": _ctx.sortable }])
           }, [
             vue.createElementVNode("div", _hoisted_1, [
-              vue.createVNode(_component_ElCheckbox, {
-                modelValue: _ctx.isChecked,
-                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.isChecked = $event),
-                indeterminate: _ctx.isIndeterminate,
-                onChange: _ctx.onCheckAllChange
-              }, {
-                default: vue.withCtx(() => [
-                  vue.createTextVNode(vue.toDisplayString(_ctx.checkAllText), 1)
-                ]),
-                _: 1
-              }, 8, ["modelValue", "indeterminate", "onChange"])
-            ]),
-            vue.createVNode(_component_ElLink, {
-              type: "primary",
-              underline: false,
-              onClick: _ctx.onReset
-            }, {
-              default: vue.withCtx(() => [
-                vue.createTextVNode(vue.toDisplayString(_ctx.resetText), 1)
+              vue.createElementVNode("div", _hoisted_2, [
+                vue.createVNode(_component_ElCheckbox, {
+                  modelValue: _ctx.isCheckAll,
+                  indeterminate: _ctx.isIndeterminate,
+                  "onUpdate:modelValue": _ctx.onCheckAllChange
+                }, {
+                  default: vue.withCtx(() => [
+                    vue.createTextVNode(vue.toDisplayString(_ctx.checkAllText), 1)
+                  ]),
+                  _: 1
+                }, 8, ["modelValue", "indeterminate", "onUpdate:modelValue"])
               ]),
-              _: 1
-            }, 8, ["onClick"])
-          ]),
-          vue.createVNode(_component_ElCheckboxGroup, {
-            modelValue: _ctx.checkedIds,
-            "onUpdate:modelValue": _cache[5] || (_cache[5] = ($event) => _ctx.checkedIds = $event),
-            onChange: _ctx.onCheckedChange
-          }, {
+              vue.createElementVNode("div", {
+                class: "ele-tool-column-link",
+                onClick: _cache[0] || (_cache[0] = (...args) => _ctx.onReset && _ctx.onReset(...args))
+              }, vue.toDisplayString(_ctx.resetText), 1)
+            ]),
+            _ctx.data.length ? (vue.openBlock(), vue.createBlock(_component_ToolColumnList, {
+              key: 0,
+              data: _ctx.data,
+              sortable: _ctx.sortable,
+              allowFixed: _ctx.allowFixed,
+              onSortChange: _ctx.onSortChange,
+              onCheckedChange: _ctx.onCheckedChange,
+              onFixedLeft: _ctx.onFixedLeft,
+              onFixedRight: _ctx.onFixedRight,
+              onFixedLeftTooltip: _ctx.onFixedLeftTooltip,
+              onFixedRightTooltip: _ctx.onFixedRightTooltip
+            }, null, 8, ["data", "sortable", "allowFixed", "onSortChange", "onCheckedChange", "onFixedLeft", "onFixedRight", "onFixedLeftTooltip", "onFixedRightTooltip"])) : vue.createCommentVNode("", true)
+          ], 2),
+          vue.createVNode(_component_EleTooltip, {
+            trigger: "hover",
+            placement: "top",
+            teleported: false,
+            persistent: false,
+            virtualTriggering: true,
+            virtualRef: _ctx.virtualRef,
+            content: _ctx.tooltipContent
+          }, null, 8, ["virtualRef", "content"])
+        ]),
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_ElIcon, null, {
             default: vue.withCtx(() => [
-              vue.createVNode(_component_VueDraggable, {
-                itemKey: "uid",
-                animation: 300,
-                modelValue: _ctx.data,
-                setData: () => void 0,
-                handle: ".ele-tool-column-handle",
-                componentData: { class: "ele-tool-column-body" },
-                "onUpdate:modelValue": _ctx.updateSortCols
-              }, {
-                item: vue.withCtx(({ element: d }) => [
-                  vue.createElementVNode("div", {
-                    class: "ele-tool-column-item",
-                    onClick: _cache[4] || (_cache[4] = vue.withModifiers(() => {
-                    }, ["stop"]))
-                  }, [
-                    _ctx.sortable ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
-                      vue.createVNode(_component_ElIcon, null, {
-                        default: vue.withCtx(() => [
-                          vue.createVNode(_component_HolderOutlined)
-                        ]),
-                        _: 1
-                      })
-                    ])) : vue.createCommentVNode("", true),
-                    vue.createElementVNode("div", _hoisted_3, [
-                      vue.createVNode(_component_ElCheckbox, {
-                        label: d.uid
-                      }, {
-                        default: vue.withCtx(() => [
-                          vue.createTextVNode(vue.toDisplayString(d.label), 1)
-                        ]),
-                        _: 2
-                      }, 1032, ["label"])
-                    ]),
-                    _ctx.allowFixed ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_4, [
-                      vue.createElementVNode("div", {
-                        class: vue.normalizeClass([
-                          "ele-tool-fixed-item",
-                          { "is-active": d.fixed === true || d.fixed === "left" }
-                        ]),
-                        onClick: ($event) => _ctx.onItemFixedLeft(d),
-                        onMouseover: _cache[2] || (_cache[2] = (e) => _ctx.openTooltip(e, _ctx.fixedLeftText))
-                      }, [
-                        vue.createVNode(_component_ElIcon, null, {
-                          default: vue.withCtx(() => [
-                            vue.createVNode(_component_VerticalRightOutlined)
-                          ]),
-                          _: 1
-                        })
-                      ], 42, _hoisted_5),
-                      vue.createElementVNode("div", {
-                        class: vue.normalizeClass([
-                          "ele-tool-fixed-item",
-                          { "is-active": d.fixed === "right" }
-                        ]),
-                        onClick: ($event) => _ctx.onItemFixedRight(d),
-                        onMouseover: _cache[3] || (_cache[3] = (e) => _ctx.openTooltip(e, _ctx.fixedRightText))
-                      }, [
-                        vue.createVNode(_component_ElIcon, null, {
-                          default: vue.withCtx(() => [
-                            vue.createVNode(_component_VerticalLeftOutlined)
-                          ]),
-                          _: 1
-                        })
-                      ], 42, _hoisted_6)
-                    ])) : vue.createCommentVNode("", true)
-                  ])
-                ]),
-                _: 1
-              }, 8, ["modelValue", "onUpdate:modelValue"])
+              vue.createVNode(_component_Setting, { style: { "transform": "scale(1.08)" } })
             ]),
             _: 1
-          }, 8, ["modelValue", "onChange"])
+          })
         ]),
         _: 1
-      }, 8, ["popperClass"]),
-      vue.createVNode(_component_EleTooltip, {
-        placement: "top",
-        virtualRef: _ctx.virtualRef,
-        content: _ctx.tooltipContent,
-        virtualTriggering: true
-      }, null, 8, ["virtualRef", "content"])
+      })
     ]),
     _: 1
   }, 8, ["title", "placement"]);