@fecp/designer 5.5.113 → 5.5.115

package/es/node_modules/vant/es/lazyload/vue-lazyload/util.mjs

@@ -0,0 +1,161 @@
+import { inBrowser } from "../../../../@vant/use/dist/index.esm.mjs";
+const hasIntersectionObserver = 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) => inBrowser ? window.devicePixelRatio || scale : scale;
+function supportWebp() {
+  if (!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();
+  }
+}
+export {
+  ImageCache,
+  getBestSelectionFromSrcset,
+  getDPR,
+  hasIntersectionObserver,
+  loadImageAsync,
+  modeType,
+  off,
+  on,
+  remove,
+  supportWebp,
+  throttle
+};

package/es/node_modules/vant/es/list/List.mjs

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

package/es/node_modules/vant/es/list/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./List.mjs";
+import { listProps } from "./List.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const List = withInstall(stdin_default);
+export {
+  List,
+  listProps
+};

package/es/node_modules/vant/es/loading/Loading.mjs

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

package/es/node_modules/vant/es/loading/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./Loading.mjs";
+import { loadingProps } from "./Loading.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const Loading = withInstall(stdin_default);
+export {
+  Loading,
+  loadingProps
+};

package/es/node_modules/vant/es/locale/index.mjs

@@ -0,0 +1,26 @@
+import { ref, reactive } from "vue";
+import { deepAssign } from "../utils/deep-assign.mjs";
+import stdin_default$1 from "./lang/zh-CN.mjs";
+const lang = ref("zh-CN");
+const messages = reactive({
+  "zh-CN": stdin_default$1
+});
+const Locale = {
+  messages() {
+    return messages[lang.value];
+  },
+  use(newLang, newMessages) {
+    lang.value = newLang;
+    this.add({ [newLang]: newMessages });
+  },
+  add(newMessages = {}) {
+    deepAssign(messages, newMessages);
+  }
+};
+const useCurrentLang = () => lang;
+var stdin_default = Locale;
+export {
+  Locale,
+  stdin_default as default,
+  useCurrentLang
+};

package/es/node_modules/vant/es/locale/lang/zh-CN.mjs

@@ -0,0 +1,65 @@
+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: "新增地址"
+  }
+};
+export {
+  stdin_default as default
+};

package/es/node_modules/vant/es/nav-bar/NavBar.mjs

@@ -0,0 +1,108 @@
+import { defineComponent, ref, createVNode } from "vue";
+import { usePlaceholder } from "../composables/use-placeholder.mjs";
+import { Icon } from "../icon/index.mjs";
+import { truthProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { getZIndexStyle } from "../utils/format.mjs";
+import { BORDER_BOTTOM, HAPTICS_FEEDBACK } from "../utils/constant.mjs";
+const [name, bem] = createNamespace("nav-bar");
+const navBarProps = {
+  title: String,
+  fixed: Boolean,
+  zIndex: numericProp,
+  border: truthProp,
+  leftText: String,
+  rightText: String,
+  leftDisabled: Boolean,
+  rightDisabled: Boolean,
+  leftArrow: Boolean,
+  placeholder: Boolean,
+  safeAreaInsetTop: Boolean,
+  clickable: truthProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: navBarProps,
+  emits: ["clickLeft", "clickRight"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const navBarRef = ref();
+    const renderPlaceholder = usePlaceholder(navBarRef, bem);
+    const onClickLeft = (event) => {
+      if (!props.leftDisabled) {
+        emit("clickLeft", event);
+      }
+    };
+    const onClickRight = (event) => {
+      if (!props.rightDisabled) {
+        emit("clickRight", event);
+      }
+    };
+    const renderLeft = () => {
+      if (slots.left) {
+        return slots.left();
+      }
+      return [props.leftArrow && createVNode(Icon, {
+        "class": bem("arrow"),
+        "name": "arrow-left"
+      }, null), props.leftText && createVNode("span", {
+        "class": bem("text")
+      }, [props.leftText])];
+    };
+    const renderRight = () => {
+      if (slots.right) {
+        return slots.right();
+      }
+      return createVNode("span", {
+        "class": bem("text")
+      }, [props.rightText]);
+    };
+    const renderNavBar = () => {
+      const {
+        title,
+        fixed,
+        border,
+        zIndex
+      } = props;
+      const style = getZIndexStyle(zIndex);
+      const hasLeft = props.leftArrow || props.leftText || slots.left;
+      const hasRight = props.rightText || slots.right;
+      return createVNode("div", {
+        "ref": navBarRef,
+        "style": style,
+        "class": [bem({
+          fixed
+        }), {
+          [BORDER_BOTTOM]: border,
+          "van-safe-area-top": props.safeAreaInsetTop
+        }]
+      }, [createVNode("div", {
+        "class": bem("content")
+      }, [hasLeft && createVNode("div", {
+        "class": [bem("left", {
+          disabled: props.leftDisabled
+        }), props.clickable && !props.leftDisabled ? HAPTICS_FEEDBACK : ""],
+        "onClick": onClickLeft
+      }, [renderLeft()]), createVNode("div", {
+        "class": [bem("title"), "van-ellipsis"]
+      }, [slots.title ? slots.title() : title]), hasRight && createVNode("div", {
+        "class": [bem("right", {
+          disabled: props.rightDisabled
+        }), props.clickable && !props.rightDisabled ? HAPTICS_FEEDBACK : ""],
+        "onClick": onClickRight
+      }, [renderRight()])])]);
+    };
+    return () => {
+      if (props.fixed && props.placeholder) {
+        return renderPlaceholder(renderNavBar);
+      }
+      return renderNavBar();
+    };
+  }
+});
+export {
+  stdin_default as default,
+  navBarProps
+};

package/es/node_modules/vant/es/nav-bar/index.mjs

@@ -0,0 +1,8 @@
+import stdin_default from "./NavBar.mjs";
+import { navBarProps } from "./NavBar.mjs";
+import { withInstall } from "../utils/with-install.mjs";
+const NavBar = withInstall(stdin_default);
+export {
+  NavBar,
+  navBarProps
+};