@fecp/mobile-designer 1.0.10 → 1.0.11

package/es/node_modules/@vant/touch-emulator/dist/index.mjs

@@ -0,0 +1,125 @@
+(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.target;
+      }
+      if (eventTarget.closest("[data-no-touch-simulate]") == null) {
+        triggerTouch(touchType, ev);
+      }
+      if (ev.type === "mouseup") {
+        eventTarget = null;
+      }
+    };
+  }
+  function triggerTouch(eventName, mouseEv) {
+    var touchEvent = document.createEvent("Event");
+    touchEvent.initEvent(eventName, true, 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/es/node_modules/@vant/use/dist/index.esm.mjs

@@ -0,0 +1,304 @@
+import { unref, onUnmounted, onDeactivated, isRef, watch, onMounted, nextTick, onActivated, reactive, getCurrentInstance, provide, isVNode, inject, computed, ref } from "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 = 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 = ref(defaultValue);
+  const toggle = (value = !state.value) => {
+    state.value = value;
+  };
+  return [state, toggle];
+}
+function useParent(key) {
+  const parent = inject(key, null);
+  if (parent) {
+    const instance = getCurrentInstance();
+    const { link, unlink, internalChildren } = parent;
+    link(instance);
+    onUnmounted(() => unlink(instance));
+    const index = computed(() => internalChildren.indexOf(instance));
+    return {
+      parent,
+      index
+    };
+  }
+  return {
+    parent: null,
+    index: ref(-1)
+  };
+}
+function flattenVNodes(children) {
+  const result = [];
+  const traverse = (children2) => {
+    if (Array.isArray(children2)) {
+      children2.forEach((child) => {
+        var _a;
+        if (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 = reactive([]);
+  const internalChildren = reactive([]);
+  const parent = 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);
+    };
+    provide(
+      key,
+      Object.assign(
+        {
+          link,
+          unlink,
+          children: publicChildren,
+          internalChildren
+        },
+        value
+      )
+    );
+  };
+  return {
+    children: publicChildren,
+    linkChildren
+  };
+}
+function onMountedOrActivated(hook) {
+  let mounted;
+  onMounted(() => {
+    hook();
+    nextTick(() => {
+      mounted = true;
+    });
+  });
+  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 = unref(target2);
+    if (element && !attached) {
+      element.addEventListener(type, listener, {
+        capture,
+        passive
+      });
+      attached = true;
+    }
+  };
+  const remove = (target2) => {
+    if (cleaned) {
+      return;
+    }
+    const element = unref(target2);
+    if (element && attached) {
+      element.removeEventListener(type, listener, capture);
+      attached = false;
+    }
+  };
+  onUnmounted(() => remove(target));
+  onDeactivated(() => remove(target));
+  onMountedOrActivated(() => add(target));
+  let stopWatch;
+  if (isRef(target)) {
+    stopWatch = 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 = 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 = ref(0);
+    height = 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 = ref();
+  onMounted(() => {
+    if (el.value) {
+      scrollParent.value = getScrollParent(el.value, root);
+    }
+  });
+  return scrollParent;
+}
+var visibility;
+function usePageVisibility() {
+  if (!visibility) {
+    visibility = 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 = inject(CUSTOM_FIELD_INJECTION_KEY, null);
+  if (field && !field.customValue.value) {
+    field.customValue.value = customValue;
+    watch(customValue, () => {
+      field.resetValidation();
+      field.validateWithTrigger("onChange");
+    });
+  }
+}
+export {
+  CUSTOM_FIELD_INJECTION_KEY,
+  cancelRaf,
+  doubleRaf,
+  flattenVNodes,
+  getScrollParent,
+  inBrowser,
+  onMountedOrActivated,
+  raf,
+  sortChildren,
+  useChildren,
+  useClickAway,
+  useCustomFieldValue,
+  useEventListener,
+  usePageVisibility,
+  useParent,
+  useRect,
+  useScrollParent,
+  useToggle,
+  useWindowSize
+};

package/es/node_modules/@vue/shared/dist/shared.esm-bundler.mjs

@@ -38,6 +38,69 @@ const hyphenate = cacheStringFunction(
 const capitalize = cacheStringFunction((str) => {
   return str.charAt(0).toUpperCase() + str.slice(1);
 });
+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();
+}
 export {
   NOOP,
   camelize,
@@ -51,6 +114,10 @@ export {
   isPlainObject,
   isPromise,
   isString,
+  normalizeClass,
+  normalizeStyle,
   objectToString,
+  parseStringStyle,
+  stringifyStyle,
   toTypeString
 };