@fecp/mobile-designer 1.0.6

package/es/packages/mobile/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/packages/mobile/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/packages/mobile/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/packages/mobile/node_modules/vant/es/cascader/Cascader.mjs

@@ -0,0 +1,243 @@
+import { defineComponent, ref, watch, createVNode, nextTick } from "vue";
+import { useRefs } from "../composables/use-refs.mjs";
+import { Tab } from "../tab/index.mjs";
+import { Tabs } from "../tabs/index.mjs";
+import { Icon } from "../icon/index.mjs";
+import { numericProp, truthProp, makeStringProp, makeArrayProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { extend } from "../utils/basic.mjs";
+import { HAPTICS_FEEDBACK } from "../utils/constant.mjs";
+const [name, bem, t] = createNamespace("cascader");
+const cascaderProps = {
+  title: String,
+  options: makeArrayProp(),
+  closeable: truthProp,
+  swipeable: truthProp,
+  closeIcon: makeStringProp("cross"),
+  showHeader: truthProp,
+  modelValue: numericProp,
+  fieldNames: Object,
+  placeholder: String,
+  activeColor: String
+};
+var stdin_default = defineComponent({
+  name,
+  props: cascaderProps,
+  emits: ["close", "change", "finish", "clickTab", "update:modelValue"],
+  setup(props, {
+    slots,
+    emit
+  }) {
+    const tabs = ref([]);
+    const activeTab = ref(0);
+    const [selectedElementRefs, setSelectedElementRefs] = useRefs();
+    const {
+      text: textKey,
+      value: valueKey,
+      children: childrenKey
+    } = extend({
+      text: "text",
+      value: "value",
+      children: "children"
+    }, props.fieldNames);
+    const getSelectedOptionsByValue = (options, value) => {
+      for (const option of options) {
+        if (option[valueKey] === value) {
+          return [option];
+        }
+        if (option[childrenKey]) {
+          const selectedOptions = getSelectedOptionsByValue(option[childrenKey], value);
+          if (selectedOptions) {
+            return [option, ...selectedOptions];
+          }
+        }
+      }
+    };
+    const updateTabs = () => {
+      const {
+        options,
+        modelValue
+      } = props;
+      if (modelValue !== void 0) {
+        const selectedOptions = getSelectedOptionsByValue(options, modelValue);
+        if (selectedOptions) {
+          let optionsCursor = options;
+          tabs.value = selectedOptions.map((option) => {
+            const tab = {
+              options: optionsCursor,
+              selected: option
+            };
+            const next = optionsCursor.find((item) => item[valueKey] === option[valueKey]);
+            if (next) {
+              optionsCursor = next[childrenKey];
+            }
+            return tab;
+          });
+          if (optionsCursor) {
+            tabs.value.push({
+              options: optionsCursor,
+              selected: null
+            });
+          }
+          nextTick(() => {
+            activeTab.value = tabs.value.length - 1;
+          });
+          return;
+        }
+      }
+      tabs.value = [{
+        options,
+        selected: null
+      }];
+    };
+    const onSelect = (option, tabIndex) => {
+      if (option.disabled) {
+        return;
+      }
+      tabs.value[tabIndex].selected = option;
+      if (tabs.value.length > tabIndex + 1) {
+        tabs.value = tabs.value.slice(0, tabIndex + 1);
+      }
+      if (option[childrenKey]) {
+        const nextTab = {
+          options: option[childrenKey],
+          selected: null
+        };
+        if (tabs.value[tabIndex + 1]) {
+          tabs.value[tabIndex + 1] = nextTab;
+        } else {
+          tabs.value.push(nextTab);
+        }
+        nextTick(() => {
+          activeTab.value++;
+        });
+      }
+      const selectedOptions = tabs.value.map((tab) => tab.selected).filter(Boolean);
+      emit("update:modelValue", option[valueKey]);
+      const params = {
+        value: option[valueKey],
+        tabIndex,
+        selectedOptions
+      };
+      emit("change", params);
+      if (!option[childrenKey]) {
+        emit("finish", params);
+      }
+    };
+    const onClose = () => emit("close");
+    const onClickTab = ({
+      name: name2,
+      title
+    }) => emit("clickTab", name2, title);
+    const renderHeader = () => props.showHeader ? createVNode("div", {
+      "class": bem("header")
+    }, [createVNode("h2", {
+      "class": bem("title")
+    }, [slots.title ? slots.title() : props.title]), props.closeable ? createVNode(Icon, {
+      "name": props.closeIcon,
+      "class": [bem("close-icon"), HAPTICS_FEEDBACK],
+      "onClick": onClose
+    }, null) : null]) : null;
+    const renderOption = (option, selectedOption, tabIndex) => {
+      const {
+        disabled
+      } = option;
+      const selected = !!(selectedOption && option[valueKey] === selectedOption[valueKey]);
+      const color = option.color || (selected ? props.activeColor : void 0);
+      const Text = slots.option ? slots.option({
+        option,
+        selected
+      }) : createVNode("span", null, [option[textKey]]);
+      return createVNode("li", {
+        "ref": selected ? setSelectedElementRefs(tabIndex) : void 0,
+        "role": "menuitemradio",
+        "class": [bem("option", {
+          selected,
+          disabled
+        }), option.className],
+        "style": {
+          color
+        },
+        "tabindex": disabled ? void 0 : selected ? 0 : -1,
+        "aria-checked": selected,
+        "aria-disabled": disabled || void 0,
+        "onClick": () => onSelect(option, tabIndex)
+      }, [Text, selected ? createVNode(Icon, {
+        "name": "success",
+        "class": bem("selected-icon")
+      }, null) : null]);
+    };
+    const renderOptions = (options, selectedOption, tabIndex) => createVNode("ul", {
+      "role": "menu",
+      "class": bem("options")
+    }, [options.map((option) => renderOption(option, selectedOption, tabIndex))]);
+    const renderTab = (tab, tabIndex) => {
+      const {
+        options,
+        selected
+      } = tab;
+      const placeholder = props.placeholder || t("select");
+      const title = selected ? selected[textKey] : placeholder;
+      return createVNode(Tab, {
+        "title": title,
+        "titleClass": bem("tab", {
+          unselected: !selected
+        })
+      }, {
+        default: () => {
+          var _a, _b;
+          return [(_a = slots["options-top"]) == null ? void 0 : _a.call(slots, {
+            tabIndex
+          }), renderOptions(options, selected, tabIndex), (_b = slots["options-bottom"]) == null ? void 0 : _b.call(slots, {
+            tabIndex
+          })];
+        }
+      });
+    };
+    const renderTabs = () => createVNode(Tabs, {
+      "active": activeTab.value,
+      "onUpdate:active": ($event) => activeTab.value = $event,
+      "shrink": true,
+      "animated": true,
+      "class": bem("tabs"),
+      "color": props.activeColor,
+      "swipeable": props.swipeable,
+      "onClickTab": onClickTab
+    }, {
+      default: () => [tabs.value.map(renderTab)]
+    });
+    const scrollIntoView = (el) => {
+      const scrollParent = el.parentElement;
+      if (scrollParent) {
+        scrollParent.scrollTop = el.offsetTop - (scrollParent.offsetHeight - el.offsetHeight) / 2;
+      }
+    };
+    updateTabs();
+    watch(activeTab, (value) => {
+      const el = selectedElementRefs.value[value];
+      if (el) scrollIntoView(el);
+    });
+    watch(() => props.options, updateTabs, {
+      deep: true
+    });
+    watch(() => props.modelValue, (value) => {
+      if (value !== void 0) {
+        const values = tabs.value.map((tab) => {
+          var _a;
+          return (_a = tab.selected) == null ? void 0 : _a[valueKey];
+        });
+        if (values.includes(value)) {
+          return;
+        }
+      }
+      updateTabs();
+    });
+    return () => createVNode("div", {
+      "class": bem()
+    }, [renderHeader(), renderTabs()]);
+  }
+});
+export {
+  cascaderProps,
+  stdin_default as default
+};

package/es/packages/mobile/node_modules/vant/es/cascader/index.mjs

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

package/es/packages/mobile/node_modules/vant/es/cell/Cell.mjs

@@ -0,0 +1,133 @@
+import { defineComponent, createVNode } from "vue";
+import { useRoute, routeProps } from "../composables/use-route.mjs";
+import { Icon } from "../icon/index.mjs";
+import { extend, isDef } from "../utils/basic.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { unknownProp, truthProp, numericProp, makeStringProp } from "../utils/props.mjs";
+const [name, bem] = createNamespace("cell");
+const cellSharedProps = {
+  tag: makeStringProp("div"),
+  icon: String,
+  size: String,
+  title: numericProp,
+  value: numericProp,
+  label: numericProp,
+  center: Boolean,
+  isLink: Boolean,
+  border: truthProp,
+  iconPrefix: String,
+  valueClass: unknownProp,
+  labelClass: unknownProp,
+  titleClass: unknownProp,
+  titleStyle: null,
+  arrowDirection: String,
+  required: {
+    type: [Boolean, String],
+    default: null
+  },
+  clickable: {
+    type: Boolean,
+    default: null
+  }
+};
+const cellProps = extend({}, cellSharedProps, routeProps);
+var stdin_default = defineComponent({
+  name,
+  props: cellProps,
+  setup(props, {
+    slots
+  }) {
+    const route = useRoute();
+    const renderLabel = () => {
+      const showLabel = slots.label || isDef(props.label);
+      if (showLabel) {
+        return createVNode("div", {
+          "class": [bem("label"), props.labelClass]
+        }, [slots.label ? slots.label() : props.label]);
+      }
+    };
+    const renderTitle = () => {
+      var _a;
+      if (slots.title || isDef(props.title)) {
+        const titleSlot = (_a = slots.title) == null ? void 0 : _a.call(slots);
+        if (Array.isArray(titleSlot) && titleSlot.length === 0) {
+          return;
+        }
+        return createVNode("div", {
+          "class": [bem("title"), props.titleClass],
+          "style": props.titleStyle
+        }, [titleSlot || createVNode("span", null, [props.title]), renderLabel()]);
+      }
+    };
+    const renderValue = () => {
+      const slot = slots.value || slots.default;
+      const hasValue = slot || isDef(props.value);
+      if (hasValue) {
+        return createVNode("div", {
+          "class": [bem("value"), props.valueClass]
+        }, [slot ? slot() : createVNode("span", null, [props.value])]);
+      }
+    };
+    const renderLeftIcon = () => {
+      if (slots.icon) {
+        return slots.icon();
+      }
+      if (props.icon) {
+        return createVNode(Icon, {
+          "name": props.icon,
+          "class": bem("left-icon"),
+          "classPrefix": props.iconPrefix
+        }, null);
+      }
+    };
+    const renderRightIcon = () => {
+      if (slots["right-icon"]) {
+        return slots["right-icon"]();
+      }
+      if (props.isLink) {
+        const name2 = props.arrowDirection && props.arrowDirection !== "right" ? `arrow-${props.arrowDirection}` : "arrow";
+        return createVNode(Icon, {
+          "name": name2,
+          "class": bem("right-icon")
+        }, null);
+      }
+    };
+    return () => {
+      var _a;
+      const {
+        tag,
+        size,
+        center,
+        border,
+        isLink,
+        required
+      } = props;
+      const clickable = (_a = props.clickable) != null ? _a : isLink;
+      const classes = {
+        center,
+        required: !!required,
+        clickable,
+        borderless: !border
+      };
+      if (size) {
+        classes[size] = !!size;
+      }
+      return createVNode(tag, {
+        "class": bem(classes),
+        "role": clickable ? "button" : void 0,
+        "tabindex": clickable ? 0 : void 0,
+        "onClick": route
+      }, {
+        default: () => {
+          var _a2;
+          return [renderLeftIcon(), renderTitle(), renderValue(), renderRightIcon(), (_a2 = slots.extra) == null ? void 0 : _a2.call(slots)];
+        }
+      });
+    };
+  }
+});
+export {
+  cellProps,
+  cellSharedProps,
+  stdin_default as default
+};