@fecp/mobile 1.1.45 → 1.1.47

package/es/node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/index.mjs

@@ -0,0 +1,17 @@
+import "../ui/index.mjs";
+import VxeTableComponent from "./src/table.mjs";
+import { useCellView } from "./src/use/cell-view.mjs";
+import { VxeUI } from "../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.mjs";
+Object.assign({}, VxeTableComponent, {
+  install(app) {
+    app.component(VxeTableComponent.name, VxeTableComponent);
+  }
+});
+const tableHandle = {
+  useCellView
+};
+if (VxeUI.dynamicApp) {
+  VxeUI.dynamicApp.component(VxeTableComponent.name, VxeTableComponent);
+}
+VxeUI.component(VxeTableComponent);
+VxeUI.tableHandle = tableHandle;

package/es/node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/table/module/custom/hook.mjs

@@ -0,0 +1,320 @@
+import { nextTick } from "vue";
+import "../../../ui/index.mjs";
+import XEUtils from "../../../../../../../../../_virtual/index.mjs";
+import { getColumnList } from "../../src/util.mjs";
+import { VxeUI } from "../../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.mjs";
+const tableCustomMethodKeys = ["openCustom", "closeCustom", "toggleCustom", "saveCustom", "cancelCustom", "resetCustom", "toggleCustomAllCheckbox", "setCustomAllCheckbox"];
+VxeUI.hooks.add("tableCustomModule", {
+  setupTable($xeTable) {
+    const { reactData, internalData } = $xeTable;
+    const { computeCustomOpts, computeRowGroupFields } = $xeTable.getComputeMaps();
+    const { refElem } = $xeTable.getRefMaps();
+    const $xeGrid = $xeTable.xeGrid;
+    const $xeGantt = $xeTable.xeGantt;
+    const calcMaxHeight = () => {
+      const { customStore } = reactData;
+      let wrapperEl = refElem.value;
+      let tableHeight = 0;
+      if ($xeGantt) {
+        const { refGanttContainerElem } = $xeGantt.getRefMaps();
+        const ganttContainerElem = refGanttContainerElem.value;
+        if (ganttContainerElem) {
+          wrapperEl = ganttContainerElem;
+        }
+      }
+      if (wrapperEl) {
+        tableHeight = wrapperEl.clientHeight - 28;
+      }
+      customStore.maxHeight = Math.max(88, tableHeight);
+    };
+    const openCustom = () => {
+      const { initStore, customStore } = reactData;
+      customStore.visible = true;
+      initStore.custom = true;
+      handleUpdateCustomColumn();
+      checkCustomStatus();
+      calcMaxHeight();
+      return nextTick().then(() => calcMaxHeight());
+    };
+    const handleUpdateCustomColumn = () => {
+      const { customStore } = reactData;
+      const { collectColumn } = internalData;
+      if (customStore.visible) {
+        const sortMaps = {};
+        const fixedMaps = {};
+        const visibleMaps = {};
+        XEUtils.eachTree(collectColumn, (column) => {
+          const colid = column.getKey();
+          column.renderFixed = column.fixed;
+          column.renderVisible = column.visible;
+          column.renderResizeWidth = column.renderWidth;
+          sortMaps[colid] = column.renderSortNumber;
+          fixedMaps[colid] = column.fixed;
+          visibleMaps[colid] = column.visible;
+        });
+        customStore.oldSortMaps = sortMaps;
+        customStore.oldFixedMaps = fixedMaps;
+        customStore.oldVisibleMaps = visibleMaps;
+        reactData.customColumnList = collectColumn.slice(0);
+      }
+    };
+    const closeCustom = () => {
+      const { customStore } = reactData;
+      const customOpts = computeCustomOpts.value;
+      if (customStore.visible) {
+        customStore.visible = false;
+        if (!customOpts.immediate) {
+          $xeTable.handleCustom();
+        }
+      }
+      return nextTick();
+    };
+    const toggleCustom = () => {
+      const { customStore } = reactData;
+      if (customStore.visible) {
+        return closeCustom();
+      }
+      return openCustom();
+    };
+    const saveCustom = () => {
+      const { customColumnList, aggHandleFields, rowGroupList } = reactData;
+      const customOpts = computeCustomOpts.value;
+      const { allowVisible, allowSort, allowFixed, allowResizable, allowGroup, allowValues } = customOpts;
+      XEUtils.eachTree(customColumnList, (column, index, items, path, parentColumn) => {
+        if (parentColumn) {
+          column.fixed = parentColumn.fixed;
+        } else {
+          if (allowSort) {
+            const sortIndex = index + 1;
+            column.renderSortNumber = sortIndex;
+          }
+          if (allowFixed) {
+            column.fixed = column.renderFixed;
+          }
+        }
+        if (allowResizable) {
+          if (column.renderVisible && (!column.children || column.children.length)) {
+            if (column.renderResizeWidth !== column.renderWidth) {
+              column.resizeWidth = column.renderResizeWidth;
+              column.renderWidth = column.renderResizeWidth;
+            }
+          }
+        }
+        if (allowVisible) {
+          column.visible = column.renderVisible;
+        }
+        if (allowGroup && allowValues) {
+          column.aggFunc = column.renderAggFn;
+        }
+      });
+      reactData.isCustomStatus = true;
+      if (allowGroup && !!$xeTable.handlePivotTableAggregateData) {
+        if (rowGroupList.length !== aggHandleFields.length || rowGroupList.some((conf, i) => conf.field !== aggHandleFields[i])) {
+          if (aggHandleFields.length) {
+            $xeTable.setRowGroups(aggHandleFields);
+          } else {
+            $xeTable.clearRowGroups();
+          }
+        } else if (allowValues) {
+          $xeTable.handleUpdateAggData();
+        }
+      }
+      if (allowSort) {
+        internalData.collectColumn = customColumnList;
+      }
+      return $xeTable.saveCustomStore("confirm");
+    };
+    const cancelCustom = () => {
+      const { customColumnList, customStore } = reactData;
+      const { oldSortMaps, oldFixedMaps, oldVisibleMaps } = customStore;
+      const customOpts = computeCustomOpts.value;
+      const { allowVisible, allowSort, allowFixed, allowResizable } = customOpts;
+      XEUtils.eachTree(customColumnList, (column) => {
+        const colid = column.getKey();
+        const visible = !!oldVisibleMaps[colid];
+        const fixed = oldFixedMaps[colid] || "";
+        if (allowVisible) {
+          column.renderVisible = visible;
+          column.visible = visible;
+        }
+        if (allowFixed) {
+          column.renderFixed = fixed;
+          column.fixed = fixed;
+        }
+        if (allowSort) {
+          column.renderSortNumber = oldSortMaps[colid] || 0;
+        }
+        if (allowResizable) {
+          column.renderResizeWidth = column.renderWidth;
+        }
+      }, { children: "children" });
+      return nextTick();
+    };
+    const setCustomAllCheckbox = (checked) => {
+      const { customStore } = reactData;
+      const { customColumnList } = reactData;
+      const customOpts = computeCustomOpts.value;
+      const { checkMethod, visibleMethod } = customOpts;
+      const isAll = !!checked;
+      if (customOpts.immediate) {
+        XEUtils.eachTree(customColumnList, (column) => {
+          if (visibleMethod && !visibleMethod({ $table: $xeTable, column })) {
+            return;
+          }
+          if (checkMethod && !checkMethod({ $table: $xeTable, column })) {
+            return;
+          }
+          column.visible = isAll;
+          column.renderVisible = isAll;
+          column.halfVisible = false;
+        });
+        customStore.isAll = isAll;
+        reactData.isCustomStatus = true;
+        $xeTable.handleCustom();
+        $xeTable.saveCustomStore("update:visible");
+      } else {
+        XEUtils.eachTree(customColumnList, (column) => {
+          if (visibleMethod && !visibleMethod({ $table: $xeTable, column })) {
+            return;
+          }
+          if (checkMethod && !checkMethod({ $table: $xeTable, column })) {
+            return;
+          }
+          column.renderVisible = isAll;
+          column.halfVisible = false;
+        });
+        customStore.isAll = isAll;
+      }
+      $xeTable.checkCustomStatus();
+      return nextTick();
+    };
+    const customMethods = {
+      getCustomVisible() {
+        const { customStore } = reactData;
+        return customStore.visible;
+      },
+      openCustom,
+      closeCustom,
+      toggleCustom,
+      saveCustom,
+      cancelCustom,
+      resetCustom(options) {
+        const { rowGroupList } = reactData;
+        const { collectColumn } = internalData;
+        const customOpts = computeCustomOpts.value;
+        const { checkMethod } = customOpts;
+        const opts = Object.assign({
+          visible: true,
+          resizable: options === true,
+          fixed: options === true,
+          sort: options === true,
+          aggFunc: options === true
+        }, options);
+        const allCols = [];
+        XEUtils.eachTree(collectColumn, (column) => {
+          if (opts.resizable) {
+            column.resizeWidth = 0;
+          }
+          if (opts.fixed) {
+            column.fixed = column.defaultFixed;
+          }
+          if (opts.sort) {
+            column.renderSortNumber = column.sortNumber;
+            column.parentId = column.defaultParentId;
+          }
+          if (!checkMethod || checkMethod({ $table: $xeTable, column })) {
+            column.visible = column.defaultVisible;
+          }
+          if (opts.aggFunc) {
+            column.aggFunc = column.defaultAggFunc;
+            column.renderAggFn = column.defaultAggFunc;
+          }
+          column.renderResizeWidth = column.renderWidth;
+          allCols.push(column);
+        });
+        if (opts.sort) {
+          const newCollectCols = XEUtils.toArrayTree(XEUtils.orderBy(allCols, "renderSortNumber"), { key: "id", parentKey: "parentId", children: "children" });
+          internalData.collectColumn = newCollectCols;
+          internalData.tableFullColumn = getColumnList(newCollectCols);
+        }
+        reactData.isCustomStatus = false;
+        return $xeTable.handleCustom().then(() => {
+          if (opts.aggFunc && $xeTable.handlePivotTableAggregateData) {
+            const rowGroupFields = computeRowGroupFields.value;
+            if (rowGroupFields ? rowGroupFields.length : rowGroupList.length) {
+              if (rowGroupFields && rowGroupFields.length) {
+                $xeTable.setRowGroups(rowGroupFields);
+              } else {
+                $xeTable.clearRowGroups();
+              }
+            } else {
+              $xeTable.handleUpdateAggData();
+            }
+          }
+          $xeTable.saveCustomStore("reset");
+        });
+      },
+      toggleCustomAllCheckbox() {
+        const { customStore } = reactData;
+        const isAll = !customStore.isAll;
+        return setCustomAllCheckbox(isAll);
+      },
+      setCustomAllCheckbox
+    };
+    const checkCustomStatus = () => {
+      const { customStore } = reactData;
+      const { collectColumn } = internalData;
+      const customOpts = computeCustomOpts.value;
+      const { checkMethod } = customOpts;
+      customStore.isAll = collectColumn.every((column) => (checkMethod ? !checkMethod({ $table: $xeTable, column }) : false) || column.renderVisible);
+      customStore.isIndeterminate = !customStore.isAll && collectColumn.some((column) => (!checkMethod || checkMethod({ $table: $xeTable, column })) && (column.renderVisible || column.halfVisible));
+    };
+    const emitCustomEvent = (type, evnt) => {
+      const comp = $xeGrid || $xeGantt || $xeTable;
+      comp.dispatchEvent("custom", { type }, evnt);
+    };
+    const customPrivateMethods = {
+      checkCustomStatus,
+      emitCustomEvent,
+      triggerCustomEvent(evnt) {
+        const reactData2 = $xeTable.reactData;
+        const { customStore } = reactData2;
+        if (customStore.visible) {
+          closeCustom();
+          emitCustomEvent("close", evnt);
+        } else {
+          customStore.btnEl = evnt.target;
+          openCustom();
+          emitCustomEvent("open", evnt);
+        }
+      },
+      customOpenEvent(evnt) {
+        const reactData2 = $xeTable.reactData;
+        const { customStore } = reactData2;
+        if (!customStore.visible) {
+          customStore.activeBtn = true;
+          customStore.btnEl = evnt.target;
+          $xeTable.openCustom();
+          $xeTable.emitCustomEvent("open", evnt);
+        }
+      },
+      customCloseEvent(evnt) {
+        const reactData2 = $xeTable.reactData;
+        const { customStore } = reactData2;
+        if (customStore.visible) {
+          customStore.activeBtn = false;
+          $xeTable.closeCustom();
+          $xeTable.emitCustomEvent("close", evnt);
+        }
+      },
+      handleUpdateCustomColumn
+    };
+    return Object.assign(Object.assign({}, customMethods), customPrivateMethods);
+  },
+  setupGrid($xeGrid) {
+    return $xeGrid.extendTableMethods(tableCustomMethodKeys);
+  },
+  setupGantt($xeGantt) {
+    return $xeGantt.extendTableMethods(tableCustomMethodKeys);
+  }
+});