@fecp/mobile 1.1.48 → 1.1.50

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

@@ -1,13 +0,0 @@
-"use strict";
-require("../ui/index.js");
-const toolbar = require("./src/toolbar.js");
-const index_esm = require("../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
-Object.assign({}, toolbar.default, {
-  install(app) {
-    app.component(toolbar.default.name, toolbar.default);
-  }
-});
-if (index_esm.VxeUI.dynamicApp) {
-  index_esm.VxeUI.dynamicApp.component(toolbar.default.name, toolbar.default);
-}
-index_esm.VxeUI.component(toolbar.default);

package/lib/node_modules/.pnpm/vxe-table@4.17.0_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/toolbar/src/toolbar.js

@@ -1,577 +0,0 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const vue = require("vue");
-const comp = require("../../ui/src/comp.js");
-const index = require("../../../../../../../../_virtual/index.js");
-require("../../ui/index.js");
-const vn = require("../../ui/src/vn.js");
-const log = require("../../ui/src/log.js");
-const index_esm = require("../../../../../../@vxe-ui_core@4.2.12_vue@3.5.13_typescript@5.7.3_/node_modules/@vxe-ui/core/es/index.esm.js");
-const { getConfig, getIcon, getI18n, renderer, commands, createEvent, useFns } = index_esm.VxeUI;
-function createInternalData() {
-  return {
-    connectTable: null
-  };
-}
-const VxeToolbarComponent = comp.defineVxeComponent({
-  name: "VxeToolbar",
-  props: {
-    loading: Boolean,
-    refresh: [Boolean, Object],
-    refreshOptions: Object,
-    import: [Boolean, Object],
-    importOptions: Object,
-    export: [Boolean, Object],
-    exportOptions: Object,
-    print: [Boolean, Object],
-    printOptions: Object,
-    zoom: [Boolean, Object],
-    zoomOptions: Object,
-    custom: [Boolean, Object],
-    customOptions: Object,
-    buttons: {
-      type: Array,
-      default: () => getConfig().toolbar.buttons
-    },
-    tools: {
-      type: Array,
-      default: () => getConfig().toolbar.tools
-    },
-    perfect: {
-      type: Boolean,
-      default: () => getConfig().toolbar.perfect
-    },
-    size: {
-      type: String,
-      default: () => getConfig().toolbar.size || getConfig().size
-    },
-    className: [String, Function]
-  },
-  emits: [
-    "button-click",
-    "tool-click"
-  ],
-  setup(props, context) {
-    const { slots, emit } = context;
-    const xID = index.default.uniqueId();
-    const VxeUIButtonComponent = index_esm.VxeUI.getComponent("VxeButton");
-    const $xeGrid = vue.inject("$xeGrid", null);
-    const $xeGantt = vue.inject("$xeGantt", null);
-    const $xeGGWrapper = $xeGrid || $xeGantt;
-    const { computeSize } = useFns.useSize(props);
-    const reactData = vue.reactive({
-      isRefresh: false,
-      connectFlag: 0,
-      columns: []
-    });
-    const internalData = createInternalData();
-    const refElem = vue.ref();
-    const refMaps = {
-      refElem
-    };
-    const $xeToolbar = {
-      xID,
-      props,
-      context,
-      reactData,
-      internalData,
-      getRefMaps: () => refMaps
-    };
-    let toolbarMethods = {};
-    const computeRefreshOpts = vue.computed(() => {
-      return Object.assign({}, index.default.clone(getConfig().toolbar.refresh, true), props.refreshOptions, props.refresh);
-    });
-    const computeImportOpts = vue.computed(() => {
-      return Object.assign({}, index.default.clone(getConfig().toolbar.import, true), props.importOptions, props.import);
-    });
-    const computeExportOpts = vue.computed(() => {
-      return Object.assign({}, index.default.clone(getConfig().toolbar.export, true), props.exportOptions, props.export);
-    });
-    const computePrintOpts = vue.computed(() => {
-      return Object.assign({}, index.default.clone(getConfig().toolbar.print, true), props.printOptions, props.print);
-    });
-    const computeZoomOpts = vue.computed(() => {
-      return Object.assign({}, index.default.clone(getConfig().toolbar.zoom, true), props.zoomOptions, props.zoom);
-    });
-    const computeCustomOpts = vue.computed(() => {
-      return Object.assign({}, index.default.clone(getConfig().toolbar.custom, true), props.customOptions, props.custom);
-    });
-    const computeTableCustomOpts = vue.computed(() => {
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      if (reactData.connectFlag || $table) {
-        if ($table) {
-          const { computeCustomOpts: computeCustomOpts2 } = $table.getComputeMaps();
-          return computeCustomOpts2.value;
-        }
-      }
-      return { trigger: "" };
-    });
-    const computeTrigger = vue.computed(() => {
-      const tableCustomOpts = computeTableCustomOpts.value;
-      return tableCustomOpts.trigger;
-    });
-    const checkTable = () => {
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      if ($table) {
-        return true;
-      }
-      log.errLog("vxe.error.barUnableLink");
-    };
-    const handleClickSettingEvent = ({ $event }) => {
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      if ($table) {
-        if ($table.triggerCustomEvent) {
-          $table.triggerCustomEvent($event);
-        }
-      }
-    };
-    const handleMouseenterSettingEvent = ({ $event }) => {
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      if ($table) {
-        $table.customOpenEvent($event);
-      }
-    };
-    const handleMouseleaveSettingEvent = ({ $event }) => {
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      if ($table) {
-        const { customStore } = $table.reactData;
-        customStore.activeBtn = false;
-        setTimeout(() => {
-          if (!customStore.activeBtn && !customStore.activeWrapper) {
-            $table.customCloseEvent($event);
-          }
-        }, 350);
-      }
-    };
-    const refreshEvent = ({ $event }) => {
-      const { isRefresh } = reactData;
-      const refreshOpts = computeRefreshOpts.value;
-      if (!isRefresh) {
-        const queryMethod = refreshOpts.queryMethod || refreshOpts.query;
-        if (queryMethod) {
-          reactData.isRefresh = true;
-          try {
-            Promise.resolve(queryMethod({})).catch((e) => e).then(() => {
-              reactData.isRefresh = false;
-            });
-          } catch (e) {
-            reactData.isRefresh = false;
-          }
-        } else if ($xeGGWrapper) {
-          reactData.isRefresh = true;
-          $xeGGWrapper.triggerToolbarCommitEvent({ code: refreshOpts.code || "reload" }, $event).catch(() => {
-          }).then(() => {
-            reactData.isRefresh = false;
-          });
-        }
-      }
-    };
-    const zoomEvent = ({ $event }) => {
-      if ($xeGGWrapper) {
-        $xeGGWrapper.triggerZoomEvent($event);
-      } else {
-        log.warnLog("vxe.error.notProp", ["[toolbar] zoom"]);
-      }
-    };
-    const importEvent = () => {
-      if (checkTable()) {
-        const { connectTable } = internalData;
-        const $table = connectTable;
-        if ($table) {
-          $table.importData();
-        }
-      }
-    };
-    const openImportEvent = () => {
-      if (checkTable()) {
-        const { connectTable } = internalData;
-        const $table = connectTable;
-        if ($table) {
-          $table.openImport();
-        }
-      }
-    };
-    const exportEvent = () => {
-      if (checkTable()) {
-        const { connectTable } = internalData;
-        const $table = connectTable;
-        if ($table) {
-          $table.exportData();
-        }
-      }
-    };
-    const openExportEvent = () => {
-      if (checkTable()) {
-        const { connectTable } = internalData;
-        const $table = connectTable;
-        if ($table) {
-          $table.openExport();
-        }
-      }
-    };
-    const printEvent = () => {
-      if (checkTable()) {
-        const { connectTable } = internalData;
-        const $table = connectTable;
-        if ($table) {
-          $table.print();
-        }
-      }
-    };
-    const openPrintEvent = () => {
-      if (checkTable()) {
-        const { connectTable } = internalData;
-        const $table = connectTable;
-        if ($table) {
-          $table.openPrint();
-        }
-      }
-    };
-    const handleDefaultCodeEvent = (eventParams, item, cb) => {
-      switch (item.code) {
-        case "print":
-          printEvent();
-          break;
-        case "open_print":
-          openPrintEvent();
-          break;
-        case "custom":
-          handleClickSettingEvent(eventParams);
-          break;
-        case "export":
-          exportEvent();
-          break;
-        case "open_export":
-          openExportEvent();
-          break;
-        case "import":
-          importEvent();
-          break;
-        case "open_import":
-          openImportEvent();
-          break;
-        case "zoom":
-          zoomEvent(eventParams);
-          break;
-        case "refresh":
-          refreshEvent(eventParams);
-          break;
-        default:
-          cb();
-          break;
-      }
-    };
-    const btnEvent = (eventParams, item) => {
-      const { $event } = eventParams;
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      const { code } = item;
-      if (code) {
-        handleDefaultCodeEvent(eventParams, item, () => {
-          if ($xeGGWrapper) {
-            $xeGGWrapper.triggerToolbarBtnEvent(item, $event);
-          } else {
-            const gCommandOpts = commands.get(code);
-            const params = { code, button: item, $table, $grid: $xeGrid, $gantt: $xeGantt, $event };
-            if (gCommandOpts) {
-              const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
-              if (tCommandMethod) {
-                tCommandMethod(params);
-              } else {
-                log.errLog("vxe.error.notCommands", [`[toolbar] ${code}`]);
-              }
-            }
-            $xeToolbar.dispatchEvent("button-click", params, $event);
-          }
-        });
-      }
-    };
-    const tolEvent = (eventParams, item) => {
-      const { $event } = eventParams;
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      const { code } = item;
-      if (code) {
-        handleDefaultCodeEvent(eventParams, item, () => {
-          if ($xeGGWrapper) {
-            $xeGGWrapper.triggerToolbarTolEvent(item, $event);
-          } else {
-            const gCommandOpts = commands.get(code);
-            const params = { code, button: null, tool: item, $table, $grid: $xeGrid, $gantt: $xeGantt, $event };
-            if (gCommandOpts) {
-              const tCommandMethod = gCommandOpts.tableCommandMethod || gCommandOpts.commandMethod;
-              if (tCommandMethod) {
-                tCommandMethod(params);
-              } else {
-                log.errLog("vxe.error.notCommands", [`[toolbar] ${code}`]);
-              }
-            }
-            $xeToolbar.dispatchEvent("tool-click", params, $event);
-          }
-        });
-      }
-    };
-    const dispatchEvent = (type, params, evnt) => {
-      emit(type, createEvent(evnt, { $toolbar: $xeToolbar }, params));
-    };
-    toolbarMethods = {
-      dispatchEvent,
-      syncUpdate(params) {
-        internalData.connectTable = params.$table;
-        reactData.columns = params.collectColumn;
-        reactData.connectFlag++;
-      }
-    };
-    Object.assign($xeToolbar, toolbarMethods);
-    const renderDropdowns = (item, isBtn) => {
-      const { dropdowns } = item;
-      const downVNs = [];
-      if (dropdowns) {
-        return dropdowns.map((child, index2) => {
-          if (child.visible === false) {
-            return vue.createCommentVNode();
-          }
-          return VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, Object.assign(Object.assign({ key: index2 }, Object.assign({}, child, {
-            content: child.name,
-            options: void 0
-          })), { onClick: (eventParams) => isBtn ? btnEvent(eventParams, child) : tolEvent(eventParams, child) })) : vue.createCommentVNode();
-        });
-      }
-      return downVNs;
-    };
-    const renderLeftBtns = () => {
-      const { buttons } = props;
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      const buttonPrefixSlot = slots.buttonPrefix || slots["button-prefix"];
-      const buttonSuffixSlot = slots.buttonSuffix || slots["button-suffix"];
-      const btnVNs = [];
-      if (buttonPrefixSlot) {
-        btnVNs.push(...vn.getSlotVNs(buttonPrefixSlot({ buttons: buttons || [], $grid: $xeGrid, $gantt: $xeGantt, $table })));
-      }
-      if (buttons) {
-        buttons.forEach((item, index$1) => {
-          const { dropdowns, buttonRender } = item;
-          if (item.visible !== false) {
-            const compConf = buttonRender ? renderer.get(buttonRender.name) : null;
-            if (buttonRender && compConf && compConf.renderToolbarButton) {
-              const toolbarButtonClassName = compConf.toolbarButtonClassName;
-              const params = { $grid: $xeGrid, $gantt: $xeGantt, $table, button: item };
-              btnVNs.push(vue.h("span", {
-                key: `br${item.code || index$1}`,
-                class: ["vxe-button--item", toolbarButtonClassName ? index.default.isFunction(toolbarButtonClassName) ? toolbarButtonClassName(params) : toolbarButtonClassName : ""]
-              }, vn.getSlotVNs(compConf.renderToolbarButton(buttonRender, params))));
-            } else {
-              if (VxeUIButtonComponent) {
-                btnVNs.push(vue.h(VxeUIButtonComponent, Object.assign(Object.assign({ key: `bd${item.code || index$1}` }, Object.assign({}, item, {
-                  content: item.name,
-                  options: void 0
-                })), { onClick: (eventParams) => btnEvent(eventParams, item) }), dropdowns && dropdowns.length ? {
-                  dropdowns: () => renderDropdowns(item, true)
-                } : {}));
-              }
-            }
-          }
-        });
-      }
-      if (buttonSuffixSlot) {
-        btnVNs.push(...vn.getSlotVNs(buttonSuffixSlot({ buttons: buttons || [], $grid: $xeGrid, $gantt: $xeGantt, $table })));
-      }
-      return btnVNs;
-    };
-    const renderRightTools = () => {
-      const { tools } = props;
-      const { connectTable } = internalData;
-      const $table = connectTable;
-      const toolPrefixSlot = slots.toolPrefix || slots["tool-prefix"];
-      const toolSuffixSlot = slots.toolSuffix || slots["tool-suffix"];
-      const btnVNs = [];
-      if (toolPrefixSlot) {
-        btnVNs.push(...vn.getSlotVNs(toolPrefixSlot({ tools: tools || [], $grid: $xeGrid, $gantt: $xeGantt, $table })));
-      }
-      if (tools) {
-        tools.forEach((item, tIndex) => {
-          const { dropdowns, toolRender } = item;
-          if (item.visible !== false) {
-            const rdName = toolRender ? toolRender.name : null;
-            const compConf = toolRender ? renderer.get(rdName) : null;
-            if (toolRender && compConf && compConf.renderToolbarTool) {
-              const toolbarToolClassName = compConf.toolbarToolClassName;
-              const params = { $grid: $xeGrid, $gantt: $xeGantt, $table, tool: item };
-              btnVNs.push(vue.h("span", {
-                key: rdName,
-                class: ["vxe-tool--item", toolbarToolClassName ? index.default.isFunction(toolbarToolClassName) ? toolbarToolClassName(params) : toolbarToolClassName : ""]
-              }, vn.getSlotVNs(compConf.renderToolbarTool(toolRender, params))));
-            } else {
-              if (VxeUIButtonComponent) {
-                btnVNs.push(vue.h(VxeUIButtonComponent, Object.assign(Object.assign({ key: tIndex }, Object.assign({}, item, {
-                  content: item.name,
-                  options: void 0
-                })), { onClick: (eventParams) => tolEvent(eventParams, item) }), dropdowns && dropdowns.length ? {
-                  dropdowns: () => renderDropdowns(item, false)
-                } : {}));
-              }
-            }
-          }
-        });
-      }
-      if (toolSuffixSlot) {
-        btnVNs.push(...vn.getSlotVNs(toolSuffixSlot({ tools: tools || [], $grid: $xeGrid, $gantt: $xeGantt, $table })));
-      }
-      return btnVNs;
-    };
-    const renderToolImport = () => {
-      const importOpts = computeImportOpts.value;
-      return VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
-        key: "import",
-        circle: true,
-        icon: importOpts.icon || getIcon().TOOLBAR_TOOLS_IMPORT,
-        title: getI18n("vxe.toolbar.import"),
-        onClick: openImportEvent
-      }) : vue.createCommentVNode();
-    };
-    const renderToolExport = () => {
-      const exportOpts = computeExportOpts.value;
-      return VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
-        key: "export",
-        circle: true,
-        icon: exportOpts.icon || getIcon().TOOLBAR_TOOLS_EXPORT,
-        title: getI18n("vxe.toolbar.export"),
-        onClick: openExportEvent
-      }) : vue.createCommentVNode();
-    };
-    const renderToolPrint = () => {
-      const printOpts = computePrintOpts.value;
-      return VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
-        key: "print",
-        circle: true,
-        icon: printOpts.icon || getIcon().TOOLBAR_TOOLS_PRINT,
-        title: getI18n("vxe.toolbar.print"),
-        onClick: openPrintEvent
-      }) : vue.createCommentVNode();
-    };
-    const renderToolRefresh = () => {
-      const refreshOpts = computeRefreshOpts.value;
-      return VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
-        key: "refresh",
-        circle: true,
-        icon: reactData.isRefresh ? refreshOpts.iconLoading || getIcon().TOOLBAR_TOOLS_REFRESH_LOADING : refreshOpts.icon || getIcon().TOOLBAR_TOOLS_REFRESH,
-        title: getI18n("vxe.toolbar.refresh"),
-        onClick: refreshEvent
-      }) : vue.createCommentVNode();
-    };
-    const renderToolZoom = () => {
-      const zoomOpts = computeZoomOpts.value;
-      return $xeGGWrapper && VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, {
-        key: "zoom",
-        circle: true,
-        icon: $xeGGWrapper.isMaximized() ? zoomOpts.iconOut || getIcon().TOOLBAR_TOOLS_MINIMIZE : zoomOpts.iconIn || getIcon().TOOLBAR_TOOLS_FULLSCREEN,
-        title: getI18n(`vxe.toolbar.zoom${$xeGGWrapper.isMaximized() ? "Out" : "In"}`),
-        onClick: zoomEvent
-      }) : vue.createCommentVNode();
-    };
-    const renderToolCustom = () => {
-      const customOpts = computeCustomOpts.value;
-      const btnTrigger = computeTrigger.value;
-      const customBtnOns = {};
-      if (btnTrigger === "manual") ;
-      else if (btnTrigger === "hover") {
-        customBtnOns.onMouseenter = handleMouseenterSettingEvent;
-        customBtnOns.onMouseleave = handleMouseleaveSettingEvent;
-      } else {
-        customBtnOns.onClick = handleClickSettingEvent;
-      }
-      return VxeUIButtonComponent ? vue.h(VxeUIButtonComponent, Object.assign({ key: "custom", circle: true, icon: customOpts.icon || getIcon().TOOLBAR_TOOLS_CUSTOM, title: getI18n("vxe.toolbar.custom"), className: "vxe-toolbar-custom-target" }, customBtnOns)) : vue.createCommentVNode();
-    };
-    const renderVN = () => {
-      const { perfect, loading, refresh, zoom, custom, className } = props;
-      const { connectTable } = internalData;
-      const vSize = computeSize.value;
-      const toolsSlot = slots.tools;
-      const buttonsSlot = slots.buttons;
-      const $table = connectTable;
-      return vue.h("div", {
-        ref: refElem,
-        class: ["vxe-toolbar", className ? index.default.isFunction(className) ? className({ $toolbar: $xeToolbar }) : className : "", {
-          [`size--${vSize}`]: vSize,
-          "is--perfect": perfect,
-          "is--loading": loading
-        }]
-      }, [
-        vue.h("div", {
-          class: "vxe-buttons--wrapper"
-        }, buttonsSlot ? buttonsSlot({ $grid: $xeGrid, $gantt: $xeGantt, $table }) : renderLeftBtns()),
-        vue.h("div", {
-          class: "vxe-tools--wrapper"
-        }, toolsSlot ? toolsSlot({ $grid: $xeGrid, $gantt: $xeGantt, $table }) : renderRightTools()),
-        vue.h("div", {
-          class: "vxe-tools--operate"
-        }, [
-          props.import ? renderToolImport() : vue.createCommentVNode(),
-          props.export ? renderToolExport() : vue.createCommentVNode(),
-          props.print ? renderToolPrint() : vue.createCommentVNode(),
-          refresh ? renderToolRefresh() : vue.createCommentVNode(),
-          zoom && $xeGGWrapper ? renderToolZoom() : vue.createCommentVNode(),
-          custom ? renderToolCustom() : vue.createCommentVNode()
-        ])
-      ]);
-    };
-    $xeToolbar.renderVN = renderVN;
-    vue.nextTick(() => {
-      const refreshOpts = computeRefreshOpts.value;
-      const queryMethod = refreshOpts.queryMethod || refreshOpts.query;
-      if (props.refresh && !$xeGGWrapper && !queryMethod) {
-        log.warnLog("vxe.error.notFunc", ["[toolbar] queryMethod"]);
-      }
-      if (index.default.isPlainObject(props.custom)) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] custom={...}", "custom=boolean & custom-options={...}"]);
-      }
-      if (index.default.isPlainObject(props.print)) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] print={...}", "print=boolean & print-options={...}"]);
-      }
-      if (index.default.isPlainObject(props.export)) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] export={...}", "export=boolean & export-options={...}"]);
-      }
-      if (index.default.isPlainObject(props.import)) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] import={...}", "import=boolean & import-options={...}"]);
-      }
-      if (index.default.isPlainObject(props.refresh)) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] refresh={...}", "refresh=boolean & refresh-options={...}"]);
-      }
-      if (index.default.isPlainObject(props.refresh)) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] zoom={...}", "zoom=boolean & zoom-options={...}"]);
-      }
-      const customOpts = computeCustomOpts.value;
-      if (customOpts.isFooter) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] toolbar.custom.isFooter", "table.custom-config.showFooter"]);
-      }
-      if (customOpts.showFooter) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] toolbar.custom.showFooter", "table.custom-config.showFooter"]);
-      }
-      if (customOpts.immediate) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] toolbar.custom.immediate", "table.custom-config.immediate"]);
-      }
-      if (customOpts.trigger) {
-        log.warnLog("vxe.error.delProp", ["[toolbar] toolbar.custom.trigger", "table.custom-config.trigger"]);
-      }
-      if (props.refresh || props.import || props.export || props.print || props.zoom) {
-        if (!VxeUIButtonComponent) {
-          log.errLog("vxe.error.reqComp", ["vxe-button"]);
-        }
-      }
-    });
-    vue.onUnmounted(() => {
-      index.default.assign(internalData, createInternalData());
-    });
-    return $xeToolbar;
-  },
-  render() {
-    return this.renderVN();
-  }
-});
-exports.default = VxeToolbarComponent;