@fecp/designer 5.5.113 → 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

@@ -0,0 +1,161 @@
+"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;
+  return function(...args) {
+    if (timeout) {
+      return;
+    }
+    const elapsed = Date.now() - lastRun;
+    const runCallback = () => {
+      lastRun = Date.now();
+      timeout = false;
+      action.apply(this, args);
+    };
+    if (elapsed >= delay) {
+      runCallback();
+    } else {
+      timeout = setTimeout(runCallback, 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/list/List.js

@@ -0,0 +1,145 @@
+"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 useExpose = require("../composables/use-expose.js");
+const useTabStatus = require("../composables/use-tab-status.js");
+const index = require("../loading/index.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const [name, bem, t] = create.createNamespace("list");
+const listProps = {
+  error: Boolean,
+  offset: props.makeNumericProp(300),
+  loading: Boolean,
+  disabled: Boolean,
+  finished: Boolean,
+  scroller: Object,
+  errorText: String,
+  direction: props.makeStringProp("down"),
+  loadingText: String,
+  finishedText: String,
+  immediateCheck: props.truthProp
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: listProps,
+  emits: ["load", "update:error", "update:loading"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const loading = Vue.ref(props2.loading);
+    const root = Vue.ref();
+    const placeholder = Vue.ref();
+    const tabStatus = useTabStatus.useTabStatus();
+    const scrollParent = index_esm.useScrollParent(root);
+    const scroller = Vue.computed(() => props2.scroller || scrollParent.value);
+    const check = () => {
+      Vue.nextTick(() => {
+        if (loading.value || props2.finished || props2.disabled || props2.error || // skip check when inside an inactive tab
+        (tabStatus == null ? void 0 : tabStatus.value) === false) {
+          return;
+        }
+        const {
+          direction
+        } = props2;
+        const offset = +props2.offset;
+        const scrollParentRect = index_esm.useRect(scroller);
+        if (!scrollParentRect.height || dom.isHidden(root)) {
+          return;
+        }
+        let isReachEdge = false;
+        const placeholderRect = index_esm.useRect(placeholder);
+        if (direction === "up") {
+          isReachEdge = scrollParentRect.top - placeholderRect.top <= offset;
+        } else {
+          isReachEdge = placeholderRect.bottom - scrollParentRect.bottom <= offset;
+        }
+        if (isReachEdge) {
+          loading.value = true;
+          emit("update:loading", true);
+          emit("load");
+        }
+      });
+    };
+    const renderFinishedText = () => {
+      if (props2.finished) {
+        const text = slots.finished ? slots.finished() : props2.finishedText;
+        if (text) {
+          return Vue.createVNode("div", {
+            "class": bem("finished-text")
+          }, [text]);
+        }
+      }
+    };
+    const clickErrorText = () => {
+      emit("update:error", false);
+      check();
+    };
+    const renderErrorText = () => {
+      if (props2.error) {
+        const text = slots.error ? slots.error() : props2.errorText;
+        if (text) {
+          return Vue.createVNode("div", {
+            "role": "button",
+            "class": bem("error-text"),
+            "tabindex": 0,
+            "onClick": clickErrorText
+          }, [text]);
+        }
+      }
+    };
+    const renderLoading = () => {
+      if (loading.value && !props2.finished && !props2.disabled) {
+        return Vue.createVNode("div", {
+          "class": bem("loading")
+        }, [slots.loading ? slots.loading() : Vue.createVNode(index.Loading, {
+          "class": bem("loading-icon")
+        }, {
+          default: () => [props2.loadingText || t("loading")]
+        })]);
+      }
+    };
+    Vue.watch(() => [props2.loading, props2.finished, props2.error], check);
+    if (tabStatus) {
+      Vue.watch(tabStatus, (tabActive) => {
+        if (tabActive) {
+          check();
+        }
+      });
+    }
+    Vue.onUpdated(() => {
+      loading.value = props2.loading;
+    });
+    Vue.onMounted(() => {
+      if (props2.immediateCheck) {
+        check();
+      }
+    });
+    useExpose.useExpose({
+      check
+    });
+    index_esm.useEventListener("scroll", check, {
+      target: scroller,
+      passive: true
+    });
+    return () => {
+      var _a;
+      const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
+      const Placeholder = Vue.createVNode("div", {
+        "ref": placeholder,
+        "class": bem("placeholder")
+      }, null);
+      return Vue.createVNode("div", {
+        "ref": root,
+        "role": "feed",
+        "class": bem(),
+        "aria-busy": loading.value
+      }, [props2.direction === "down" ? Content : Placeholder, renderLoading(), renderFinishedText(), renderErrorText(), props2.direction === "up" ? Content : Placeholder]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.listProps = listProps;

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

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

package/lib/node_modules/vant/es/loading/Loading.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const format = require("../utils/format.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const [name, bem] = create.createNamespace("loading");
+const SpinIcon = Array(12).fill(null).map((_, index) => Vue.createVNode("i", {
+  "class": bem("line", String(index + 1))
+}, null));
+const CircularIcon = Vue.createVNode("svg", {
+  "class": bem("circular"),
+  "viewBox": "25 25 50 50"
+}, [Vue.createVNode("circle", {
+  "cx": "50",
+  "cy": "50",
+  "r": "20",
+  "fill": "none"
+}, null)]);
+const loadingProps = {
+  size: props.numericProp,
+  type: props.makeStringProp("circular"),
+  color: String,
+  vertical: Boolean,
+  textSize: props.numericProp,
+  textColor: String
+};
+var stdin_default = Vue.defineComponent({
+  name,
+  props: loadingProps,
+  setup(props2, {
+    slots
+  }) {
+    const spinnerStyle = Vue.computed(() => basic.extend({
+      color: props2.color
+    }, format.getSizeStyle(props2.size)));
+    const renderIcon = () => {
+      const DefaultIcon = props2.type === "spinner" ? SpinIcon : CircularIcon;
+      return Vue.createVNode("span", {
+        "class": bem("spinner", props2.type),
+        "style": spinnerStyle.value
+      }, [slots.icon ? slots.icon() : DefaultIcon]);
+    };
+    const renderText = () => {
+      var _a;
+      if (slots.default) {
+        return Vue.createVNode("span", {
+          "class": bem("text"),
+          "style": {
+            fontSize: format.addUnit(props2.textSize),
+            color: (_a = props2.textColor) != null ? _a : props2.color
+          }
+        }, [slots.default()]);
+      }
+    };
+    return () => {
+      const {
+        type,
+        vertical
+      } = props2;
+      return Vue.createVNode("div", {
+        "class": bem([type, {
+          vertical
+        }]),
+        "aria-live": "polite",
+        "aria-busy": true
+      }, [renderIcon(), renderText()]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.loadingProps = loadingProps;

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

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

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Vue = require("vue");
+const deepAssign = require("../utils/deep-assign.js");
+const zhCN = require("./lang/zh-CN.js");
+const lang = Vue.ref("zh-CN");
+const messages = Vue.reactive({
+  "zh-CN": zhCN.default
+});
+const Locale = {
+  messages() {
+    return messages[lang.value];
+  },
+  use(newLang, newMessages) {
+    lang.value = newLang;
+    this.add({ [newLang]: newMessages });
+  },
+  add(newMessages = {}) {
+    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/locale/lang/zh-CN.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var stdin_default = {
+  name: "姓名",
+  tel: "电话",
+  save: "保存",
+  clear: "清空",
+  cancel: "取消",
+  confirm: "确认",
+  delete: "删除",
+  loading: "加载中...",
+  noCoupon: "暂无优惠券",
+  nameEmpty: "请填写姓名",
+  addContact: "添加联系人",
+  telInvalid: "请填写正确的电话",
+  vanCalendar: {
+    end: "结束",
+    start: "开始",
+    title: "日期选择",
+    weekdays: ["日", "一", "二", "三", "四", "五", "六"],
+    monthTitle: (year, month) => `${year}年${month}月`,
+    rangePrompt: (maxRange) => `最多选择 ${maxRange} 天`
+  },
+  vanCascader: {
+    select: "请选择"
+  },
+  vanPagination: {
+    prev: "上一页",
+    next: "下一页"
+  },
+  vanPullRefresh: {
+    pulling: "下拉即可刷新...",
+    loosing: "释放即可刷新..."
+  },
+  vanSubmitBar: {
+    label: "合计:"
+  },
+  vanCoupon: {
+    unlimited: "无门槛",
+    discount: (discount) => `${discount}折`,
+    condition: (condition) => `满${condition}元可用`
+  },
+  vanCouponCell: {
+    title: "优惠券",
+    count: (count) => `${count}张可用`
+  },
+  vanCouponList: {
+    exchange: "兑换",
+    close: "不使用",
+    enable: "可用",
+    disabled: "不可用",
+    placeholder: "输入优惠码"
+  },
+  vanAddressEdit: {
+    area: "地区",
+    areaEmpty: "请选择地区",
+    addressEmpty: "请填写详细地址",
+    addressDetail: "详细地址",
+    defaultAddress: "设为默认收货地址"
+  },
+  vanAddressList: {
+    add: "新增地址"
+  }
+};
+exports.default = stdin_default;