@fecp/mobile 1.0.1

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/tabs/Tabs.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const utils = require("./utils.js");
+const index_esm = require("../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.js");
+const useId = require("../composables/use-id.js");
+const useRoute = require("../composables/use-route.js");
+const useRefs = require("../composables/use-refs.js");
+const useExpose = require("../composables/use-expose.js");
+const onPopupReopen = require("../composables/on-popup-reopen.js");
+const useVisibilityChange = require("../composables/use-visibility-change.js");
+const index = require("../sticky/index.js");
+const TabsContent = require("./TabsContent.js");
+const constant = require("../utils/constant.js");
+const dom = require("../utils/dom.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const basic = require("../utils/basic.js");
+const interceptor = require("../utils/interceptor.js");
+const [name, bem] = create.createNamespace("tabs");
+const tabsProps = {
+  type: props.makeStringProp("line"),
+  color: String,
+  border: Boolean,
+  sticky: Boolean,
+  shrink: Boolean,
+  active: props.makeNumericProp(0),
+  duration: props.makeNumericProp(0.3),
+  animated: Boolean,
+  ellipsis: props.truthProp,
+  swipeable: Boolean,
+  scrollspy: Boolean,
+  offsetTop: props.makeNumericProp(0),
+  background: String,
+  lazyRender: props.truthProp,
+  showHeader: props.truthProp,
+  lineWidth: props.numericProp,
+  lineHeight: props.numericProp,
+  beforeChange: Function,
+  swipeThreshold: props.makeNumericProp(5),
+  titleActiveColor: String,
+  titleInactiveColor: String
+};
+const TABS_KEY = Symbol(name);
+var stdin_default = vue.defineComponent({
+  name,
+  props: tabsProps,
+  emits: ["change", "scroll", "rendered", "clickTab", "update:active"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    let tabHeight;
+    let lockScroll;
+    let stickyFixed;
+    let cancelScrollLeftToRaf;
+    let cancelScrollTopToRaf;
+    const root = vue.ref();
+    const navRef = vue.ref();
+    const wrapRef = vue.ref();
+    const contentRef = vue.ref();
+    const id = useId.useId();
+    const scroller = index_esm.useScrollParent(root);
+    const [titleRefs, setTitleRefs] = useRefs.useRefs();
+    const {
+      children,
+      linkChildren
+    } = index_esm.useChildren(TABS_KEY);
+    const state = vue.reactive({
+      inited: false,
+      position: "",
+      lineStyle: {},
+      currentIndex: -1
+    });
+    const scrollable = vue.computed(() => children.length > +props2.swipeThreshold || !props2.ellipsis || props2.shrink);
+    const navStyle = vue.computed(() => ({
+      borderColor: props2.color,
+      background: props2.background
+    }));
+    const getTabName = (tab, index2) => {
+      var _a;
+      return (_a = tab.name) != null ? _a : index2;
+    };
+    const currentName = vue.computed(() => {
+      const activeTab = children[state.currentIndex];
+      if (activeTab) {
+        return getTabName(activeTab, state.currentIndex);
+      }
+    });
+    const offsetTopPx = vue.computed(() => format.unitToPx(props2.offsetTop));
+    const scrollOffset = vue.computed(() => {
+      if (props2.sticky) {
+        return offsetTopPx.value + tabHeight;
+      }
+      return 0;
+    });
+    const scrollIntoView = (immediate) => {
+      const nav = navRef.value;
+      const titles = titleRefs.value;
+      if (!scrollable.value || !nav || !titles || !titles[state.currentIndex]) {
+        return;
+      }
+      const title = titles[state.currentIndex].$el;
+      const to = title.offsetLeft - (nav.offsetWidth - title.offsetWidth) / 2;
+      if (cancelScrollLeftToRaf) cancelScrollLeftToRaf();
+      cancelScrollLeftToRaf = utils.scrollLeftTo(nav, to, immediate ? 0 : +props2.duration);
+    };
+    const setLine = () => {
+      const shouldAnimate = state.inited;
+      vue.nextTick(() => {
+        const titles = titleRefs.value;
+        if (!titles || !titles[state.currentIndex] || props2.type !== "line" || dom.isHidden(root.value)) {
+          return;
+        }
+        const title = titles[state.currentIndex].$el;
+        const {
+          lineWidth,
+          lineHeight
+        } = props2;
+        const left = title.offsetLeft + title.offsetWidth / 2;
+        const lineStyle = {
+          width: format.addUnit(lineWidth),
+          backgroundColor: props2.color,
+          transform: `translateX(${left}px) translateX(-50%)`
+        };
+        if (shouldAnimate) {
+          lineStyle.transitionDuration = `${props2.duration}s`;
+        }
+        if (basic.isDef(lineHeight)) {
+          const height = format.addUnit(lineHeight);
+          lineStyle.height = height;
+          lineStyle.borderRadius = height;
+        }
+        state.lineStyle = lineStyle;
+      });
+    };
+    const findAvailableTab = (index2) => {
+      const diff = index2 < state.currentIndex ? -1 : 1;
+      while (index2 >= 0 && index2 < children.length) {
+        if (!children[index2].disabled) {
+          return index2;
+        }
+        index2 += diff;
+      }
+    };
+    const setCurrentIndex = (currentIndex, skipScrollIntoView) => {
+      const newIndex = findAvailableTab(currentIndex);
+      if (!basic.isDef(newIndex)) {
+        return;
+      }
+      const newTab = children[newIndex];
+      const newName = getTabName(newTab, newIndex);
+      const shouldEmitChange = state.currentIndex !== null;
+      if (state.currentIndex !== newIndex) {
+        state.currentIndex = newIndex;
+        if (!skipScrollIntoView) {
+          scrollIntoView();
+        }
+        setLine();
+      }
+      if (newName !== props2.active) {
+        emit("update:active", newName);
+        if (shouldEmitChange) {
+          emit("change", newName, newTab.title);
+        }
+      }
+      if (stickyFixed && !props2.scrollspy) {
+        dom.setRootScrollTop(Math.ceil(dom.getElementTop(root.value) - offsetTopPx.value));
+      }
+    };
+    const setCurrentIndexByName = (name2, skipScrollIntoView) => {
+      const matched = children.find((tab, index22) => getTabName(tab, index22) === name2);
+      const index2 = matched ? children.indexOf(matched) : 0;
+      setCurrentIndex(index2, skipScrollIntoView);
+    };
+    const scrollToCurrentContent = (immediate = false) => {
+      if (props2.scrollspy) {
+        const target = children[state.currentIndex].$el;
+        if (target && scroller.value) {
+          const to = dom.getElementTop(target, scroller.value) - scrollOffset.value;
+          lockScroll = true;
+          if (cancelScrollTopToRaf) cancelScrollTopToRaf();
+          cancelScrollTopToRaf = utils.scrollTopTo(scroller.value, to, immediate ? 0 : +props2.duration, () => {
+            lockScroll = false;
+          });
+        }
+      }
+    };
+    const onClickTab = (item, index2, event) => {
+      const {
+        title,
+        disabled
+      } = children[index2];
+      const name2 = getTabName(children[index2], index2);
+      if (!disabled) {
+        interceptor.callInterceptor(props2.beforeChange, {
+          args: [name2],
+          done: () => {
+            setCurrentIndex(index2);
+            scrollToCurrentContent();
+          }
+        });
+        useRoute.route(item);
+      }
+      emit("clickTab", {
+        name: name2,
+        title,
+        event,
+        disabled
+      });
+    };
+    const onStickyScroll = (params) => {
+      stickyFixed = params.isFixed;
+      emit("scroll", params);
+    };
+    const scrollTo = (name2) => {
+      vue.nextTick(() => {
+        setCurrentIndexByName(name2);
+        scrollToCurrentContent(true);
+      });
+    };
+    const getCurrentIndexOnScroll = () => {
+      for (let index2 = 0; index2 < children.length; index2++) {
+        const {
+          top
+        } = index_esm.useRect(children[index2].$el);
+        if (top > scrollOffset.value) {
+          return index2 === 0 ? 0 : index2 - 1;
+        }
+      }
+      return children.length - 1;
+    };
+    const onScroll = () => {
+      if (props2.scrollspy && !lockScroll) {
+        const index2 = getCurrentIndexOnScroll();
+        setCurrentIndex(index2);
+      }
+    };
+    const renderLine = () => {
+      if (props2.type === "line" && children.length) {
+        return vue.createVNode("div", {
+          "class": bem("line"),
+          "style": state.lineStyle
+        }, null);
+      }
+    };
+    const renderHeader = () => {
+      var _a, _b, _c;
+      const {
+        type,
+        border,
+        sticky
+      } = props2;
+      const Header = [vue.createVNode("div", {
+        "ref": sticky ? void 0 : wrapRef,
+        "class": [bem("wrap"), {
+          [constant.BORDER_TOP_BOTTOM]: type === "line" && border
+        }]
+      }, [vue.createVNode("div", {
+        "ref": navRef,
+        "role": "tablist",
+        "class": bem("nav", [type, {
+          shrink: props2.shrink,
+          complete: scrollable.value
+        }]),
+        "style": navStyle.value,
+        "aria-orientation": "horizontal"
+      }, [(_a = slots["nav-left"]) == null ? void 0 : _a.call(slots), children.map((item) => item.renderTitle(onClickTab)), renderLine(), (_b = slots["nav-right"]) == null ? void 0 : _b.call(slots)])]), (_c = slots["nav-bottom"]) == null ? void 0 : _c.call(slots)];
+      if (sticky) {
+        return vue.createVNode("div", {
+          "ref": wrapRef
+        }, [Header]);
+      }
+      return Header;
+    };
+    const resize = () => {
+      setLine();
+      vue.nextTick(() => {
+        var _a, _b;
+        scrollIntoView(true);
+        (_b = (_a = contentRef.value) == null ? void 0 : _a.swipeRef.value) == null ? void 0 : _b.resize();
+      });
+    };
+    vue.watch(() => [props2.color, props2.duration, props2.lineWidth, props2.lineHeight], setLine);
+    vue.watch(dom.windowWidth, resize);
+    vue.watch(() => props2.active, (value) => {
+      if (value !== currentName.value) {
+        setCurrentIndexByName(value);
+      }
+    });
+    vue.watch(() => children.length, () => {
+      if (state.inited) {
+        setCurrentIndexByName(props2.active);
+        setLine();
+        vue.nextTick(() => {
+          scrollIntoView(true);
+        });
+      }
+    });
+    const init = () => {
+      setCurrentIndexByName(props2.active, true);
+      vue.nextTick(() => {
+        state.inited = true;
+        if (wrapRef.value) {
+          tabHeight = index_esm.useRect(wrapRef.value).height;
+        }
+        scrollIntoView(true);
+      });
+    };
+    const onRendered = (name2, title) => emit("rendered", name2, title);
+    useExpose.useExpose({
+      resize,
+      scrollTo
+    });
+    vue.onActivated(setLine);
+    onPopupReopen.onPopupReopen(setLine);
+    index_esm.onMountedOrActivated(init);
+    useVisibilityChange.useVisibilityChange(root, setLine);
+    index_esm.useEventListener("scroll", onScroll, {
+      target: scroller,
+      passive: true
+    });
+    linkChildren({
+      id,
+      props: props2,
+      setLine,
+      scrollable,
+      onRendered,
+      currentName,
+      setTitleRefs,
+      scrollIntoView
+    });
+    return () => vue.createVNode("div", {
+      "ref": root,
+      "class": bem([props2.type])
+    }, [props2.showHeader ? props2.sticky ? vue.createVNode(index.Sticky, {
+      "container": root.value,
+      "offsetTop": offsetTopPx.value,
+      "onScroll": onStickyScroll
+    }, {
+      default: () => [renderHeader()]
+    }) : renderHeader() : null, vue.createVNode(TabsContent.default, {
+      "ref": contentRef,
+      "count": children.length,
+      "inited": state.inited,
+      "animated": props2.animated,
+      "duration": props2.duration,
+      "swipeable": props2.swipeable,
+      "lazyRender": props2.lazyRender,
+      "currentIndex": state.currentIndex,
+      "onChange": setCurrentIndex
+    }, {
+      default: () => {
+        var _a;
+        return [(_a = slots.default) == null ? void 0 : _a.call(slots)];
+      }
+    })]);
+  }
+});
+exports.TABS_KEY = TABS_KEY;
+exports.default = stdin_default;
+exports.tabsProps = tabsProps;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/tabs/TabsContent.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const index = require("../swipe/index.js");
+const useExpose = require("../composables/use-expose.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const [name, bem] = create.createNamespace("tabs");
+var stdin_default = vue.defineComponent({
+  name,
+  props: {
+    count: props.makeRequiredProp(Number),
+    inited: Boolean,
+    animated: Boolean,
+    duration: props.makeRequiredProp(props.numericProp),
+    swipeable: Boolean,
+    lazyRender: Boolean,
+    currentIndex: props.makeRequiredProp(Number)
+  },
+  emits: ["change"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const swipeRef = vue.ref();
+    const onChange = (index2) => emit("change", index2);
+    const renderChildren = () => {
+      var _a;
+      const Content = (_a = slots.default) == null ? void 0 : _a.call(slots);
+      if (props2.animated || props2.swipeable) {
+        return vue.createVNode(index.Swipe, {
+          "ref": swipeRef,
+          "loop": false,
+          "class": bem("track"),
+          "duration": +props2.duration * 1e3,
+          "touchable": props2.swipeable,
+          "lazyRender": props2.lazyRender,
+          "showIndicators": false,
+          "onChange": onChange
+        }, {
+          default: () => [Content]
+        });
+      }
+      return Content;
+    };
+    const swipeToCurrentTab = (index2) => {
+      const swipe = swipeRef.value;
+      if (swipe && swipe.state.active !== index2) {
+        swipe.swipeTo(index2, {
+          immediate: !props2.inited
+        });
+      }
+    };
+    vue.watch(() => props2.currentIndex, swipeToCurrentTab);
+    vue.onMounted(() => {
+      swipeToCurrentTab(props2.currentIndex);
+    });
+    useExpose.useExpose({
+      swipeRef
+    });
+    return () => vue.createVNode("div", {
+      "class": bem("content", {
+        animated: props2.animated || props2.swipeable
+      })
+    }, [renderChildren()]);
+  }
+});
+exports.default = stdin_default;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/tabs/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Tabs$1 = require("./Tabs.js");
+const withInstall = require("../utils/with-install.js");
+const Tabs = withInstall.withInstall(Tabs$1.default);
+exports.tabsProps = Tabs$1.tabsProps;
+exports.Tabs = Tabs;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/tabs/utils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index_esm = require("../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.js");
+const dom = require("../utils/dom.js");
+function scrollLeftTo(scroller, to, duration) {
+  let rafId;
+  let count = 0;
+  const from = scroller.scrollLeft;
+  const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
+  let scrollLeft = from;
+  function cancel() {
+    index_esm.cancelRaf(rafId);
+  }
+  function animate() {
+    scrollLeft += (to - from) / frames;
+    scroller.scrollLeft = scrollLeft;
+    if (++count < frames) {
+      rafId = index_esm.raf(animate);
+    }
+  }
+  animate();
+  return cancel;
+}
+function scrollTopTo(scroller, to, duration, callback) {
+  let rafId;
+  let current = dom.getScrollTop(scroller);
+  const isDown = current < to;
+  const frames = duration === 0 ? 1 : Math.round(duration * 1e3 / 16);
+  const step = (to - current) / frames;
+  function cancel() {
+    index_esm.cancelRaf(rafId);
+  }
+  function animate() {
+    current += step;
+    if (isDown && current > to || !isDown && current < to) {
+      current = to;
+    }
+    dom.setScrollTop(scroller, current);
+    if (isDown && current < to || !isDown && current > to) {
+      rafId = index_esm.raf(animate);
+    } else if (callback) {
+      rafId = index_esm.raf(callback);
+    }
+  }
+  animate();
+  return cancel;
+}
+exports.scrollLeftTo = scrollLeftTo;
+exports.scrollTopTo = scrollTopTo;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/text-ellipsis/TextEllipsis.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const useExpose = require("../composables/use-expose.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const [name, bem] = create.createNamespace("text-ellipsis");
+const textEllipsisProps = {
+  rows: props.makeNumericProp(1),
+  dots: props.makeStringProp("..."),
+  content: props.makeStringProp(""),
+  expandText: props.makeStringProp(""),
+  collapseText: props.makeStringProp(""),
+  position: props.makeStringProp("end")
+};
+var stdin_default = vue.defineComponent({
+  name,
+  props: textEllipsisProps,
+  emits: ["clickAction"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const text = vue.ref(props2.content);
+    const expanded = vue.ref(false);
+    const hasAction = vue.ref(false);
+    const root = vue.ref();
+    const actionRef = vue.ref();
+    let needRecalculate = false;
+    const actionText = vue.computed(() => expanded.value ? props2.collapseText : props2.expandText);
+    const pxToNum = (value) => {
+      if (!value) return 0;
+      const match = value.match(/^\d*(\.\d*)?/);
+      return match ? Number(match[0]) : 0;
+    };
+    const cloneContainer = () => {
+      if (!root.value || !root.value.isConnected) return;
+      const originStyle = window.getComputedStyle(root.value);
+      const container = document.createElement("div");
+      const styleNames = Array.prototype.slice.apply(originStyle);
+      styleNames.forEach((name2) => {
+        container.style.setProperty(name2, originStyle.getPropertyValue(name2));
+      });
+      container.style.position = "fixed";
+      container.style.zIndex = "-9999";
+      container.style.top = "-9999px";
+      container.style.height = "auto";
+      container.style.minHeight = "auto";
+      container.style.maxHeight = "auto";
+      container.innerText = props2.content;
+      document.body.appendChild(container);
+      return container;
+    };
+    const calcEllipsisText = (container, maxHeight) => {
+      var _a, _b;
+      const {
+        content,
+        position,
+        dots
+      } = props2;
+      const end = content.length;
+      const middle = 0 + end >> 1;
+      const actionHTML = slots.action ? (_b = (_a = actionRef.value) == null ? void 0 : _a.outerHTML) != null ? _b : "" : props2.expandText;
+      const calcEllipse = () => {
+        const tail = (left, right) => {
+          if (right - left <= 1) {
+            if (position === "end") {
+              return content.slice(0, left) + dots;
+            }
+            return dots + content.slice(right, end);
+          }
+          const middle2 = Math.round((left + right) / 2);
+          if (position === "end") {
+            container.innerText = content.slice(0, middle2) + dots;
+          } else {
+            container.innerText = dots + content.slice(middle2, end);
+          }
+          container.innerHTML += actionHTML;
+          if (container.offsetHeight > maxHeight) {
+            if (position === "end") {
+              return tail(left, middle2);
+            }
+            return tail(middle2, right);
+          }
+          if (position === "end") {
+            return tail(middle2, right);
+          }
+          return tail(left, middle2);
+        };
+        return tail(0, end);
+      };
+      const middleTail = (leftPart, rightPart) => {
+        if (leftPart[1] - leftPart[0] <= 1 && rightPart[1] - rightPart[0] <= 1) {
+          return content.slice(0, leftPart[0]) + dots + content.slice(rightPart[1], end);
+        }
+        const leftMiddle = Math.floor((leftPart[0] + leftPart[1]) / 2);
+        const rightMiddle = Math.ceil((rightPart[0] + rightPart[1]) / 2);
+        container.innerText = props2.content.slice(0, leftMiddle) + props2.dots + props2.content.slice(rightMiddle, end);
+        container.innerHTML += actionHTML;
+        if (container.offsetHeight >= maxHeight) {
+          return middleTail([leftPart[0], leftMiddle], [rightMiddle, rightPart[1]]);
+        }
+        return middleTail([leftMiddle, leftPart[1]], [rightPart[0], rightMiddle]);
+      };
+      return props2.position === "middle" ? middleTail([0, middle], [middle, end]) : calcEllipse();
+    };
+    const calcEllipsised = () => {
+      const container = cloneContainer();
+      if (!container) {
+        needRecalculate = true;
+        return;
+      }
+      const {
+        paddingBottom,
+        paddingTop,
+        lineHeight
+      } = container.style;
+      const maxHeight = Math.ceil((Number(props2.rows) + 0.5) * pxToNum(lineHeight) + pxToNum(paddingTop) + pxToNum(paddingBottom));
+      if (maxHeight < container.offsetHeight) {
+        hasAction.value = true;
+        text.value = calcEllipsisText(container, maxHeight);
+      } else {
+        hasAction.value = false;
+        text.value = props2.content;
+      }
+      document.body.removeChild(container);
+    };
+    const toggle = (isExpanded = !expanded.value) => {
+      expanded.value = isExpanded;
+    };
+    const onClickAction = (event) => {
+      toggle();
+      emit("clickAction", event);
+    };
+    const renderAction = () => {
+      const action = slots.action ? slots.action({
+        expanded: expanded.value
+      }) : actionText.value;
+      return vue.createVNode("span", {
+        "ref": actionRef,
+        "class": bem("action"),
+        "onClick": onClickAction
+      }, [action]);
+    };
+    vue.onMounted(() => {
+      calcEllipsised();
+      if (slots.action) {
+        vue.nextTick(calcEllipsised);
+      }
+    });
+    vue.onActivated(() => {
+      if (needRecalculate) {
+        needRecalculate = false;
+        calcEllipsised();
+      }
+    });
+    vue.watch([dom.windowWidth, () => [props2.content, props2.rows, props2.position]], calcEllipsised);
+    useExpose.useExpose({
+      toggle
+    });
+    return () => vue.createVNode("div", {
+      "ref": root,
+      "class": bem()
+    }, [expanded.value ? props2.content : text.value, hasAction.value ? renderAction() : null]);
+  }
+});
+exports.default = stdin_default;
+exports.textEllipsisProps = textEllipsisProps;

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/text-ellipsis/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const TextEllipsis$1 = require("./TextEllipsis.js");
+const withInstall = require("../utils/with-install.js");
+const TextEllipsis = withInstall.withInstall(TextEllipsis$1.default);
+exports.textEllipsisProps = TextEllipsis$1.textEllipsisProps;
+exports.TextEllipsis = TextEllipsis;