@fecp/mobile 1.0.1

package/es/node_modules/.pnpm/vant@4.9.17_vue@3.5.13_typescript@5.7.3_/node_modules/vant/es/floating-bubble/FloatingBubble.mjs

@@ -0,0 +1,179 @@
+import { defineComponent, ref, computed, onMounted, nextTick, watch, onActivated, onDeactivated, withDirectives, createVNode, mergeProps, vShow, Teleport } from "vue";
+import { useEventListener, useRect } from "../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.mjs";
+import { useTouch } from "../composables/use-touch.mjs";
+import stdin_default$1 from "../icon/index.mjs";
+import { closest } from "../utils/closest.mjs";
+import { makeStringProp, makeNumberProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { windowHeight, windowWidth } from "../utils/dom.mjs";
+import { addUnit } from "../utils/format.mjs";
+import { pick } from "../utils/basic.mjs";
+const floatingBubbleProps = {
+  gap: makeNumberProp(24),
+  icon: String,
+  axis: makeStringProp("y"),
+  magnetic: String,
+  offset: {
+    type: Object,
+    default: () => ({
+      x: -1,
+      y: -1
+    })
+  },
+  teleport: {
+    type: [String, Object],
+    default: "body"
+  }
+};
+const [name, bem] = createNamespace("floating-bubble");
+var stdin_default = defineComponent({
+  name,
+  inheritAttrs: false,
+  props: floatingBubbleProps,
+  emits: ["click", "update:offset", "offsetChange"],
+  setup(props, {
+    slots,
+    emit,
+    attrs
+  }) {
+    const rootRef = ref();
+    const state = ref({
+      x: 0,
+      y: 0,
+      width: 0,
+      height: 0
+    });
+    const boundary = computed(() => ({
+      top: props.gap,
+      right: windowWidth.value - state.value.width - props.gap,
+      bottom: windowHeight.value - state.value.height - props.gap,
+      left: props.gap
+    }));
+    const dragging = ref(false);
+    let initialized = false;
+    const rootStyle = computed(() => {
+      const style = {};
+      const x = addUnit(state.value.x);
+      const y = 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
+      } = useRect(rootRef.value);
+      const {
+        offset
+      } = props;
+      state.value = {
+        x: offset.x > -1 ? offset.x : windowWidth.value - width - props.gap,
+        y: offset.y > -1 ? offset.y : windowHeight.value - height - props.gap,
+        width,
+        height
+      };
+    };
+    const touch = 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 (props.axis === "lock") return;
+      if (!touch.isTap.value) {
+        if (props.axis === "x" || props.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 (props.axis === "y" || props.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 = pick(state.value, ["x", "y"]);
+        emit("update:offset", offset);
+      }
+    };
+    useEventListener("touchmove", onTouchMove, {
+      target: rootRef
+    });
+    const onTouchEnd = () => {
+      dragging.value = false;
+      nextTick(() => {
+        if (props.magnetic === "x") {
+          const nextX = closest([boundary.value.left, boundary.value.right], state.value.x);
+          state.value.x = nextX;
+        }
+        if (props.magnetic === "y") {
+          const nextY = closest([boundary.value.top, boundary.value.bottom], state.value.y);
+          state.value.y = nextY;
+        }
+        if (!touch.isTap.value) {
+          const offset = 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();
+    };
+    onMounted(() => {
+      updateState();
+      nextTick(() => {
+        initialized = true;
+      });
+    });
+    watch([windowWidth, windowHeight, () => props.gap, () => props.offset], updateState, {
+      deep: true
+    });
+    const show = ref(true);
+    onActivated(() => {
+      show.value = true;
+    });
+    onDeactivated(() => {
+      if (props.teleport) {
+        show.value = false;
+      }
+    });
+    return () => {
+      const Content = withDirectives(createVNode("div", mergeProps({
+        "class": bem(),
+        "ref": rootRef,
+        "onTouchstartPassive": onTouchStart,
+        "onTouchend": onTouchEnd,
+        "onTouchcancel": onTouchEnd,
+        "onClickCapture": onClick,
+        "style": rootStyle.value
+      }, attrs), [slots.default ? slots.default() : createVNode(stdin_default$1, {
+        "name": props.icon,
+        "class": bem("icon")
+      }, null)]), [[vShow, show.value]]);
+      return props.teleport ? createVNode(Teleport, {
+        "to": props.teleport
+      }, {
+        default: () => [Content]
+      }) : Content;
+    };
+  }
+});
+export {
+  stdin_default as default,
+  floatingBubbleProps
+};

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

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

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

@@ -0,0 +1,138 @@
+import { defineComponent, ref, computed, watch, createVNode } from "vue";
+import { useEventListener } from "../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.mjs";
+import { useLockScroll } from "../composables/use-lock-scroll.mjs";
+import { useTouch } from "../composables/use-touch.mjs";
+import { useSyncPropRef } from "../composables/use-sync-prop-ref.mjs";
+import { truthProp, makeNumericProp, makeArrayProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { windowHeight, preventDefault } from "../utils/dom.mjs";
+import { addUnit } from "../utils/format.mjs";
+import { closest } from "../utils/closest.mjs";
+const floatingPanelProps = {
+  height: makeNumericProp(0),
+  anchors: makeArrayProp(),
+  duration: makeNumericProp(0.3),
+  contentDraggable: truthProp,
+  lockScroll: Boolean,
+  safeAreaInsetBottom: truthProp
+};
+const [name, bem] = createNamespace("floating-panel");
+var stdin_default = defineComponent({
+  name,
+  props: floatingPanelProps,
+  emits: ["heightChange", "update:height"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const DAMP = 0.2;
+    const rootRef = ref();
+    const contentRef = ref();
+    const height = useSyncPropRef(() => +props.height, (value) => emit("update:height", value));
+    const boundary = computed(() => {
+      var _a, _b;
+      return {
+        min: (_a = props.anchors[0]) != null ? _a : 100,
+        max: (_b = props.anchors[props.anchors.length - 1]) != null ? _b : Math.round(windowHeight.value * 0.6)
+      };
+    });
+    const anchors = computed(() => props.anchors.length >= 2 ? props.anchors : [boundary.value.min, boundary.value.max]);
+    const dragging = ref(false);
+    const rootStyle = computed(() => ({
+      height: addUnit(boundary.value.max),
+      transform: `translateY(calc(100% + ${addUnit(-height.value)}))`,
+      transition: !dragging.value ? `transform ${props.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();
+    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 (!props.contentDraggable) return;
+        if (-startY < boundary.value.max) {
+          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(anchors.value, height.value);
+      if (height.value !== -startY) {
+        emit("heightChange", {
+          height: height.value
+        });
+      }
+    };
+    watch(boundary, () => {
+      height.value = closest(anchors.value, height.value);
+    }, {
+      immediate: true
+    });
+    useLockScroll(rootRef, () => props.lockScroll || dragging.value);
+    useEventListener("touchmove", onTouchmove, {
+      target: rootRef
+    });
+    const renderHeader = () => {
+      if (slots.header) {
+        return slots.header();
+      }
+      return createVNode("div", {
+        "class": bem("header")
+      }, [createVNode("div", {
+        "class": bem("header-bar")
+      }, null)]);
+    };
+    return () => {
+      var _a;
+      return createVNode("div", {
+        "class": [bem(), {
+          "van-safe-area-bottom": props.safeAreaInsetBottom
+        }],
+        "ref": rootRef,
+        "style": rootStyle.value,
+        "onTouchstartPassive": onTouchstart,
+        "onTouchend": onTouchend,
+        "onTouchcancel": onTouchend
+      }, [renderHeader(), createVNode("div", {
+        "class": bem("content"),
+        "ref": contentRef
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)])]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  floatingPanelProps
+};

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

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

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

@@ -0,0 +1,171 @@
+import { defineComponent, createVNode } from "vue";
+import { useChildren } from "../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.mjs";
+import { useExpose } from "../composables/use-expose.mjs";
+import { FORM_KEY } from "../utils/constant.mjs";
+import { truthProp, numericProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { preventDefault } from "../utils/dom.mjs";
+const [name, bem] = createNamespace("form");
+const formProps = {
+  colon: Boolean,
+  disabled: Boolean,
+  readonly: Boolean,
+  required: [Boolean, String],
+  showError: Boolean,
+  labelWidth: numericProp,
+  labelAlign: String,
+  inputAlign: String,
+  scrollToError: Boolean,
+  scrollToErrorPosition: String,
+  validateFirst: Boolean,
+  submitOnEnter: truthProp,
+  showErrorMessage: truthProp,
+  errorMessageAlign: String,
+  validateTrigger: {
+    type: [String, Array],
+    default: "onBlur"
+  }
+};
+var stdin_default = defineComponent({
+  name,
+  props: formProps,
+  emits: ["submit", "failed"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const {
+      children,
+      linkChildren
+    } = useChildren(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 props.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
+        } = props;
+        if (scrollToError && errors[0].name) {
+          scrollToField(errors[0].name, scrollToErrorPosition ? {
+            block: scrollToErrorPosition
+          } : void 0);
+        }
+      });
+    };
+    const onSubmit = (event) => {
+      preventDefault(event);
+      submit();
+    };
+    linkChildren({
+      props
+    });
+    useExpose({
+      submit,
+      validate,
+      getValues,
+      scrollToField,
+      resetValidation,
+      getValidationStatus
+    });
+    return () => {
+      var _a;
+      return createVNode("form", {
+        "class": bem(),
+        "onSubmit": onSubmit
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+export {
+  stdin_default as default,
+  formProps
+};

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

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

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

@@ -0,0 +1,49 @@
+import { defineComponent, createVNode } from "vue";
+import { BORDER_TOP } from "../utils/constant.mjs";
+import { useChildren } from "../../../../../@vant_use@1.6.0_vue@3.5.13_typescript@5.7.3_/node_modules/@vant/use/dist/index.esm.mjs";
+import { makeNumericProp, numericProp, truthProp } from "../utils/props.mjs";
+import { createNamespace } from "../utils/create.mjs";
+import { addUnit } from "../utils/format.mjs";
+const [name, bem] = createNamespace("grid");
+const gridProps = {
+  square: Boolean,
+  center: truthProp,
+  border: truthProp,
+  gutter: numericProp,
+  reverse: Boolean,
+  iconSize: numericProp,
+  direction: String,
+  clickable: Boolean,
+  columnNum: makeNumericProp(4)
+};
+const GRID_KEY = Symbol(name);
+var stdin_default = defineComponent({
+  name,
+  props: gridProps,
+  setup(props, {
+    slots
+  }) {
+    const {
+      linkChildren
+    } = useChildren(GRID_KEY);
+    linkChildren({
+      props
+    });
+    return () => {
+      var _a;
+      return createVNode("div", {
+        "style": {
+          paddingLeft: addUnit(props.gutter)
+        },
+        "class": [bem(), {
+          [BORDER_TOP]: props.border && !props.gutter
+        }]
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});
+export {
+  GRID_KEY,
+  stdin_default as default,
+  gridProps
+};

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

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