@fecp/designer 5.5.113 → 5.5.115

package/es/node_modules/vant/es/calendar/CalendarDay.mjs

@@ -0,0 +1,132 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { isLastRowInMonth, bem } from "./utils.mjs";
+import { makeNumberProp, makeRequiredProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+const [name] = createNamespace("calendar-day");
+var stdin_default = defineComponent({
+  name,
+  props: {
+    item: makeRequiredProp(Object),
+    color: String,
+    index: Number,
+    offset: makeNumberProp(0),
+    rowHeight: String
+  },
+  emits: ["click", "clickDisabledDate"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const style = computed(() => {
+      const {
+        item,
+        index,
+        color,
+        offset,
+        rowHeight
+      } = props;
+      const style2 = {
+        height: rowHeight
+      };
+      if (item.type === "placeholder") {
+        style2.width = "100%";
+        return style2;
+      }
+      if (index === 0) {
+        style2.marginLeft = `${100 * offset / 7}%`;
+      }
+      if (color) {
+        switch (item.type) {
+          case "end":
+          case "start":
+          case "start-end":
+          case "multiple-middle":
+          case "multiple-selected":
+            style2.background = color;
+            break;
+          case "middle":
+            style2.color = color;
+            break;
+        }
+      }
+      if (item.date && isLastRowInMonth(item.date, offset)) {
+        style2.marginBottom = 0;
+      }
+      return style2;
+    });
+    const onClick = () => {
+      if (props.item.type !== "disabled") {
+        emit("click", props.item);
+      } else {
+        emit("clickDisabledDate", props.item);
+      }
+    };
+    const renderTopInfo = () => {
+      const {
+        topInfo
+      } = props.item;
+      if (topInfo || slots["top-info"]) {
+        return createVNode("div", {
+          "class": bem("top-info")
+        }, [slots["top-info"] ? slots["top-info"](props.item) : topInfo]);
+      }
+    };
+    const renderBottomInfo = () => {
+      const {
+        bottomInfo
+      } = props.item;
+      if (bottomInfo || slots["bottom-info"]) {
+        return createVNode("div", {
+          "class": bem("bottom-info")
+        }, [slots["bottom-info"] ? slots["bottom-info"](props.item) : bottomInfo]);
+      }
+    };
+    const renderText = () => {
+      return slots.text ? slots.text(props.item) : props.item.text;
+    };
+    const renderContent = () => {
+      const {
+        item,
+        color,
+        rowHeight
+      } = props;
+      const {
+        type
+      } = item;
+      const Nodes = [renderTopInfo(), renderText(), renderBottomInfo()];
+      if (type === "selected") {
+        return createVNode("div", {
+          "class": bem("selected-day"),
+          "style": {
+            width: rowHeight,
+            height: rowHeight,
+            background: color
+          }
+        }, [Nodes]);
+      }
+      return Nodes;
+    };
+    return () => {
+      const {
+        type,
+        className
+      } = props.item;
+      if (type === "placeholder") {
+        return createVNode("div", {
+          "class": bem("day"),
+          "style": style.value
+        }, null);
+      }
+      return createVNode("div", {
+        "role": "gridcell",
+        "style": style.value,
+        "class": [bem("day", type), className],
+        "tabindex": type === "disabled" ? void 0 : -1,
+        "onClick": onClick
+      }, [renderContent()]);
+    };
+  }
+});
+export {
+  stdin_default as default
+};

package/es/node_modules/vant/es/calendar/CalendarHeader.mjs

@@ -0,0 +1,115 @@
+import { defineComponent, computed, createVNode } from "vue";
+import { compareMonth, getPrevMonth, getPrevYear, getNextMonth, getNextYear, bem, t } from "./utils.mjs";
+import { Icon } from "../icon/index.mjs";
+import { makeStringProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { HAPTICS_FEEDBACK } from "../utils/constant.mjs";
+const [name] = createNamespace("calendar-header");
+var stdin_default = defineComponent({
+  name,
+  props: {
+    date: Date,
+    minDate: Date,
+    maxDate: Date,
+    title: String,
+    subtitle: String,
+    showTitle: Boolean,
+    showSubtitle: Boolean,
+    firstDayOfWeek: Number,
+    switchMode: makeStringProp("none")
+  },
+  emits: ["clickSubtitle", "panelChange"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const prevMonthDisabled = computed(() => props.date && props.minDate && compareMonth(getPrevMonth(props.date), props.minDate) < 0);
+    const prevYearDisabled = computed(() => props.date && props.minDate && compareMonth(getPrevYear(props.date), props.minDate) < 0);
+    const nextMonthDisabled = computed(() => props.date && props.maxDate && compareMonth(getNextMonth(props.date), props.maxDate) > 0);
+    const nextYearDisabled = computed(() => props.date && props.maxDate && compareMonth(getNextYear(props.date), props.maxDate) > 0);
+    const renderTitle = () => {
+      if (props.showTitle) {
+        const text = props.title || t("title");
+        const title = slots.title ? slots.title() : text;
+        return createVNode("div", {
+          "class": bem("header-title")
+        }, [title]);
+      }
+    };
+    const onClickSubtitle = (event) => emit("clickSubtitle", event);
+    const onPanelChange = (date) => emit("panelChange", date);
+    const renderAction = (isNext) => {
+      const showYearAction = props.switchMode === "year-month";
+      const monthSlot = slots[isNext ? "next-month" : "prev-month"];
+      const yearSlot = slots[isNext ? "next-year" : "prev-year"];
+      const monthDisabled = isNext ? nextMonthDisabled.value : prevMonthDisabled.value;
+      const yearDisabled = isNext ? nextYearDisabled.value : prevYearDisabled.value;
+      const monthIconName = isNext ? "arrow" : "arrow-left";
+      const yearIconName = isNext ? "arrow-double-right" : "arrow-double-left";
+      const onMonthChange = () => onPanelChange((isNext ? getNextMonth : getPrevMonth)(props.date));
+      const onYearChange = () => onPanelChange((isNext ? getNextYear : getPrevYear)(props.date));
+      const MonthAction = createVNode("view", {
+        "class": bem("header-action", {
+          disabled: monthDisabled
+        }),
+        "onClick": monthDisabled ? void 0 : onMonthChange
+      }, [monthSlot ? monthSlot({
+        disabled: monthDisabled
+      }) : createVNode(Icon, {
+        "class": {
+          [HAPTICS_FEEDBACK]: !monthDisabled
+        },
+        "name": monthIconName
+      }, null)]);
+      const YearAction = showYearAction && createVNode("view", {
+        "class": bem("header-action", {
+          disabled: yearDisabled
+        }),
+        "onClick": yearDisabled ? void 0 : onYearChange
+      }, [yearSlot ? yearSlot({
+        disabled: yearDisabled
+      }) : createVNode(Icon, {
+        "class": {
+          [HAPTICS_FEEDBACK]: !yearDisabled
+        },
+        "name": yearIconName
+      }, null)]);
+      return isNext ? [MonthAction, YearAction] : [YearAction, MonthAction];
+    };
+    const renderSubtitle = () => {
+      if (props.showSubtitle) {
+        const title = slots.subtitle ? slots.subtitle({
+          date: props.date,
+          text: props.subtitle
+        }) : props.subtitle;
+        const canSwitch = props.switchMode !== "none";
+        return createVNode("div", {
+          "class": bem("header-subtitle", {
+            "with-switch": canSwitch
+          }),
+          "onClick": onClickSubtitle
+        }, [canSwitch ? [renderAction(), createVNode("div", {
+          "class": bem("header-subtitle-text")
+        }, [title]), renderAction(true)] : title]);
+      }
+    };
+    const renderWeekDays = () => {
+      const {
+        firstDayOfWeek
+      } = props;
+      const weekdays = t("weekdays");
+      const renderWeekDays2 = [...weekdays.slice(firstDayOfWeek, 7), ...weekdays.slice(0, firstDayOfWeek)];
+      return createVNode("div", {
+        "class": bem("weekdays")
+      }, [renderWeekDays2.map((text) => createVNode("span", {
+        "class": bem("weekday")
+      }, [text]))]);
+    };
+    return () => createVNode("div", {
+      "class": bem("header")
+    }, [renderTitle(), renderSubtitle(), renderWeekDays()]);
+  }
+});
+export {
+  stdin_default as default
+};

package/es/node_modules/vant/es/calendar/CalendarMonth.mjs

@@ -0,0 +1,217 @@
+import { defineComponent, ref, computed, createVNode } from "vue";
+import { getMonthEndDay } from "../date-picker/utils.mjs";
+import { formatMonthTitle, bem, compareDay, t, getPrevDay, getNextDay } from "./utils.mjs";
+import { useToggle, useRect } from "../../../@vant/use/dist/index.esm.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { useHeight } from "../composables/use-height.mjs";
+import stdin_default$1 from "./CalendarDay.mjs";
+import { numericProp, makeRequiredProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { addUnit } from "../utils/format.mjs";
+import { setScrollTop } from "../utils/dom.mjs";
+import { pick } from "../utils/basic.mjs";
+const [name] = createNamespace("calendar-month");
+const calendarMonthProps = {
+  date: makeRequiredProp(Date),
+  type: String,
+  color: String,
+  minDate: Date,
+  maxDate: Date,
+  showMark: Boolean,
+  rowHeight: numericProp,
+  formatter: Function,
+  lazyRender: Boolean,
+  currentDate: [Date, Array],
+  allowSameDay: Boolean,
+  showSubtitle: Boolean,
+  showMonthTitle: Boolean,
+  firstDayOfWeek: Number
+};
+var stdin_default = defineComponent({
+  name,
+  props: calendarMonthProps,
+  emits: ["click", "clickDisabledDate"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const [visible, setVisible] = useToggle();
+    const daysRef = ref();
+    const monthRef = ref();
+    const height = useHeight(monthRef);
+    const title = computed(() => formatMonthTitle(props.date));
+    const rowHeight = computed(() => addUnit(props.rowHeight));
+    const offset = computed(() => {
+      const date = props.date.getDate();
+      const day = props.date.getDay();
+      const realDay = (day - date % 7 + 8) % 7;
+      if (props.firstDayOfWeek) {
+        return (realDay + 7 - props.firstDayOfWeek) % 7;
+      }
+      return realDay;
+    });
+    const totalDay = computed(() => getMonthEndDay(props.date.getFullYear(), props.date.getMonth() + 1));
+    const shouldRender = computed(() => visible.value || !props.lazyRender);
+    const getTitle = () => title.value;
+    const getMultipleDayType = (day) => {
+      const isSelected = (date) => props.currentDate.some((item) => compareDay(item, date) === 0);
+      if (isSelected(day)) {
+        const prevDay = getPrevDay(day);
+        const nextDay = getNextDay(day);
+        const prevSelected = isSelected(prevDay);
+        const nextSelected = isSelected(nextDay);
+        if (prevSelected && nextSelected) {
+          return "multiple-middle";
+        }
+        if (prevSelected) {
+          return "end";
+        }
+        if (nextSelected) {
+          return "start";
+        }
+        return "multiple-selected";
+      }
+      return "";
+    };
+    const getRangeDayType = (day) => {
+      const [startDay, endDay] = props.currentDate;
+      if (!startDay) {
+        return "";
+      }
+      const compareToStart = compareDay(day, startDay);
+      if (!endDay) {
+        return compareToStart === 0 ? "start" : "";
+      }
+      const compareToEnd = compareDay(day, endDay);
+      if (props.allowSameDay && compareToStart === 0 && compareToEnd === 0) {
+        return "start-end";
+      }
+      if (compareToStart === 0) {
+        return "start";
+      }
+      if (compareToEnd === 0) {
+        return "end";
+      }
+      if (compareToStart > 0 && compareToEnd < 0) {
+        return "middle";
+      }
+      return "";
+    };
+    const getDayType = (day) => {
+      const {
+        type,
+        minDate,
+        maxDate,
+        currentDate
+      } = props;
+      if (minDate && compareDay(day, minDate) < 0 || maxDate && compareDay(day, maxDate) > 0) {
+        return "disabled";
+      }
+      if (currentDate === null) {
+        return "";
+      }
+      if (Array.isArray(currentDate)) {
+        if (type === "multiple") {
+          return getMultipleDayType(day);
+        }
+        if (type === "range") {
+          return getRangeDayType(day);
+        }
+      } else if (type === "single") {
+        return compareDay(day, currentDate) === 0 ? "selected" : "";
+      }
+      return "";
+    };
+    const getBottomInfo = (dayType) => {
+      if (props.type === "range") {
+        if (dayType === "start" || dayType === "end") {
+          return t(dayType);
+        }
+        if (dayType === "start-end") {
+          return `${t("start")}/${t("end")}`;
+        }
+      }
+    };
+    const renderTitle = () => {
+      if (props.showMonthTitle) {
+        return createVNode("div", {
+          "class": bem("month-title")
+        }, [slots["month-title"] ? slots["month-title"]({
+          date: props.date,
+          text: title.value
+        }) : title.value]);
+      }
+    };
+    const renderMark = () => {
+      if (props.showMark && shouldRender.value) {
+        return createVNode("div", {
+          "class": bem("month-mark")
+        }, [props.date.getMonth() + 1]);
+      }
+    };
+    const placeholders = computed(() => {
+      const count = Math.ceil((totalDay.value + offset.value) / 7);
+      return Array(count).fill({
+        type: "placeholder"
+      });
+    });
+    const days = computed(() => {
+      const days2 = [];
+      const year = props.date.getFullYear();
+      const month = props.date.getMonth();
+      for (let day = 1; day <= totalDay.value; day++) {
+        const date = new Date(year, month, day);
+        const type = getDayType(date);
+        let config = {
+          date,
+          type,
+          text: day,
+          bottomInfo: getBottomInfo(type)
+        };
+        if (props.formatter) {
+          config = props.formatter(config);
+        }
+        days2.push(config);
+      }
+      return days2;
+    });
+    const disabledDays = computed(() => days.value.filter((day) => day.type === "disabled"));
+    const scrollToDate = (body, targetDate) => {
+      if (daysRef.value) {
+        const daysRect = useRect(daysRef.value);
+        const totalRows = placeholders.value.length;
+        const currentRow = Math.ceil((targetDate.getDate() + offset.value) / 7);
+        const rowOffset = (currentRow - 1) * daysRect.height / totalRows;
+        setScrollTop(body, daysRect.top + rowOffset + body.scrollTop - useRect(body).top);
+      }
+    };
+    const renderDay = (item, index) => createVNode(stdin_default$1, {
+      "item": item,
+      "index": index,
+      "color": props.color,
+      "offset": offset.value,
+      "rowHeight": rowHeight.value,
+      "onClick": (item2) => emit("click", item2),
+      "onClickDisabledDate": (item2) => emit("clickDisabledDate", item2)
+    }, pick(slots, ["top-info", "bottom-info", "text"]));
+    const renderDays = () => createVNode("div", {
+      "ref": daysRef,
+      "role": "grid",
+      "class": bem("days")
+    }, [renderMark(), (shouldRender.value ? days : placeholders).value.map(renderDay)]);
+    useExpose({
+      getTitle,
+      getHeight: () => height.value,
+      setVisible,
+      scrollToDate,
+      disabledDays
+    });
+    return () => createVNode("div", {
+      "class": bem("month"),
+      "ref": monthRef
+    }, [renderTitle(), renderDays()]);
+  }
+});
+export {
+  stdin_default as default
+};

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

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

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

@@ -0,0 +1,89 @@
+import { createNamespace } from "../utils/create.mjs";
+const [name, bem, t] = createNamespace("calendar");
+const formatMonthTitle = (date) => t("monthTitle", date.getFullYear(), date.getMonth() + 1);
+function compareMonth(date1, date2) {
+  const year1 = date1.getFullYear();
+  const year2 = date2.getFullYear();
+  if (year1 === year2) {
+    const month1 = date1.getMonth();
+    const month2 = date2.getMonth();
+    return month1 === month2 ? 0 : month1 > month2 ? 1 : -1;
+  }
+  return year1 > year2 ? 1 : -1;
+}
+function compareDay(day1, day2) {
+  const compareMonthResult = compareMonth(day1, day2);
+  if (compareMonthResult === 0) {
+    const date1 = day1.getDate();
+    const date2 = day2.getDate();
+    return date1 === date2 ? 0 : date1 > date2 ? 1 : -1;
+  }
+  return compareMonthResult;
+}
+const cloneDate = (date) => new Date(date);
+const cloneDates = (dates) => Array.isArray(dates) ? dates.map(cloneDate) : cloneDate(dates);
+function getDayByOffset(date, offset) {
+  const cloned = cloneDate(date);
+  cloned.setDate(cloned.getDate() + offset);
+  return cloned;
+}
+function getMonthByOffset(date, offset) {
+  const cloned = cloneDate(date);
+  cloned.setMonth(cloned.getMonth() + offset);
+  if (cloned.getDate() !== date.getDate()) {
+    cloned.setDate(0);
+  }
+  return cloned;
+}
+function getYearByOffset(date, offset) {
+  const cloned = cloneDate(date);
+  cloned.setFullYear(cloned.getFullYear() + offset);
+  if (cloned.getDate() !== date.getDate()) {
+    cloned.setDate(0);
+  }
+  return cloned;
+}
+const getPrevDay = (date) => getDayByOffset(date, -1);
+const getNextDay = (date) => getDayByOffset(date, 1);
+const getPrevMonth = (date) => getMonthByOffset(date, -1);
+const getNextMonth = (date) => getMonthByOffset(date, 1);
+const getPrevYear = (date) => getYearByOffset(date, -1);
+const getNextYear = (date) => getYearByOffset(date, 1);
+const getToday = () => {
+  const today = /* @__PURE__ */ new Date();
+  today.setHours(0, 0, 0, 0);
+  return today;
+};
+function calcDateNum(date) {
+  const day1 = date[0].getTime();
+  const day2 = date[1].getTime();
+  return (day2 - day1) / (1e3 * 60 * 60 * 24) + 1;
+}
+function isLastRowInMonth(date, offset = 0) {
+  const lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0);
+  const currentPos = offset + date.getDate() - 1;
+  const lastDayPos = offset + lastDay.getDate() - 1;
+  return Math.floor(currentPos / 7) === Math.floor(lastDayPos / 7);
+}
+export {
+  bem,
+  calcDateNum,
+  cloneDate,
+  cloneDates,
+  compareDay,
+  compareMonth,
+  formatMonthTitle,
+  getDayByOffset,
+  getMonthByOffset,
+  getNextDay,
+  getNextMonth,
+  getNextYear,
+  getPrevDay,
+  getPrevMonth,
+  getPrevYear,
+  getToday,
+  getYearByOffset,
+  isLastRowInMonth,
+  name,
+  t
+};

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