@fecp/designer 5.5.113 → 5.5.115

package/lib/node_modules/vant/es/utils/create.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const basic = require("./basic.js");
+const format = require("./format.js");
+const index = require("../locale/index.js");
+function createTranslate(name) {
+  const prefix = format.camelize(name) + ".";
+  return (path, ...args) => {
+    const messages = index.default.messages();
+    const message = basic.get(messages, prefix + path) || basic.get(messages, path);
+    return basic.isFunction(message) ? message(...args) : message;
+  };
+}
+function genBem(name, mods) {
+  if (!mods) {
+    return "";
+  }
+  if (typeof mods === "string") {
+    return ` ${name}--${mods}`;
+  }
+  if (Array.isArray(mods)) {
+    return mods.reduce(
+      (ret, item) => ret + genBem(name, item),
+      ""
+    );
+  }
+  return Object.keys(mods).reduce(
+    (ret, key) => ret + (mods[key] ? genBem(name, key) : ""),
+    ""
+  );
+}
+function createBEM(name) {
+  return (el, mods) => {
+    if (el && typeof el !== "string") {
+      mods = el;
+      el = "";
+    }
+    el = el ? `${name}__${el}` : name;
+    return `${el}${genBem(el, mods)}`;
+  };
+}
+function createNamespace(name) {
+  const prefixedName = `van-${name}`;
+  return [
+    prefixedName,
+    createBEM(prefixedName),
+    createTranslate(prefixedName)
+  ];
+}
+exports.createBEM = createBEM;
+exports.createNamespace = createNamespace;
+exports.createTranslate = createTranslate;

package/lib/node_modules/vant/es/utils/deep-assign.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const basic = require("./basic.js");
+const { hasOwnProperty } = Object.prototype;
+function assignKey(to, from, key) {
+  const val = from[key];
+  if (!basic.isDef(val)) {
+    return;
+  }
+  if (!hasOwnProperty.call(to, key) || !basic.isObject(val)) {
+    to[key] = val;
+  } else {
+    to[key] = deepAssign(Object(to[key]), val);
+  }
+}
+function deepAssign(to, from) {
+  Object.keys(from).forEach((key) => {
+    assignKey(to, from, key);
+  });
+  return to;
+}
+exports.deepAssign = deepAssign;

package/lib/node_modules/vant/es/utils/dom.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const Vue = require("vue");
+const basic = require("./basic.js");
+function getScrollTop(el) {
+  const top = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
+  return Math.max(top, 0);
+}
+function setScrollTop(el, value) {
+  if ("scrollTop" in el) {
+    el.scrollTop = value;
+  } else {
+    el.scrollTo(el.scrollX, value);
+  }
+}
+function getRootScrollTop() {
+  return window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0;
+}
+function setRootScrollTop(value) {
+  setScrollTop(window, value);
+  setScrollTop(document.body, value);
+}
+function getElementTop(el, scroller) {
+  if (el === window) {
+    return 0;
+  }
+  const scrollTop = scroller ? getScrollTop(scroller) : getRootScrollTop();
+  return index_esm.useRect(el).top + scrollTop;
+}
+const isIOS = basic.isIOS();
+function resetScroll() {
+  if (isIOS) {
+    setRootScrollTop(getRootScrollTop());
+  }
+}
+const stopPropagation = (event) => event.stopPropagation();
+function preventDefault(event, isStopPropagation) {
+  if (typeof event.cancelable !== "boolean" || event.cancelable) {
+    event.preventDefault();
+  }
+  if (isStopPropagation) {
+    stopPropagation(event);
+  }
+}
+function isHidden(elementRef) {
+  const el = Vue.unref(elementRef);
+  if (!el) {
+    return false;
+  }
+  const style = window.getComputedStyle(el);
+  const hidden = style.display === "none";
+  const parentHidden = el.offsetParent === null && style.position !== "fixed";
+  return hidden || parentHidden;
+}
+const { width: windowWidth, height: windowHeight } = index_esm.useWindowSize();
+function isContainingBlock(el) {
+  const css = window.getComputedStyle(el);
+  return css.transform !== "none" || css.perspective !== "none" || ["transform", "perspective", "filter"].some(
+    (value) => (css.willChange || "").includes(value)
+  );
+}
+function getContainingBlock(el) {
+  let node = el.parentElement;
+  while (node) {
+    if (node && node.tagName !== "HTML" && node.tagName !== "BODY" && isContainingBlock(node)) {
+      return node;
+    }
+    node = node.parentElement;
+  }
+  return null;
+}
+exports.getContainingBlock = getContainingBlock;
+exports.getElementTop = getElementTop;
+exports.getRootScrollTop = getRootScrollTop;
+exports.getScrollTop = getScrollTop;
+exports.isHidden = isHidden;
+exports.preventDefault = preventDefault;
+exports.resetScroll = resetScroll;
+exports.setRootScrollTop = setRootScrollTop;
+exports.setScrollTop = setScrollTop;
+exports.stopPropagation = stopPropagation;
+exports.windowHeight = windowHeight;
+exports.windowWidth = windowWidth;

package/lib/node_modules/vant/es/utils/format.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const basic = require("./basic.js");
+const dom = require("./dom.js");
+function addUnit(value) {
+  if (basic.isDef(value)) {
+    return basic.isNumeric(value) ? `${value}px` : String(value);
+  }
+  return void 0;
+}
+function getSizeStyle(originSize) {
+  if (basic.isDef(originSize)) {
+    if (Array.isArray(originSize)) {
+      return {
+        width: addUnit(originSize[0]),
+        height: addUnit(originSize[1])
+      };
+    }
+    const size = addUnit(originSize);
+    return {
+      width: size,
+      height: size
+    };
+  }
+}
+function getZIndexStyle(zIndex) {
+  const style = {};
+  if (zIndex !== void 0) {
+    style.zIndex = +zIndex;
+  }
+  return style;
+}
+let rootFontSize;
+function getRootFontSize() {
+  if (!rootFontSize) {
+    const doc = document.documentElement;
+    const fontSize = doc.style.fontSize || window.getComputedStyle(doc).fontSize;
+    rootFontSize = parseFloat(fontSize);
+  }
+  return rootFontSize;
+}
+function convertRem(value) {
+  value = value.replace(/rem/g, "");
+  return +value * getRootFontSize();
+}
+function convertVw(value) {
+  value = value.replace(/vw/g, "");
+  return +value * dom.windowWidth.value / 100;
+}
+function convertVh(value) {
+  value = value.replace(/vh/g, "");
+  return +value * dom.windowHeight.value / 100;
+}
+function unitToPx(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (basic.inBrowser) {
+    if (value.includes("rem")) {
+      return convertRem(value);
+    }
+    if (value.includes("vw")) {
+      return convertVw(value);
+    }
+    if (value.includes("vh")) {
+      return convertVh(value);
+    }
+  }
+  return parseFloat(value);
+}
+const camelizeRE = /-(\w)/g;
+const camelize = (str) => str.replace(camelizeRE, (_, c) => c.toUpperCase());
+const kebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase().replace(/^-/, "");
+function padZero(num, targetLength = 2) {
+  let str = num + "";
+  while (str.length < targetLength) {
+    str = "0" + str;
+  }
+  return str;
+}
+const clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+function trimExtraChar(value, char, regExp) {
+  const index = value.indexOf(char);
+  if (index === -1) {
+    return value;
+  }
+  if (char === "-" && index !== 0) {
+    return value.slice(0, index);
+  }
+  return value.slice(0, index + 1) + value.slice(index).replace(regExp, "");
+}
+function formatNumber(value, allowDot = true, allowMinus = true) {
+  if (allowDot) {
+    value = trimExtraChar(value, ".", /\./g);
+  } else {
+    value = value.split(".")[0];
+  }
+  if (allowMinus) {
+    value = trimExtraChar(value, "-", /-/g);
+  } else {
+    value = value.replace(/-/, "");
+  }
+  const regExp = allowDot ? /[^-0-9.]/g : /[^-0-9]/g;
+  return value.replace(regExp, "");
+}
+function addNumber(num1, num2) {
+  const cardinal = 10 ** 10;
+  return Math.round((num1 + num2) * cardinal) / cardinal;
+}
+exports.addNumber = addNumber;
+exports.addUnit = addUnit;
+exports.camelize = camelize;
+exports.clamp = clamp;
+exports.formatNumber = formatNumber;
+exports.getSizeStyle = getSizeStyle;
+exports.getZIndexStyle = getZIndexStyle;
+exports.kebabCase = kebabCase;
+exports.padZero = padZero;
+exports.unitToPx = unitToPx;

package/lib/node_modules/vant/es/utils/interceptor.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const basic = require("./basic.js");
+function callInterceptor(interceptor, {
+  args = [],
+  done,
+  canceled,
+  error
+}) {
+  if (interceptor) {
+    const returnVal = interceptor.apply(null, args);
+    if (basic.isPromise(returnVal)) {
+      returnVal.then((value) => {
+        if (value) {
+          done();
+        } else if (canceled) {
+          canceled();
+        }
+      }).catch(error || basic.noop);
+    } else if (returnVal) {
+      done();
+    } else if (canceled) {
+      canceled();
+    }
+  } else {
+    done();
+  }
+}
+exports.callInterceptor = callInterceptor;

package/lib/node_modules/vant/es/utils/mount-component.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Vue = require("vue");
+const basic = require("./basic.js");
+const useExpose = require("../composables/use-expose.js");
+function usePopupState() {
+  const state = Vue.reactive({
+    show: false
+  });
+  const toggle = (show) => {
+    state.show = show;
+  };
+  const open = (props) => {
+    basic.extend(state, props, { transitionAppear: true });
+    toggle(true);
+  };
+  const close = () => toggle(false);
+  useExpose.useExpose({ open, close, toggle });
+  return {
+    open,
+    close,
+    state,
+    toggle
+  };
+}
+function mountComponent(RootComponent) {
+  const app = Vue.createApp(RootComponent);
+  const root = document.createElement("div");
+  document.body.appendChild(root);
+  return {
+    instance: app.mount(root),
+    unmount() {
+      app.unmount();
+      document.body.removeChild(root);
+    }
+  };
+}
+exports.mountComponent = mountComponent;
+exports.usePopupState = usePopupState;

package/lib/node_modules/vant/es/utils/props.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const unknownProp = null;
+const numericProp = [Number, String];
+const truthProp = {
+  type: Boolean,
+  default: true
+};
+const makeRequiredProp = (type) => ({
+  type,
+  required: true
+});
+const makeArrayProp = () => ({
+  type: Array,
+  default: () => []
+});
+const makeNumberProp = (defaultVal) => ({
+  type: Number,
+  default: defaultVal
+});
+const makeNumericProp = (defaultVal) => ({
+  type: numericProp,
+  default: defaultVal
+});
+const makeStringProp = (defaultVal) => ({
+  type: String,
+  default: defaultVal
+});
+exports.makeArrayProp = makeArrayProp;
+exports.makeNumberProp = makeNumberProp;
+exports.makeNumericProp = makeNumericProp;
+exports.makeRequiredProp = makeRequiredProp;
+exports.makeStringProp = makeStringProp;
+exports.numericProp = numericProp;
+exports.truthProp = truthProp;
+exports.unknownProp = unknownProp;

package/lib/node_modules/vant/es/utils/with-install.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const format = require("./format.js");
+function withInstall(options) {
+  options.install = (app) => {
+    const { name } = options;
+    if (name) {
+      app.component(name, options);
+      app.component(format.camelize(`-${name}`), options);
+    }
+  };
+  return options;
+}
+exports.withInstall = withInstall;

package/lib/node_modules/vant/es/watermark/Watermark.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const format = require("../utils/format.js");
+const [name, bem] = create.createNamespace("watermark");
+const watermarkProps = {
+  gapX: props.makeNumberProp(0),
+  gapY: props.makeNumberProp(0),
+  image: String,
+  width: props.makeNumberProp(100),
+  height: props.makeNumberProp(100),
+  rotate: props.makeNumericProp(-22),
+  zIndex: props.numericProp,
+  content: String,
+  opacity: props.numericProp,
+  fullPage: props.truthProp,
+  textColor: props.makeStringProp("#dcdee0")
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: watermarkProps,
+  setup(props2, {
+    slots
+  }) {
+    const svgElRef = Vue.ref();
+    const watermarkUrl = Vue.ref("");
+    const imageBase64 = Vue.ref("");
+    const renderWatermark = () => {
+      const rotateStyle = {
+        transformOrigin: "center",
+        transform: `rotate(${props2.rotate}deg)`
+      };
+      const svgInner = () => {
+        if (props2.image && !slots.content) {
+          return Vue.createVNode("image", {
+            "href": imageBase64.value,
+            "xlink:href": imageBase64.value,
+            "x": "0",
+            "y": "0",
+            "width": props2.width,
+            "height": props2.height,
+            "style": rotateStyle
+          }, null);
+        }
+        return Vue.createVNode("foreignObject", {
+          "x": "0",
+          "y": "0",
+          "width": props2.width,
+          "height": props2.height
+        }, [Vue.createVNode("div", {
+          "xmlns": "http://www.w3.org/1999/xhtml",
+          "style": rotateStyle
+        }, [slots.content ? slots.content() : Vue.createVNode("span", {
+          "style": {
+            color: props2.textColor
+          }
+        }, [props2.content])])]);
+      };
+      const svgWidth = props2.width + props2.gapX;
+      const svgHeight = props2.height + props2.gapY;
+      return Vue.createVNode("svg", {
+        "viewBox": `0 0 ${svgWidth} ${svgHeight}`,
+        "width": svgWidth,
+        "height": svgHeight,
+        "xmlns": "http://www.w3.org/2000/svg",
+        "xmlns:xlink": "http://www.w3.org/1999/xlink",
+        "style": {
+          padding: `0 ${props2.gapX}px ${props2.gapY}px 0`,
+          opacity: props2.opacity
+        }
+      }, [svgInner()]);
+    };
+    const makeImageToBase64 = (url) => {
+      const canvas = document.createElement("canvas");
+      const image = new Image();
+      image.crossOrigin = "anonymous";
+      image.referrerPolicy = "no-referrer";
+      image.onload = () => {
+        canvas.width = image.naturalWidth;
+        canvas.height = image.naturalHeight;
+        const ctx = canvas.getContext("2d");
+        ctx == null ? void 0 : ctx.drawImage(image, 0, 0);
+        imageBase64.value = canvas.toDataURL();
+      };
+      image.src = url;
+    };
+    const makeSvgToBlobUrl = (svgStr) => {
+      const svgBlob = new Blob([svgStr], {
+        type: "image/svg+xml"
+      });
+      return URL.createObjectURL(svgBlob);
+    };
+    Vue.watchEffect(() => {
+      if (props2.image) {
+        makeImageToBase64(props2.image);
+      }
+    });
+    Vue.watch(() => [imageBase64.value, props2.content, props2.textColor, props2.height, props2.width, props2.rotate, props2.gapX, props2.gapY], () => {
+      Vue.nextTick(() => {
+        if (svgElRef.value) {
+          if (watermarkUrl.value) {
+            URL.revokeObjectURL(watermarkUrl.value);
+          }
+          watermarkUrl.value = makeSvgToBlobUrl(svgElRef.value.innerHTML);
+        }
+      });
+    }, {
+      immediate: true
+    });
+    Vue.onUnmounted(() => {
+      if (watermarkUrl.value) {
+        URL.revokeObjectURL(watermarkUrl.value);
+      }
+    });
+    return () => {
+      const style = basic.extend({
+        backgroundImage: `url(${watermarkUrl.value})`
+      }, format.getZIndexStyle(props2.zIndex));
+      return Vue.createVNode("div", {
+        "class": bem({
+          full: props2.fullPage
+        }),
+        "style": style
+      }, [Vue.createVNode("div", {
+        "class": bem("wrapper"),
+        "ref": svgElRef
+      }, [renderWatermark()])]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.watermarkProps = watermarkProps;

package/lib/node_modules/vant/es/watermark/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Watermark$1 = require("./Watermark.js");
+const withInstall = require("../utils/with-install.js");
+const Watermark = withInstall.withInstall(Watermark$1.default);
+exports.watermarkProps = Watermark$1.watermarkProps;
+exports.Watermark = Watermark;