@fecp/designer 5.5.114 → 5.5.115

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/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
+};

package/es/node_modules/vant/es/button/Button.mjs

@@ -4,9 +4,9 @@ import { Icon } from "../icon/index.mjs";
 import { Loading } from "../loading/index.mjs";
 import { BORDER_SURROUND } from "../utils/constant.mjs";
 import { preventDefault } from "../utils/dom.mjs";
-import { createNamespace } from "../utils/create.mjs";
 import { extend } from "../utils/basic.mjs";
 import { makeStringProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
 const [name, bem] = createNamespace("button");
 const buttonProps = extend({}, routeProps, {
   tag: makeStringProp("button"),

package/es/node_modules/vant/es/card/Card.mjs

@@ -0,0 +1,128 @@
+import { defineComponent, createVNode, Fragment, createTextVNode } from "vue";
+import { Tag } from "../tag/index.mjs";
+import { Image } from "../image/index.mjs";
+import { numericProp, makeStringProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { isDef } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("card");
+const cardProps = {
+  tag: String,
+  num: numericProp,
+  desc: String,
+  thumb: String,
+  title: String,
+  price: numericProp,
+  centered: Boolean,
+  lazyLoad: Boolean,
+  currency: makeStringProp("¥"),
+  thumbLink: String,
+  originPrice: numericProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: cardProps,
+  emits: ["clickThumb"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const renderTitle = () => {
+      if (slots.title) {
+        return slots.title();
+      }
+      if (props.title) {
+        return createVNode("div", {
+          "class": [bem("title"), "van-multi-ellipsis--l2"]
+        }, [props.title]);
+      }
+    };
+    const renderThumbTag = () => {
+      if (slots.tag || props.tag) {
+        return createVNode("div", {
+          "class": bem("tag")
+        }, [slots.tag ? slots.tag() : createVNode(Tag, {
+          "mark": true,
+          "type": "primary"
+        }, {
+          default: () => [props.tag]
+        })]);
+      }
+    };
+    const renderThumbImage = () => {
+      if (slots.thumb) {
+        return slots.thumb();
+      }
+      return createVNode(Image, {
+        "src": props.thumb,
+        "fit": "cover",
+        "width": "100%",
+        "height": "100%",
+        "lazyLoad": props.lazyLoad
+      }, null);
+    };
+    const renderThumb = () => {
+      if (slots.thumb || props.thumb) {
+        return createVNode("a", {
+          "href": props.thumbLink,
+          "class": bem("thumb"),
+          "onClick": (event) => emit("clickThumb", event)
+        }, [renderThumbImage(), renderThumbTag()]);
+      }
+    };
+    const renderDesc = () => {
+      if (slots.desc) {
+        return slots.desc();
+      }
+      if (props.desc) {
+        return createVNode("div", {
+          "class": [bem("desc"), "van-ellipsis"]
+        }, [props.desc]);
+      }
+    };
+    const renderPriceText = () => {
+      const priceArr = props.price.toString().split(".");
+      return createVNode("div", null, [createVNode("span", {
+        "class": bem("price-currency")
+      }, [props.currency]), createVNode("span", {
+        "class": bem("price-integer")
+      }, [priceArr[0]]), priceArr.length > 1 && createVNode(Fragment, null, [createTextVNode("."), createVNode("span", {
+        "class": bem("price-decimal")
+      }, [priceArr[1]])])]);
+    };
+    return () => {
+      var _a, _b, _c;
+      const showNum = slots.num || isDef(props.num);
+      const showPrice = slots.price || isDef(props.price);
+      const showOriginPrice = slots["origin-price"] || isDef(props.originPrice);
+      const showBottom = showNum || showPrice || showOriginPrice || slots.bottom;
+      const Price = showPrice && createVNode("div", {
+        "class": bem("price")
+      }, [slots.price ? slots.price() : renderPriceText()]);
+      const OriginPrice = showOriginPrice && createVNode("div", {
+        "class": bem("origin-price")
+      }, [slots["origin-price"] ? slots["origin-price"]() : `${props.currency} ${props.originPrice}`]);
+      const Num = showNum && createVNode("div", {
+        "class": bem("num")
+      }, [slots.num ? slots.num() : `x${props.num}`]);
+      const Footer = slots.footer && createVNode("div", {
+        "class": bem("footer")
+      }, [slots.footer()]);
+      const Bottom = showBottom && createVNode("div", {
+        "class": bem("bottom")
+      }, [(_a = slots["price-top"]) == null ? void 0 : _a.call(slots), Price, OriginPrice, Num, (_b = slots.bottom) == null ? void 0 : _b.call(slots)]);
+      return createVNode("div", {
+        "class": bem()
+      }, [createVNode("div", {
+        "class": bem("header")
+      }, [renderThumb(), createVNode("div", {
+        "class": bem("content", {
+          centered: props.centered
+        })
+      }, [createVNode("div", null, [renderTitle(), renderDesc(), (_c = slots.tags) == null ? void 0 : _c.call(slots)]), Bottom])]), Footer]);
+    };
+  }
+});
+export {
+  cardProps,
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/checkbox/Checkbox.mjs

@@ -4,8 +4,8 @@ import { useParent, useCustomFieldValue } from "../../../@vant/use/dist/index.es
 import { useExpose } from "../composables/use-expose.mjs";
 import stdin_default$1, { checkerProps } from "./Checker.mjs";
 import { extend, pick } from "../utils/basic.mjs";
-import { createNamespace } from "../utils/create.mjs";
 import { truthProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
 const [name, bem] = createNamespace("checkbox");
 const checkboxProps = extend({}, checkerProps, {
   shape: String,

package/es/node_modules/vant/es/checkbox-group/CheckboxGroup.mjs

@@ -1,8 +1,8 @@
 import { defineComponent, watch, createVNode } from "vue";
 import { useChildren, useCustomFieldValue } from "../../../@vant/use/dist/index.esm.mjs";
 import { useExpose } from "../composables/use-expose.mjs";
-import { createNamespace } from "../utils/create.mjs";
 import { makeArrayProp, numericProp, makeStringProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
 const [name, bem] = createNamespace("checkbox-group");
 const checkboxGroupProps = {
   max: numericProp,

package/es/node_modules/vant/es/circle/Circle.mjs

@@ -0,0 +1,155 @@
+import { defineComponent, computed, watch, createVNode } from "vue";
+import { cancelRaf, raf } from "../../../@vant/use/dist/index.esm.mjs";
+import { makeStringProp, makeNumericProp, makeNumberProp, truthProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { getSizeStyle } from "../utils/format.mjs";
+import { isObject } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("circle");
+let uid = 0;
+const format = (rate) => Math.min(Math.max(+rate, 0), 100);
+function getPath(clockwise, viewBoxSize) {
+  const sweepFlag = clockwise ? 1 : 0;
+  return `M ${viewBoxSize / 2} ${viewBoxSize / 2} m 0, -500 a 500, 500 0 1, ${sweepFlag} 0, 1000 a 500, 500 0 1, ${sweepFlag} 0, -1000`;
+}
+const circleProps = {
+  text: String,
+  size: numericProp,
+  fill: makeStringProp("none"),
+  rate: makeNumericProp(100),
+  speed: makeNumericProp(0),
+  color: [String, Object],
+  clockwise: truthProp,
+  layerColor: String,
+  currentRate: makeNumberProp(0),
+  strokeWidth: makeNumericProp(40),
+  strokeLinecap: String,
+  startPosition: makeStringProp("top")
+};
+var stdin_default = defineComponent({
+  name,
+  props: circleProps,
+  emits: ["update:currentRate"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const id = `van-circle-${uid++}`;
+    const viewBoxSize = computed(() => +props.strokeWidth + 1e3);
+    const path = computed(() => getPath(props.clockwise, viewBoxSize.value));
+    const svgStyle = computed(() => {
+      const ROTATE_ANGLE_MAP = {
+        top: 0,
+        right: 90,
+        bottom: 180,
+        left: 270
+      };
+      const angleValue = ROTATE_ANGLE_MAP[props.startPosition];
+      if (angleValue) {
+        return {
+          transform: `rotate(${angleValue}deg)`
+        };
+      }
+    });
+    watch(() => props.rate, (rate) => {
+      let rafId;
+      const startTime = Date.now();
+      const startRate = props.currentRate;
+      const endRate = format(rate);
+      const duration = Math.abs((startRate - endRate) * 1e3 / +props.speed);
+      const animate = () => {
+        const now = Date.now();
+        const progress = Math.min((now - startTime) / duration, 1);
+        const rate2 = progress * (endRate - startRate) + startRate;
+        emit("update:currentRate", format(parseFloat(rate2.toFixed(1))));
+        if (endRate > startRate ? rate2 < endRate : rate2 > endRate) {
+          rafId = raf(animate);
+        }
+      };
+      if (props.speed) {
+        if (rafId) {
+          cancelRaf(rafId);
+        }
+        rafId = raf(animate);
+      } else {
+        emit("update:currentRate", endRate);
+      }
+    }, {
+      immediate: true
+    });
+    const renderHover = () => {
+      const PERIMETER = 3140;
+      const {
+        strokeWidth,
+        currentRate,
+        strokeLinecap
+      } = props;
+      const offset = PERIMETER * currentRate / 100;
+      const color = isObject(props.color) ? `url(#${id})` : props.color;
+      const style = {
+        stroke: color,
+        strokeWidth: `${+strokeWidth + 1}px`,
+        strokeLinecap,
+        strokeDasharray: `${offset}px ${PERIMETER}px`
+      };
+      return createVNode("path", {
+        "d": path.value,
+        "style": style,
+        "class": bem("hover"),
+        "stroke": color
+      }, null);
+    };
+    const renderLayer = () => {
+      const style = {
+        fill: props.fill,
+        stroke: props.layerColor,
+        strokeWidth: `${props.strokeWidth}px`
+      };
+      return createVNode("path", {
+        "class": bem("layer"),
+        "style": style,
+        "d": path.value
+      }, null);
+    };
+    const renderGradient = () => {
+      const {
+        color
+      } = props;
+      if (!isObject(color)) {
+        return;
+      }
+      const Stops = Object.keys(color).sort((a, b) => parseFloat(a) - parseFloat(b)).map((key, index) => createVNode("stop", {
+        "key": index,
+        "offset": key,
+        "stop-color": color[key]
+      }, null));
+      return createVNode("defs", null, [createVNode("linearGradient", {
+        "id": id,
+        "x1": "100%",
+        "y1": "0%",
+        "x2": "0%",
+        "y2": "0%"
+      }, [Stops])]);
+    };
+    const renderText = () => {
+      if (slots.default) {
+        return slots.default();
+      }
+      if (props.text) {
+        return createVNode("div", {
+          "class": bem("text")
+        }, [props.text]);
+      }
+    };
+    return () => createVNode("div", {
+      "class": bem(),
+      "style": getSizeStyle(props.size)
+    }, [createVNode("svg", {
+      "viewBox": `0 0 ${viewBoxSize.value} ${viewBoxSize.value}`,
+      "style": svgStyle.value
+    }, [renderGradient(), renderLayer(), renderHover()]), renderText()]);
+  }
+});
+export {
+  circleProps,
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/col/Col.mjs

@@ -0,0 +1,73 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { useParent } from "../../../@vant/use/dist/index.esm.mjs";
+import { ROW_KEY } from "../row/Row.mjs";
+import { numericProp, makeNumericProp, makeStringProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { extend } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("col");
+const colProps = {
+  tag: makeStringProp("div"),
+  span: makeNumericProp(0),
+  offset: numericProp
+};
+var stdin_default = defineComponent({
+  name,
+  props: colProps,
+  setup(props, {
+    slots
+  }) {
+    const {
+      parent,
+      index
+    } = useParent(ROW_KEY);
+    const style = computed(() => {
+      if (!parent) {
+        return;
+      }
+      const {
+        spaces,
+        verticalSpaces
+      } = parent;
+      let styles = {};
+      if (spaces && spaces.value && spaces.value[index.value]) {
+        const {
+          left,
+          right
+        } = spaces.value[index.value];
+        styles = {
+          paddingLeft: left ? `${left}px` : null,
+          paddingRight: right ? `${right}px` : null
+        };
+      }
+      const {
+        bottom
+      } = verticalSpaces.value[index.value] || {};
+      return extend(styles, {
+        marginBottom: bottom ? `${bottom}px` : null
+      });
+    });
+    return () => {
+      const {
+        tag,
+        span,
+        offset
+      } = props;
+      return createVNode(tag, {
+        "style": style.value,
+        "class": bem({
+          [span]: span,
+          [`offset-${offset}`]: offset
+        })
+      }, {
+        default: () => {
+          var _a;
+          return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
+        }
+      });
+    };
+  }
+});
+export {
+  colProps,
+  stdin_default as default
+};

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

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

package/es/node_modules/vant/es/config-provider/ConfigProvider.mjs

@@ -39,7 +39,7 @@ function syncThemeVarsOnRoot(newStyle = {}, oldStyle = {}) {
     }
   });
 }
-defineComponent({
+var stdin_default = defineComponent({
   name,
   props: configProviderProps,
   setup(props, {
@@ -100,5 +100,6 @@ defineComponent({
 });
 export {
   CONFIG_PROVIDER_KEY,
-  configProviderProps
+  configProviderProps,
+  stdin_default as default
 };

package/es/node_modules/vant/es/config-provider/index.mjs

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