@fecp/designer 5.5.113 → 5.5.115

package/es/node_modules/vant/es/address-list/AddressListItem.mjs

@@ -0,0 +1,110 @@
+import { defineComponent, createVNode } from "vue";
+import { Tag } from "../tag/index.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Cell } from "../cell/index.mjs";
+import { Radio } from "../radio/index.mjs";
+import { Checkbox } from "../checkbox/index.mjs";
+import { makeStringProp, makeRequiredProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { extend } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("address-item");
+var stdin_default = defineComponent({
+  name,
+  props: {
+    address: makeRequiredProp(Object),
+    disabled: Boolean,
+    switchable: Boolean,
+    singleChoice: Boolean,
+    defaultTagText: String,
+    rightIcon: makeStringProp("edit")
+  },
+  emits: ["edit", "click", "select"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const onClick = (event) => {
+      if (props.switchable) {
+        emit("select");
+      }
+      emit("click", event);
+    };
+    const renderRightIcon = () => createVNode(Icon, {
+      "name": props.rightIcon,
+      "class": bem("edit"),
+      "onClick": (event) => {
+        event.stopPropagation();
+        emit("edit");
+        emit("click", event);
+      }
+    }, null);
+    const renderTag = () => {
+      if (slots.tag) {
+        return slots.tag(props.address);
+      }
+      if (props.address.isDefault && props.defaultTagText) {
+        return createVNode(Tag, {
+          "type": "primary",
+          "round": true,
+          "class": bem("tag")
+        }, {
+          default: () => [props.defaultTagText]
+        });
+      }
+    };
+    const renderContent = () => {
+      const {
+        address,
+        disabled,
+        switchable,
+        singleChoice
+      } = props;
+      const Info = [createVNode("div", {
+        "class": bem("name")
+      }, [`${address.name} ${address.tel}`, renderTag()]), createVNode("div", {
+        "class": bem("address")
+      }, [address.address])];
+      if (switchable && !disabled) {
+        if (singleChoice) {
+          return createVNode(Radio, {
+            "name": address.id,
+            "iconSize": 18
+          }, {
+            default: () => [Info]
+          });
+        } else {
+          return createVNode(Checkbox, {
+            "name": address.id,
+            "iconSize": 18
+          }, {
+            default: () => [Info]
+          });
+        }
+      }
+      return Info;
+    };
+    return () => {
+      var _a;
+      const {
+        disabled
+      } = props;
+      return createVNode("div", {
+        "class": bem({
+          disabled
+        }),
+        "onClick": onClick
+      }, [createVNode(Cell, {
+        "border": false,
+        "titleClass": bem("title")
+      }, {
+        title: renderContent,
+        "right-icon": renderRightIcon
+      }), (_a = slots.bottom) == null ? void 0 : _a.call(slots, extend({}, props.address, {
+        disabled
+      }))]);
+    };
+  }
+});
+export {
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/area/Area.mjs

@@ -0,0 +1,78 @@
+import { defineComponent, ref, computed, watch, createVNode, mergeProps } from "vue";
+import { pickerSharedProps } from "../picker/Picker.mjs";
+import { INHERIT_PROPS, formatDataForCascade, INHERIT_SLOTS } from "./utils.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { Picker } from "../picker/index.mjs";
+import { extend, pick } from "../utils/basic.mjs";
+import { makeArrayProp, makeNumericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+const [name, bem] = createNamespace("area");
+const areaProps = extend({}, pick(pickerSharedProps, INHERIT_PROPS), {
+  modelValue: String,
+  columnsNum: makeNumericProp(3),
+  columnsPlaceholder: makeArrayProp(),
+  areaList: {
+    type: Object,
+    default: () => ({})
+  }
+});
+var stdin_default = defineComponent({
+  name,
+  props: areaProps,
+  emits: ["change", "confirm", "cancel", "update:modelValue"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const codes = ref([]);
+    const picker = ref();
+    const columns = computed(() => formatDataForCascade(props));
+    const onChange = (...args) => emit("change", ...args);
+    const onCancel = (...args) => emit("cancel", ...args);
+    const onConfirm = (...args) => emit("confirm", ...args);
+    watch(codes, (newCodes) => {
+      const lastCode = newCodes.length ? newCodes[newCodes.length - 1] : "";
+      if (lastCode && lastCode !== props.modelValue) {
+        emit("update:modelValue", lastCode);
+      }
+    }, {
+      deep: true
+    });
+    watch(() => props.modelValue, (newCode) => {
+      if (newCode) {
+        const lastCode = codes.value.length ? codes.value[codes.value.length - 1] : "";
+        if (newCode !== lastCode) {
+          codes.value = [`${newCode.slice(0, 2)}0000`, `${newCode.slice(0, 4)}00`, newCode].slice(0, +props.columnsNum);
+        }
+      } else {
+        codes.value = [];
+      }
+    }, {
+      immediate: true
+    });
+    useExpose({
+      confirm: () => {
+        var _a;
+        return (_a = picker.value) == null ? void 0 : _a.confirm();
+      },
+      getSelectedOptions: () => {
+        var _a;
+        return ((_a = picker.value) == null ? void 0 : _a.getSelectedOptions()) || [];
+      }
+    });
+    return () => createVNode(Picker, mergeProps({
+      "ref": picker,
+      "modelValue": codes.value,
+      "onUpdate:modelValue": ($event) => codes.value = $event,
+      "class": bem(),
+      "columns": columns.value,
+      "onChange": onChange,
+      "onCancel": onCancel,
+      "onConfirm": onConfirm
+    }, pick(props, INHERIT_PROPS)), pick(slots, INHERIT_SLOTS));
+  }
+});
+export {
+  areaProps,
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/area/utils.mjs

@@ -0,0 +1,92 @@
+const AREA_EMPTY_CODE = "000000";
+const INHERIT_SLOTS = [
+  "title",
+  "cancel",
+  "confirm",
+  "toolbar",
+  "columns-top",
+  "columns-bottom"
+];
+const INHERIT_PROPS = [
+  "title",
+  "loading",
+  "readonly",
+  "optionHeight",
+  "swipeDuration",
+  "visibleOptionNum",
+  "cancelButtonText",
+  "confirmButtonText"
+];
+const makeOption = (text = "", value = AREA_EMPTY_CODE, children = void 0) => ({
+  text,
+  value,
+  children
+});
+function formatDataForCascade({
+  areaList,
+  columnsNum,
+  columnsPlaceholder: placeholder
+}) {
+  const {
+    city_list: city = {},
+    county_list: county = {},
+    province_list: province = {}
+  } = areaList;
+  const showCity = +columnsNum > 1;
+  const showCounty = +columnsNum > 2;
+  const getProvinceChildren = () => {
+    if (showCity) {
+      return placeholder.length > 1 ? [
+        makeOption(
+          placeholder[1],
+          AREA_EMPTY_CODE,
+          showCounty ? [] : void 0
+        )
+      ] : [];
+    }
+  };
+  const provinceMap = /* @__PURE__ */ new Map();
+  Object.keys(province).forEach((code) => {
+    provinceMap.set(
+      code.slice(0, 2),
+      makeOption(province[code], code, getProvinceChildren())
+    );
+  });
+  const cityMap = /* @__PURE__ */ new Map();
+  if (showCity) {
+    const getCityChildren = () => {
+      if (showCounty) {
+        return placeholder.length > 2 ? [makeOption(placeholder[2])] : [];
+      }
+    };
+    Object.keys(city).forEach((code) => {
+      const option = makeOption(city[code], code, getCityChildren());
+      cityMap.set(code.slice(0, 4), option);
+      const province2 = provinceMap.get(code.slice(0, 2));
+      if (province2) {
+        province2.children.push(option);
+      }
+    });
+  }
+  if (showCounty) {
+    Object.keys(county).forEach((code) => {
+      const city2 = cityMap.get(code.slice(0, 4));
+      if (city2) {
+        city2.children.push(makeOption(county[code], code));
+      }
+    });
+  }
+  const options = Array.from(provinceMap.values());
+  if (placeholder.length) {
+    const county2 = showCounty ? [makeOption(placeholder[2])] : void 0;
+    const city2 = showCity ? [makeOption(placeholder[1], AREA_EMPTY_CODE, county2)] : void 0;
+    options.unshift(makeOption(placeholder[0], AREA_EMPTY_CODE, city2));
+  }
+  return options;
+}
+export {
+  AREA_EMPTY_CODE,
+  INHERIT_PROPS,
+  INHERIT_SLOTS,
+  formatDataForCascade
+};

package/es/node_modules/vant/es/back-top/BackTop.mjs

@@ -0,0 +1,119 @@
+import { defineComponent, ref, computed, onMounted, onActivated, onDeactivated, watch, createVNode, mergeProps, Teleport, nextTick } from "vue";
+import { throttle } from "../lazyload/vue-lazyload/util.mjs";
+import { useEventListener, getScrollParent } from "../../../@vant/use/dist/index.esm.mjs";
+import { Icon } from "../icon/index.mjs";
+import { makeNumericProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { extend, inBrowser } from "../utils/basic.mjs";
+import { getZIndexStyle, addUnit } from "../utils/format.mjs";
+import { getScrollTop } from "../utils/dom.mjs";
+const [name, bem] = createNamespace("back-top");
+const backTopProps = {
+  right: numericProp,
+  bottom: numericProp,
+  zIndex: numericProp,
+  target: [String, Object],
+  offset: makeNumericProp(200),
+  immediate: Boolean,
+  teleport: {
+    type: [String, Object],
+    default: "body"
+  }
+};
+var stdin_default = defineComponent({
+  name,
+  inheritAttrs: false,
+  props: backTopProps,
+  emits: ["click"],
+  setup(props, {
+    emit,
+    slots,
+    attrs
+  }) {
+    let shouldReshow = false;
+    const show = ref(false);
+    const root = ref();
+    const scrollParent = ref();
+    const style = computed(() => extend(getZIndexStyle(props.zIndex), {
+      right: addUnit(props.right),
+      bottom: addUnit(props.bottom)
+    }));
+    const onClick = (event) => {
+      var _a;
+      emit("click", event);
+      (_a = scrollParent.value) == null ? void 0 : _a.scrollTo({
+        top: 0,
+        behavior: props.immediate ? "auto" : "smooth"
+      });
+    };
+    const scroll = () => {
+      show.value = scrollParent.value ? getScrollTop(scrollParent.value) >= +props.offset : false;
+    };
+    const getTarget = () => {
+      const {
+        target
+      } = props;
+      if (typeof target === "string") {
+        const el = document.querySelector(target);
+        if (el) {
+          return el;
+        }
+      } else {
+        return target;
+      }
+    };
+    const updateTarget = () => {
+      if (inBrowser) {
+        nextTick(() => {
+          scrollParent.value = props.target ? getTarget() : getScrollParent(root.value);
+          scroll();
+        });
+      }
+    };
+    useEventListener("scroll", throttle(scroll, 100), {
+      target: scrollParent
+    });
+    onMounted(updateTarget);
+    onActivated(() => {
+      if (shouldReshow) {
+        show.value = true;
+        shouldReshow = false;
+      }
+    });
+    onDeactivated(() => {
+      if (show.value && props.teleport) {
+        show.value = false;
+        shouldReshow = true;
+      }
+    });
+    watch(() => props.target, updateTarget);
+    return () => {
+      const Content = createVNode("div", mergeProps({
+        "ref": !props.teleport ? root : void 0,
+        "class": bem({
+          active: show.value
+        }),
+        "style": style.value,
+        "onClick": onClick
+      }, attrs), [slots.default ? slots.default() : createVNode(Icon, {
+        "name": "back-top",
+        "class": bem("icon")
+      }, null)]);
+      if (props.teleport) {
+        return [createVNode("div", {
+          "ref": root,
+          "class": bem("placeholder")
+        }, null), createVNode(Teleport, {
+          "to": props.teleport
+        }, {
+          default: () => [Content]
+        })];
+      }
+      return Content;
+    };
+  }
+});
+export {
+  backTopProps,
+  stdin_default as default
+};

package/es/node_modules/vant/es/back-top/index.mjs

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

package/es/node_modules/vant/es/badge/Badge.mjs

@@ -0,0 +1,107 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { makeStringProp, truthProp, numericProp } from "../utils/props.mjs";
+import { addUnit } from "../utils/format.mjs";
+import { isDef, isNumeric } from "../utils/basic.mjs";
+import { createNamespace } from "../utils/create.mjs";
+const [name, bem] = createNamespace("badge");
+const badgeProps = {
+  dot: Boolean,
+  max: numericProp,
+  tag: makeStringProp("div"),
+  color: String,
+  offset: Array,
+  content: numericProp,
+  showZero: truthProp,
+  position: makeStringProp("top-right")
+};
+var stdin_default = defineComponent({
+  name,
+  props: badgeProps,
+  setup(props, {
+    slots
+  }) {
+    const hasContent = () => {
+      if (slots.content) {
+        return true;
+      }
+      const {
+        content,
+        showZero
+      } = props;
+      return isDef(content) && content !== "" && (showZero || content !== 0 && content !== "0");
+    };
+    const renderContent = () => {
+      const {
+        dot,
+        max,
+        content
+      } = props;
+      if (!dot && hasContent()) {
+        if (slots.content) {
+          return slots.content();
+        }
+        if (isDef(max) && isNumeric(content) && +content > +max) {
+          return `${max}+`;
+        }
+        return content;
+      }
+    };
+    const getOffsetWithMinusString = (val) => val.startsWith("-") ? val.replace("-", "") : `-${val}`;
+    const style = computed(() => {
+      const style2 = {
+        background: props.color
+      };
+      if (props.offset) {
+        const [x, y] = props.offset;
+        const {
+          position
+        } = props;
+        const [offsetY, offsetX] = position.split("-");
+        if (slots.default) {
+          if (typeof y === "number") {
+            style2[offsetY] = addUnit(offsetY === "top" ? y : -y);
+          } else {
+            style2[offsetY] = offsetY === "top" ? addUnit(y) : getOffsetWithMinusString(y);
+          }
+          if (typeof x === "number") {
+            style2[offsetX] = addUnit(offsetX === "left" ? x : -x);
+          } else {
+            style2[offsetX] = offsetX === "left" ? addUnit(x) : getOffsetWithMinusString(x);
+          }
+        } else {
+          style2.marginTop = addUnit(y);
+          style2.marginLeft = addUnit(x);
+        }
+      }
+      return style2;
+    });
+    const renderBadge = () => {
+      if (hasContent() || props.dot) {
+        return createVNode("div", {
+          "class": bem([props.position, {
+            dot: props.dot,
+            fixed: !!slots.default
+          }]),
+          "style": style.value
+        }, [renderContent()]);
+      }
+    };
+    return () => {
+      if (slots.default) {
+        const {
+          tag
+        } = props;
+        return createVNode(tag, {
+          "class": bem("wrapper")
+        }, {
+          default: () => [slots.default(), renderBadge()]
+        });
+      }
+      return renderBadge();
+    };
+  }
+});
+export {
+  badgeProps,
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/barrage/Barrage.mjs

@@ -0,0 +1,134 @@
+import { defineComponent, ref, watch, onMounted, createVNode, nextTick } from "vue";
+import { useExpose } from "../composables/use-expose.mjs";
+import { makeArrayProp, makeNumberProp, truthProp, makeNumericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+const barrageProps = {
+  top: makeNumericProp(10),
+  rows: makeNumericProp(4),
+  duration: makeNumericProp(4e3),
+  autoPlay: truthProp,
+  delay: makeNumberProp(300),
+  modelValue: makeArrayProp()
+};
+const [name, bem] = createNamespace("barrage");
+var stdin_default = defineComponent({
+  name,
+  props: barrageProps,
+  emits: ["update:modelValue"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const barrageWrapper = ref();
+    const className = bem("item");
+    const total = ref(0);
+    const barrageItems = [];
+    const createBarrageItem = (text, delay = props.delay) => {
+      const item = document.createElement("span");
+      item.className = className;
+      item.innerText = String(text);
+      item.style.animationDuration = `${props.duration}ms`;
+      item.style.animationDelay = `${delay}ms`;
+      item.style.animationName = "van-barrage";
+      item.style.animationTimingFunction = "linear";
+      return item;
+    };
+    const isInitBarrage = ref(true);
+    const isPlay = ref(props.autoPlay);
+    const appendBarrageItem = ({
+      id,
+      text
+    }, i) => {
+      var _a;
+      const item = createBarrageItem(text, isInitBarrage.value ? i * props.delay : void 0);
+      if (!props.autoPlay && isPlay.value === false) {
+        item.style.animationPlayState = "paused";
+      }
+      (_a = barrageWrapper.value) == null ? void 0 : _a.append(item);
+      total.value++;
+      const top = (total.value - 1) % +props.rows * item.offsetHeight + +props.top;
+      item.style.top = `${top}px`;
+      item.dataset.id = String(id);
+      barrageItems.push(item);
+      item.addEventListener("animationend", () => {
+        emit("update:modelValue", [...props.modelValue].filter((v) => String(v.id) !== item.dataset.id));
+      });
+    };
+    const updateBarrages = (newValue, oldValue) => {
+      const map = new Map(oldValue.map((item) => [item.id, item]));
+      newValue.forEach((item, i) => {
+        if (map.has(item.id)) {
+          map.delete(item.id);
+        } else {
+          appendBarrageItem(item, i);
+        }
+      });
+      map.forEach((item) => {
+        const index = barrageItems.findIndex((span) => span.dataset.id === String(item.id));
+        if (index > -1) {
+          barrageItems[index].remove();
+          barrageItems.splice(index, 1);
+        }
+      });
+      isInitBarrage.value = false;
+    };
+    watch(() => props.modelValue.slice(), (newValue, oldValue) => updateBarrages(newValue != null ? newValue : [], oldValue != null ? oldValue : []), {
+      deep: true
+    });
+    const rootStyle = ref({});
+    onMounted(() => __async(this, null, function* () {
+      var _a;
+      rootStyle.value["--move-distance"] = `-${(_a = barrageWrapper.value) == null ? void 0 : _a.offsetWidth}px`;
+      yield nextTick();
+      updateBarrages(props.modelValue, []);
+    }));
+    const play = () => {
+      isPlay.value = true;
+      barrageItems.forEach((item) => {
+        item.style.animationPlayState = "running";
+      });
+    };
+    const pause = () => {
+      isPlay.value = false;
+      barrageItems.forEach((item) => {
+        item.style.animationPlayState = "paused";
+      });
+    };
+    useExpose({
+      play,
+      pause
+    });
+    return () => {
+      var _a;
+      return createVNode("div", {
+        "class": bem(),
+        "ref": barrageWrapper,
+        "style": rootStyle.value
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+export {
+  barrageProps,
+  stdin_default as default
+};

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

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