@fecp/mobile 1.1.53 → 1.1.55

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

@@ -0,0 +1,348 @@
+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";
+import { getFuncText } from "./src/utils.mjs";
+const version = "4.13.2";
+VxeUI.version = version;
+VxeUI.tableVersion = version;
+VxeUI.setConfig({
+  emptyCell: "　",
+  table: {
+    fit: true,
+    showHeader: true,
+    animat: true,
+    delayHover: 250,
+    autoResize: true,
+    minHeight: 144,
+    // keepSource: false,
+    // showOverflow: null,
+    // showHeaderOverflow: null,
+    // showFooterOverflow: null,
+    // resizeInterval: 500,
+    // size: null,
+    // zIndex: null,
+    // stripe: false,
+    // border: false,
+    // round: false,
+    // emptyText: '暂无数据',
+    // emptyRender: {
+    //   name: ''
+    // },
+    // rowConfig: {
+    //   keyField: '_X_ROW_KEY' // 行数据的唯一主键字段名
+    // },
+    resizeConfig: {
+      // refreshDelay: 20
+    },
+    resizableConfig: {
+      dragMode: "auto",
+      showDragTip: true,
+      isSyncAutoHeight: true,
+      isSyncAutoWidth: true,
+      minHeight: 18
+    },
+    radioConfig: {
+      // trigger: 'default'
+      strict: true
+    },
+    rowDragConfig: {
+      showIcon: true,
+      animation: true,
+      showGuidesStatus: true,
+      showDragTip: true
+    },
+    columnDragConfig: {
+      showIcon: true,
+      animation: true,
+      showGuidesStatus: true,
+      showDragTip: true
+    },
+    checkboxConfig: {
+      // trigger: 'default',
+      strict: true
+    },
+    tooltipConfig: {
+      enterable: true
+    },
+    validConfig: {
+      showMessage: true,
+      autoClear: true,
+      autoPos: true,
+      message: "inline",
+      msgMode: "single",
+      theme: "beautify"
+    },
+    columnConfig: {
+      maxFixedSize: 4
+    },
+    cellConfig: {
+      padding: true
+    },
+    headerCellConfig: {
+      height: "unset"
+    },
+    footerCellConfig: {
+      height: "unset"
+    },
+    // menuConfig: {
+    //   visibleMethod () {}
+    // },
+    customConfig: {
+      // enabled: false,
+      allowVisible: true,
+      allowResizable: true,
+      allowFixed: true,
+      allowSort: true,
+      showFooter: true,
+      placement: "top-right",
+      //  storage: false,
+      //  checkMethod () {},
+      modalOptions: {
+        showMaximize: true,
+        mask: true,
+        lockView: true,
+        resize: true,
+        escClosable: true
+      },
+      drawerOptions: {
+        mask: true,
+        lockView: true,
+        escClosable: true,
+        resize: true
+      }
+    },
+    sortConfig: {
+      // remote: false,
+      // trigger: 'default',
+      // orders: ['asc', 'desc', null],
+      // sortMethod: null,
+      showIcon: true,
+      allowClear: true,
+      allowBtn: true,
+      iconLayout: "vertical"
+    },
+    filterConfig: {
+      // remote: false,
+      // filterMethod: null,
+      // destroyOnClose: false,
+      // isEvery: false,
+      showIcon: true
+    },
+    treeConfig: {
+      rowField: "id",
+      parentField: "parentId",
+      childrenField: "children",
+      hasChildField: "hasChild",
+      mapChildrenField: "_X_ROW_CHILD",
+      indent: 20,
+      showIcon: true
+    },
+    expandConfig: {
+      // trigger: 'default',
+      showIcon: true,
+      mode: "fixed"
+    },
+    editConfig: {
+      // mode: 'cell',
+      showIcon: true,
+      showAsterisk: true,
+      autoFocus: true
+    },
+    importConfig: {
+      _typeMaps: {
+        csv: 1,
+        html: 1,
+        xml: 1,
+        txt: 1
+      }
+    },
+    exportConfig: {
+      _typeMaps: {
+        csv: 1,
+        html: 1,
+        xml: 1,
+        txt: 1
+      }
+    },
+    printConfig: {},
+    mouseConfig: {
+      extension: true
+    },
+    keyboardConfig: {
+      isEsc: true
+    },
+    areaConfig: {
+      autoClear: true,
+      selectCellByHeader: true,
+      selectCellByBody: true,
+      extendDirection: {
+        top: true,
+        left: true,
+        bottom: true,
+        right: true
+      }
+    },
+    clipConfig: {
+      isCopy: true,
+      isCut: true,
+      isPaste: true
+    },
+    fnrConfig: {
+      isFind: true,
+      isReplace: true
+    },
+    virtualXConfig: {
+      enabled: true,
+      gt: 28,
+      preSize: 1,
+      oSize: 0
+    },
+    virtualYConfig: {
+      enabled: true,
+      gt: 100,
+      preSize: 1,
+      oSize: 0
+    },
+    scrollbarConfig: {
+      // width: 0,
+      // height: 0
+    }
+  },
+  // export: {
+  //   types: {}
+  // },
+  grid: {
+    // size: null,
+    // zoomConfig: {
+    //   escRestore: true
+    // },
+    formConfig: {
+      enabled: true
+    },
+    pagerConfig: {
+      enabled: true
+      // perfect: false
+    },
+    toolbarConfig: {
+      enabled: true
+      // perfect: false
+    },
+    proxyConfig: {
+      enabled: true,
+      autoLoad: true,
+      showResponseMsg: true,
+      showActiveMsg: true,
+      props: {
+        list: null,
+        result: "result",
+        total: "page.total",
+        message: "message"
+      }
+      // beforeItem: null,
+      // beforeColumn: null,
+      // beforeQuery: null,
+      // afterQuery: null,
+      // beforeDelete: null,
+      // afterDelete: null,
+      // beforeSave: null,
+      // afterSave: null
+    }
+  },
+  toolbar: {
+    // size: null,
+    // import: {
+    //   mode: 'covering'
+    // },
+    // export: {
+    //   types: ['csv', 'html', 'xml', 'txt']
+    // },
+    // buttons: []
+  }
+});
+const iconPrefix = "vxe-table-icon-";
+VxeUI.setIcon({
+  // table
+  TABLE_SORT_ASC: iconPrefix + "caret-up",
+  TABLE_SORT_DESC: iconPrefix + "caret-down",
+  TABLE_FILTER_NONE: iconPrefix + "funnel",
+  TABLE_FILTER_MATCH: iconPrefix + "funnel",
+  TABLE_EDIT: iconPrefix + "edit",
+  TABLE_TITLE_PREFIX: iconPrefix + "question-circle-fill",
+  TABLE_TITLE_SUFFIX: iconPrefix + "question-circle-fill",
+  TABLE_TREE_LOADED: iconPrefix + "spinner roll",
+  TABLE_TREE_OPEN: iconPrefix + "caret-right rotate90",
+  TABLE_TREE_CLOSE: iconPrefix + "caret-right",
+  TABLE_EXPAND_LOADED: iconPrefix + "spinner roll",
+  TABLE_EXPAND_OPEN: iconPrefix + "arrow-right rotate90",
+  TABLE_EXPAND_CLOSE: iconPrefix + "arrow-right",
+  TABLE_CHECKBOX_CHECKED: iconPrefix + "checkbox-checked-fill",
+  TABLE_CHECKBOX_UNCHECKED: iconPrefix + "checkbox-unchecked",
+  TABLE_CHECKBOX_INDETERMINATE: iconPrefix + "checkbox-indeterminate-fill",
+  TABLE_RADIO_CHECKED: iconPrefix + "radio-checked-fill",
+  TABLE_RADIO_UNCHECKED: iconPrefix + "radio-unchecked",
+  TABLE_CUSTOM_SORT: iconPrefix + "drag-handle",
+  TABLE_MENU_OPTIONS: iconPrefix + "arrow-right",
+  TABLE_DRAG_ROW: iconPrefix + "drag-handle",
+  TABLE_DRAG_COLUMN: iconPrefix + "drag-handle",
+  TABLE_DRAG_STATUS_ROW: iconPrefix + "sort",
+  TABLE_DRAG_STATUS_SUB_ROW: iconPrefix + "add-sub",
+  TABLE_DRAG_STATUS_COLUMN: iconPrefix + "swap",
+  TABLE_DRAG_DISABLED: iconPrefix + "no-drop",
+  // toolbar
+  TOOLBAR_TOOLS_REFRESH: iconPrefix + "repeat",
+  TOOLBAR_TOOLS_REFRESH_LOADING: iconPrefix + "repeat roll",
+  TOOLBAR_TOOLS_IMPORT: iconPrefix + "upload",
+  TOOLBAR_TOOLS_EXPORT: iconPrefix + "download",
+  TOOLBAR_TOOLS_PRINT: iconPrefix + "print",
+  TOOLBAR_TOOLS_FULLSCREEN: iconPrefix + "fullscreen",
+  TOOLBAR_TOOLS_MINIMIZE: iconPrefix + "minimize",
+  TOOLBAR_TOOLS_CUSTOM: iconPrefix + "custom-column",
+  TOOLBAR_TOOLS_FIXED_LEFT: iconPrefix + "fixed-left",
+  TOOLBAR_TOOLS_FIXED_LEFT_ACTIVE: iconPrefix + "fixed-left-fill",
+  TOOLBAR_TOOLS_FIXED_RIGHT: iconPrefix + "fixed-right",
+  TOOLBAR_TOOLS_FIXED_RIGHT_ACTIVE: iconPrefix + "fixed-right-fill"
+});
+VxeUI.setTheme;
+VxeUI.getTheme;
+VxeUI.setConfig;
+VxeUI.getConfig;
+VxeUI.setIcon;
+VxeUI.getIcon;
+VxeUI.setLanguage;
+VxeUI.setI18n;
+VxeUI.getI18n;
+VxeUI.globalEvents;
+VxeUI.globalResize;
+VxeUI.renderer;
+VxeUI.validators;
+VxeUI.menus;
+VxeUI.formats;
+VxeUI.commands;
+VxeUI.interceptor;
+VxeUI.clipboard;
+VxeUI.log;
+VxeUI.hooks;
+VxeUI.use;
+const setup = (options) => {
+  return VxeUI.setConfig(options);
+};
+VxeUI.setup = setup;
+const config = (options) => {
+  return VxeUI.setConfig(options);
+};
+VxeUI.config = config;
+const t = (key, args) => {
+  return VxeUI.getI18n(key, args);
+};
+VxeUI.t = t;
+const _t = (content, args) => {
+  return getFuncText(content, args);
+};
+VxeUI._t = _t;
+export {
+  VxeUI,
+  _t,
+  config,
+  VxeUI as default,
+  setup,
+  t,
+  version
+};

package/es/node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/ui/src/dom.mjs

@@ -0,0 +1,165 @@
+import XEUtils from "../../../../../../../../_virtual/index.mjs";
+const reClsMap = {};
+let tpImgEl;
+function initTpImg() {
+  if (!tpImgEl) {
+    tpImgEl = new Image();
+    tpImgEl.src = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNkYAAAAAYAAjCB0C8AAAAASUVORK5CYII=";
+  }
+  return tpImgEl;
+}
+function getTpImg() {
+  if (!tpImgEl) {
+    return initTpImg();
+  }
+  return tpImgEl;
+}
+function getPropClass(property, params) {
+  return property ? XEUtils.isFunction(property) ? property(params) : property : "";
+}
+function getClsRE(cls) {
+  if (!reClsMap[cls]) {
+    reClsMap[cls] = new RegExp(`(?:^|\\s)${cls}(?!\\S)`, "g");
+  }
+  return reClsMap[cls];
+}
+function getNodeOffset(elem, container, rest) {
+  if (elem) {
+    const parentElem = elem.parentNode;
+    rest.top += elem.offsetTop;
+    rest.left += elem.offsetLeft;
+    if (parentElem && parentElem !== document.documentElement && parentElem !== document.body) {
+      rest.top -= parentElem.scrollTop;
+      rest.left -= parentElem.scrollLeft;
+    }
+    if (container && (elem === container || elem.offsetParent === container) ? 0 : elem.offsetParent) {
+      return getNodeOffset(elem.offsetParent, container, rest);
+    }
+  }
+  return rest;
+}
+function isPx(val) {
+  return val && /^\d+(px)?$/.test(val);
+}
+function isScale(val) {
+  return val && /^\d+%$/.test(val);
+}
+function hasClass(elem, cls) {
+  return elem && elem.className && elem.className.match && elem.className.match(getClsRE(cls));
+}
+function removeClass(elem, cls) {
+  if (elem && hasClass(elem, cls)) {
+    elem.className = elem.className.replace(getClsRE(cls), "");
+  }
+}
+function addClass(elem, cls) {
+  if (elem && !hasClass(elem, cls)) {
+    removeClass(elem, cls);
+    elem.className = `${elem.className} ${cls}`;
+  }
+}
+function toCssUnit(val, unit = "px") {
+  if (XEUtils.isNumber(val) || /^\d+$/.test(`${val}`)) {
+    return `${val}${unit}`;
+  }
+  return `${val || ""}`;
+}
+function getDomNode() {
+  const documentElement = document.documentElement;
+  const bodyElem = document.body;
+  return {
+    scrollTop: documentElement.scrollTop || bodyElem.scrollTop,
+    scrollLeft: documentElement.scrollLeft || bodyElem.scrollLeft,
+    visibleHeight: documentElement.clientHeight || bodyElem.clientHeight,
+    visibleWidth: documentElement.clientWidth || bodyElem.clientWidth
+  };
+}
+function getOffsetHeight(elem) {
+  return elem ? elem.offsetHeight : 0;
+}
+function getPaddingTopBottomSize(elem) {
+  if (elem) {
+    const computedStyle = getComputedStyle(elem);
+    const paddingTop = XEUtils.toNumber(computedStyle.paddingTop);
+    const paddingBottom = XEUtils.toNumber(computedStyle.paddingBottom);
+    return paddingTop + paddingBottom;
+  }
+  return 0;
+}
+function setScrollTop(elem, scrollTop) {
+  if (elem) {
+    elem.scrollTop = scrollTop;
+  }
+}
+function setScrollLeft(elem, scrollLeft) {
+  if (elem) {
+    elem.scrollLeft = scrollLeft;
+  }
+}
+function updateCellTitle(overflowElem, column) {
+  const content = column.type === "html" ? overflowElem.innerText : overflowElem.textContent;
+  if (overflowElem.getAttribute("title") !== content) {
+    overflowElem.setAttribute("title", content);
+  }
+}
+function getEventTargetNode(evnt, container, queryCls, queryMethod) {
+  let targetElem;
+  let target = evnt.target.shadowRoot && evnt.composed ? evnt.composedPath()[0] || evnt.target : evnt.target;
+  while (target && target.nodeType && target !== document) {
+    if (queryCls && hasClass(target, queryCls) && (!queryMethod || queryMethod(target))) {
+      targetElem = target;
+    } else if (target === container) {
+      return { flag: queryCls ? !!targetElem : true, container, targetElem };
+    }
+    target = target.parentNode;
+  }
+  return { flag: false };
+}
+function getOffsetPos(elem, container) {
+  return getNodeOffset(elem, container, { left: 0, top: 0 });
+}
+function getAbsolutePos(elem) {
+  const bounding = elem.getBoundingClientRect();
+  const boundingTop = bounding.top;
+  const boundingLeft = bounding.left;
+  const { scrollTop, scrollLeft, visibleHeight, visibleWidth } = getDomNode();
+  return { boundingTop, top: scrollTop + boundingTop, boundingLeft, left: scrollLeft + boundingLeft, visibleHeight, visibleWidth };
+}
+const scrollIntoViewIfNeeded = "scrollIntoViewIfNeeded";
+const scrollIntoView = "scrollIntoView";
+function scrollToView(elem) {
+  if (elem) {
+    if (elem[scrollIntoViewIfNeeded]) {
+      elem[scrollIntoViewIfNeeded]();
+    } else if (elem[scrollIntoView]) {
+      elem[scrollIntoView]();
+    }
+  }
+}
+function triggerEvent(targetElem, type) {
+  if (targetElem) {
+    targetElem.dispatchEvent(new Event(type));
+  }
+}
+export {
+  addClass,
+  getAbsolutePos,
+  getDomNode,
+  getEventTargetNode,
+  getOffsetHeight,
+  getOffsetPos,
+  getPaddingTopBottomSize,
+  getPropClass,
+  getTpImg,
+  hasClass,
+  initTpImg,
+  isPx,
+  isScale,
+  removeClass,
+  scrollToView,
+  setScrollLeft,
+  setScrollTop,
+  toCssUnit,
+  triggerEvent,
+  updateCellTitle
+};

package/es/node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/ui/src/log.mjs

@@ -0,0 +1,9 @@
+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 { log } = VxeUI;
+const version = `table v${"4.13.2"}`;
+const warnLog = log.create("warn", version);
+const errLog = log.create("error", version);
+export {
+  errLog,
+  warnLog
+};

package/es/node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/ui/src/utils.mjs

@@ -0,0 +1,49 @@
+import XEUtils from "../../../../../../../../_virtual/index.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";
+import DomZIndex from "../../../../../../dom-zindex@1.0.6/node_modules/dom-zindex/es/index.esm.mjs";
+function isEnableConf(conf) {
+  return conf && conf.enabled !== false;
+}
+function isEmptyValue(cellValue) {
+  return cellValue === null || cellValue === void 0 || cellValue === "";
+}
+function parseFile(file) {
+  const name = file.name;
+  const tIndex = XEUtils.lastIndexOf(name, ".");
+  const type = name.substring(tIndex + 1, name.length).toLowerCase();
+  const filename = name.substring(0, tIndex);
+  return { filename, type };
+}
+function nextZIndex() {
+  return DomZIndex.getNext();
+}
+function getLastZIndex() {
+  return DomZIndex.getCurrent();
+}
+function hasChildrenList(item) {
+  return item && item.children && item.children.length > 0;
+}
+function getFuncText(content, args) {
+  if (content) {
+    const translate = VxeUI.getConfig().translate;
+    return XEUtils.toValueString(translate ? translate("" + content, args) : content);
+  }
+  return "";
+}
+function formatText(value, placeholder) {
+  return "" + (isEmptyValue(value) ? placeholder ? VxeUI.getConfig().emptyCell : "" : value);
+}
+function eqEmptyValue(cellValue) {
+  return cellValue === "" || XEUtils.eqNull(cellValue);
+}
+export {
+  eqEmptyValue,
+  formatText,
+  getFuncText,
+  getLastZIndex,
+  hasChildrenList,
+  isEmptyValue,
+  isEnableConf,
+  nextZIndex,
+  parseFile
+};

package/es/node_modules/.pnpm/vxe-table@4.13.2_vue@3.5.13_typescript@5.7.3_/node_modules/vxe-table/es/ui/src/vn.mjs

@@ -0,0 +1,42 @@
+import XEUtils from "../../../../../../../../_virtual/index.mjs";
+function getOnName(type) {
+  return "on" + type.substring(0, 1).toLocaleUpperCase() + type.substring(1);
+}
+function getModelEvent(renderOpts) {
+  switch (renderOpts.name) {
+    case "input":
+    case "textarea":
+      return "input";
+    case "select":
+      return "change";
+  }
+  return "update:modelValue";
+}
+function getChangeEvent(renderOpts) {
+  switch (renderOpts.name) {
+    case "input":
+    case "textarea":
+    case "VxeInput":
+    case "VxeNumberInput":
+    case "VxeTextarea":
+    case "$input":
+    case "$textarea":
+      return "input";
+  }
+  return "change";
+}
+function getSlotVNs(vns) {
+  if (vns === null || vns === void 0) {
+    return [];
+  }
+  if (XEUtils.isArray(vns)) {
+    return vns;
+  }
+  return [vns];
+}
+export {
+  getChangeEvent,
+  getModelEvent,
+  getOnName,
+  getSlotVNs
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/add.mjs

@@ -0,0 +1,18 @@
+import { __require as requireHelperNumberAdd } from "./helperNumberAdd.mjs";
+import { __require as requireToNumber } from "./toNumber.mjs";
+var add_1;
+var hasRequiredAdd;
+function requireAdd() {
+  if (hasRequiredAdd) return add_1;
+  hasRequiredAdd = 1;
+  var helperNumberAdd = requireHelperNumberAdd();
+  var toNumber = requireToNumber();
+  function add(num1, num2) {
+    return helperNumberAdd(toNumber(num1), toNumber(num2));
+  }
+  add_1 = add;
+  return add_1;
+}
+export {
+  requireAdd as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/after.mjs

@@ -0,0 +1,27 @@
+import { __require as requireSlice } from "./slice.mjs";
+var after_1;
+var hasRequiredAfter;
+function requireAfter() {
+  if (hasRequiredAfter) return after_1;
+  hasRequiredAfter = 1;
+  var slice = requireSlice();
+  function after(count, callback, context) {
+    var runCount = 0;
+    var rests = [];
+    return function() {
+      var args = arguments;
+      runCount++;
+      if (runCount <= count) {
+        rests.push(args[0]);
+      }
+      if (runCount >= count) {
+        callback.apply(context, [rests].concat(slice(args)));
+      }
+    };
+  }
+  after_1 = after;
+  return after_1;
+}
+export {
+  requireAfter as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/arrayEach.mjs

@@ -0,0 +1,22 @@
+var arrayEach_1;
+var hasRequiredArrayEach;
+function requireArrayEach() {
+  if (hasRequiredArrayEach) return arrayEach_1;
+  hasRequiredArrayEach = 1;
+  function arrayEach(list, iterate, context) {
+    if (list) {
+      if (list.forEach) {
+        list.forEach(iterate, context);
+      } else {
+        for (var index = 0, len = list.length; index < len; index++) {
+          iterate.call(context, list[index], index, list);
+        }
+      }
+    }
+  }
+  arrayEach_1 = arrayEach;
+  return arrayEach_1;
+}
+export {
+  requireArrayEach as __require
+};

package/es/node_modules/.pnpm/xe-utils@3.7.9/node_modules/xe-utils/arrayIndexOf.mjs

@@ -0,0 +1,21 @@
+var arrayIndexOf_1;
+var hasRequiredArrayIndexOf;
+function requireArrayIndexOf() {
+  if (hasRequiredArrayIndexOf) return arrayIndexOf_1;
+  hasRequiredArrayIndexOf = 1;
+  function arrayIndexOf(list, val) {
+    if (list.indexOf) {
+      return list.indexOf(val);
+    }
+    for (var index = 0, len = list.length; index < len; index++) {
+      if (val === list[index]) {
+        return index;
+      }
+    }
+  }
+  arrayIndexOf_1 = arrayIndexOf;
+  return arrayIndexOf_1;
+}
+export {
+  requireArrayIndexOf as __require
+};