@fecp/designer 5.4.100 → 5.4.104

package/lib/packages/mobile/node_modules/@vant/touch-emulator/dist/index.js

@@ -0,0 +1,129 @@
+"use strict";
+(function() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  var eventTarget;
+  var supportTouch = "ontouchstart" in window;
+  if (!document.createTouch) {
+    document.createTouch = function(view, target, identifier, pageX, pageY, screenX, screenY) {
+      return new Touch(
+        target,
+        identifier,
+        {
+          pageX,
+          pageY,
+          screenX,
+          screenY,
+          clientX: pageX - window.pageXOffset,
+          clientY: pageY - window.pageYOffset
+        },
+        0,
+        0
+      );
+    };
+  }
+  if (!document.createTouchList) {
+    document.createTouchList = function() {
+      var touchList = TouchList();
+      for (var i = 0; i < arguments.length; i++) {
+        touchList[i] = arguments[i];
+      }
+      touchList.length = arguments.length;
+      return touchList;
+    };
+  }
+  if (!Element.prototype.matches) {
+    Element.prototype.matches = Element.prototype.msMatchesSelector || Element.prototype.webkitMatchesSelector;
+  }
+  if (!Element.prototype.closest) {
+    Element.prototype.closest = function(s) {
+      var el = this;
+      do {
+        if (el.matches(s)) return el;
+        el = el.parentElement || el.parentNode;
+      } while (el !== null && el.nodeType === 1);
+      return null;
+    };
+  }
+  var Touch = function Touch2(target, identifier, pos, deltaX, deltaY) {
+    deltaX = deltaX || 0;
+    deltaY = deltaY || 0;
+    this.identifier = identifier;
+    this.target = target;
+    this.clientX = pos.clientX + deltaX;
+    this.clientY = pos.clientY + deltaY;
+    this.screenX = pos.screenX + deltaX;
+    this.screenY = pos.screenY + deltaY;
+    this.pageX = pos.pageX + deltaX;
+    this.pageY = pos.pageY + deltaY;
+  };
+  function TouchList() {
+    var touchList = [];
+    touchList["item"] = function(index) {
+      return this[index] || null;
+    };
+    touchList["identifiedTouch"] = function(id) {
+      return this[id + 1] || null;
+    };
+    return touchList;
+  }
+  var initiated = false;
+  function onMouse(touchType) {
+    return function(ev) {
+      if (ev.type === "mousedown") {
+        initiated = true;
+      }
+      if (ev.type === "mouseup") {
+        initiated = false;
+      }
+      if (ev.type === "mousemove" && !initiated) {
+        return;
+      }
+      if (ev.type === "mousedown" || !eventTarget || eventTarget && !eventTarget.dispatchEvent) {
+        eventTarget = ev.composed ? ev.composedPath()[0] : ev.target;
+      }
+      if (eventTarget.closest("[data-no-touch-simulate]") == null) {
+        triggerTouch(touchType, ev);
+      }
+      if (ev.type === "mouseup") {
+        eventTarget = null;
+      }
+    };
+  }
+  function triggerTouch(eventName, mouseEv) {
+    var touchEvent = new Event(eventName, {
+      bubbles: true,
+      cancelable: true,
+      composed: true
+    });
+    touchEvent.altKey = mouseEv.altKey;
+    touchEvent.ctrlKey = mouseEv.ctrlKey;
+    touchEvent.metaKey = mouseEv.metaKey;
+    touchEvent.shiftKey = mouseEv.shiftKey;
+    touchEvent.touches = getActiveTouches(mouseEv);
+    touchEvent.targetTouches = getActiveTouches(mouseEv);
+    touchEvent.changedTouches = createTouchList(mouseEv);
+    eventTarget.dispatchEvent(touchEvent);
+  }
+  function createTouchList(mouseEv) {
+    var touchList = TouchList();
+    touchList.push(new Touch(eventTarget, 1, mouseEv, 0, 0));
+    return touchList;
+  }
+  function getActiveTouches(mouseEv) {
+    if (mouseEv.type === "mouseup") {
+      return TouchList();
+    }
+    return createTouchList(mouseEv);
+  }
+  function TouchEmulator() {
+    window.addEventListener("mousedown", onMouse("touchstart"), true);
+    window.addEventListener("mousemove", onMouse("touchmove"), true);
+    window.addEventListener("mouseup", onMouse("touchend"), true);
+  }
+  TouchEmulator["multiTouchOffset"] = 75;
+  if (!supportTouch) {
+    new TouchEmulator();
+  }
+})();

package/lib/packages/mobile/node_modules/@vant/use/dist/index.esm.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vue = require("vue");
+var inBrowser = typeof window !== "undefined";
+function raf(fn) {
+  return inBrowser ? requestAnimationFrame(fn) : -1;
+}
+function cancelRaf(id) {
+  if (inBrowser) {
+    cancelAnimationFrame(id);
+  }
+}
+function doubleRaf(fn) {
+  raf(() => raf(fn));
+}
+var isWindow = (val) => val === window;
+var makeDOMRect = (width2, height2) => ({
+  top: 0,
+  left: 0,
+  right: width2,
+  bottom: height2,
+  width: width2,
+  height: height2
+});
+var useRect = (elementOrRef) => {
+  const element = vue.unref(elementOrRef);
+  if (isWindow(element)) {
+    const width2 = element.innerWidth;
+    const height2 = element.innerHeight;
+    return makeDOMRect(width2, height2);
+  }
+  if (element == null ? void 0 : element.getBoundingClientRect) {
+    return element.getBoundingClientRect();
+  }
+  return makeDOMRect(0, 0);
+};
+function useToggle(defaultValue = false) {
+  const state = vue.ref(defaultValue);
+  const toggle = (value = !state.value) => {
+    state.value = value;
+  };
+  return [state, toggle];
+}
+function useParent(key) {
+  const parent = vue.inject(key, null);
+  if (parent) {
+    const instance = vue.getCurrentInstance();
+    const { link, unlink, internalChildren } = parent;
+    link(instance);
+    vue.onUnmounted(() => unlink(instance));
+    const index = vue.computed(() => internalChildren.indexOf(instance));
+    return {
+      parent,
+      index
+    };
+  }
+  return {
+    parent: null,
+    index: vue.ref(-1)
+  };
+}
+function flattenVNodes(children) {
+  const result = [];
+  const traverse = (children2) => {
+    if (Array.isArray(children2)) {
+      children2.forEach((child) => {
+        var _a;
+        if (vue.isVNode(child)) {
+          result.push(child);
+          if ((_a = child.component) == null ? void 0 : _a.subTree) {
+            result.push(child.component.subTree);
+            traverse(child.component.subTree.children);
+          }
+          if (child.children) {
+            traverse(child.children);
+          }
+        }
+      });
+    }
+  };
+  traverse(children);
+  return result;
+}
+var findVNodeIndex = (vnodes, vnode) => {
+  const index = vnodes.indexOf(vnode);
+  if (index === -1) {
+    return vnodes.findIndex(
+      (item) => vnode.key !== void 0 && vnode.key !== null && item.type === vnode.type && item.key === vnode.key
+    );
+  }
+  return index;
+};
+function sortChildren(parent, publicChildren, internalChildren) {
+  const vnodes = flattenVNodes(parent.subTree.children);
+  internalChildren.sort(
+    (a, b) => findVNodeIndex(vnodes, a.vnode) - findVNodeIndex(vnodes, b.vnode)
+  );
+  const orderedPublicChildren = internalChildren.map((item) => item.proxy);
+  publicChildren.sort((a, b) => {
+    const indexA = orderedPublicChildren.indexOf(a);
+    const indexB = orderedPublicChildren.indexOf(b);
+    return indexA - indexB;
+  });
+}
+function useChildren(key) {
+  const publicChildren = vue.reactive([]);
+  const internalChildren = vue.reactive([]);
+  const parent = vue.getCurrentInstance();
+  const linkChildren = (value) => {
+    const link = (child) => {
+      if (child.proxy) {
+        internalChildren.push(child);
+        publicChildren.push(child.proxy);
+        sortChildren(parent, publicChildren, internalChildren);
+      }
+    };
+    const unlink = (child) => {
+      const index = internalChildren.indexOf(child);
+      publicChildren.splice(index, 1);
+      internalChildren.splice(index, 1);
+    };
+    vue.provide(
+      key,
+      Object.assign(
+        {
+          link,
+          unlink,
+          children: publicChildren,
+          internalChildren
+        },
+        value
+      )
+    );
+  };
+  return {
+    children: publicChildren,
+    linkChildren
+  };
+}
+function onMountedOrActivated(hook) {
+  let mounted;
+  vue.onMounted(() => {
+    hook();
+    vue.nextTick(() => {
+      mounted = true;
+    });
+  });
+  vue.onActivated(() => {
+    if (mounted) {
+      hook();
+    }
+  });
+}
+function useEventListener(type, listener, options = {}) {
+  if (!inBrowser) {
+    return;
+  }
+  const { target = window, passive = false, capture = false } = options;
+  let cleaned = false;
+  let attached;
+  const add = (target2) => {
+    if (cleaned) {
+      return;
+    }
+    const element = vue.unref(target2);
+    if (element && !attached) {
+      element.addEventListener(type, listener, {
+        capture,
+        passive
+      });
+      attached = true;
+    }
+  };
+  const remove = (target2) => {
+    if (cleaned) {
+      return;
+    }
+    const element = vue.unref(target2);
+    if (element && attached) {
+      element.removeEventListener(type, listener, capture);
+      attached = false;
+    }
+  };
+  vue.onUnmounted(() => remove(target));
+  vue.onDeactivated(() => remove(target));
+  onMountedOrActivated(() => add(target));
+  let stopWatch;
+  if (vue.isRef(target)) {
+    stopWatch = vue.watch(target, (val, oldVal) => {
+      remove(oldVal);
+      add(val);
+    });
+  }
+  return () => {
+    stopWatch == null ? void 0 : stopWatch();
+    remove(target);
+    cleaned = true;
+  };
+}
+function useClickAway(target, listener, options = {}) {
+  if (!inBrowser) {
+    return;
+  }
+  const { eventName = "click" } = options;
+  const onClick = (event) => {
+    const targets = Array.isArray(target) ? target : [target];
+    const isClickAway = targets.every((item) => {
+      const element = vue.unref(item);
+      return element && !element.contains(event.target);
+    });
+    if (isClickAway) {
+      listener(event);
+    }
+  };
+  useEventListener(eventName, onClick, { target: document });
+}
+var width;
+var height;
+function useWindowSize() {
+  if (!width) {
+    width = vue.ref(0);
+    height = vue.ref(0);
+    if (inBrowser) {
+      const update = () => {
+        width.value = window.innerWidth;
+        height.value = window.innerHeight;
+      };
+      update();
+      window.addEventListener("resize", update, { passive: true });
+      window.addEventListener("orientationchange", update, { passive: true });
+    }
+  }
+  return { width, height };
+}
+var overflowScrollReg = /scroll|auto|overlay/i;
+var defaultRoot = inBrowser ? window : void 0;
+function isElement(node) {
+  const ELEMENT_NODE_TYPE = 1;
+  return node.tagName !== "HTML" && node.tagName !== "BODY" && node.nodeType === ELEMENT_NODE_TYPE;
+}
+function getScrollParent(el, root = defaultRoot) {
+  let node = el;
+  while (node && node !== root && isElement(node)) {
+    const { overflowY } = window.getComputedStyle(node);
+    if (overflowScrollReg.test(overflowY)) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return root;
+}
+function useScrollParent(el, root = defaultRoot) {
+  const scrollParent = vue.ref();
+  vue.onMounted(() => {
+    if (el.value) {
+      scrollParent.value = getScrollParent(el.value, root);
+    }
+  });
+  return scrollParent;
+}
+var visibility;
+function usePageVisibility() {
+  if (!visibility) {
+    visibility = vue.ref("visible");
+    if (inBrowser) {
+      const update = () => {
+        visibility.value = document.hidden ? "hidden" : "visible";
+      };
+      update();
+      window.addEventListener("visibilitychange", update);
+    }
+  }
+  return visibility;
+}
+var CUSTOM_FIELD_INJECTION_KEY = Symbol("van-field");
+function useCustomFieldValue(customValue) {
+  const field = vue.inject(CUSTOM_FIELD_INJECTION_KEY, null);
+  if (field && !field.customValue.value) {
+    field.customValue.value = customValue;
+    vue.watch(customValue, () => {
+      field.resetValidation();
+      field.validateWithTrigger("onChange");
+    });
+  }
+}
+exports.CUSTOM_FIELD_INJECTION_KEY = CUSTOM_FIELD_INJECTION_KEY;
+exports.cancelRaf = cancelRaf;
+exports.doubleRaf = doubleRaf;
+exports.flattenVNodes = flattenVNodes;
+exports.getScrollParent = getScrollParent;
+exports.inBrowser = inBrowser;
+exports.onMountedOrActivated = onMountedOrActivated;
+exports.raf = raf;
+exports.sortChildren = sortChildren;
+exports.useChildren = useChildren;
+exports.useClickAway = useClickAway;
+exports.useCustomFieldValue = useCustomFieldValue;
+exports.useEventListener = useEventListener;
+exports.usePageVisibility = usePageVisibility;
+exports.useParent = useParent;
+exports.useRect = useRect;
+exports.useScrollParent = useScrollParent;
+exports.useToggle = useToggle;
+exports.useWindowSize = useWindowSize;

package/lib/packages/mobile/node_modules/@vue/shared/dist/shared.esm-bundler.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+/**
+* @vue/shared v3.5.34
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+const isArray = Array.isArray;
+const isString = (val) => typeof val === "string";
+const isObject = (val) => val !== null && typeof val === "object";
+const cacheStringFunction = (fn) => {
+  const cache = /* @__PURE__ */ Object.create(null);
+  return (str) => {
+    const hit = cache[str];
+    return hit || (cache[str] = fn(str));
+  };
+};
+const hyphenateRE = /\B([A-Z])/g;
+const hyphenate = cacheStringFunction(
+  (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+);
+function normalizeStyle(value) {
+  if (isArray(value)) {
+    const res = {};
+    for (let i = 0; i < value.length; i++) {
+      const item = value[i];
+      const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+      if (normalized) {
+        for (const key in normalized) {
+          res[key] = normalized[key];
+        }
+      }
+    }
+    return res;
+  } else if (isString(value) || isObject(value)) {
+    return value;
+  }
+}
+const listDelimiterRE = /;(?![^(]*\))/g;
+const propertyDelimiterRE = /:([^]+)/;
+const styleCommentRE = /\/\*[^]*?\*\//g;
+function parseStringStyle(cssText) {
+  const ret = {};
+  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+    if (item) {
+      const tmp = item.split(propertyDelimiterRE);
+      tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+    }
+  });
+  return ret;
+}
+function stringifyStyle(styles) {
+  if (!styles) return "";
+  if (isString(styles)) return styles;
+  let ret = "";
+  for (const key in styles) {
+    const value = styles[key];
+    if (isString(value) || typeof value === "number") {
+      const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+      ret += `${normalizedKey}:${value};`;
+    }
+  }
+  return ret;
+}
+function normalizeClass(value) {
+  let res = "";
+  if (isString(value)) {
+    res = value;
+  } else if (isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const normalized = normalizeClass(value[i]);
+      if (normalized) {
+        res += normalized + " ";
+      }
+    }
+  } else if (isObject(value)) {
+    for (const name in value) {
+      if (value[name]) {
+        res += name + " ";
+      }
+    }
+  }
+  return res.trim();
+}
+exports.hyphenate = hyphenate;
+exports.isArray = isArray;
+exports.isObject = isObject;
+exports.isString = isString;
+exports.normalizeClass = normalizeClass;
+exports.normalizeStyle = normalizeStyle;
+exports.parseStringStyle = parseStringStyle;
+exports.stringifyStyle = stringifyStyle;

package/lib/packages/mobile/node_modules/@vxe-ui/core/es/index.esm.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const core = require("./src/core.js");
+const vue = require("vue");
+const config = require("./src/config.js");
+const dataStore = require("./src/dataStore.js");
+const icon = require("./src/icon.js");
+const theme = require("./src/theme.js");
+const event = require("./src/event.js");
+const resize = require("./src/resize.js");
+const i18n = require("./src/i18n.js");
+const renderer = require("./src/renderer.js");
+const validators = require("./src/validators.js");
+const menus = require("./src/menus.js");
+const formats = require("./src/formats.js");
+const commands = require("./src/commands.js");
+const interceptor = require("./src/interceptor.js");
+const clipboard = require("./src/clipboard.js");
+const permission = require("./src/permission.js");
+const log = require("./src/log.js");
+const hooks = require("./src/hooks.js");
+const useFns = require("./src/useFns.js");
+const vm = require("./src/vm.js");
+require("../node_modules/xe-utils/es/index.esm.js");
+const ctor = require("../node_modules/xe-utils/es/ctor.js");
+const installedPlugins = [];
+function use(Plugin, options) {
+  if (Plugin && Plugin.install) {
+    if (installedPlugins.indexOf(Plugin) === -1) {
+      Plugin.install(VxeUI, options);
+      installedPlugins.push(Plugin);
+    }
+  }
+  return VxeUI;
+}
+const components = {};
+function getComponent(name) {
+  return components[name] || null;
+}
+function hasComponent(name) {
+  return !!components[name];
+}
+function component(comp) {
+  if (comp && comp.name) {
+    components[comp.name] = comp;
+    components[ctor.default.kebabCase(comp.name)] = comp;
+  }
+}
+function renderEmptyElement() {
+  return vue.createCommentVNode();
+}
+function checkVersion(version, pVersion, sVersion) {
+  if (version) {
+    const vRest = `${version}`.match(/(\d+).(\d+).(\d+)/);
+    if (vRest) {
+      const pV = ctor.default.toNumber(vRest[1]);
+      if (sVersion) {
+        const sV = ctor.default.toNumber(vRest[2]);
+        return pV >= pVersion && sV >= sVersion;
+      }
+      return pV >= pVersion;
+    }
+  }
+  return false;
+}
+const VxeUI = Object.assign(core.VxeCore, {
+  renderEmptyElement,
+  setTheme: theme.setTheme,
+  getTheme: theme.getTheme,
+  setConfig: config.setConfig,
+  getConfig: config.getConfig,
+  setIcon: icon.setIcon,
+  getIcon: icon.getIcon,
+  renderGlobalIcon: icon.renderGlobalIcon,
+  renderCustomIcon: icon.renderCustomIcon,
+  setLanguage: i18n.setLanguage,
+  hasLanguage: i18n.hasLanguage,
+  getLanguage: i18n.getLanguage,
+  setI18n: i18n.setI18n,
+  getI18n: i18n.getI18n,
+  globalEvents: event.globalEvents,
+  GLOBAL_EVENT_KEYS: event.GLOBAL_EVENT_KEYS,
+  createEvent: event.createEvent,
+  globalResize: resize.globalResize,
+  renderer: renderer.renderer,
+  validators: validators.validators,
+  menus: menus.menus,
+  formats: formats.formats,
+  commands: commands.commands,
+  interceptor: interceptor.interceptor,
+  clipboard: clipboard.clipboard,
+  log: log.log,
+  permission: permission.permission,
+  globalStore: dataStore.globalStore,
+  hooks: hooks.hooks,
+  component,
+  getComponent,
+  hasComponent,
+  useFns: useFns.useFns,
+  getSlotVNs: vm.getSlotVNs,
+  checkVersion,
+  use
+});
+theme.setTheme();
+exports.VxeCore = core.VxeCore;
+exports.coreVersion = core.coreVersion;
+exports.getConfig = config.getConfig;
+exports.setConfig = config.setConfig;
+exports.globalStore = dataStore.globalStore;
+exports.getIcon = icon.getIcon;
+exports.renderCustomIcon = icon.renderCustomIcon;
+exports.renderGlobalIcon = icon.renderGlobalIcon;
+exports.setIcon = icon.setIcon;
+exports.getTheme = theme.getTheme;
+exports.setTheme = theme.setTheme;
+exports.GLOBAL_EVENT_KEYS = event.GLOBAL_EVENT_KEYS;
+exports.createEvent = event.createEvent;
+exports.globalEvents = event.globalEvents;
+exports.globalResize = resize.globalResize;
+exports.getI18n = i18n.getI18n;
+exports.getLanguage = i18n.getLanguage;
+exports.hasLanguage = i18n.hasLanguage;
+exports.setI18n = i18n.setI18n;
+exports.setLanguage = i18n.setLanguage;
+exports.renderer = renderer.renderer;
+exports.validators = validators.validators;
+exports.menus = menus.menus;
+exports.formats = formats.formats;
+exports.commands = commands.commands;
+exports.interceptor = interceptor.interceptor;
+exports.clipboard = clipboard.clipboard;
+exports.handleCheckInfo = permission.handleCheckInfo;
+exports.permission = permission.permission;
+exports.log = log.log;
+exports.hooks = hooks.hooks;
+exports.useFns = useFns.useFns;
+exports.usePermission = useFns.usePermission;
+exports.useSize = useFns.useSize;
+exports.getSlotVNs = vm.getSlotVNs;
+exports.VxeUI = VxeUI;
+exports.checkVersion = checkVersion;
+exports.component = component;
+exports.default = VxeUI;
+exports.getComponent = getComponent;
+exports.hasComponent = hasComponent;
+exports.renderEmptyElement = renderEmptyElement;
+exports.use = use;