@fecp/designer 5.5.114 → 5.5.116

package/es/node_modules/vant/es/popover/Popover.mjs

@@ -0,0 +1,200 @@
+import { defineComponent, ref, onMounted, watchEffect, onBeforeUnmount, watch, createVNode, Fragment, mergeProps, nextTick } from "vue";
+import { createPopper, offsetModifier as offset_default } from "../../../@vant/popperjs/dist/index.esm.mjs";
+import { useClickAway } from "../../../@vant/use/dist/index.esm.mjs";
+import { useScopeId } from "../composables/use-scope-id.mjs";
+import { useSyncPropRef } from "../composables/use-sync-prop-ref.mjs";
+import { Icon } from "../icon/index.mjs";
+import { Popup } from "../popup/index.mjs";
+import { BORDER_RIGHT, BORDER_BOTTOM } from "../utils/constant.mjs";
+import { truthProp, unknownProp, makeStringProp, numericProp, makeArrayProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { pick, inBrowser, extend } from "../utils/basic.mjs";
+const [name, bem] = createNamespace("popover");
+const popupProps = ["overlay", "duration", "teleport", "overlayStyle", "overlayClass", "closeOnClickOverlay"];
+const popoverProps = {
+  show: Boolean,
+  theme: makeStringProp("light"),
+  overlay: Boolean,
+  actions: makeArrayProp(),
+  actionsDirection: makeStringProp("vertical"),
+  trigger: makeStringProp("click"),
+  duration: numericProp,
+  showArrow: truthProp,
+  placement: makeStringProp("bottom"),
+  iconPrefix: String,
+  overlayClass: unknownProp,
+  overlayStyle: Object,
+  closeOnClickAction: truthProp,
+  closeOnClickOverlay: truthProp,
+  closeOnClickOutside: truthProp,
+  offset: {
+    type: Array,
+    default: () => [0, 8]
+  },
+  teleport: {
+    type: [String, Object],
+    default: "body"
+  }
+};
+var stdin_default = defineComponent({
+  name,
+  props: popoverProps,
+  emits: ["select", "touchstart", "update:show"],
+  setup(props, {
+    emit,
+    slots,
+    attrs
+  }) {
+    let popper;
+    const popupRef = ref();
+    const wrapperRef = ref();
+    const popoverRef = ref();
+    const show = useSyncPropRef(() => props.show, (value) => emit("update:show", value));
+    const getPopoverOptions = () => ({
+      placement: props.placement,
+      modifiers: [{
+        name: "computeStyles",
+        options: {
+          adaptive: false,
+          gpuAcceleration: false
+        }
+      }, extend({}, offset_default, {
+        options: {
+          offset: props.offset
+        }
+      })]
+    });
+    const createPopperInstance = () => {
+      if (wrapperRef.value && popoverRef.value) {
+        return createPopper(wrapperRef.value, popoverRef.value.popupRef.value, getPopoverOptions());
+      }
+      return null;
+    };
+    const updateLocation = () => {
+      nextTick(() => {
+        if (!show.value) {
+          return;
+        }
+        if (!popper) {
+          popper = createPopperInstance();
+          if (inBrowser) {
+            window.addEventListener("animationend", updateLocation);
+            window.addEventListener("transitionend", updateLocation);
+          }
+        } else {
+          popper.setOptions(getPopoverOptions());
+        }
+      });
+    };
+    const updateShow = (value) => {
+      show.value = value;
+    };
+    const onClickWrapper = () => {
+      if (props.trigger === "click") {
+        show.value = !show.value;
+      }
+    };
+    const onClickAction = (action, index) => {
+      if (action.disabled) {
+        return;
+      }
+      emit("select", action, index);
+      if (props.closeOnClickAction) {
+        show.value = false;
+      }
+    };
+    const onClickAway = () => {
+      if (show.value && props.closeOnClickOutside && (!props.overlay || props.closeOnClickOverlay)) {
+        show.value = false;
+      }
+    };
+    const renderActionContent = (action, index) => {
+      if (slots.action) {
+        return slots.action({
+          action,
+          index
+        });
+      }
+      return [action.icon && createVNode(Icon, {
+        "name": action.icon,
+        "classPrefix": props.iconPrefix,
+        "class": bem("action-icon")
+      }, null), createVNode("div", {
+        "class": [bem("action-text"), {
+          [BORDER_BOTTOM]: props.actionsDirection === "vertical"
+        }]
+      }, [action.text])];
+    };
+    const renderAction = (action, index) => {
+      const {
+        icon,
+        color,
+        disabled,
+        className
+      } = action;
+      return createVNode("div", {
+        "role": "menuitem",
+        "class": [bem("action", {
+          disabled,
+          "with-icon": icon
+        }), {
+          [BORDER_RIGHT]: props.actionsDirection === "horizontal"
+        }, className],
+        "style": {
+          color
+        },
+        "tabindex": disabled ? void 0 : 0,
+        "aria-disabled": disabled || void 0,
+        "onClick": () => onClickAction(action, index)
+      }, [renderActionContent(action, index)]);
+    };
+    onMounted(() => {
+      updateLocation();
+      watchEffect(() => {
+        var _a;
+        popupRef.value = (_a = popoverRef.value) == null ? void 0 : _a.popupRef.value;
+      });
+    });
+    onBeforeUnmount(() => {
+      if (popper) {
+        if (inBrowser) {
+          window.removeEventListener("animationend", updateLocation);
+          window.removeEventListener("transitionend", updateLocation);
+        }
+        popper.destroy();
+        popper = null;
+      }
+    });
+    watch(() => [show.value, props.offset, props.placement], updateLocation);
+    useClickAway([wrapperRef, popupRef], onClickAway, {
+      eventName: "touchstart"
+    });
+    return () => {
+      var _a;
+      return createVNode(Fragment, null, [createVNode("span", {
+        "ref": wrapperRef,
+        "class": bem("wrapper"),
+        "onClick": onClickWrapper
+      }, [(_a = slots.reference) == null ? void 0 : _a.call(slots)]), createVNode(Popup, mergeProps({
+        "ref": popoverRef,
+        "show": show.value,
+        "class": bem([props.theme]),
+        "position": "",
+        "transition": "van-popover-zoom",
+        "lockScroll": false,
+        "onUpdate:show": updateShow
+      }, attrs, useScopeId(), pick(props, popupProps)), {
+        default: () => [props.showArrow && createVNode("div", {
+          "class": bem("arrow")
+        }, null), createVNode("div", {
+          "role": "menu",
+          "class": bem("content", props.actionsDirection)
+        }, [slots.default ? slots.default() : props.actions.map(renderAction)])]
+      })]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  popoverProps
+};

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

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

package/es/node_modules/vant/es/progress/Progress.mjs

@@ -0,0 +1,78 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { numericProp, truthProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { addUnit } from "../utils/format.mjs";
+const [name, bem] = createNamespace("progress");
+const progressProps = {
+  color: String,
+  inactive: Boolean,
+  pivotText: String,
+  textColor: String,
+  showPivot: truthProp,
+  pivotColor: String,
+  trackColor: String,
+  strokeWidth: numericProp,
+  percentage: {
+    type: numericProp,
+    default: 0,
+    validator: (value) => +value >= 0 && +value <= 100
+  }
+};
+var stdin_default = defineComponent({
+  name,
+  props: progressProps,
+  setup(props) {
+    const background = computed(() => props.inactive ? void 0 : props.color);
+    const renderPivot = () => {
+      const {
+        textColor,
+        pivotText,
+        pivotColor,
+        percentage
+      } = props;
+      const text = pivotText != null ? pivotText : `${percentage}%`;
+      if (props.showPivot && text) {
+        const style = {
+          color: textColor,
+          left: `${+percentage}%`,
+          transform: `translate(-${+percentage}%,-50%)`,
+          background: pivotColor || background.value
+        };
+        return createVNode("span", {
+          "style": style,
+          "class": bem("pivot", {
+            inactive: props.inactive
+          })
+        }, [text]);
+      }
+    };
+    return () => {
+      const {
+        trackColor,
+        percentage,
+        strokeWidth
+      } = props;
+      const rootStyle = {
+        background: trackColor,
+        height: addUnit(strokeWidth)
+      };
+      const portionStyle = {
+        width: `${percentage}%`,
+        background: background.value
+      };
+      return createVNode("div", {
+        "class": bem(),
+        "style": rootStyle
+      }, [createVNode("span", {
+        "class": bem("portion", {
+          inactive: props.inactive
+        }),
+        "style": portionStyle
+      }, null), renderPivot()]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  progressProps
+};

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

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

package/es/node_modules/vant/es/rate/Rate.mjs

@@ -0,0 +1,227 @@
+import { defineComponent, ref, computed, createVNode } from "vue";
+import { useCustomFieldValue, useEventListener, useRect } from "../../../@vant/use/dist/index.esm.mjs";
+import { useRefs } from "../composables/use-refs.mjs";
+import { useTouch } from "../composables/use-touch.mjs";
+import { Icon } from "../icon/index.mjs";
+import { makeNumberProp, truthProp, makeStringProp, numericProp, makeNumericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { preventDefault } from "../utils/dom.mjs";
+import { addUnit } from "../utils/format.mjs";
+const [name, bem] = createNamespace("rate");
+function getRateStatus(value, index, allowHalf, readonly) {
+  if (value >= index) {
+    return {
+      status: "full",
+      value: 1
+    };
+  }
+  if (value + 0.5 >= index && allowHalf && !readonly) {
+    return {
+      status: "half",
+      value: 0.5
+    };
+  }
+  if (value + 1 >= index && allowHalf && readonly) {
+    const cardinal = 10 ** 10;
+    return {
+      status: "half",
+      value: Math.round((value - index + 1) * cardinal) / cardinal
+    };
+  }
+  return {
+    status: "void",
+    value: 0
+  };
+}
+const rateProps = {
+  size: numericProp,
+  icon: makeStringProp("star"),
+  color: String,
+  count: makeNumericProp(5),
+  gutter: numericProp,
+  clearable: Boolean,
+  readonly: Boolean,
+  disabled: Boolean,
+  voidIcon: makeStringProp("star-o"),
+  allowHalf: Boolean,
+  voidColor: String,
+  touchable: truthProp,
+  iconPrefix: String,
+  modelValue: makeNumberProp(0),
+  disabledColor: String
+};
+var stdin_default = defineComponent({
+  name,
+  props: rateProps,
+  emits: ["change", "update:modelValue"],
+  setup(props, {
+    emit
+  }) {
+    const touch = useTouch();
+    const [itemRefs, setItemRefs] = useRefs();
+    const groupRef = ref();
+    const unselectable = computed(() => props.readonly || props.disabled);
+    const untouchable = computed(() => unselectable.value || !props.touchable);
+    const list = computed(() => Array(+props.count).fill("").map((_, i) => getRateStatus(props.modelValue, i + 1, props.allowHalf, props.readonly)));
+    let ranges;
+    let groupRefRect;
+    let minRectTop = Number.MAX_SAFE_INTEGER;
+    let maxRectTop = Number.MIN_SAFE_INTEGER;
+    const updateRanges = () => {
+      groupRefRect = useRect(groupRef);
+      const rects = itemRefs.value.map(useRect);
+      ranges = [];
+      rects.forEach((rect, index) => {
+        minRectTop = Math.min(rect.top, minRectTop);
+        maxRectTop = Math.max(rect.top, maxRectTop);
+        if (props.allowHalf) {
+          ranges.push({
+            score: index + 0.5,
+            left: rect.left,
+            top: rect.top,
+            height: rect.height
+          }, {
+            score: index + 1,
+            left: rect.left + rect.width / 2,
+            top: rect.top,
+            height: rect.height
+          });
+        } else {
+          ranges.push({
+            score: index + 1,
+            left: rect.left,
+            top: rect.top,
+            height: rect.height
+          });
+        }
+      });
+    };
+    const getScoreByPosition = (x, y) => {
+      for (let i = ranges.length - 1; i > 0; i--) {
+        if (y >= groupRefRect.top && y <= groupRefRect.bottom) {
+          if (x > ranges[i].left && y >= ranges[i].top && y <= ranges[i].top + ranges[i].height) {
+            return ranges[i].score;
+          }
+        } else {
+          const curTop = y < groupRefRect.top ? minRectTop : maxRectTop;
+          if (x > ranges[i].left && ranges[i].top === curTop) {
+            return ranges[i].score;
+          }
+        }
+      }
+      return props.allowHalf ? 0.5 : 1;
+    };
+    const select = (value) => {
+      if (unselectable.value || value === props.modelValue) return;
+      emit("update:modelValue", value);
+      emit("change", value);
+    };
+    const onTouchStart = (event) => {
+      if (untouchable.value) {
+        return;
+      }
+      touch.start(event);
+      updateRanges();
+    };
+    const onTouchMove = (event) => {
+      if (untouchable.value) {
+        return;
+      }
+      touch.move(event);
+      if (touch.isHorizontal() && !touch.isTap.value) {
+        const {
+          clientX,
+          clientY
+        } = event.touches[0];
+        preventDefault(event);
+        select(getScoreByPosition(clientX, clientY));
+      }
+    };
+    const renderStar = (item, index) => {
+      const {
+        icon,
+        size,
+        color,
+        count,
+        gutter,
+        voidIcon,
+        disabled,
+        voidColor,
+        allowHalf,
+        iconPrefix,
+        disabledColor
+      } = props;
+      const score = index + 1;
+      const isFull = item.status === "full";
+      const isVoid = item.status === "void";
+      const renderHalf = allowHalf && item.value > 0 && item.value < 1;
+      let style;
+      if (gutter && score !== +count) {
+        style = {
+          paddingRight: addUnit(gutter)
+        };
+      }
+      const onClickItem = (event) => {
+        updateRanges();
+        let value = allowHalf ? getScoreByPosition(event.clientX, event.clientY) : score;
+        if (props.clearable && touch.isTap.value && value === props.modelValue) {
+          value = 0;
+        }
+        select(value);
+      };
+      return createVNode("div", {
+        "key": index,
+        "ref": setItemRefs(index),
+        "role": "radio",
+        "style": style,
+        "class": bem("item"),
+        "tabindex": disabled ? void 0 : 0,
+        "aria-setsize": count,
+        "aria-posinset": score,
+        "aria-checked": !isVoid,
+        "onClick": onClickItem
+      }, [createVNode(Icon, {
+        "size": size,
+        "name": isFull ? icon : voidIcon,
+        "class": bem("icon", {
+          disabled,
+          full: isFull
+        }),
+        "color": disabled ? disabledColor : isFull ? color : voidColor,
+        "classPrefix": iconPrefix
+      }, null), renderHalf && createVNode(Icon, {
+        "size": size,
+        "style": {
+          width: item.value + "em"
+        },
+        "name": isVoid ? voidIcon : icon,
+        "class": bem("icon", ["half", {
+          disabled,
+          full: !isVoid
+        }]),
+        "color": disabled ? disabledColor : isVoid ? voidColor : color,
+        "classPrefix": iconPrefix
+      }, null)]);
+    };
+    useCustomFieldValue(() => props.modelValue);
+    useEventListener("touchmove", onTouchMove, {
+      target: groupRef
+    });
+    return () => createVNode("div", {
+      "ref": groupRef,
+      "role": "radiogroup",
+      "class": bem({
+        readonly: props.readonly,
+        disabled: props.disabled
+      }),
+      "tabindex": props.disabled ? void 0 : 0,
+      "aria-disabled": props.disabled,
+      "aria-readonly": props.readonly,
+      "onTouchstartPassive": onTouchStart
+    }, [list.value.map(renderStar)]);
+  }
+});
+export {
+  stdin_default as default,
+  rateProps
+};

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

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

package/es/node_modules/vant/es/rolling-text/RollingText.mjs

@@ -0,0 +1,96 @@
+import { defineComponent, computed, ref, watch, createVNode } from "vue";
+import { raf } from "../../../@vant/use/dist/index.esm.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import stdin_default$1 from "./RollingTextItem.mjs";
+import { makeNumberProp, makeStringProp, truthProp, makeArrayProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { padZero } from "../utils/format.mjs";
+const [name, bem] = createNamespace("rolling-text");
+const rollingTextProps = {
+  startNum: makeNumberProp(0),
+  targetNum: Number,
+  textList: makeArrayProp(),
+  duration: makeNumberProp(2),
+  autoStart: truthProp,
+  direction: makeStringProp("down"),
+  stopOrder: makeStringProp("ltr"),
+  height: makeNumberProp(40)
+};
+const CIRCLE_NUM = 2;
+var stdin_default = defineComponent({
+  name,
+  props: rollingTextProps,
+  setup(props) {
+    const isCustomType = computed(() => Array.isArray(props.textList) && props.textList.length);
+    const itemLength = computed(() => {
+      if (isCustomType.value) return props.textList[0].length;
+      return `${Math.max(props.startNum, props.targetNum)}`.length;
+    });
+    const getTextArrByIdx = (idx) => {
+      const result = [];
+      for (let i = 0; i < props.textList.length; i++) {
+        result.push(props.textList[i][idx]);
+      }
+      return result;
+    };
+    const targetNumArr = computed(() => {
+      if (isCustomType.value) return new Array(itemLength.value).fill("");
+      return padZero(props.targetNum, itemLength.value).split("");
+    });
+    const startNumArr = computed(() => padZero(props.startNum, itemLength.value).split(""));
+    const getFigureArr = (i) => {
+      const start2 = +startNumArr.value[i];
+      const target = +targetNumArr.value[i];
+      const result = [];
+      for (let i2 = start2; i2 <= 9; i2++) {
+        result.push(i2);
+      }
+      for (let i2 = 0; i2 <= CIRCLE_NUM; i2++) {
+        for (let j = 0; j <= 9; j++) {
+          result.push(j);
+        }
+      }
+      for (let i2 = 0; i2 <= target; i2++) {
+        result.push(i2);
+      }
+      return result;
+    };
+    const getDelay = (i, len) => {
+      if (props.stopOrder === "ltr") return 0.2 * i;
+      return 0.2 * (len - 1 - i);
+    };
+    const rolling = ref(props.autoStart);
+    const start = () => {
+      rolling.value = true;
+    };
+    const reset = () => {
+      rolling.value = false;
+      if (props.autoStart) {
+        raf(() => start());
+      }
+    };
+    watch(() => props.autoStart, (value) => {
+      if (value) {
+        start();
+      }
+    });
+    useExpose({
+      start,
+      reset
+    });
+    return () => createVNode("div", {
+      "class": bem()
+    }, [targetNumArr.value.map((_, i) => createVNode(stdin_default$1, {
+      "figureArr": isCustomType.value ? getTextArrByIdx(i) : getFigureArr(i),
+      "duration": props.duration,
+      "direction": props.direction,
+      "isStart": rolling.value,
+      "height": props.height,
+      "delay": getDelay(i, itemLength.value)
+    }, null))]);
+  }
+});
+export {
+  stdin_default as default,
+  rollingTextProps
+};

package/es/node_modules/vant/es/rolling-text/RollingTextItem.mjs

@@ -0,0 +1,48 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { makeNumberProp, makeStringProp, makeArrayProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { addUnit } from "../utils/format.mjs";
+const props = {
+  figureArr: makeArrayProp(),
+  delay: Number,
+  duration: makeNumberProp(2),
+  isStart: Boolean,
+  direction: makeStringProp("down"),
+  height: makeNumberProp(40)
+};
+const [name, bem] = createNamespace("rolling-text-item");
+var stdin_default = defineComponent({
+  name,
+  props,
+  setup(props2) {
+    const newFigureArr = computed(() => props2.direction === "down" ? props2.figureArr.slice().reverse() : props2.figureArr);
+    const translatePx = computed(() => {
+      const totalHeight = props2.height * (props2.figureArr.length - 1);
+      return `-${totalHeight}px`;
+    });
+    const itemStyle = computed(() => ({
+      lineHeight: addUnit(props2.height)
+    }));
+    const rootStyle = computed(() => ({
+      height: addUnit(props2.height),
+      "--van-translate": translatePx.value,
+      "--van-duration": props2.duration + "s",
+      "--van-delay": props2.delay + "s"
+    }));
+    return () => createVNode("div", {
+      "class": bem([props2.direction]),
+      "style": rootStyle.value
+    }, [createVNode("div", {
+      "class": bem("box", {
+        animate: props2.isStart
+      })
+    }, [Array.isArray(newFigureArr.value) && newFigureArr.value.map((figure) => createVNode("div", {
+      "class": bem("item"),
+      "style": itemStyle.value
+    }, [figure]))])]);
+  }
+});
+export {
+  stdin_default as default,
+  props
+};

package/es/node_modules/vant/es/rolling-text/index.mjs

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