first commit

node_modules/vant/lib/form/Form.d.ts

@@ -0,0 +1,94 @@
+import { type PropType, type ExtractPropTypes } from 'vue';
+import type { FieldTextAlign, FieldValidateTrigger } from '../field/types';
+export declare const formProps: {
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    required: PropType<boolean | "auto">;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: PropType<FieldTextAlign>;
+    inputAlign: PropType<FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    scrollToErrorPosition: PropType<ScrollLogicalPosition>;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: PropType<FieldTextAlign>;
+    validateTrigger: {
+        type: PropType<FieldValidateTrigger | FieldValidateTrigger[]>;
+        default: string;
+    };
+};
+export type FormProps = ExtractPropTypes<typeof formProps>;
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    required: PropType<boolean | "auto">;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: PropType<FieldTextAlign>;
+    inputAlign: PropType<FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    scrollToErrorPosition: PropType<ScrollLogicalPosition>;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: PropType<FieldTextAlign>;
+    validateTrigger: {
+        type: PropType<FieldValidateTrigger | FieldValidateTrigger[]>;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("submit" | "failed")[], "submit" | "failed", import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    required: PropType<boolean | "auto">;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: PropType<FieldTextAlign>;
+    inputAlign: PropType<FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    scrollToErrorPosition: PropType<ScrollLogicalPosition>;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: PropType<FieldTextAlign>;
+    validateTrigger: {
+        type: PropType<FieldValidateTrigger | FieldValidateTrigger[]>;
+        default: string;
+    };
+}>> & Readonly<{
+    onSubmit?: ((...args: any[]) => any) | undefined;
+    onFailed?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    readonly: boolean;
+    colon: boolean;
+    showError: boolean;
+    scrollToError: boolean;
+    validateFirst: boolean;
+    submitOnEnter: boolean;
+    showErrorMessage: boolean;
+    validateTrigger: FieldValidateTrigger | FieldValidateTrigger[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

node_modules/vant/lib/form/Form.js

@@ -0,0 +1,187 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  default: () => stdin_default,
+  formProps: () => formProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_vue = require("vue");
+var import_utils = require("../utils");
+var import_use = require("@vant/use");
+var import_use_expose = require("../composables/use-expose");
+const [name, bem] = (0, import_utils.createNamespace)("form");
+const formProps = {
+  colon: Boolean,
+  disabled: Boolean,
+  readonly: Boolean,
+  required: [Boolean, String],
+  showError: Boolean,
+  labelWidth: import_utils.numericProp,
+  labelAlign: String,
+  inputAlign: String,
+  scrollToError: Boolean,
+  scrollToErrorPosition: String,
+  validateFirst: Boolean,
+  submitOnEnter: import_utils.truthProp,
+  showErrorMessage: import_utils.truthProp,
+  errorMessageAlign: String,
+  validateTrigger: {
+    type: [String, Array],
+    default: "onBlur"
+  }
+};
+var stdin_default = (0, import_vue.defineComponent)({
+  name,
+  props: formProps,
+  emits: ["submit", "failed"],
+  setup(props, {
+    emit,
+    slots
+  }) {
+    const {
+      children,
+      linkChildren
+    } = (0, import_use.useChildren)(import_utils.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) => {
+      (0, import_utils.preventDefault)(event);
+      submit();
+    };
+    linkChildren({
+      props
+    });
+    (0, import_use_expose.useExpose)({
+      submit,
+      validate,
+      getValues,
+      scrollToField,
+      resetValidation,
+      getValidationStatus
+    });
+    return () => {
+      var _a;
+      return (0, import_vue.createVNode)("form", {
+        "class": bem(),
+        "onSubmit": onSubmit
+      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
+    };
+  }
+});

node_modules/vant/lib/form/index.d.ts

@@ -0,0 +1,74 @@
+import { FormProps } from './Form';
+export declare const Form: import("../utils").WithInstall<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    required: import("vue").PropType<boolean | "auto">;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: import("vue").PropType<import("..").FieldTextAlign>;
+    inputAlign: import("vue").PropType<import("..").FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    scrollToErrorPosition: import("vue").PropType<ScrollLogicalPosition>;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: import("vue").PropType<import("..").FieldTextAlign>;
+    validateTrigger: {
+        type: import("vue").PropType<import("..").FieldValidateTrigger | import("..").FieldValidateTrigger[]>;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("submit" | "failed")[], "submit" | "failed", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    colon: BooleanConstructor;
+    disabled: BooleanConstructor;
+    readonly: BooleanConstructor;
+    required: import("vue").PropType<boolean | "auto">;
+    showError: BooleanConstructor;
+    labelWidth: (NumberConstructor | StringConstructor)[];
+    labelAlign: import("vue").PropType<import("..").FieldTextAlign>;
+    inputAlign: import("vue").PropType<import("..").FieldTextAlign>;
+    scrollToError: BooleanConstructor;
+    scrollToErrorPosition: import("vue").PropType<ScrollLogicalPosition>;
+    validateFirst: BooleanConstructor;
+    submitOnEnter: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    showErrorMessage: {
+        type: BooleanConstructor;
+        default: true;
+    };
+    errorMessageAlign: import("vue").PropType<import("..").FieldTextAlign>;
+    validateTrigger: {
+        type: import("vue").PropType<import("..").FieldValidateTrigger | import("..").FieldValidateTrigger[]>;
+        default: string;
+    };
+}>> & Readonly<{
+    onSubmit?: ((...args: any[]) => any) | undefined;
+    onFailed?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    readonly: boolean;
+    colon: boolean;
+    showError: boolean;
+    scrollToError: boolean;
+    validateFirst: boolean;
+    submitOnEnter: boolean;
+    showErrorMessage: boolean;
+    validateTrigger: import("..").FieldValidateTrigger | import("..").FieldValidateTrigger[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+export default Form;
+export { formProps } from './Form';
+export type { FormProps };
+export type { FormInstance } from './types';
+declare module 'vue' {
+    interface GlobalComponents {
+        VanForm: typeof Form;
+    }
+}

node_modules/vant/lib/form/index.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+__export(stdin_exports, {
+  Form: () => Form,
+  default: () => stdin_default,
+  formProps: () => import_Form2.formProps
+});
+module.exports = __toCommonJS(stdin_exports);
+var import_utils = require("../utils");
+var import_Form = __toESM(require("./Form"));
+var import_Form2 = require("./Form");
+const Form = (0, import_utils.withInstall)(import_Form.default);
+var stdin_default = Form;

node_modules/vant/lib/form/style/index.d.ts

@@ -0,0 +1 @@
+export {};

node_modules/vant/lib/form/style/index.js

@@ -0,0 +1 @@
+require("../../style/base.css");

node_modules/vant/lib/form/types.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentPublicInstance } from 'vue';
+import type { FormProps } from './Form';
+import type { FieldValidationStatus } from '../field';
+export type FormExpose = {
+    submit: () => void;
+    validate: (name?: string | string[] | undefined) => Promise<void>;
+    getValues: () => Record<string, unknown>;
+    scrollToField: (name: string, options?: boolean | ScrollIntoViewOptions | undefined) => void;
+    resetValidation: (name?: string | string[] | undefined) => void;
+    getValidationStatus: () => Record<string, FieldValidationStatus>;
+};
+export type FormProvide = {
+    props: FormProps;
+};
+export type FormInstance = ComponentPublicInstance<FormProps, FormExpose>;

node_modules/vant/lib/form/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stdin_exports = {};
+module.exports = __toCommonJS(stdin_exports);