@fecp/mobile 1.1.23 → 1.1.24

package/lib/node_modules/.pnpm/vxe-table@4.13.27_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/custom/panel.js

@@ -0,0 +1,987 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+require("../../../ui/index.js");
+const utils = require("../../../ui/src/utils.js");
+const dom = require("../../../ui/src/dom.js");
+const log = require("../../../ui/src/log.js");
+const index = require("../../../../../../../../../_virtual/index.js");
+const index_esm = require("../../../../../../../@vxe-ui_core@4.1.3_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
+const { getI18n, getIcon, renderEmptyElement } = index_esm.VxeUI;
+const TableCustomPanelComponent = vue.defineComponent({
+  name: "TableCustomPanel",
+  props: {
+    customStore: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  setup(props) {
+    const VxeUIModalComponent = index_esm.VxeUI.getComponent("VxeModal");
+    const VxeUIDrawerComponent = index_esm.VxeUI.getComponent("VxeDrawer");
+    const VxeUIButtonComponent = index_esm.VxeUI.getComponent("VxeButton");
+    const VxeUINumberInputComponent = index_esm.VxeUI.getComponent("VxeNumberInput");
+    const VxeUIRadioGroupComponent = index_esm.VxeUI.getComponent("VxeRadioGroup");
+    const $xeTable = vue.inject("$xeTable", {});
+    const { props: tableProps, reactData, internalData } = $xeTable;
+    const { computeCustomOpts, computeColumnDragOpts, computeColumnOpts, computeIsMaxFixedColumn, computeResizableOpts } = $xeTable.getComputeMaps();
+    const refElem = vue.ref();
+    const bodyElemRef = vue.ref();
+    const refDragLineElem = vue.ref();
+    const refDragTipElem = vue.ref();
+    const dragColumnRef = vue.ref();
+    let prevDragCol;
+    let prevDragToChild = false;
+    let prevDragPos;
+    const handleWrapperMouseenterEvent = (evnt) => {
+      const { customStore } = props;
+      customStore.activeWrapper = true;
+      $xeTable.customOpenEvent(evnt);
+    };
+    const handleWrapperMouseleaveEvent = (evnt) => {
+      const { customStore } = props;
+      customStore.activeWrapper = false;
+      setTimeout(() => {
+        if (!customStore.activeBtn && !customStore.activeWrapper) {
+          $xeTable.customCloseEvent(evnt);
+        }
+      }, 300);
+    };
+    const confirmCustomEvent = ({ $event }) => {
+      reactData.isCustomStatus = true;
+      $xeTable.saveCustom();
+      $xeTable.closeCustom();
+      $xeTable.emitCustomEvent("confirm", $event);
+    };
+    const cancelCloseEvent = ({ $event }) => {
+      $xeTable.closeCustom();
+      $xeTable.emitCustomEvent("close", $event);
+    };
+    const cancelCustomEvent = ({ $event }) => {
+      $xeTable.cancelCustom();
+      $xeTable.closeCustom();
+      $xeTable.emitCustomEvent("cancel", $event);
+    };
+    const handleResetCustomEvent = (evnt) => {
+      $xeTable.resetCustom(true);
+      $xeTable.closeCustom();
+      $xeTable.emitCustomEvent("reset", evnt);
+    };
+    const resetCustomEvent = ({ $event }) => {
+      if (index_esm.VxeUI.modal) {
+        index_esm.VxeUI.modal.confirm({
+          content: getI18n("vxe.custom.cstmConfirmRestore"),
+          className: "vxe-table--ignore-clear",
+          escClosable: true
+        }).then((type) => {
+          if (type === "confirm") {
+            handleResetCustomEvent($event);
+          }
+        });
+      } else {
+        handleResetCustomEvent($event);
+      }
+    };
+    const handleOptionCheck = (column) => {
+      const { customColumnList } = reactData;
+      const matchObj = index.default.findTree(customColumnList, (item) => item === column);
+      if (matchObj && matchObj.parent) {
+        const { parent } = matchObj;
+        if (parent.children && parent.children.length) {
+          parent.renderVisible = parent.children.every((column2) => column2.renderVisible);
+          parent.halfVisible = !parent.renderVisible && parent.children.some((column2) => column2.renderVisible || column2.halfVisible);
+          handleOptionCheck(parent);
+        }
+      }
+    };
+    const changeCheckboxOption = (column) => {
+      const isChecked = !column.renderVisible;
+      const customOpts = computeCustomOpts.value;
+      if (customOpts.immediate) {
+        index.default.eachTree([column], (item) => {
+          item.visible = isChecked;
+          item.renderVisible = isChecked;
+          item.halfVisible = false;
+        });
+        reactData.isCustomStatus = true;
+        $xeTable.handleCustom();
+        $xeTable.saveCustomStore("update:visible");
+      } else {
+        index.default.eachTree([column], (item) => {
+          item.renderVisible = isChecked;
+          item.halfVisible = false;
+        });
+      }
+      handleOptionCheck(column);
+      $xeTable.checkCustomStatus();
+    };
+    const changeColumnWidth = (column) => {
+      const customOpts = computeCustomOpts.value;
+      if (customOpts.immediate) {
+        if (column.renderResizeWidth !== column.renderWidth) {
+          column.resizeWidth = column.renderResizeWidth;
+          column.renderWidth = column.renderResizeWidth;
+          reactData.isCustomStatus = true;
+          $xeTable.handleCustom();
+          $xeTable.saveCustomStore("update:width");
+        }
+      }
+    };
+    const changeFixedOption = (column, colFixed) => {
+      const isMaxFixedColumn = computeIsMaxFixedColumn.value;
+      const customOpts = computeCustomOpts.value;
+      if (customOpts.immediate) {
+        if (column.renderFixed === colFixed) {
+          index.default.eachTree([column], (col) => {
+            col.fixed = "";
+            col.renderFixed = "";
+          });
+        } else {
+          if (!isMaxFixedColumn || column.renderFixed) {
+            index.default.eachTree([column], (col) => {
+              col.fixed = colFixed;
+              col.renderFixed = colFixed;
+            });
+          }
+        }
+        reactData.isCustomStatus = true;
+        $xeTable.handleCustom();
+        $xeTable.saveCustomStore("update:fixed");
+      } else {
+        if (column.renderFixed === colFixed) {
+          index.default.eachTree([column], (col) => {
+            col.renderFixed = "";
+          });
+        } else {
+          if (!isMaxFixedColumn || column.renderFixed) {
+            index.default.eachTree([column], (col) => {
+              col.renderFixed = colFixed;
+            });
+          }
+        }
+      }
+    };
+    const allOptionEvent = () => {
+      $xeTable.toggleCustomAllCheckbox();
+    };
+    const showDropTip = (evnt, optEl, showLine, dragPos) => {
+      const el = bodyElemRef.value;
+      if (!el) {
+        return;
+      }
+      const wrapperRect = el.getBoundingClientRect();
+      if (optEl) {
+        const dragLineEl = refDragLineElem.value;
+        if (dragLineEl) {
+          if (showLine) {
+            const optRect = optEl.getBoundingClientRect();
+            dragLineEl.style.display = "block";
+            dragLineEl.style.top = `${Math.max(1, optRect.y + el.scrollTop - wrapperRect.y)}px`;
+            dragLineEl.style.height = `${optRect.height}px`;
+            dragLineEl.style.width = `${optRect.width}px`;
+            dragLineEl.setAttribute("drag-pos", dragPos);
+            dragLineEl.setAttribute("drag-to-child", prevDragToChild ? "y" : "n");
+          } else {
+            dragLineEl.style.display = "";
+          }
+        }
+      }
+      const dragTipEl = refDragTipElem.value;
+      if (dragTipEl) {
+        dragTipEl.style.display = "block";
+        dragTipEl.style.top = `${Math.min(el.clientHeight + el.scrollTop - dragTipEl.clientHeight, evnt.clientY + el.scrollTop - wrapperRect.y)}px`;
+        dragTipEl.style.left = `${Math.min(el.clientWidth + el.scrollLeft - dragTipEl.clientWidth, evnt.clientX + el.scrollLeft - wrapperRect.x)}px`;
+        dragTipEl.setAttribute("drag-status", showLine ? prevDragToChild ? "sub" : "normal" : "disabled");
+      }
+    };
+    const hideDropTip = () => {
+      const dragTipEl = refDragTipElem.value;
+      const dragLineEl = refDragLineElem.value;
+      if (dragTipEl) {
+        dragTipEl.style.display = "";
+      }
+      if (dragLineEl) {
+        dragLineEl.style.display = "";
+      }
+    };
+    const sortMousedownEvent = (evnt) => {
+      const btnEl = evnt.currentTarget;
+      const cellEl = btnEl.parentElement;
+      const tdEl = cellEl.parentElement;
+      const trEl = tdEl.parentElement;
+      const colid = trEl.getAttribute("colid");
+      const column = $xeTable.getColumnById(colid);
+      trEl.draggable = true;
+      dragColumnRef.value = column;
+      dom.addClass(trEl, "active--drag-origin");
+    };
+    const sortMouseupEvent = (evnt) => {
+      const btnEl = evnt.currentTarget;
+      const cellEl = btnEl.parentElement;
+      const tdEl = cellEl.parentElement;
+      const trEl = tdEl.parentElement;
+      hideDropTip();
+      trEl.draggable = false;
+      dragColumnRef.value = null;
+      dom.removeClass(trEl, "active--drag-origin");
+    };
+    const sortDragstartEvent = (evnt) => {
+      if (evnt.dataTransfer) {
+        evnt.dataTransfer.setDragImage(dom.getTpImg(), 0, 0);
+      }
+    };
+    const sortDragendEvent = (evnt) => {
+      const { mouseConfig } = tableProps;
+      const { customColumnList } = reactData;
+      const { collectColumn } = internalData;
+      const customOpts = computeCustomOpts.value;
+      const { immediate } = customOpts;
+      const trEl = evnt.currentTarget;
+      const dragCol = dragColumnRef.value;
+      const columnDragOpts = computeColumnDragOpts.value;
+      const { isCrossDrag, isSelfToChildDrag, isToChildDrag, dragEndMethod } = columnDragOpts;
+      const dragOffsetIndex = prevDragPos === "bottom" ? 1 : 0;
+      if (prevDragCol && dragCol) {
+        if (prevDragCol !== dragCol) {
+          const dragColumn = dragCol;
+          const newColumn = prevDragCol;
+          Promise.resolve(dragEndMethod ? dragEndMethod({
+            oldColumn: dragColumn,
+            newColumn,
+            dragColumn,
+            dragPos: prevDragPos,
+            dragToChild: !!prevDragToChild,
+            offsetIndex: dragOffsetIndex
+          }) : true).then((status) => {
+            if (!status) {
+              return;
+            }
+            let oafIndex = -1;
+            let nafIndex = -1;
+            const oldAllMaps = {};
+            index.default.eachTree([dragColumn], (column) => {
+              oldAllMaps[column.id] = column;
+            });
+            let isSelfToChildStatus = false;
+            if (immediate) {
+              if (dragColumn.parentId && newColumn.parentId) {
+                if (!isCrossDrag) {
+                  return;
+                }
+                if (oldAllMaps[newColumn.id]) {
+                  isSelfToChildStatus = true;
+                  if (!(isCrossDrag && isSelfToChildDrag)) {
+                    if (index_esm.VxeUI.modal) {
+                      index_esm.VxeUI.modal.message({
+                        status: "error",
+                        content: getI18n("vxe.error.treeDragChild")
+                      });
+                    }
+                    return;
+                  }
+                }
+              } else if (dragColumn.parentId) {
+                if (!isCrossDrag) {
+                  return;
+                }
+              } else if (newColumn.parentId) {
+                if (!isCrossDrag) {
+                  return;
+                }
+                if (oldAllMaps[newColumn.id]) {
+                  isSelfToChildStatus = true;
+                  if (!(isCrossDrag && isSelfToChildDrag)) {
+                    if (index_esm.VxeUI.modal) {
+                      index_esm.VxeUI.modal.message({
+                        status: "error",
+                        content: getI18n("vxe.error.treeDragChild")
+                      });
+                    }
+                    return;
+                  }
+                }
+              } else ;
+              const oldewMatchRest = index.default.findTree(collectColumn, (item) => item.id === dragColumn.id);
+              if (isSelfToChildStatus && (isCrossDrag && isSelfToChildDrag)) {
+                if (oldewMatchRest) {
+                  const { items: oCols, index: oIndex } = oldewMatchRest;
+                  const childList = dragColumn.children || [];
+                  childList.forEach((column) => {
+                    column.parentId = dragColumn.parentId;
+                  });
+                  oCols.splice(oIndex, 1, ...childList);
+                  dragColumn.children = [];
+                }
+              } else {
+                if (oldewMatchRest) {
+                  const { items: oCols, index: oIndex, parent: oParent } = oldewMatchRest;
+                  oCols.splice(oIndex, 1);
+                  if (!oParent) {
+                    oafIndex = oIndex;
+                  }
+                }
+              }
+              const newMatchRest = index.default.findTree(collectColumn, (item) => item.id === newColumn.id);
+              if (newMatchRest) {
+                const { items: nCols, index: nIndex, parent: nParent } = newMatchRest;
+                if (isCrossDrag && isToChildDrag && prevDragToChild) {
+                  dragColumn.parentId = newColumn.id;
+                  newColumn.children = (newColumn.children || []).concat([dragColumn]);
+                } else {
+                  dragColumn.parentId = newColumn.parentId;
+                  nCols.splice(nIndex + dragOffsetIndex, 0, dragColumn);
+                }
+                if (!nParent) {
+                  nafIndex = nIndex;
+                }
+              }
+              index.default.eachTree(collectColumn, (column, index2, items, path, parent) => {
+                if (!parent) {
+                  const sortIndex = index2 + 1;
+                  column.renderSortNumber = sortIndex;
+                }
+              });
+            } else {
+              oafIndex = index.default.findIndexOf(customColumnList, (item) => item.id === dragColumn.id);
+              customColumnList.splice(oafIndex, 1);
+              nafIndex = index.default.findIndexOf(customColumnList, (item) => item.id === newColumn.id);
+              customColumnList.splice(nafIndex + dragOffsetIndex, 0, dragColumn);
+            }
+            reactData.isDragColMove = true;
+            if (mouseConfig) {
+              if ($xeTable.clearSelected) {
+                $xeTable.clearSelected();
+              }
+              if ($xeTable.clearCellAreas) {
+                $xeTable.clearCellAreas();
+                $xeTable.clearCopyCellArea();
+              }
+            }
+            $xeTable.dispatchEvent("column-dragend", {
+              oldColumn: dragColumn,
+              newColumn,
+              dragColumn,
+              dragPos: prevDragPos,
+              offsetIndex: dragOffsetIndex,
+              _index: {
+                newIndex: nafIndex,
+                oldIndex: oafIndex
+              }
+            }, evnt);
+            if (immediate) {
+              reactData.customColumnList = collectColumn.slice(0);
+              $xeTable.handleColDragSwapColumn();
+            }
+          }).catch(() => {
+          });
+        }
+      }
+      hideDropTip();
+      dragColumnRef.value = null;
+      trEl.draggable = false;
+      trEl.removeAttribute("drag-pos");
+      dom.removeClass(trEl, "active--drag-target");
+      dom.removeClass(trEl, "active--drag-origin");
+    };
+    const sortDragoverEvent = (evnt) => {
+      const customOpts = computeCustomOpts.value;
+      const { immediate } = customOpts;
+      const columnDragOpts = computeColumnDragOpts.value;
+      const { isCrossDrag, isToChildDrag } = columnDragOpts;
+      const optEl = evnt.currentTarget;
+      const isControlKey = dom.hasControlKey(evnt);
+      const colid = optEl.getAttribute("colid");
+      const column = $xeTable.getColumnById(colid);
+      const dragCol = dragColumnRef.value;
+      if (column && (isCrossDrag || column.level === 1)) {
+        evnt.preventDefault();
+        const offsetY = evnt.clientY - optEl.getBoundingClientRect().y;
+        const dragPos = offsetY < optEl.clientHeight / 2 ? "top" : "bottom";
+        if (dragCol && dragCol.id === column.id || !isCrossDrag && column.level > 1 || !immediate && column.level > 1 || column.renderFixed) {
+          showDropTip(evnt, optEl, false, dragPos);
+          return;
+        }
+        prevDragToChild = !!(isCrossDrag && isToChildDrag && isControlKey && immediate);
+        prevDragCol = column;
+        prevDragPos = dragPos;
+        showDropTip(evnt, optEl, true, dragPos);
+      }
+    };
+    const renderDragTip = () => {
+      const dragCol = dragColumnRef.value;
+      const columnDragOpts = computeColumnDragOpts.value;
+      return vue.h("div", {}, [
+        vue.h("div", {
+          ref: refDragLineElem,
+          class: ["vxe-table-custom-popup--drag-line", {
+            "is--guides": columnDragOpts.showGuidesStatus
+          }]
+        }),
+        vue.h("div", {
+          ref: refDragTipElem,
+          class: "vxe-table-custom-popup--drag-tip"
+        }, [
+          vue.h("div", {
+            class: "vxe-table-custom-popup--drag-tip-wrapper"
+          }, [
+            vue.h("div", {
+              class: "vxe-table-custom-popup--drag-tip-status"
+            }, [
+              vue.h("span", {
+                class: ["vxe-table-custom-popup--drag-tip-normal-status", getIcon().TABLE_DRAG_STATUS_ROW]
+              }),
+              vue.h("span", {
+                class: ["vxe-table-custom-popup--drag-tip-sub-status", getIcon().TABLE_DRAG_STATUS_SUB_ROW]
+              }),
+              vue.h("span", {
+                class: ["vxe-table-custom-popup--drag-tip-disabled-status", getIcon().TABLE_DRAG_DISABLED]
+              })
+            ]),
+            vue.h("div", {
+              class: "vxe-table-custom-popup--drag-tip-content"
+            }, getI18n("vxe.custom.cstmDragTarget", [dragCol && dragCol.type !== "html" ? dragCol.getTitle() : ""]))
+          ])
+        ])
+      ]);
+    };
+    const renderSimplePanel = () => {
+      const $xeGrid = $xeTable.xeGrid;
+      const { customStore } = props;
+      const { isCustomStatus, customColumnList } = reactData;
+      const customOpts = computeCustomOpts.value;
+      const { immediate } = customOpts;
+      const columnDragOpts = computeColumnDragOpts.value;
+      const { maxHeight } = customStore;
+      const { checkMethod, visibleMethod, allowVisible, allowSort, allowFixed, trigger, placement } = customOpts;
+      const isMaxFixedColumn = computeIsMaxFixedColumn.value;
+      const { isCrossDrag } = columnDragOpts;
+      const slots = customOpts.slots || {};
+      const headerSlot = slots.header;
+      const topSlot = slots.top;
+      const bottomSlot = slots.bottom;
+      const defaultSlot = slots.default;
+      const footerSlot = slots.footer;
+      const colVNs = [];
+      const customWrapperOns = {};
+      const isAllChecked = customStore.isAll;
+      const isAllIndeterminate = customStore.isIndeterminate;
+      if (trigger === "hover") {
+        customWrapperOns.onMouseenter = handleWrapperMouseenterEvent;
+        customWrapperOns.onMouseleave = handleWrapperMouseleaveEvent;
+      }
+      const params = {
+        $table: $xeTable,
+        $grid: $xeGrid,
+        columns: customColumnList,
+        isAllChecked,
+        isAllIndeterminate,
+        isCustomStatus
+      };
+      index.default.eachTree(customColumnList, (column, index2, items, path, parent) => {
+        const isVisible = visibleMethod ? visibleMethod({ $table: $xeTable, column }) : true;
+        if (isVisible) {
+          const isChecked = column.renderVisible;
+          const isIndeterminate = column.halfVisible;
+          const isColGroup = column.children && column.children.length;
+          const colTitle = utils.formatText(column.getTitle(), 1);
+          const isDisabled = checkMethod ? !checkMethod({ $table: $xeTable, column }) : false;
+          const isHidden = !isChecked;
+          colVNs.push(vue.h("li", {
+            key: column.id,
+            colid: column.id,
+            class: ["vxe-table-custom--option", `level--${column.level}`, {
+              "is--hidden": isDisabled || isHidden,
+              "is--group": isColGroup
+            }],
+            onDragstart: sortDragstartEvent,
+            onDragend: sortDragendEvent,
+            onDragover: sortDragoverEvent
+          }, [
+            allowVisible ? vue.h("div", {
+              class: ["vxe-table-custom--checkbox-option", {
+                "is--checked": isChecked,
+                "is--indeterminate": isIndeterminate,
+                "is--disabled": isDisabled
+              }],
+              title: getI18n("vxe.custom.setting.colVisible"),
+              onClick: () => {
+                if (!isDisabled) {
+                  changeCheckboxOption(column);
+                }
+              }
+            }, [
+              vue.h("span", {
+                class: ["vxe-checkbox--icon", isIndeterminate ? getIcon().TABLE_CHECKBOX_INDETERMINATE : isChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+              })
+            ]) : vue.createCommentVNode(),
+            vue.h("div", {
+              class: "vxe-table-custom--name-option"
+            }, [
+              allowSort && ((isCrossDrag ? immediate : false) || column.level === 1) ? vue.h("div", {
+                class: "vxe-table-custom--sort-option"
+              }, [
+                vue.h("span", Object.assign({ class: ["vxe-table-custom--sort-btn", {
+                  "is--disabled": isDisabled || isHidden || column.renderFixed
+                }], title: getI18n("vxe.custom.setting.sortHelpTip") }, isDisabled || isHidden || column.renderFixed ? {} : {
+                  onMousedown: sortMousedownEvent,
+                  onMouseup: sortMouseupEvent
+                }), [
+                  vue.h("i", {
+                    class: getIcon().TABLE_CUSTOM_SORT
+                  })
+                ])
+              ]) : vue.createCommentVNode(),
+              column.type === "html" ? vue.h("div", {
+                key: "1",
+                class: "vxe-table-custom--checkbox-label",
+                innerHTML: colTitle
+              }) : vue.h("div", {
+                key: "0",
+                class: "vxe-table-custom--checkbox-label"
+              }, colTitle)
+            ]),
+            !parent && allowFixed ? vue.h("div", {
+              class: "vxe-table-custom--fixed-option"
+            }, [
+              VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+                mode: "text",
+                icon: column.renderFixed === "left" ? getIcon().TOOLBAR_TOOLS_FIXED_LEFT_ACTIVE : getIcon().TOOLBAR_TOOLS_FIXED_LEFT,
+                status: column.renderFixed === "left" ? "primary" : "",
+                disabled: isDisabled || isHidden || isMaxFixedColumn && !column.renderFixed,
+                title: getI18n(column.renderFixed === "left" ? "vxe.toolbar.cancelFixed" : "vxe.toolbar.fixedLeft"),
+                onClick: () => {
+                  changeFixedOption(column, "left");
+                }
+              }) : vue.createCommentVNode(),
+              VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+                mode: "text",
+                icon: column.renderFixed === "right" ? getIcon().TOOLBAR_TOOLS_FIXED_RIGHT_ACTIVE : getIcon().TOOLBAR_TOOLS_FIXED_RIGHT,
+                status: column.renderFixed === "right" ? "primary" : "",
+                disabled: isDisabled || isHidden || isMaxFixedColumn && !column.renderFixed,
+                title: getI18n(column.renderFixed === "right" ? "vxe.toolbar.cancelFixed" : "vxe.toolbar.fixedRight"),
+                onClick: () => {
+                  changeFixedOption(column, "right");
+                }
+              }) : vue.createCommentVNode()
+            ]) : vue.createCommentVNode()
+          ]));
+        }
+      });
+      return vue.h("div", {
+        ref: refElem,
+        key: "simple",
+        class: ["vxe-table-custom-wrapper", `placement--${placement}`, {
+          "is--active": customStore.visible
+        }],
+        style: maxHeight && !["left", "right"].includes(placement) ? {
+          maxHeight: `${maxHeight}px`
+        } : {}
+      }, customStore.visible ? [
+        vue.h("div", {
+          class: "vxe-table-custom--header"
+        }, headerSlot ? $xeTable.callSlot(headerSlot, params) : [
+          vue.h("ul", {
+            class: "vxe-table-custom--panel-list"
+          }, [
+            vue.h("li", {
+              class: "vxe-table-custom--option"
+            }, [
+              allowVisible ? vue.h("div", {
+                class: ["vxe-table-custom--checkbox-option", {
+                  "is--checked": isAllChecked,
+                  "is--indeterminate": isAllIndeterminate
+                }],
+                title: getI18n("vxe.table.allTitle"),
+                onClick: allOptionEvent
+              }, [
+                vue.h("span", {
+                  class: ["vxe-checkbox--icon", isAllIndeterminate ? getIcon().TABLE_CHECKBOX_INDETERMINATE : isAllChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+                }),
+                vue.h("span", {
+                  class: "vxe-checkbox--label"
+                }, getI18n("vxe.toolbar.customAll"))
+              ]) : vue.h("span", {
+                class: "vxe-checkbox--label"
+              }, getI18n("vxe.table.customTitle"))
+            ])
+          ])
+        ]),
+        vue.h("div", {
+          ref: bodyElemRef,
+          class: "vxe-table-custom--body"
+        }, [
+          topSlot ? vue.h("div", {
+            class: "vxe-table-custom--panel-top"
+          }, $xeTable.callSlot(topSlot, params)) : renderEmptyElement($xeTable),
+          defaultSlot ? vue.h("div", {
+            class: "vxe-table-custom--panel-body"
+          }, $xeTable.callSlot(defaultSlot, params)) : vue.h(vue.TransitionGroup, Object.assign({ class: "vxe-table-custom--panel-list", name: "vxe-table-custom--list", tag: "ul" }, customWrapperOns), {
+            default: () => colVNs
+          }),
+          bottomSlot ? vue.h("div", {
+            class: "vxe-table-custom--panel-bottom"
+          }, $xeTable.callSlot(bottomSlot, params)) : renderEmptyElement($xeTable),
+          renderDragTip()
+        ]),
+        customOpts.showFooter ? vue.h("div", {
+          class: "vxe-table-custom--footer"
+        }, footerSlot ? $xeTable.callSlot(footerSlot, params) : [
+          vue.h("div", {
+            class: "vxe-table-custom--footer-buttons"
+          }, [
+            VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              mode: "text",
+              content: customOpts.resetButtonText || getI18n("vxe.table.customRestore"),
+              disabled: !isCustomStatus,
+              onClick: resetCustomEvent
+            }) : vue.createCommentVNode(),
+            immediate ? VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              mode: "text",
+              content: customOpts.closeButtonText || getI18n("vxe.table.customClose"),
+              onClick: cancelCloseEvent
+            }) : vue.createCommentVNode() : VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              mode: "text",
+              content: customOpts.cancelButtonText || getI18n("vxe.table.customCancel"),
+              onClick: cancelCustomEvent
+            }) : vue.createCommentVNode(),
+            immediate ? vue.createCommentVNode() : VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              mode: "text",
+              status: "primary",
+              content: customOpts.confirmButtonText || getI18n("vxe.table.customConfirm"),
+              onClick: confirmCustomEvent
+            }) : vue.createCommentVNode()
+          ])
+        ]) : null
+      ] : []);
+    };
+    const renderPopupPanel = () => {
+      const $xeGrid = $xeTable.xeGrid;
+      const { customStore } = props;
+      const { resizable: allResizable } = tableProps;
+      const { isCustomStatus, customColumnList } = reactData;
+      const customOpts = computeCustomOpts.value;
+      const { immediate } = customOpts;
+      const columnDragOpts = computeColumnDragOpts.value;
+      const { mode, modalOptions, drawerOptions, allowVisible, allowSort, allowFixed, allowResizable, checkMethod, visibleMethod } = customOpts;
+      const columnOpts = computeColumnOpts.value;
+      const { maxFixedSize } = columnOpts;
+      const resizableOpts = computeResizableOpts.value;
+      const { minWidth: reMinWidth, maxWidth: reMaxWidth } = resizableOpts;
+      const modalOpts = Object.assign({}, modalOptions);
+      const drawerOpts = Object.assign({}, drawerOptions);
+      const isMaxFixedColumn = computeIsMaxFixedColumn.value;
+      const { isCrossDrag } = columnDragOpts;
+      const slots = customOpts.slots || {};
+      const headerSlot = slots.header;
+      const topSlot = slots.top;
+      const bottomSlot = slots.bottom;
+      const defaultSlot = slots.default;
+      const footerSlot = slots.footer;
+      const trVNs = [];
+      const isAllChecked = customStore.isAll;
+      const isAllIndeterminate = customStore.isIndeterminate;
+      const params = {
+        $table: $xeTable,
+        $grid: $xeGrid,
+        columns: customColumnList,
+        isAllChecked,
+        isAllIndeterminate,
+        isCustomStatus
+      };
+      index.default.eachTree(customColumnList, (column, index$1, items, path, parent) => {
+        const isVisible = visibleMethod ? visibleMethod({ $table: $xeTable, column }) : true;
+        if (isVisible) {
+          let customMinWidth = 0;
+          let customMaxWidth = 0;
+          if (allowResizable) {
+            const resizeParams = {
+              $table: $xeTable,
+              column,
+              columnIndex: index$1,
+              $columnIndex: index$1,
+              $rowIndex: -1
+            };
+            if (reMinWidth) {
+              customMinWidth = index.default.toNumber(index.default.isFunction(reMinWidth) ? reMinWidth(resizeParams) : reMinWidth);
+            }
+            if (reMaxWidth) {
+              customMaxWidth = index.default.toNumber(index.default.isFunction(reMaxWidth) ? reMaxWidth(resizeParams) : reMaxWidth);
+            }
+          }
+          const isChecked = column.renderVisible;
+          const isIndeterminate = column.halfVisible;
+          const colTitle = utils.formatText(column.getTitle(), 1);
+          const isColGroup = column.children && column.children.length;
+          const isDisabled = checkMethod ? !checkMethod({ $table: $xeTable, column }) : false;
+          const isHidden = !isChecked;
+          trVNs.push(vue.h("tr", {
+            key: column.id,
+            colid: column.id,
+            class: [`vxe-table-custom-popup--row level--${column.level}`, {
+              "is--group": isColGroup
+            }],
+            onDragstart: sortDragstartEvent,
+            onDragend: sortDragendEvent,
+            onDragover: sortDragoverEvent
+          }, [
+            allowVisible ? vue.h("td", {
+              class: "vxe-table-custom-popup--column-item col--visible"
+            }, [
+              vue.h("div", {
+                class: ["vxe-table-custom--checkbox-option", {
+                  "is--checked": isChecked,
+                  "is--indeterminate": isIndeterminate,
+                  "is--disabled": isDisabled
+                }],
+                title: getI18n("vxe.custom.setting.colVisible"),
+                onClick: () => {
+                  if (!isDisabled) {
+                    changeCheckboxOption(column);
+                  }
+                }
+              }, [
+                vue.h("span", {
+                  class: ["vxe-checkbox--icon", isIndeterminate ? getIcon().TABLE_CHECKBOX_INDETERMINATE : isChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+                })
+              ])
+            ]) : vue.createCommentVNode(),
+            vue.h("td", {
+              class: "vxe-table-custom-popup--column-item col--name"
+            }, [
+              vue.h("div", {
+                class: "vxe-table-custom-popup--name"
+              }, [
+                allowSort ? (isCrossDrag ? immediate : false) || column.level === 1 ? vue.h("div", Object.assign({ class: ["vxe-table-custom-popup--column-sort-btn", {
+                  "is--disabled": isDisabled || isHidden || column.renderFixed
+                }], title: getI18n("vxe.custom.setting.sortHelpTip") }, isDisabled || isHidden || column.renderFixed ? {} : {
+                  onMousedown: sortMousedownEvent,
+                  onMouseup: sortMouseupEvent
+                }), [
+                  vue.h("i", {
+                    class: getIcon().TABLE_CUSTOM_SORT
+                  })
+                ]) : vue.h("div", {
+                  class: "vxe-table-custom-popup--column-sort-placeholder"
+                }) : vue.createCommentVNode(),
+                column.type === "html" ? vue.h("div", {
+                  key: "1",
+                  class: "vxe-table-custom-popup--title",
+                  innerHTML: colTitle
+                }) : vue.h("div", {
+                  key: "0",
+                  class: "vxe-table-custom-popup--title",
+                  title: colTitle
+                }, colTitle)
+              ])
+            ]),
+            allowResizable ? vue.h("td", {
+              class: "vxe-table-custom-popup--column-item col--resizable"
+            }, [
+              column.children && column.children.length || !(index.default.isBoolean(column.resizable) ? column.resizable : columnOpts.resizable || allResizable) ? vue.h("span", "-") : VxeUINumberInputComponent ? vue.h(VxeUINumberInputComponent, {
+                type: "integer",
+                immediate: false,
+                disabled: isDisabled || isHidden,
+                modelValue: column.renderResizeWidth,
+                min: customMinWidth || void 0,
+                max: customMaxWidth || void 0,
+                "onUpdate:modelValue"(value) {
+                  const width = Math.max(0, Number(value));
+                  column.renderResizeWidth = width;
+                },
+                onChange() {
+                  changeColumnWidth(column);
+                }
+              }) : vue.createCommentVNode()
+            ]) : vue.createCommentVNode(),
+            allowFixed ? vue.h("td", {
+              class: "vxe-table-custom-popup--column-item col--fixed"
+            }, [
+              parent ? vue.h("span", "-") : VxeUIRadioGroupComponent ? vue.h(VxeUIRadioGroupComponent, {
+                modelValue: column.renderFixed || "",
+                type: "button",
+                size: "mini",
+                disabled: isDisabled || isHidden,
+                options: [
+                  { label: getI18n("vxe.custom.setting.fixedLeft"), value: "left", disabled: isDisabled || isHidden || isMaxFixedColumn },
+                  { label: getI18n("vxe.custom.setting.fixedUnset"), value: "", disabled: isDisabled || isHidden },
+                  { label: getI18n("vxe.custom.setting.fixedRight"), value: "right", disabled: isDisabled || isHidden || isMaxFixedColumn }
+                ],
+                "onUpdate:modelValue"(value) {
+                  changeFixedOption(column, value);
+                }
+              }) : vue.createCommentVNode()
+            ]) : vue.createCommentVNode()
+          ]));
+        }
+      });
+      const scopedSlots = {
+        default: () => {
+          if (defaultSlot) {
+            return $xeTable.callSlot(defaultSlot, params);
+          }
+          return vue.h("div", {
+            ref: bodyElemRef,
+            class: "vxe-table-custom-popup--body"
+          }, [
+            topSlot ? vue.h("div", {
+              class: "vxe-table-custom-popup--table-top"
+            }, $xeTable.callSlot(topSlot, params)) : renderEmptyElement($xeTable),
+            vue.h("div", {
+              class: "vxe-table-custom-popup--table-wrapper"
+            }, [
+              vue.h("table", {}, [
+                vue.h("colgroup", {}, [
+                  allowVisible ? vue.h("col", {
+                    class: "vxe-table-custom-popup--table-col-seq"
+                  }) : vue.createCommentVNode(),
+                  vue.h("col", {
+                    class: "vxe-table-custom-popup--table-col-title"
+                  }),
+                  allowResizable ? vue.h("col", {
+                    class: "vxe-table-custom-popup--table-col-width"
+                  }) : vue.createCommentVNode(),
+                  allowFixed ? vue.h("col", {
+                    class: "vxe-table-custom-popup--table-col-fixed"
+                  }) : vue.createCommentVNode()
+                ]),
+                vue.h("thead", {}, [
+                  vue.h("tr", {}, [
+                    allowVisible ? vue.h("th", {}, [
+                      vue.h("div", {
+                        class: ["vxe-table-custom--checkbox-option", {
+                          "is--checked": isAllChecked,
+                          "is--indeterminate": isAllIndeterminate
+                        }],
+                        title: getI18n("vxe.table.allTitle"),
+                        onClick: allOptionEvent
+                      }, [
+                        vue.h("span", {
+                          class: ["vxe-checkbox--icon", isAllIndeterminate ? getIcon().TABLE_CHECKBOX_INDETERMINATE : isAllChecked ? getIcon().TABLE_CHECKBOX_CHECKED : getIcon().TABLE_CHECKBOX_UNCHECKED]
+                        }),
+                        vue.h("span", {
+                          class: "vxe-checkbox--label"
+                        }, getI18n("vxe.toolbar.customAll"))
+                      ])
+                    ]) : vue.createCommentVNode(),
+                    vue.h("th", {}, getI18n("vxe.custom.setting.colTitle")),
+                    allowResizable ? vue.h("th", {}, getI18n("vxe.custom.setting.colResizable")) : vue.createCommentVNode(),
+                    allowFixed ? vue.h("th", {}, getI18n(`vxe.custom.setting.${maxFixedSize ? "colFixedMax" : "colFixed"}`, [maxFixedSize])) : vue.createCommentVNode()
+                  ])
+                ]),
+                vue.h(vue.TransitionGroup, {
+                  class: "vxe-table-custom--panel-list",
+                  tag: "tbody",
+                  name: "vxe-table-custom--list"
+                }, {
+                  default: () => trVNs
+                })
+              ])
+            ]),
+            bottomSlot ? vue.h("div", {
+              class: "vxe-table-custom-popup--table-bottom"
+            }, $xeTable.callSlot(bottomSlot, params)) : renderEmptyElement($xeTable),
+            renderDragTip()
+          ]);
+        },
+        footer: () => {
+          if (footerSlot) {
+            return $xeTable.callSlot(footerSlot, params);
+          }
+          return vue.h("div", {
+            class: "vxe-table-custom-popup--footer"
+          }, [
+            VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              content: customOpts.resetButtonText || getI18n("vxe.custom.cstmRestore"),
+              disabled: !isCustomStatus,
+              onClick: resetCustomEvent
+            }) : vue.createCommentVNode(),
+            immediate ? VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              content: customOpts.closeButtonText || getI18n("vxe.table.customClose"),
+              onClick: cancelCloseEvent
+            }) : vue.createCommentVNode() : VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              content: customOpts.cancelButtonText || getI18n("vxe.table.customCancel"),
+              onClick: cancelCustomEvent
+            }) : vue.createCommentVNode(),
+            immediate ? vue.createCommentVNode() : VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
+              status: "primary",
+              content: customOpts.confirmButtonText || getI18n("vxe.custom.cstmConfirm"),
+              onClick: confirmCustomEvent
+            }) : vue.createCommentVNode()
+          ]);
+        }
+      };
+      if (headerSlot) {
+        scopedSlots.header = () => $xeTable.callSlot(headerSlot, params);
+      }
+      if (mode === "drawer") {
+        return VxeUIDrawerComponent ? vue.h(VxeUIDrawerComponent, {
+          key: "drawer",
+          className: ["vxe-table-custom-drawer-wrapper", "vxe-table--ignore-clear", drawerOpts.className || ""].join(" "),
+          modelValue: customStore.visible,
+          title: drawerOpts.title || getI18n("vxe.custom.cstmTitle"),
+          width: drawerOpts.width || Math.min(880, Math.floor(document.documentElement.clientWidth * 0.6)),
+          position: drawerOpts.position,
+          resize: !!drawerOpts.resize,
+          escClosable: !!drawerOpts.escClosable,
+          maskClosable: !!drawerOpts.maskClosable,
+          destroyOnClose: true,
+          showFooter: true,
+          "onUpdate:modelValue"(value) {
+            customStore.visible = value;
+          }
+        }, scopedSlots) : vue.createCommentVNode();
+      }
+      return VxeUIModalComponent ? vue.h(VxeUIModalComponent, {
+        key: "modal",
+        className: ["vxe-table-custom-modal-wrapper", "vxe-table--ignore-clear", modalOpts.className || ""].join(" "),
+        modelValue: customStore.visible,
+        title: modalOpts.title || getI18n("vxe.custom.cstmTitle"),
+        width: modalOpts.width || Math.min(880, document.documentElement.clientWidth),
+        minWidth: modalOpts.minWidth || 700,
+        height: modalOpts.height || Math.min(680, document.documentElement.clientHeight),
+        minHeight: modalOpts.minHeight || 400,
+        showZoom: modalOpts.showZoom,
+        showMaximize: modalOpts.showMaximize,
+        showMinimize: modalOpts.showMinimize,
+        mask: modalOpts.mask,
+        lockView: modalOpts.lockView,
+        resize: modalOpts.resize,
+        escClosable: !!modalOpts.escClosable,
+        maskClosable: !!modalOpts.maskClosable,
+        destroyOnClose: true,
+        showFooter: true,
+        "onUpdate:modelValue"(value) {
+          customStore.visible = value;
+        }
+      }, scopedSlots) : vue.createCommentVNode();
+    };
+    const renderVN = () => {
+      const customOpts = computeCustomOpts.value;
+      if (["modal", "drawer", "popup"].includes(`${customOpts.mode}`)) {
+        return renderPopupPanel();
+      }
+      return renderSimplePanel();
+    };
+    vue.nextTick(() => {
+      const customOpts = computeCustomOpts.value;
+      const { mode } = customOpts;
+      if (!VxeUIModalComponent && mode === "modal") {
+        log.errLog("vxe.error.reqComp", ["vxe-modal"]);
+      }
+      if (!VxeUIDrawerComponent && mode === "drawer") {
+        log.errLog("vxe.error.reqComp", ["vxe-drawer"]);
+      }
+      if (!VxeUIButtonComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-button"]);
+      }
+      if (!VxeUINumberInputComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-number-input"]);
+      }
+      if (!VxeUIRadioGroupComponent) {
+        log.errLog("vxe.error.reqComp", ["vxe-radio-group"]);
+      }
+    });
+    return renderVN;
+  }
+});
+exports.default = TableCustomPanelComponent;