@fecp/designer 5.5.114 → 5.5.115

package/lib/node_modules/vant/es/lazyload/vue-lazyload/listener.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm = require("../../../../@vant/use/dist/index.esm.js");
+const util = require("./util.js");
+const basic = require("../../utils/basic.js");
+class ReactiveListener {
+  constructor({
+    el,
+    src,
+    error,
+    loading,
+    bindType,
+    $parent,
+    options,
+    cors,
+    elRenderer,
+    imageCache
+  }) {
+    this.el = el;
+    this.src = src;
+    this.error = error;
+    this.loading = loading;
+    this.bindType = bindType;
+    this.attempt = 0;
+    this.cors = cors;
+    this.naturalHeight = 0;
+    this.naturalWidth = 0;
+    this.options = options;
+    this.$parent = $parent;
+    this.elRenderer = elRenderer;
+    this.imageCache = imageCache;
+    this.performanceData = {
+      loadStart: 0,
+      loadEnd: 0
+    };
+    this.filter();
+    this.initState();
+    this.render("loading", false);
+  }
+  /*
+   * init listener state
+   * @return
+   */
+  initState() {
+    if ("dataset" in this.el) {
+      this.el.dataset.src = this.src;
+    } else {
+      this.el.setAttribute("data-src", this.src);
+    }
+    this.state = {
+      loading: false,
+      error: false,
+      loaded: false,
+      rendered: false
+    };
+  }
+  /*
+   * record performance
+   * @return
+   */
+  record(event) {
+    this.performanceData[event] = Date.now();
+  }
+  /*
+   * update image listener data
+   * @param  {String} image uri
+   * @param  {String} loading image uri
+   * @param  {String} error image uri
+   * @return
+   */
+  update({ src, loading, error }) {
+    const oldSrc = this.src;
+    this.src = src;
+    this.loading = loading;
+    this.error = error;
+    this.filter();
+    if (oldSrc !== this.src) {
+      this.attempt = 0;
+      this.initState();
+    }
+  }
+  /*
+   *  check el is in view
+   * @return {Boolean} el is in view
+   */
+  checkInView() {
+    const rect = index_esm.useRect(this.el);
+    return rect.top < window.innerHeight * this.options.preLoad && rect.bottom > this.options.preLoadTop && rect.left < window.innerWidth * this.options.preLoad && rect.right > 0;
+  }
+  /*
+   * listener filter
+   */
+  filter() {
+    Object.keys(this.options.filter).forEach((key) => {
+      this.options.filter[key](this, this.options);
+    });
+  }
+  /*
+   * render loading first
+   * @params cb:Function
+   * @return
+   */
+  renderLoading(cb) {
+    this.state.loading = true;
+    util.loadImageAsync(
+      {
+        src: this.loading,
+        cors: this.cors
+      },
+      () => {
+        this.render("loading", false);
+        this.state.loading = false;
+        cb();
+      },
+      () => {
+        cb();
+        this.state.loading = false;
+      }
+    );
+  }
+  /*
+   * try load image and  render it
+   * @return
+   */
+  load(onFinish = basic.noop) {
+    if (this.attempt > this.options.attempt - 1 && this.state.error) {
+      onFinish();
+      return;
+    }
+    if (this.state.rendered && this.state.loaded) return;
+    if (this.imageCache.has(this.src)) {
+      this.state.loaded = true;
+      this.render("loaded", true);
+      this.state.rendered = true;
+      return onFinish();
+    }
+    this.renderLoading(() => {
+      var _a, _b;
+      this.attempt++;
+      (_b = (_a = this.options.adapter).beforeLoad) == null ? void 0 : _b.call(_a, this, this.options);
+      this.record("loadStart");
+      util.loadImageAsync(
+        {
+          src: this.src,
+          cors: this.cors
+        },
+        (data) => {
+          this.naturalHeight = data.naturalHeight;
+          this.naturalWidth = data.naturalWidth;
+          this.state.loaded = true;
+          this.state.error = false;
+          this.record("loadEnd");
+          this.render("loaded", false);
+          this.state.rendered = true;
+          this.imageCache.add(this.src);
+          onFinish();
+        },
+        (err) => {
+          !this.options.silent && console.error(err);
+          this.state.error = true;
+          this.state.loaded = false;
+          this.render("error", false);
+        }
+      );
+    });
+  }
+  /*
+   * render image
+   * @param  {String} state to render // ['loading', 'src', 'error']
+   * @param  {String} is form cache
+   * @return
+   */
+  render(state, cache) {
+    this.elRenderer(this, state, cache);
+  }
+  /*
+   * output performance data
+   * @return {Object} performance data
+   */
+  performance() {
+    let state = "loading";
+    let time = 0;
+    if (this.state.loaded) {
+      state = "loaded";
+      time = (this.performanceData.loadEnd - this.performanceData.loadStart) / 1e3;
+    }
+    if (this.state.error) state = "error";
+    return {
+      src: this.src,
+      state,
+      time
+    };
+  }
+  /*
+   * $destroy
+   * @return
+   */
+  $destroy() {
+    this.el = null;
+    this.src = null;
+    this.error = null;
+    this.loading = null;
+    this.bindType = null;
+    this.attempt = 0;
+  }
+}
+exports.default = ReactiveListener;

package/lib/node_modules/vant/es/lazyload/vue-lazyload/util.js

@@ -1,5 +1,87 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index_esm = require("../../../../@vant/use/dist/index.esm.js");
+const hasIntersectionObserver = index_esm.inBrowser && "IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype;
+const modeType = {
+  event: "event",
+  observer: "observer"
+};
+function remove(arr, item) {
+  if (!arr.length) return;
+  const index = arr.indexOf(item);
+  if (index > -1) return arr.splice(index, 1);
+}
+function getBestSelectionFromSrcset(el, scale) {
+  if (el.tagName !== "IMG" || !el.getAttribute("data-srcset")) return;
+  let options = el.getAttribute("data-srcset");
+  const container = el.parentNode;
+  const containerWidth = container.offsetWidth * scale;
+  let spaceIndex;
+  let tmpSrc;
+  let tmpWidth;
+  options = options.trim().split(",");
+  const result = options.map((item) => {
+    item = item.trim();
+    spaceIndex = item.lastIndexOf(" ");
+    if (spaceIndex === -1) {
+      tmpSrc = item;
+      tmpWidth = 999998;
+    } else {
+      tmpSrc = item.substr(0, spaceIndex);
+      tmpWidth = parseInt(
+        item.substr(spaceIndex + 1, item.length - spaceIndex - 2),
+        10
+      );
+    }
+    return [tmpWidth, tmpSrc];
+  });
+  result.sort((a, b) => {
+    if (a[0] < b[0]) {
+      return 1;
+    }
+    if (a[0] > b[0]) {
+      return -1;
+    }
+    if (a[0] === b[0]) {
+      if (b[1].indexOf(".webp", b[1].length - 5) !== -1) {
+        return 1;
+      }
+      if (a[1].indexOf(".webp", a[1].length - 5) !== -1) {
+        return -1;
+      }
+    }
+    return 0;
+  });
+  let bestSelectedSrc = "";
+  let tmpOption;
+  for (let i = 0; i < result.length; i++) {
+    tmpOption = result[i];
+    bestSelectedSrc = tmpOption[1];
+    const next = result[i + 1];
+    if (next && next[0] < containerWidth) {
+      bestSelectedSrc = tmpOption[1];
+      break;
+    } else if (!next) {
+      bestSelectedSrc = tmpOption[1];
+      break;
+    }
+  }
+  return bestSelectedSrc;
+}
+const getDPR = (scale = 1) => index_esm.inBrowser ? window.devicePixelRatio || scale : scale;
+function supportWebp() {
+  if (!index_esm.inBrowser) return false;
+  let support = true;
+  try {
+    const elem = document.createElement("canvas");
+    if (elem.getContext && elem.getContext("2d")) {
+      support = elem.toDataURL("image/webp").indexOf("data:image/webp") === 0;
+    }
+  } catch (err) {
+    support = false;
+  }
+  return support;
+}
 function throttle(action, delay) {
   let timeout = null;
   let lastRun = 0;
@@ -20,4 +102,60 @@ function throttle(action, delay) {
     }
   };
 }
+function on(el, type, func) {
+  el.addEventListener(type, func, {
+    capture: false,
+    passive: true
+  });
+}
+function off(el, type, func) {
+  el.removeEventListener(type, func, false);
+}
+const loadImageAsync = (item, resolve, reject) => {
+  const image = new Image();
+  if (!item || !item.src) {
+    return reject(new Error("image src is required"));
+  }
+  image.src = item.src;
+  if (item.cors) {
+    image.crossOrigin = item.cors;
+  }
+  image.onload = () => resolve({
+    naturalHeight: image.naturalHeight,
+    naturalWidth: image.naturalWidth,
+    src: image.src
+  });
+  image.onerror = (e) => reject(e);
+};
+class ImageCache {
+  constructor({ max }) {
+    this.options = {
+      max: max || 100
+    };
+    this.caches = [];
+  }
+  has(key) {
+    return this.caches.indexOf(key) > -1;
+  }
+  add(key) {
+    if (this.has(key)) return;
+    this.caches.push(key);
+    if (this.caches.length > this.options.max) {
+      this.free();
+    }
+  }
+  free() {
+    this.caches.shift();
+  }
+}
+exports.ImageCache = ImageCache;
+exports.getBestSelectionFromSrcset = getBestSelectionFromSrcset;
+exports.getDPR = getDPR;
+exports.hasIntersectionObserver = hasIntersectionObserver;
+exports.loadImageAsync = loadImageAsync;
+exports.modeType = modeType;
+exports.off = off;
+exports.on = on;
+exports.remove = remove;
+exports.supportWebp = supportWebp;
 exports.throttle = throttle;

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

@@ -19,6 +19,8 @@ const Locale = {
     deepAssign.deepAssign(messages, newMessages);
   }
 };
+const useCurrentLang = () => lang;
 var stdin_default = Locale;
 exports.Locale = Locale;
 exports.default = stdin_default;
+exports.useCurrentLang = useCurrentLang;

package/lib/node_modules/vant/es/notify/Notify.js

@@ -4,8 +4,8 @@ const Vue = require("vue");
 const index = require("../popup/index.js");
 const shared = require("../popup/shared.js");
 const basic = require("../utils/basic.js");
-const create = require("../utils/create.js");
 const props = require("../utils/props.js");
+const create = require("../utils/create.js");
 const [name, bem] = create.createNamespace("notify");
 const popupInheritProps = ["lockScroll", "position", "show", "teleport", "zIndex"];
 const notifyProps = basic.extend({}, shared.popupSharedProps, {

package/lib/node_modules/vant/es/notify/function-call.js

@@ -58,5 +58,11 @@ function showNotify(options) {
   }
   return instance;
 }
+const setNotifyDefaultOptions = (options) => basic.extend(currentOptions, options);
+const resetNotifyDefaultOptions = () => {
+  currentOptions = getDefaultOptions();
+};
 exports.closeNotify = closeNotify;
+exports.resetNotifyDefaultOptions = resetNotifyDefaultOptions;
+exports.setNotifyDefaultOptions = setNotifyDefaultOptions;
 exports.showNotify = showNotify;

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

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

package/lib/node_modules/vant/es/number-keyboard/NumberKeyboard.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const index_esm = require("../../../@vant/use/dist/index.esm.js");
+const NumberKeyboardKey = require("./NumberKeyboardKey.js");
+const dom = require("../utils/dom.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const constant = require("../utils/constant.js");
+const [name, bem] = create.createNamespace("number-keyboard");
+const numberKeyboardProps = {
+  show: Boolean,
+  title: String,
+  theme: props.makeStringProp("default"),
+  zIndex: props.numericProp,
+  teleport: [String, Object],
+  maxlength: props.makeNumericProp(Infinity),
+  modelValue: props.makeStringProp(""),
+  transition: props.truthProp,
+  blurOnClose: props.truthProp,
+  showDeleteKey: props.truthProp,
+  randomKeyOrder: Boolean,
+  closeButtonText: String,
+  deleteButtonText: String,
+  closeButtonLoading: Boolean,
+  hideOnClickOutside: props.truthProp,
+  safeAreaInsetBottom: props.truthProp,
+  extraKey: {
+    type: [String, Array],
+    default: ""
+  }
+};
+function shuffle(array) {
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    const temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+  }
+  return array;
+}
+var stdin_default = Vue.defineComponent({
+  name,
+  inheritAttrs: false,
+  props: numberKeyboardProps,
+  emits: ["show", "hide", "blur", "input", "close", "delete", "update:modelValue"],
+  setup(props2, {
+    emit,
+    slots,
+    attrs
+  }) {
+    const root = Vue.ref();
+    const genBasicKeys = () => {
+      const keys2 = Array(9).fill("").map((_, i) => ({
+        text: i + 1
+      }));
+      if (props2.randomKeyOrder) {
+        shuffle(keys2);
+      }
+      return keys2;
+    };
+    const genDefaultKeys = () => [...genBasicKeys(), {
+      text: props2.extraKey,
+      type: "extra"
+    }, {
+      text: 0
+    }, {
+      text: props2.showDeleteKey ? props2.deleteButtonText : "",
+      type: props2.showDeleteKey ? "delete" : ""
+    }];
+    const genCustomKeys = () => {
+      const keys2 = genBasicKeys();
+      const {
+        extraKey
+      } = props2;
+      const extraKeys = Array.isArray(extraKey) ? extraKey : [extraKey];
+      if (extraKeys.length === 0) {
+        keys2.push({
+          text: 0,
+          wider: true
+        });
+      } else if (extraKeys.length === 1) {
+        keys2.push({
+          text: 0,
+          wider: true
+        }, {
+          text: extraKeys[0],
+          type: "extra"
+        });
+      } else if (extraKeys.length === 2) {
+        keys2.push({
+          text: extraKeys[0],
+          type: "extra"
+        }, {
+          text: 0
+        }, {
+          text: extraKeys[1],
+          type: "extra"
+        });
+      }
+      return keys2;
+    };
+    const keys = Vue.computed(() => props2.theme === "custom" ? genCustomKeys() : genDefaultKeys());
+    const onBlur = () => {
+      if (props2.show) {
+        emit("blur");
+      }
+    };
+    const onClose = () => {
+      emit("close");
+      if (props2.blurOnClose) {
+        onBlur();
+      }
+    };
+    const onAnimationEnd = () => emit(props2.show ? "show" : "hide");
+    const onPress = (text, type) => {
+      if (text === "") {
+        if (type === "extra") {
+          onBlur();
+        }
+        return;
+      }
+      const value = props2.modelValue;
+      if (type === "delete") {
+        emit("delete");
+        emit("update:modelValue", value.slice(0, value.length - 1));
+      } else if (type === "close") {
+        onClose();
+      } else if (value.length < +props2.maxlength) {
+        emit("input", text);
+        emit("update:modelValue", value + text);
+      }
+    };
+    const renderTitle = () => {
+      const {
+        title,
+        theme,
+        closeButtonText
+      } = props2;
+      const leftSlot = slots["title-left"];
+      const showClose = closeButtonText && theme === "default";
+      const showTitle = title || showClose || leftSlot;
+      if (!showTitle) {
+        return;
+      }
+      return Vue.createVNode("div", {
+        "class": bem("header")
+      }, [leftSlot && Vue.createVNode("span", {
+        "class": bem("title-left")
+      }, [leftSlot()]), title && Vue.createVNode("h2", {
+        "class": bem("title")
+      }, [title]), showClose && Vue.createVNode("button", {
+        "type": "button",
+        "class": [bem("close"), constant.HAPTICS_FEEDBACK],
+        "onClick": onClose
+      }, [closeButtonText])]);
+    };
+    const renderKeys = () => keys.value.map((key) => {
+      const keySlots = {};
+      if (key.type === "delete") {
+        keySlots.default = slots.delete;
+      }
+      if (key.type === "extra") {
+        keySlots.default = slots["extra-key"];
+      }
+      return Vue.createVNode(NumberKeyboardKey.default, {
+        "key": key.text,
+        "text": key.text,
+        "type": key.type,
+        "wider": key.wider,
+        "color": key.color,
+        "onPress": onPress
+      }, keySlots);
+    });
+    const renderSidebar = () => {
+      if (props2.theme === "custom") {
+        return Vue.createVNode("div", {
+          "class": bem("sidebar")
+        }, [props2.showDeleteKey && Vue.createVNode(NumberKeyboardKey.default, {
+          "large": true,
+          "text": props2.deleteButtonText,
+          "type": "delete",
+          "onPress": onPress
+        }, {
+          default: slots.delete
+        }), Vue.createVNode(NumberKeyboardKey.default, {
+          "large": true,
+          "text": props2.closeButtonText,
+          "type": "close",
+          "color": "blue",
+          "loading": props2.closeButtonLoading,
+          "onPress": onPress
+        }, null)]);
+      }
+    };
+    Vue.watch(() => props2.show, (value) => {
+      if (!props2.transition) {
+        emit(value ? "show" : "hide");
+      }
+    });
+    if (props2.hideOnClickOutside) {
+      index_esm.useClickAway(root, onBlur, {
+        eventName: "touchstart"
+      });
+    }
+    return () => {
+      const Title = renderTitle();
+      const Content = Vue.createVNode(Vue.Transition, {
+        "name": props2.transition ? "van-slide-up" : ""
+      }, {
+        default: () => [Vue.withDirectives(Vue.createVNode("div", Vue.mergeProps({
+          "ref": root,
+          "style": format.getZIndexStyle(props2.zIndex),
+          "class": bem({
+            unfit: !props2.safeAreaInsetBottom,
+            "with-title": !!Title
+          }),
+          "onAnimationend": onAnimationEnd,
+          "onTouchstartPassive": dom.stopPropagation
+        }, attrs), [Title, Vue.createVNode("div", {
+          "class": bem("body")
+        }, [Vue.createVNode("div", {
+          "class": bem("keys")
+        }, [renderKeys()]), renderSidebar()])]), [[Vue.vShow, props2.show]])]
+      });
+      if (props2.teleport) {
+        return Vue.createVNode(Vue.Teleport, {
+          "to": props2.teleport
+        }, {
+          default: () => [Content]
+        });
+      }
+      return Content;
+    };
+  }
+});
+exports.default = stdin_default;
+exports.numberKeyboardProps = numberKeyboardProps;