@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/floating-bubble/FloatingBubble.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 index = require("../icon/index.js");
+const closest = require("../utils/closest.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 basic = require("../utils/basic.js");
+const floatingBubbleProps = {
+  gap: props.makeNumberProp(24),
+  icon: String,
+  axis: props.makeStringProp("y"),
+  magnetic: String,
+  offset: {
+    type: Object,
+    default: () => ({
+      x: -1,
+      y: -1
+    })
+  },
+  teleport: {
+    type: [String, Object],
+    default: "body"
+  }
+};
+const [name, bem] = create.createNamespace("floating-bubble");
+var stdin_default = vue.defineComponent({
+  name,
+  inheritAttrs: false,
+  props: floatingBubbleProps,
+  emits: ["click", "update:offset", "offsetChange"],
+  setup(props2, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const rootRef = vue.ref();
+    const state = vue.ref({
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    });
+    const boundary = vue.computed(() => ({
+      top: props2.gap,
+      right: dom.windowWidth.value - state.value.width - props2.gap,
+      bottom: dom.windowHeight.value - state.value.height - props2.gap,
+      left: props2.gap
+    }));
+    const dragging = vue.ref(false);
+    let initialized = false;
+    const rootStyle = vue.computed(() => {
+      const style = {};
+      const x = format.addUnit(state.value.x);
+      const y = format.addUnit(state.value.y);
+      style.transform = `translate3d(${x}, ${y}, 0)`;
+      if (dragging.value || !initialized) {
+        style.transition = "none";
+      }
+      return style;
+    });
+    const updateState = () => {
+      if (!show.value) return;
+      const {
+        width,
+        height
+      } = index_esm.useRect(rootRef.value);
+      const {
+        offset
+      } = props2;
+      state.value = {
+        x: offset.x > -1 ? offset.x : dom.windowWidth.value - width - props2.gap,
+        y: offset.y > -1 ? offset.y : dom.windowHeight.value - height - props2.gap,
+        width,
+        height
+      };
+    };
+    const touch = useTouch.useTouch();
+    let prevX = 0;
+    let prevY = 0;
+    const onTouchStart = (e) => {
+      touch.start(e);
+      dragging.value = true;
+      prevX = state.value.x;
+      prevY = state.value.y;
+    };
+    const onTouchMove = (e) => {
+      e.preventDefault();
+      touch.move(e);
+      if (props2.axis === "lock") return;
+      if (!touch.isTap.value) {
+        if (props2.axis === "x" || props2.axis === "xy") {
+          let nextX = prevX + touch.deltaX.value;
+          if (nextX < boundary.value.left) nextX = boundary.value.left;
+          if (nextX > boundary.value.right) nextX = boundary.value.right;
+          state.value.x = nextX;
+        }
+        if (props2.axis === "y" || props2.axis === "xy") {
+          let nextY = prevY + touch.deltaY.value;
+          if (nextY < boundary.value.top) nextY = boundary.value.top;
+          if (nextY > boundary.value.bottom) nextY = boundary.value.bottom;
+          state.value.y = nextY;
+        }
+        const offset = basic.pick(state.value, ["x", "y"]);
+        emit("update:offset", offset);
+      }
+    };
+    index_esm.useEventListener("touchmove", onTouchMove, {
+      target: rootRef
+    });
+    const onTouchEnd = () => {
+      dragging.value = false;
+      vue.nextTick(() => {
+        if (props2.magnetic === "x") {
+          const nextX = closest.closest([boundary.value.left, boundary.value.right], state.value.x);
+          state.value.x = nextX;
+        }
+        if (props2.magnetic === "y") {
+          const nextY = closest.closest([boundary.value.top, boundary.value.bottom], state.value.y);
+          state.value.y = nextY;
+        }
+        if (!touch.isTap.value) {
+          const offset = basic.pick(state.value, ["x", "y"]);
+          emit("update:offset", offset);
+          if (prevX !== offset.x || prevY !== offset.y) {
+            emit("offsetChange", offset);
+          }
+        }
+      });
+    };
+    const onClick = (e) => {
+      if (touch.isTap.value) emit("click", e);
+      else e.stopPropagation();
+    };
+    vue.onMounted(() => {
+      updateState();
+      vue.nextTick(() => {
+        initialized = true;
+      });
+    });
+    vue.watch([dom.windowWidth, dom.windowHeight, () => props2.gap, () => props2.offset], updateState, {
+      deep: true
+    });
+    const show = vue.ref(true);
+    vue.onActivated(() => {
+      show.value = true;
+    });
+    vue.onDeactivated(() => {
+      if (props2.teleport) {
+        show.value = false;
+      }
+    });
+    return () => {
+      const Content = vue.withDirectives(vue.createVNode("div", vue.mergeProps({
+        "class": bem(),
+        "ref": rootRef,
+        "onTouchstartPassive": onTouchStart,
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd,
+        "onClickCapture": onClick,
+        "style": rootStyle.value
+      }, attrs), [slots.default ? slots.default() : vue.createVNode(index.default, {
+        "name": props2.icon,
+        "class": bem("icon")
+      }, null)]), [[vue.vShow, show.value]]);
+      return props2.teleport ? vue.createVNode(vue.Teleport, {
+        "to": props2.teleport
+      }, {
+        default: () => [Content]
+      }) : Content;
+    };
+  }
+});
+exports.default = stdin_default;
+exports.floatingBubbleProps = floatingBubbleProps;

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

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

package/lib/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/floating-panel/FloatingPanel.js

@@ -0,0 +1,138 @@
+"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 useLockScroll = require("../composables/use-lock-scroll.js");
+const useTouch = require("../composables/use-touch.js");
+const useSyncPropRef = require("../composables/use-sync-prop-ref.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 closest = require("../utils/closest.js");
+const floatingPanelProps = {
+  height: props.makeNumericProp(0),
+  anchors: props.makeArrayProp(),
+  duration: props.makeNumericProp(0.3),
+  contentDraggable: props.truthProp,
+  lockScroll: Boolean,
+  safeAreaInsetBottom: props.truthProp
+};
+const [name, bem] = create.createNamespace("floating-panel");
+var stdin_default = vue.defineComponent({
+  name,
+  props: floatingPanelProps,
+  emits: ["heightChange", "update:height"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const DAMP = 0.2;
+    const rootRef = vue.ref();
+    const contentRef = vue.ref();
+    const height = useSyncPropRef.useSyncPropRef(() => +props2.height, (value) => emit("update:height", value));
+    const boundary = vue.computed(() => {
+      var _a, _b;
+      return {
+        min: (_a = props2.anchors[0]) != null ? _a : 100,
+        max: (_b = props2.anchors[props2.anchors.length - 1]) != null ? _b : Math.round(dom.windowHeight.value * 0.6)
+      };
+    });
+    const anchors = vue.computed(() => props2.anchors.length >= 2 ? props2.anchors : [boundary.value.min, boundary.value.max]);
+    const dragging = vue.ref(false);
+    const rootStyle = vue.computed(() => ({
+      height: format.addUnit(boundary.value.max),
+      transform: `translateY(calc(100% + ${format.addUnit(-height.value)}))`,
+      transition: !dragging.value ? `transform ${props2.duration}s cubic-bezier(0.18, 0.89, 0.32, 1.28)` : "none"
+    }));
+    const ease = (moveY) => {
+      const absDistance = Math.abs(moveY);
+      const {
+        min,
+        max
+      } = boundary.value;
+      if (absDistance > max) {
+        return -(max + (absDistance - max) * DAMP);
+      }
+      if (absDistance < min) {
+        return -(min - (min - absDistance) * DAMP);
+      }
+      return moveY;
+    };
+    let startY;
+    let maxScroll = -1;
+    const touch = useTouch.useTouch();
+    const onTouchstart = (e) => {
+      touch.start(e);
+      dragging.value = true;
+      startY = -height.value;
+      maxScroll = -1;
+    };
+    const onTouchmove = (e) => {
+      var _a;
+      touch.move(e);
+      const target = e.target;
+      if (contentRef.value === target || ((_a = contentRef.value) == null ? void 0 : _a.contains(target))) {
+        const {
+          scrollTop
+        } = contentRef.value;
+        maxScroll = Math.max(maxScroll, scrollTop);
+        if (!props2.contentDraggable) return;
+        if (-startY < boundary.value.max) {
+          dom.preventDefault(e, true);
+        } else if (!(scrollTop <= 0 && touch.deltaY.value > 0) || maxScroll > 0) {
+          return;
+        }
+      }
+      const moveY = touch.deltaY.value + startY;
+      height.value = -ease(moveY);
+    };
+    const onTouchend = () => {
+      maxScroll = -1;
+      dragging.value = false;
+      height.value = closest.closest(anchors.value, height.value);
+      if (height.value !== -startY) {
+        emit("heightChange", {
+          height: height.value
+        });
+      }
+    };
+    vue.watch(boundary, () => {
+      height.value = closest.closest(anchors.value, height.value);
+    }, {
+      immediate: true
+    });
+    useLockScroll.useLockScroll(rootRef, () => props2.lockScroll || dragging.value);
+    index_esm.useEventListener("touchmove", onTouchmove, {
+      target: rootRef
+    });
+    const renderHeader = () => {
+      if (slots.header) {
+        return slots.header();
+      }
+      return vue.createVNode("div", {
+        "class": bem("header")
+      }, [vue.createVNode("div", {
+        "class": bem("header-bar")
+      }, null)]);
+    };
+    return () => {
+      var _a;
+      return vue.createVNode("div", {
+        "class": [bem(), {
+          "van-safe-area-bottom": props2.safeAreaInsetBottom
+        }],
+        "ref": rootRef,
+        "style": rootStyle.value,
+        "onTouchstartPassive": onTouchstart,
+        "onTouchend": onTouchend,
+        "onTouchcancel": onTouchend
+      }, [renderHeader(), vue.createVNode("div", {
+        "class": bem("content"),
+        "ref": contentRef
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.floatingPanelProps = floatingPanelProps;

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

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

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

@@ -0,0 +1,171 @@
+"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 useExpose = require("../composables/use-expose.js");
+const constant = require("../utils/constant.js");
+const props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const dom = require("../utils/dom.js");
+const [name, bem] = create.createNamespace("form");
+const formProps = {
+  colon: Boolean,
+  disabled: Boolean,
+  readonly: Boolean,
+  required: [Boolean, String],
+  showError: Boolean,
+  labelWidth: props.numericProp,
+  labelAlign: String,
+  inputAlign: String,
+  scrollToError: Boolean,
+  scrollToErrorPosition: String,
+  validateFirst: Boolean,
+  submitOnEnter: props.truthProp,
+  showErrorMessage: props.truthProp,
+  errorMessageAlign: String,
+  validateTrigger: {
+    type: [String, Array],
+    default: "onBlur"
+  }
+};
+var stdin_default = vue.defineComponent({
+  name,
+  props: formProps,
+  emits: ["submit", "failed"],
+  setup(props2, {
+    emit,
+    slots
+  }) {
+    const {
+      children,
+      linkChildren
+    } = index_esm.useChildren(constant.FORM_KEY);
+    const getFieldsByNames = (names) => {
+      if (names) {
+        return children.filter((field) => names.includes(field.name));
+      }
+      return children;
+    };
+    const validateSeq = (names) => new Promise((resolve, reject) => {
+      const errors = [];
+      const fields = getFieldsByNames(names);
+      fields.reduce((promise, field) => promise.then(() => {
+        if (!errors.length) {
+          return field.validate().then((error) => {
+            if (error) {
+              errors.push(error);
+            }
+          });
+        }
+      }), Promise.resolve()).then(() => {
+        if (errors.length) {
+          reject(errors);
+        } else {
+          resolve();
+        }
+      });
+    });
+    const validateAll = (names) => new Promise((resolve, reject) => {
+      const fields = getFieldsByNames(names);
+      Promise.all(fields.map((item) => item.validate())).then((errors) => {
+        errors = errors.filter(Boolean);
+        if (errors.length) {
+          reject(errors);
+        } else {
+          resolve();
+        }
+      });
+    });
+    const validateField = (name2) => {
+      const matched = children.find((item) => item.name === name2);
+      if (matched) {
+        return new Promise((resolve, reject) => {
+          matched.validate().then((error) => {
+            if (error) {
+              reject(error);
+            } else {
+              resolve();
+            }
+          });
+        });
+      }
+      return Promise.reject();
+    };
+    const validate = (name2) => {
+      if (typeof name2 === "string") {
+        return validateField(name2);
+      }
+      return props2.validateFirst ? validateSeq(name2) : validateAll(name2);
+    };
+    const resetValidation = (name2) => {
+      if (typeof name2 === "string") {
+        name2 = [name2];
+      }
+      const fields = getFieldsByNames(name2);
+      fields.forEach((item) => {
+        item.resetValidation();
+      });
+    };
+    const getValidationStatus = () => children.reduce((form, field) => {
+      form[field.name] = field.getValidationStatus();
+      return form;
+    }, {});
+    const scrollToField = (name2, options) => {
+      children.some((item) => {
+        if (item.name === name2) {
+          item.$el.scrollIntoView(options);
+          return true;
+        }
+        return false;
+      });
+    };
+    const getValues = () => children.reduce((form, field) => {
+      if (field.name !== void 0) {
+        form[field.name] = field.formValue.value;
+      }
+      return form;
+    }, {});
+    const submit = () => {
+      const values = getValues();
+      validate().then(() => emit("submit", values)).catch((errors) => {
+        emit("failed", {
+          values,
+          errors
+        });
+        const {
+          scrollToError,
+          scrollToErrorPosition
+        } = props2;
+        if (scrollToError && errors[0].name) {
+          scrollToField(errors[0].name, scrollToErrorPosition ? {
+            block: scrollToErrorPosition
+          } : void 0);
+        }
+      });
+    };
+    const onSubmit = (event) => {
+      dom.preventDefault(event);
+      submit();
+    };
+    linkChildren({
+      props: props2
+    });
+    useExpose.useExpose({
+      submit,
+      validate,
+      getValues,
+      scrollToField,
+      resetValidation,
+      getValidationStatus
+    });
+    return () => {
+      var _a;
+      return vue.createVNode("form", {
+        "class": bem(),
+        "onSubmit": onSubmit
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+exports.default = stdin_default;
+exports.formProps = formProps;

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

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

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const vue = require("vue");
+const constant = require("../utils/constant.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 props = require("../utils/props.js");
+const create = require("../utils/create.js");
+const format = require("../utils/format.js");
+const [name, bem] = create.createNamespace("grid");
+const gridProps = {
+  square: Boolean,
+  center: props.truthProp,
+  border: props.truthProp,
+  gutter: props.numericProp,
+  reverse: Boolean,
+  iconSize: props.numericProp,
+  direction: String,
+  clickable: Boolean,
+  columnNum: props.makeNumericProp(4)
+};
+const GRID_KEY = Symbol(name);
+var stdin_default = vue.defineComponent({
+  name,
+  props: gridProps,
+  setup(props2, {
+    slots
+  }) {
+    const {
+      linkChildren
+    } = index_esm.useChildren(GRID_KEY);
+    linkChildren({
+      props: props2
+    });
+    return () => {
+      var _a;
+      return vue.createVNode("div", {
+        "style": {
+          paddingLeft: format.addUnit(props2.gutter)
+        },
+        "class": [bem(), {
+          [constant.BORDER_TOP]: props2.border && !props2.gutter
+        }]
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+exports.GRID_KEY = GRID_KEY;
+exports.default = stdin_default;
+exports.gridProps = gridProps;

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

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