@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/swipe/Swipe.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+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 useTouch = require("../composables/use-touch.js");
+const useExpose = require("../composables/use-expose.js");
+const onPopupReopen = require("../composables/on-popup-reopen.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const format = require("../utils/format.js");
+const [name, bem] = create.createNamespace("swipe");
+const swipeProps = {
+  loop: props.truthProp,
+  width: props.numericProp,
+  height: props.numericProp,
+  vertical: Boolean,
+  autoplay: props.makeNumericProp(0),
+  duration: props.makeNumericProp(500),
+  touchable: props.truthProp,
+  lazyRender: Boolean,
+  initialSwipe: props.makeNumericProp(0),
+  indicatorColor: String,
+  showIndicators: props.truthProp,
+  stopPropagation: props.truthProp
+};
+const SWIPE_KEY = Symbol(name);
+var stdin_default = vue.defineComponent({
+  name,
+  props: swipeProps,
+  emits: ["change", "dragStart", "dragEnd"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const root = vue.ref();
+    const track = vue.ref();
+    const state = vue.reactive({
+      rect: null,
+      width: 0,
+      height: 0,
+      offset: 0,
+      active: 0,
+      swiping: false
+    });
+    let dragging = false;
+    const touch = useTouch.useTouch();
+    const {
+      children,
+      linkChildren
+    } = index_esm.useChildren(SWIPE_KEY);
+    const count = vue.computed(() => children.length);
+    const size = vue.computed(() => state[props2.vertical ? "height" : "width"]);
+    const delta = vue.computed(() => props2.vertical ? touch.deltaY.value : touch.deltaX.value);
+    const minOffset = vue.computed(() => {
+      if (state.rect) {
+        const base = props2.vertical ? state.rect.height : state.rect.width;
+        return base - size.value * count.value;
+      }
+      return 0;
+    });
+    const maxCount = vue.computed(() => size.value ? Math.ceil(Math.abs(minOffset.value) / size.value) : count.value);
+    const trackSize = vue.computed(() => count.value * size.value);
+    const activeIndicator = vue.computed(() => (state.active + count.value) % count.value);
+    const isCorrectDirection = vue.computed(() => {
+      const expect = props2.vertical ? "vertical" : "horizontal";
+      return touch.direction.value === expect;
+    });
+    const trackStyle = vue.computed(() => {
+      const style = {
+        transitionDuration: `${state.swiping ? 0 : props2.duration}ms`,
+        transform: `translate${props2.vertical ? "Y" : "X"}(${+state.offset.toFixed(2)}px)`
+      };
+      if (size.value) {
+        const mainAxis = props2.vertical ? "height" : "width";
+        const crossAxis = props2.vertical ? "width" : "height";
+        style[mainAxis] = `${trackSize.value}px`;
+        style[crossAxis] = props2[crossAxis] ? `${props2[crossAxis]}px` : "";
+      }
+      return style;
+    });
+    const getTargetActive = (pace) => {
+      const {
+        active
+      } = state;
+      if (pace) {
+        if (props2.loop) {
+          return format.clamp(active + pace, -1, count.value);
+        }
+        return format.clamp(active + pace, 0, maxCount.value);
+      }
+      return active;
+    };
+    const getTargetOffset = (targetActive, offset = 0) => {
+      let currentPosition = targetActive * size.value;
+      if (!props2.loop) {
+        currentPosition = Math.min(currentPosition, -minOffset.value);
+      }
+      let targetOffset = offset - currentPosition;
+      if (!props2.loop) {
+        targetOffset = format.clamp(targetOffset, minOffset.value, 0);
+      }
+      return targetOffset;
+    };
+    const move = ({
+      pace = 0,
+      offset = 0,
+      emitChange
+    }) => {
+      if (count.value <= 1) {
+        return;
+      }
+      const {
+        active
+      } = state;
+      const targetActive = getTargetActive(pace);
+      const targetOffset = getTargetOffset(targetActive, offset);
+      if (props2.loop) {
+        if (children[0] && targetOffset !== minOffset.value) {
+          const outRightBound = targetOffset < minOffset.value;
+          children[0].setOffset(outRightBound ? trackSize.value : 0);
+        }
+        if (children[count.value - 1] && targetOffset !== 0) {
+          const outLeftBound = targetOffset > 0;
+          children[count.value - 1].setOffset(outLeftBound ? -trackSize.value : 0);
+        }
+      }
+      state.active = targetActive;
+      state.offset = targetOffset;
+      if (emitChange && targetActive !== active) {
+        emit("change", activeIndicator.value);
+      }
+    };
+    const correctPosition = () => {
+      state.swiping = true;
+      if (state.active <= -1) {
+        move({
+          pace: count.value
+        });
+      } else if (state.active >= count.value) {
+        move({
+          pace: -count.value
+        });
+      }
+    };
+    const prev = () => {
+      correctPosition();
+      touch.reset();
+      index_esm.doubleRaf(() => {
+        state.swiping = false;
+        move({
+          pace: -1,
+          emitChange: true
+        });
+      });
+    };
+    const next = () => {
+      correctPosition();
+      touch.reset();
+      index_esm.doubleRaf(() => {
+        state.swiping = false;
+        move({
+          pace: 1,
+          emitChange: true
+        });
+      });
+    };
+    let autoplayTimer;
+    const stopAutoplay = () => clearTimeout(autoplayTimer);
+    const autoplay = () => {
+      stopAutoplay();
+      if (+props2.autoplay > 0 && count.value > 1) {
+        autoplayTimer = setTimeout(() => {
+          next();
+          autoplay();
+        }, +props2.autoplay);
+      }
+    };
+    const initialize = (active = +props2.initialSwipe) => {
+      if (!root.value) {
+        return;
+      }
+      const cb = () => {
+        var _a, _b;
+        if (!dom.isHidden(root)) {
+          const rect = {
+            width: root.value.offsetWidth,
+            height: root.value.offsetHeight
+          };
+          state.rect = rect;
+          state.width = +((_a = props2.width) != null ? _a : rect.width);
+          state.height = +((_b = props2.height) != null ? _b : rect.height);
+        }
+        if (count.value) {
+          active = Math.min(count.value - 1, active);
+          if (active === -1) {
+            active = count.value - 1;
+          }
+        }
+        state.active = active;
+        state.swiping = true;
+        state.offset = getTargetOffset(active);
+        children.forEach((swipe) => {
+          swipe.setOffset(0);
+        });
+        autoplay();
+      };
+      if (dom.isHidden(root)) {
+        vue.nextTick().then(cb);
+      } else {
+        cb();
+      }
+    };
+    const resize = () => initialize(state.active);
+    let touchStartTime;
+    const onTouchStart = (event) => {
+      if (!props2.touchable || // avoid resetting position on multi-finger touch
+      event.touches.length > 1) return;
+      touch.start(event);
+      dragging = false;
+      touchStartTime = Date.now();
+      stopAutoplay();
+      correctPosition();
+    };
+    const onTouchMove = (event) => {
+      if (props2.touchable && state.swiping) {
+        touch.move(event);
+        if (isCorrectDirection.value) {
+          const isEdgeTouch = !props2.loop && (state.active === 0 && delta.value > 0 || state.active === count.value - 1 && delta.value < 0);
+          if (!isEdgeTouch) {
+            dom.preventDefault(event, props2.stopPropagation);
+            move({
+              offset: delta.value
+            });
+            if (!dragging) {
+              emit("dragStart", {
+                index: activeIndicator.value
+              });
+              dragging = true;
+            }
+          }
+        }
+      }
+    };
+    const onTouchEnd = () => {
+      if (!props2.touchable || !state.swiping) {
+        return;
+      }
+      const duration = Date.now() - touchStartTime;
+      const speed = delta.value / duration;
+      const shouldSwipe = Math.abs(speed) > 0.25 || Math.abs(delta.value) > size.value / 2;
+      if (shouldSwipe && isCorrectDirection.value) {
+        const offset = props2.vertical ? touch.offsetY.value : touch.offsetX.value;
+        let pace = 0;
+        if (props2.loop) {
+          pace = offset > 0 ? delta.value > 0 ? -1 : 1 : 0;
+        } else {
+          pace = -Math[delta.value > 0 ? "ceil" : "floor"](delta.value / size.value);
+        }
+        move({
+          pace,
+          emitChange: true
+        });
+      } else if (delta.value) {
+        move({
+          pace: 0
+        });
+      }
+      dragging = false;
+      state.swiping = false;
+      emit("dragEnd", {
+        index: activeIndicator.value
+      });
+      autoplay();
+    };
+    const swipeTo = (index, options = {}) => {
+      correctPosition();
+      touch.reset();
+      index_esm.doubleRaf(() => {
+        let targetIndex;
+        if (props2.loop && index === count.value) {
+          targetIndex = state.active === 0 ? 0 : index;
+        } else {
+          targetIndex = index % count.value;
+        }
+        if (options.immediate) {
+          index_esm.doubleRaf(() => {
+            state.swiping = false;
+          });
+        } else {
+          state.swiping = false;
+        }
+        move({
+          pace: targetIndex - state.active,
+          emitChange: true
+        });
+      });
+    };
+    const renderDot = (_, index) => {
+      const active = index === activeIndicator.value;
+      const style = active ? {
+        backgroundColor: props2.indicatorColor
+      } : void 0;
+      return vue.createVNode("i", {
+        "style": style,
+        "class": bem("indicator", {
+          active
+        })
+      }, null);
+    };
+    const renderIndicator = () => {
+      if (slots.indicator) {
+        return slots.indicator({
+          active: activeIndicator.value,
+          total: count.value
+        });
+      }
+      if (props2.showIndicators && count.value > 1) {
+        return vue.createVNode("div", {
+          "class": bem("indicators", {
+            vertical: props2.vertical
+          })
+        }, [Array(count.value).fill("").map(renderDot)]);
+      }
+    };
+    useExpose.useExpose({
+      prev,
+      next,
+      state,
+      resize,
+      swipeTo
+    });
+    linkChildren({
+      size,
+      props: props2,
+      count,
+      activeIndicator
+    });
+    vue.watch(() => props2.initialSwipe, (value) => initialize(+value));
+    vue.watch(count, () => initialize(state.active));
+    vue.watch(() => props2.autoplay, autoplay);
+    vue.watch([dom.windowWidth, dom.windowHeight, () => props2.width, () => props2.height], resize);
+    vue.watch(index_esm.usePageVisibility(), (visible) => {
+      if (visible === "visible") {
+        autoplay();
+      } else {
+        stopAutoplay();
+      }
+    });
+    vue.onMounted(initialize);
+    vue.onActivated(() => initialize(state.active));
+    onPopupReopen.onPopupReopen(() => initialize(state.active));
+    vue.onDeactivated(stopAutoplay);
+    vue.onBeforeUnmount(stopAutoplay);
+    index_esm.useEventListener("touchmove", onTouchMove, {
+      target: track
+    });
+    return () => {
+      var _a;
+      return vue.createVNode("div", {
+        "ref": root,
+        "class": bem()
+      }, [vue.createVNode("div", {
+        "ref": track,
+        "style": trackStyle.value,
+        "class": bem("track", {
+          vertical: props2.vertical
+        }),
+        "onTouchstartPassive": onTouchStart,
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]), renderIndicator()]);
+    };
+  }
+});
+exports.SWIPE_KEY = SWIPE_KEY;
+exports.default = stdin_default;
+exports.swipeProps = swipeProps;

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

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

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/swipe-cell/SwipeCell.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+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 useTouch = require("../composables/use-touch.js");
+const useExpose = require("../composables/use-expose.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const basic = require("../utils/basic.js");
+const interceptor = require("../utils/interceptor.js");
+const dom = require("../utils/dom.js");
+const format = require("../utils/format.js");
+const [name, bem] = create.createNamespace("swipe-cell");
+const swipeCellProps = {
+  name: props.makeNumericProp(""),
+  disabled: Boolean,
+  leftWidth: props.numericProp,
+  rightWidth: props.numericProp,
+  beforeClose: Function,
+  stopPropagation: Boolean
+};
+var stdin_default = vue.defineComponent({
+  name,
+  props: swipeCellProps,
+  emits: ["open", "close", "click"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    let opened;
+    let lockClick;
+    let startOffset;
+    let isInBeforeClosing;
+    const root = vue.ref();
+    const leftRef = vue.ref();
+    const rightRef = vue.ref();
+    const state = vue.reactive({
+      offset: 0,
+      dragging: false
+    });
+    const touch = useTouch.useTouch();
+    const getWidthByRef = (ref2) => ref2.value ? index_esm.useRect(ref2).width : 0;
+    const leftWidth = vue.computed(() => basic.isDef(props2.leftWidth) ? +props2.leftWidth : getWidthByRef(leftRef));
+    const rightWidth = vue.computed(() => basic.isDef(props2.rightWidth) ? +props2.rightWidth : getWidthByRef(rightRef));
+    const open = (side) => {
+      state.offset = side === "left" ? leftWidth.value : -rightWidth.value;
+      if (!opened) {
+        opened = true;
+        emit("open", {
+          name: props2.name,
+          position: side
+        });
+      }
+    };
+    const close = (position) => {
+      state.offset = 0;
+      if (opened) {
+        opened = false;
+        emit("close", {
+          name: props2.name,
+          position
+        });
+      }
+    };
+    const toggle = (side) => {
+      const offset = Math.abs(state.offset);
+      const THRESHOLD = 0.15;
+      const threshold = opened ? 1 - THRESHOLD : THRESHOLD;
+      const width = side === "left" ? leftWidth.value : rightWidth.value;
+      if (width && offset > width * threshold) {
+        open(side);
+      } else {
+        close(side);
+      }
+    };
+    const onTouchStart = (event) => {
+      if (!props2.disabled) {
+        startOffset = state.offset;
+        touch.start(event);
+      }
+    };
+    const onTouchMove = (event) => {
+      if (props2.disabled) {
+        return;
+      }
+      const {
+        deltaX
+      } = touch;
+      touch.move(event);
+      if (touch.isHorizontal()) {
+        lockClick = true;
+        state.dragging = true;
+        const isEdge = !opened || deltaX.value * startOffset < 0;
+        if (isEdge) {
+          dom.preventDefault(event, props2.stopPropagation);
+        }
+        state.offset = format.clamp(deltaX.value + startOffset, -rightWidth.value, leftWidth.value);
+      }
+    };
+    const onTouchEnd = () => {
+      if (state.dragging) {
+        state.dragging = false;
+        toggle(state.offset > 0 ? "left" : "right");
+        setTimeout(() => {
+          lockClick = false;
+        }, 0);
+      }
+    };
+    const onClick = (position = "outside", event) => {
+      if (isInBeforeClosing) return;
+      emit("click", position);
+      if (opened && !lockClick) {
+        isInBeforeClosing = true;
+        interceptor.callInterceptor(props2.beforeClose, {
+          args: [{
+            event,
+            name: props2.name,
+            position
+          }],
+          done: () => {
+            isInBeforeClosing = false;
+            close(position);
+          },
+          canceled: () => isInBeforeClosing = false,
+          error: () => isInBeforeClosing = false
+        });
+      }
+    };
+    const getClickHandler = (position, stop) => (event) => {
+      if (stop) {
+        event.stopPropagation();
+      }
+      if (lockClick) {
+        return;
+      }
+      onClick(position, event);
+    };
+    const renderSideContent = (side, ref2) => {
+      const contentSlot = slots[side];
+      if (contentSlot) {
+        return vue.createVNode("div", {
+          "ref": ref2,
+          "class": bem(side),
+          "onClick": getClickHandler(side, true)
+        }, [contentSlot()]);
+      }
+    };
+    useExpose.useExpose({
+      open,
+      close
+    });
+    index_esm.useClickAway(root, (event) => onClick("outside", event), {
+      eventName: "touchstart"
+    });
+    index_esm.useEventListener("touchmove", onTouchMove, {
+      target: root
+    });
+    return () => {
+      var _a;
+      const wrapperStyle = {
+        transform: `translate3d(${state.offset}px, 0, 0)`,
+        transitionDuration: state.dragging ? "0s" : ".6s"
+      };
+      return vue.createVNode("div", {
+        "ref": root,
+        "class": bem(),
+        "onClick": getClickHandler("cell", lockClick),
+        "onTouchstartPassive": onTouchStart,
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd
+      }, [vue.createVNode("div", {
+        "class": bem("wrapper"),
+        "style": wrapperStyle
+      }, [renderSideContent("left", leftRef), (_a = slots.default) == null ? void 0 : _a.call(slots), renderSideContent("right", rightRef)])]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.swipeCellProps = swipeCellProps;

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

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

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/swipe-item/SwipeItem.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const Swipe = require("../swipe/Swipe.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 useExpose = require("../composables/use-expose.js");
+const create = require("../utils/create.js");
+const [name, bem] = create.createNamespace("swipe-item");
+var stdin_default = vue.defineComponent({
+  name,
+  setup(props, {
+    slots
+  }) {
+    let rendered;
+    const state = vue.reactive({
+      offset: 0,
+      inited: false,
+      mounted: false
+    });
+    const {
+      parent,
+      index
+    } = index_esm.useParent(Swipe.SWIPE_KEY);
+    if (!parent) {
+      if (process.env.NODE_ENV !== "production") {
+        console.error("[Vant] <SwipeItem> must be a child component of <Swipe>.");
+      }
+      return;
+    }
+    const style = vue.computed(() => {
+      const style2 = {};
+      const {
+        vertical
+      } = parent.props;
+      if (parent.size.value) {
+        style2[vertical ? "height" : "width"] = `${parent.size.value}px`;
+      }
+      if (state.offset) {
+        style2.transform = `translate${vertical ? "Y" : "X"}(${state.offset}px)`;
+      }
+      return style2;
+    });
+    const shouldRender = vue.computed(() => {
+      const {
+        loop,
+        lazyRender
+      } = parent.props;
+      if (!lazyRender || rendered) {
+        return true;
+      }
+      if (!state.mounted) {
+        return false;
+      }
+      const active = parent.activeIndicator.value;
+      const maxActive = parent.count.value - 1;
+      const prevActive = active === 0 && loop ? maxActive : active - 1;
+      const nextActive = active === maxActive && loop ? 0 : active + 1;
+      rendered = index.value === active || index.value === prevActive || index.value === nextActive;
+      return rendered;
+    });
+    const setOffset = (offset) => {
+      state.offset = offset;
+    };
+    vue.onMounted(() => {
+      vue.nextTick(() => {
+        state.mounted = true;
+      });
+    });
+    useExpose.useExpose({
+      setOffset
+    });
+    return () => {
+      var _a;
+      return vue.createVNode("div", {
+        "class": bem(),
+        "style": style.value
+      }, [shouldRender.value ? (_a = slots.default) == null ? void 0 : _a.call(slots) : null]);
+    };
+  }
+});
+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/swipe-item/index.js

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