vue-form-submit 5.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Ilya Semenov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,348 @@
+# vue-form-submit
+
+Simple Vue 3 composables for handling form submission.
+
+Supports optional validation with any [Standard Schema](https://standardschema.dev/) compatible validation library, such as [Zod](https://zod.dev), [Valibot](https://valibot.dev/), [ArkType](https://arktype.io/), and others.
+
+Unlike FormKit, VeeValidate, and similar libraries, this keeps things simple and doesn't interfere with either data storage or the UI workflow.
+
+Full TypeScript support with type inference.
+
+## Install
+
+```sh
+npm install vue-form-submit
+```
+
+## Use
+
+```vue
+<script setup lang="ts">
+import * as v from "valibot"
+import { useSubmit } from "vue-form-submit"
+
+// Store input data however you prefer, e.g. with Vue reactive or ref.
+const fields = reactive({
+  name: "",
+})
+
+const { form, submit, submitting, errors } = useSubmit({
+  input: fields,
+  // Schema is optional but usually recommended.
+  // Use any Standard Schema compatible library (Valibot in this example).
+  schema: v.object({
+    name: v.pipe(v.string(), v.trim(), v.minLength(1, "Please enter your name.")),
+  }),
+  async onSubmit(input) {
+    // Input is validated against the schema and typed accordingly.
+    await api.post(input)
+  },
+})
+</script>
+
+<template>
+  <form ref="form" @submit.prevent="submit">
+    <!-- No special syntax for input fields — just use what you prefer. -->
+    Name: <input v-model="fields.name" />
+
+    <button type="submit" :disabled="submitting">Submit</button>
+
+    <!-- Raw validation errors. See below for how to flatten or structure them. -->
+    <div v-for="error in errors">{{ error }}</div>
+  </form>
+</template>
+```
+
+## useSubmit composable
+
+```ts
+const {
+  // All return values are optional to use.
+  form,
+  submit,
+  submitting,
+  submitted,
+  errors,
+} = useSubmit({
+  // All options are optional.
+  input,
+  schema,
+  onSubmit,
+  onErrors,
+  // Optional overrides for the return value refs.
+  form,
+  submitting,
+  submitted,
+  errors,
+})
+```
+
+## useSubmit options
+
+### `input`
+
+(Optional) The data to be validated and/or passed to `submit`. Can be a plain value, a ref, or a getter.
+
+### `schema`
+
+(Optional) A Standard Schema compatible schema (or a function returning a schema, useful when the schema depends on context). Works with Zod, Valibot, ArkType, and other Standard Schema compatible libraries.
+
+### `onSubmit`
+
+(Optional) `onSubmit` callback.
+
+Only called if:
+
+- The form is not already being submitted (`submitting.value` is falsy).
+- HTML5 validation passes (if enabled).
+- Schema validation passes (if used).
+
+If `input` and/or `schema` are provided, the first argument passed to the `onSubmit` callback is the (possibly validated) form input. Any remaining arguments are the submit function arguments.
+
+While submission is in progress, `submitting` is true.
+After successful execution, `submitted` is true.
+
+### `formatErrors`
+
+(Optional) Error formatter function that transforms raw Standard Schema issues into the desired format.
+
+See _"Formatting errors"_ below.
+
+### `onErrors`
+
+(Optional) Error callback.
+
+Called (and awaited) when validation fails or when `errors.value` is set by the `onSubmit` handler.
+
+### `form`, `submitting`, `submitted`, `errors`
+
+Normally, `useSubmit` creates and returns these refs (see below), but you can optionally provide your own.
+
+For example, you can share a single `submitting` flag between multiple forms:
+
+```ts
+const submitting = ref(false)
+
+const { submit: submit1 } = useSubmit({
+  submitting,
+  async onSubmit() { /* ... */ }
+})
+
+const { submit: submit2 } = useSubmit({
+  submitting,
+  async onSubmit() { /* ... */ }
+})
+
+// `submitting` will be true during submission of either form.
+```
+
+## useSubmit with a separate onSubmit handler
+
+The `onSubmit` handler can be passed as a separate argument — either alone or together with an options object:
+
+```ts
+// onSubmit handler only (shortcut):
+const { submit, submitting } = useSubmit(async () => {
+  await api.post()
+})
+
+// onSubmit handler with options:
+const { submit, submitting } = useSubmit({ input, schema }, async (input) => {
+  await api.post(input)
+},)
+```
+
+## useSubmit return
+
+### `form`
+
+The form element ref.
+
+Binding it with `<form ref="form">` enables HTML5 validation on submit.
+
+### `submit`
+
+The form submit function. Use it like:
+
+- `<form @submit.prevent="submit">`
+- `<button @click="submit">`
+
+It will:
+
+- Run HTML5 validation (if the form ref is set).
+- Validate against the schema (if provided).
+- Call the `onSubmit` callback (if provided).
+
+Arguments passed to this function are forwarded to the `onSubmit` callback, prepended with the form input (if `input` and/or `schema` are provided).
+
+While submission is in progress, `submitting` is true. After successful execution, `submitted` is true.
+
+### `submitting`
+
+Whether a submission is currently in progress.
+
+Use this to disable the submit button.
+
+`useSubmit` will also skip submission if this is already `true`.
+
+Type: `Ref<boolean>`.
+
+### `submitted`
+
+Whether the form has been successfully submitted.
+
+Feel free to reset this manually. `useSubmit` doesn't depend on this value.
+
+Type: `Ref<boolean>`.
+
+### `errors`
+
+Validation errors, either from schema validation or set manually in the `onSubmit` callback.
+
+## Formatting errors
+
+By default, errors are returned as raw Standard Schema issues.
+
+Use the `formatErrors` option to format or structure them differently. For example, use the built-in `flatten` to convert them to `FlatErrors` (compatible with Valibot's `flatten()`):
+
+```vue
+<script setup lang="ts">
+import * as v from "valibot"
+import { flatten, useSubmit } from "vue-form-submit"
+
+const fields = reactive({
+  name: "",
+})
+
+const { form, submit, submitting, errors } = useSubmit({
+  input: fields,
+  schema: v.object({
+    name: v.pipe(v.string(), v.trim(), v.minLength(1, "Please enter your name.")),
+  }),
+  formatErrors: flatten, // <--- Custom error formatter.
+  async onSubmit(input) {
+    await api.post(input)
+  },
+})
+</script>
+
+<template>
+  <form ref="form" @submit.prevent="submit">
+    Name: <input v-model="fields.name" />
+
+    <!-- Field errors. -->
+    <div v-for="error in errors?.nested?.name">{{ error }}</div>
+
+    <button type="submit" :disabled="submitting">Submit</button>
+
+    <!-- Form-level errors. -->
+    <div v-for="error in errors?.root">{{ error }}</div>
+  </form>
+</template>
+```
+
+## Submit with arguments
+
+Additional arguments passed to `submit` are forwarded to the `onSubmit` callback after `input`:
+
+```ts
+const { submit } = useSubmit({
+  input,
+  schema,
+  async onSubmit(input, chargeImmediately = false) {
+    await api.post({ ...input, chargeImmediately })
+  },
+})
+```
+
+Then in the template:
+
+```html
+<form ref="form" @submit.prevent="submit">
+  <!-- Input fields omitted for brevity. -->
+  <button type="submit">Submit</button>
+  <button type="button" @click="submit(true)">
+    Submit and Charge Immediately
+  </button>
+</form>
+```
+
+If no `input` option was provided, all arguments are passed through directly:
+
+```ts
+const { submit, submitting } = useSubmit(
+  async (arg1: number, arg2: string, arg3 = false) => {
+    // Note: no `input` argument.
+    await api.post({ arg1, arg2, arg3 })
+  },
+)
+
+// Arguments are type-checked:
+submit(10, "foo")
+submit(20, "bar", true)
+```
+
+## Custom submit errors
+
+You can set `errors` inside the `onSubmit` handler. These are treated the same way as schema validation errors.
+
+This is particularly useful together with `onErrors`:
+
+```ts
+const { submit, errors } = useSubmit({
+  input,
+  schema,
+  onSubmit(input) {
+    if (!validateInput(input)) {
+      errors.value = [{ message: "Input is invalid." }]
+    }
+  },
+  onErrors(errors) {
+    // Errors here come from either schema validation or the onSubmit handler.
+    console.error(errors)
+  },
+})
+```
+
+## useParse
+
+`useParse` reactively runs Standard Schema validation on every input change.
+
+It can be used together with `useSubmit` or independently.
+
+Example with Valibot:
+
+```vue
+<script setup lang="ts">
+import * as v from "valibot"
+import { flatten, useParse } from "vue-form-submit"
+
+const input = reactive({
+  age: "" as string | number,
+})
+
+// By default, returns raw Standard Schema issues.
+const { errors: presubmitErrors } = useParse({
+  input,
+  schema: v.object({
+    age: v.number(),
+  })
+})
+
+// Or use flatten for Valibot-style errors.
+const { errors: presubmitErrors } = useParse({
+  input,
+  schema: v.object({
+    age: v.number(),
+  }),
+  formatErrors: flatten
+})
+</script>
+
+<template>
+  <form @submit="...">
+    Age: <input v-model.number="age" type="number">
+    <button type="submit" :disabled="!presubmitErrors">Submit</button>
+  </form>
+</template>
+```

package/dist/index.cjs

@@ -0,0 +1,115 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _standard_schema_utils = require("@standard-schema/utils");
+let _vue_reactivity = require("@vue/reactivity");
+let _vue_runtime_core = require("@vue/runtime-core");
+
+//#region src/errors/flatten.ts
+/**
+* Built-in error formatter that converts Standard Schema issues to FlatErrors format,
+* compatible with Valibot's flatten() function.
+*/
+function flatten(issues) {
+	const errors = {};
+	for (const issue of issues) {
+		const dotPath = (0, _standard_schema_utils.getDotPath)(issue);
+		if (dotPath) {
+			errors.nested ??= {};
+			errors.nested[dotPath] ??= [];
+			errors.nested[dotPath].push(issue.message);
+		} else {
+			errors.root ??= [];
+			errors.root.push(issue.message);
+		}
+	}
+	return errors;
+}
+
+//#endregion
+//#region src/parse.ts
+function useParse(options, watchOptions) {
+	const result = (0, _vue_reactivity.ref)();
+	const output = (0, _vue_reactivity.ref)();
+	const errors = (0, _vue_reactivity.ref)();
+	const formatErrors = options.formatErrors ?? ((issues) => issues);
+	function applyResult(r) {
+		result.value = r;
+		if (r.issues) {
+			output.value = void 0;
+			errors.value = formatErrors(r.issues);
+		} else {
+			output.value = r.value;
+			errors.value = void 0;
+		}
+	}
+	(0, _vue_runtime_core.watchEffect)((onCleanup) => {
+		const schema = (0, _vue_reactivity.toValue)(options.schema);
+		const input = (0, _vue_reactivity.toValue)(options.input);
+		const resultOrPromise = schema["~standard"].validate(input);
+		if (resultOrPromise instanceof Promise) {
+			let cancelled = false;
+			onCleanup(() => {
+				cancelled = true;
+			});
+			resultOrPromise.then((r) => {
+				if (!cancelled) applyResult(r);
+			});
+		} else applyResult(resultOrPromise);
+	}, watchOptions);
+	return {
+		result,
+		output,
+		errors
+	};
+}
+
+//#endregion
+//#region src/submit.ts
+function useSubmit(optionsOrOnSubmit, externalOnSubmit) {
+	const options = (typeof optionsOrOnSubmit === "function" ? void 0 : optionsOrOnSubmit) ?? {};
+	const onSubmitCallback = typeof optionsOrOnSubmit === "function" ? optionsOrOnSubmit : externalOnSubmit ?? options?.onSubmit;
+	const hasInput = options.input !== void 0;
+	const form = options.form ?? (0, _vue_reactivity.ref)();
+	const errors = options.errors ?? (0, _vue_reactivity.ref)();
+	const submitting = options.submitting ?? (0, _vue_reactivity.ref)(false);
+	const submitted = options.submitted ?? (0, _vue_reactivity.ref)(false);
+	const formatErrors = options.formatErrors ?? ((issues) => issues);
+	async function submit(...args) {
+		if (submitting.value) return;
+		submitted.value = false;
+		errors.value = void 0;
+		if (form.value && !form.value.checkValidity()) {
+			form.value.reportValidity();
+			return;
+		}
+		submitting.value = true;
+		try {
+			const input = (0, _vue_reactivity.toValue)(options.input);
+			const schema = (0, _vue_reactivity.toValue)(options.schema);
+			const parseResult = schema ? await schema["~standard"].validate(input) : void 0;
+			if (parseResult && parseResult.issues) {
+				errors.value = formatErrors(parseResult.issues);
+				await options.onErrors?.(errors.value);
+			} else {
+				const returnValue = await (hasInput || parseResult ? onSubmitCallback?.(parseResult ? parseResult.value : input, ...args) : onSubmitCallback?.(...args));
+				if (errors.value) await options.onErrors?.(errors.value);
+				else submitted.value = true;
+				return returnValue;
+			}
+		} finally {
+			submitting.value = false;
+		}
+	}
+	return {
+		form,
+		submit,
+		submitting,
+		submitted,
+		errors
+	};
+}
+
+//#endregion
+exports.flatten = flatten;
+exports.useParse = useParse;
+exports.useSubmit = useSubmit;
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":[],"sources":["../src/errors/flatten.ts","../src/parse.ts","../src/submit.ts"],"sourcesContent":["import { getDotPath } from \"@standard-schema/utils\"\n\nimport type { StandardErrors } from \"./base\"\n\n/**\n * The FlatErrors interface, compatible with Valibot.\n *\n * TODO: accept Schema as a generic parameter, allow typed errors.\n */\nexport interface FlatErrors {\n  /**\n   * Root-level errors.\n   *\n   * Contains error messages from issues without a path (belonging to the root of the schema).\n   */\n  root?: string[]\n  /**\n   * Nested field errors.\n   *\n   * Contains error messages from issues with a path (belonging to nested parts\n   * of the schema), keyed by their dot-notation path.\n   */\n  nested?: Partial<{\n    [key: string]: string[]\n  }>\n}\n\n/**\n * Built-in error formatter that converts Standard Schema issues to FlatErrors format,\n * compatible with Valibot's flatten() function.\n */\nexport function flatten(issues: StandardErrors): FlatErrors {\n  const errors: FlatErrors = {}\n  for (const issue of issues) {\n    const dotPath = getDotPath(issue)\n    if (dotPath) {\n      errors.nested ??= {}\n      errors.nested[dotPath] ??= []\n      errors.nested[dotPath]!.push(issue.message)\n    } else {\n      errors.root ??= []\n      errors.root.push(issue.message)\n    }\n  }\n\n  return errors\n}\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { ref, toValue } from \"@vue/reactivity\"\nimport type { MaybeRefOrGetter, Ref, WatchOptionsBase } from \"@vue/runtime-core\"\nimport { watchEffect } from \"@vue/runtime-core\"\n\nimport type { ErrorsFormatter, StandardErrors } from \"./errors\"\n\nexport type UseParseReturn<TSchema extends StandardSchemaV1, TErrors = StandardErrors> = {\n  result: Ref<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>\n  output: Ref<StandardSchemaV1.InferOutput<TSchema> | undefined>\n  errors: Ref<TErrors | undefined>\n}\n\nexport function useParse<TSchema extends StandardSchemaV1, TErrors = StandardErrors>(\n  options: {\n    /**\n     * The input data to validate (plain value, ref, or getter).\n     */\n    input?: unknown\n    /**\n     * A Standard Schema compatible schema (plain value, ref, or getter).\n     */\n    schema: MaybeRefOrGetter<TSchema>\n    /**\n     * Error formatter function that transforms raw Standard Schema issues into the desired format.\n     */\n    formatErrors?: ErrorsFormatter<TErrors>\n  },\n  watchOptions?: WatchOptionsBase,\n): UseParseReturn<TSchema, TErrors> {\n  type Output = StandardSchemaV1.InferOutput<TSchema>\n  const result = ref<StandardSchemaV1.Result<Output>>() as Ref<StandardSchemaV1.Result<Output>>\n  const output = ref<Output>()\n  const errors = ref<TErrors | undefined>()\n  const formatErrors = options.formatErrors ?? ((issues: StandardErrors) => issues as TErrors)\n\n  function applyResult(r: StandardSchemaV1.Result<Output>) {\n    result.value = r\n    if (r.issues) {\n      output.value = undefined\n      errors.value = formatErrors(r.issues)\n    } else {\n      output.value = r.value\n      errors.value = undefined\n    }\n  }\n\n  watchEffect((onCleanup) => {\n    const schema = toValue(options.schema)\n    const input = toValue(options.input)\n    const resultOrPromise = schema[\"~standard\"].validate(input)\n\n    if (resultOrPromise instanceof Promise) {\n      let cancelled = false\n      onCleanup(() => {\n        cancelled = true\n      })\n      resultOrPromise.then((r) => {\n        if (!cancelled) {\n          applyResult(r)\n        }\n      })\n    } else {\n      applyResult(resultOrPromise)\n    }\n  }, watchOptions)\n\n  return { result, output, errors }\n}\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\"\nimport type { MaybeRefOrGetter, Ref } from \"@vue/reactivity\"\nimport { ref, toValue } from \"@vue/reactivity\"\n\nimport type { ErrorsFormatter, StandardErrors } from \"./errors\"\n\nexport interface UseSubmitReturn<TArgs extends any[], TResult, TErrors> {\n  /**\n   * The form element ref.\n   *\n   * Using it with `<form ref=\"form\">` will enable HTML5 validation on submit.\n   */\n  form: Ref<HTMLFormElement | undefined>\n  /**\n   * The form submit function. Use it like:\n   *\n   * - `<form @submit.prevent=\"submit\">`\n   * - `<button @click=\"submit\">`\n   *\n   * It will:\n   *\n   * - Run HTML5 validation (if the form ref is set).\n   * - Run Standard Schema validation (if the schema is provided).\n   * - Call the `onSubmit` callback (if provided).\n   *\n   * Arguments passed to this function are forwarded to the `onSubmit` callback,\n   * prepended with the (possibly validated) form input (unless using the shortcut variant of `useSubmit`).\n   *\n   * While submission is in progress, `submitting` is true.\n   * After successful execution, `submitted` is true.\n   */\n  submit: (...args: TArgs) => Promise<TResult | undefined>\n  /**\n   * Whether a submission is currently in progress.\n   *\n   * Use this to disable the submit button.\n   *\n   * `useSubmit` will also skip submission if this is already `true`.\n   */\n  submitting: Ref<boolean>\n  /**\n   * Has the form been successfully submitted?\n   *\n   * Feel free to reset. `useSubmit` doesn't depend on this value.\n   */\n  submitted: Ref<boolean>\n  /**\n   * Validation errors.\n   */\n  errors: Ref<TErrors | undefined>\n}\n\ninterface BaseOptions<TErrors> {\n  /**\n   * Error formatter function that transforms raw Standard Schema issues into the desired format.\n   */\n  formatErrors?: ErrorsFormatter<TErrors>\n  /**\n   * Error callback.\n   *\n   * Called (and awaited) when validation fails or when `errors.value` is set by the `onSubmit` handler.\n   */\n  onErrors?: (errors: TErrors) => any\n  /**\n   * User-provided ref for the `form` return value.\n   */\n  form?: Ref<HTMLFormElement | undefined>\n  /**\n   * User-provided ref for the `submitting` return value.\n   */\n  submitting?: Ref<boolean>\n  /**\n   * User-provided ref for the `submitted` return value.\n   */\n  submitted?: Ref<boolean>\n  /**\n   * User-provided ref for the `errors` return value.\n   */\n  errors?: Ref<TErrors | undefined>\n}\n\ntype SubmitCallback<Args extends any[], Result> = (\n  ...args: Args\n) => Result | PromiseLike<Result>\n\n//\n// No input.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input?: never\n    schema?: never\n    /**\n     * onSubmit callback.\n     *\n     * Only called if:\n     * - The form is not already being submitted (`submitting.value` is falsy).\n     * - HTML5 validation passes (if enabled).\n     *\n     * Arguments are passed through from the submit function.\n     *\n     * While submission is in progress, `submitting` is true.\n     * After successful execution, `submitted` is true.\n     */\n    onSubmit?: SubmitCallback<Args, Result>\n  },\n): UseSubmitReturn<Args, Result, TErrors>\n\n//\n// Input only (no schema).\n//\n\n/**\n * Vue 3 composable for handling form submission.\n *\n * Validates the input using Standard Schema.\n */\nexport function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    /**\n     * The input data: a plain value, ref, or getter.\n     */\n    input: MaybeRefOrGetter<TInput>\n    schema?: never\n    /**\n     * onSubmit callback.\n     *\n     * Only called if:\n     * - The form is not already being submitted (`submitting.value` is falsy).\n     * - HTML5 validation passes (if enabled).\n     *\n     * The first argument is the form input; the remaining arguments are passed through from the submit function.\n     *\n     * While submission is in progress, `submitting` is true.\n     * After successful execution, `submitted` is true.\n     */\n    onSubmit?: SubmitCallback<[TInput, ...TArgs], TResult>\n  },\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// Schema.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n *\n * Validates the input using Standard Schema.\n */\nexport function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    /**\n     * The input data to validate (plain value, ref, or getter).\n     */\n    input?: unknown\n    /**\n     * A Standard Schema compatible schema (plain value, ref, or getter).\n     */\n    schema: MaybeRefOrGetter<TSchema>\n    /**\n     * onSubmit callback.\n     *\n     * Only called if:\n     * - The form is not already being submitted (`submitting.value` is falsy).\n     * - HTML5 validation passes (if enabled).\n     * - Standard Schema validation passes.\n     *\n     * The first argument is the validated input; the remaining arguments are passed through from the submit function.\n     *\n     * While submission is in progress, `submitting` is true.\n     * After successful execution, `submitted` is true.\n     */\n    onSubmit?: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>\n  },\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// No input, separate submit.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input?: never\n    schema?: never\n    onSubmit?: never\n  },\n  onSubmit: SubmitCallback<Args, Result>,\n): UseSubmitReturn<Args, Result, TErrors>\n\n//\n// Input only (no schema), separate submit.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input: MaybeRefOrGetter<TInput>\n    schema?: never\n    onSubmit?: never\n  },\n  onSubmit: SubmitCallback<[TInput, ...TArgs], TResult>,\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// Schema, separate submit.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input?: unknown\n    schema: MaybeRefOrGetter<TSchema>\n    onSubmit?: never\n  },\n  onSubmit: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>,\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// No input, callback only.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<TArgs extends any[], TResult>(\n/**\n * onSubmit callback.\n *\n * Only called if:\n * - The form is not already being submitted (`submitting.value` is falsy).\n * - HTML5 validation passes (if enabled).\n *\n * Arguments are passed through from the submit function.\n *\n * While submission is in progress, `submitting` is true.\n * After successful execution, `submitted` is true.\n */\n  onSubmit?: SubmitCallback<TArgs, TResult>,\n): UseSubmitReturn<TArgs, TResult, StandardErrors>\n\n//\n// Implementation.\n//\n\nexport function useSubmit(\n  optionsOrOnSubmit?:\n    | (BaseOptions<unknown> & {\n      input?: unknown\n      schema?: MaybeRefOrGetter<StandardSchemaV1>\n      onSubmit?: SubmitCallback<unknown[], unknown>\n    })\n    | SubmitCallback<unknown[], unknown>,\n  externalOnSubmit?: SubmitCallback<unknown[], unknown>,\n): UseSubmitReturn<unknown[], unknown, unknown> {\n  const options\n    = (typeof optionsOrOnSubmit === \"function\" ? undefined : optionsOrOnSubmit) ?? {}\n  const onSubmitCallback\n    = typeof optionsOrOnSubmit === \"function\" ? optionsOrOnSubmit : externalOnSubmit ?? options?.onSubmit\n  const hasInput = options.input !== undefined\n\n  const form = options.form ?? ref<HTMLFormElement>()\n  const errors = options.errors ?? ref()\n  const submitting = options.submitting ?? ref(false)\n  const submitted = options.submitted ?? ref(false)\n\n  const formatErrors = options.formatErrors ?? ((issues: StandardErrors) => issues)\n\n  async function submit(...args: unknown[]) {\n    if (submitting.value) {\n      return\n    }\n    submitted.value = false\n    errors.value = undefined\n    if (form.value && !form.value.checkValidity()) {\n      form.value.reportValidity()\n      return\n    }\n    submitting.value = true\n    try {\n      const input = toValue(options.input)\n      const schema = toValue(options.schema)\n      const parseResult = schema ? await schema[\"~standard\"].validate(input) : undefined\n      if (parseResult && parseResult.issues) {\n        errors.value = formatErrors(parseResult.issues)\n        await options.onErrors?.(errors.value)\n      } else {\n        const returnValue = await (\n          hasInput || parseResult\n            ? onSubmitCallback?.(parseResult ? parseResult.value : input, ...args)\n            : onSubmitCallback?.(...args)\n        )\n        if (errors.value) {\n          await options.onErrors?.(errors.value)\n        } else {\n          submitted.value = true\n        }\n        return returnValue\n      }\n    } finally {\n      submitting.value = false\n    }\n  }\n\n  return { form, submit, submitting, submitted, errors }\n}\n"],"mappings":";;;;;;;;;;AA+BA,SAAgB,QAAQ,QAAoC;CAC1D,MAAM,SAAqB,EAAE;AAC7B,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,iDAAqB,MAAM;AACjC,MAAI,SAAS;AACX,UAAO,WAAW,EAAE;AACpB,UAAO,OAAO,aAAa,EAAE;AAC7B,UAAO,OAAO,SAAU,KAAK,MAAM,QAAQ;SACtC;AACL,UAAO,SAAS,EAAE;AAClB,UAAO,KAAK,KAAK,MAAM,QAAQ;;;AAInC,QAAO;;;;;AChCT,SAAgB,SACd,SAcA,cACkC;CAElC,MAAM,mCAA+C;CACrD,MAAM,mCAAsB;CAC5B,MAAM,mCAAmC;CACzC,MAAM,eAAe,QAAQ,kBAAkB,WAA2B;CAE1E,SAAS,YAAY,GAAoC;AACvD,SAAO,QAAQ;AACf,MAAI,EAAE,QAAQ;AACZ,UAAO,QAAQ;AACf,UAAO,QAAQ,aAAa,EAAE,OAAO;SAChC;AACL,UAAO,QAAQ,EAAE;AACjB,UAAO,QAAQ;;;AAInB,qCAAa,cAAc;EACzB,MAAM,sCAAiB,QAAQ,OAAO;EACtC,MAAM,qCAAgB,QAAQ,MAAM;EACpC,MAAM,kBAAkB,OAAO,aAAa,SAAS,MAAM;AAE3D,MAAI,2BAA2B,SAAS;GACtC,IAAI,YAAY;AAChB,mBAAgB;AACd,gBAAY;KACZ;AACF,mBAAgB,MAAM,MAAM;AAC1B,QAAI,CAAC,UACH,aAAY,EAAE;KAEhB;QAEF,aAAY,gBAAgB;IAE7B,aAAa;AAEhB,QAAO;EAAE;EAAQ;EAAQ;EAAQ;;;;;AC4LnC,SAAgB,UACd,mBAOA,kBAC8C;CAC9C,MAAM,WACD,OAAO,sBAAsB,aAAa,SAAY,sBAAsB,EAAE;CACnF,MAAM,mBACF,OAAO,sBAAsB,aAAa,oBAAoB,oBAAoB,SAAS;CAC/F,MAAM,WAAW,QAAQ,UAAU;CAEnC,MAAM,OAAO,QAAQ,kCAA8B;CACnD,MAAM,SAAS,QAAQ,oCAAe;CACtC,MAAM,aAAa,QAAQ,uCAAkB,MAAM;CACnD,MAAM,YAAY,QAAQ,sCAAiB,MAAM;CAEjD,MAAM,eAAe,QAAQ,kBAAkB,WAA2B;CAE1E,eAAe,OAAO,GAAG,MAAiB;AACxC,MAAI,WAAW,MACb;AAEF,YAAU,QAAQ;AAClB,SAAO,QAAQ;AACf,MAAI,KAAK,SAAS,CAAC,KAAK,MAAM,eAAe,EAAE;AAC7C,QAAK,MAAM,gBAAgB;AAC3B;;AAEF,aAAW,QAAQ;AACnB,MAAI;GACF,MAAM,qCAAgB,QAAQ,MAAM;GACpC,MAAM,sCAAiB,QAAQ,OAAO;GACtC,MAAM,cAAc,SAAS,MAAM,OAAO,aAAa,SAAS,MAAM,GAAG;AACzE,OAAI,eAAe,YAAY,QAAQ;AACrC,WAAO,QAAQ,aAAa,YAAY,OAAO;AAC/C,UAAM,QAAQ,WAAW,OAAO,MAAM;UACjC;IACL,MAAM,cAAc,OAClB,YAAY,cACR,mBAAmB,cAAc,YAAY,QAAQ,OAAO,GAAG,KAAK,GACpE,mBAAmB,GAAG,KAAK;AAEjC,QAAI,OAAO,MACT,OAAM,QAAQ,WAAW,OAAO,MAAM;QAEtC,WAAU,QAAQ;AAEpB,WAAO;;YAED;AACR,cAAW,QAAQ;;;AAIvB,QAAO;EAAE;EAAM;EAAQ;EAAY;EAAW;EAAQ"}

package/dist/index.d.cts

@@ -0,0 +1,252 @@
+import { StandardSchemaV1 } from "@standard-schema/spec";
+import { MaybeRefOrGetter, Ref, WatchOptionsBase } from "@vue/runtime-core";
+import { MaybeRefOrGetter as MaybeRefOrGetter$1, Ref as Ref$1 } from "@vue/reactivity";
+
+//#region src/errors/base.d.ts
+type StandardErrors = readonly StandardSchemaV1.Issue[];
+type ErrorsFormatter<TErrors> = (issues: StandardErrors) => TErrors;
+//#endregion
+//#region src/errors/flatten.d.ts
+/**
+ * The FlatErrors interface, compatible with Valibot.
+ *
+ * TODO: accept Schema as a generic parameter, allow typed errors.
+ */
+interface FlatErrors {
+  /**
+   * Root-level errors.
+   *
+   * Contains error messages from issues without a path (belonging to the root of the schema).
+   */
+  root?: string[];
+  /**
+   * Nested field errors.
+   *
+   * Contains error messages from issues with a path (belonging to nested parts
+   * of the schema), keyed by their dot-notation path.
+   */
+  nested?: Partial<{
+    [key: string]: string[];
+  }>;
+}
+/**
+ * Built-in error formatter that converts Standard Schema issues to FlatErrors format,
+ * compatible with Valibot's flatten() function.
+ */
+declare function flatten(issues: StandardErrors): FlatErrors;
+//#endregion
+//#region src/parse.d.ts
+type UseParseReturn<TSchema extends StandardSchemaV1, TErrors = StandardErrors> = {
+  result: Ref<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  output: Ref<StandardSchemaV1.InferOutput<TSchema> | undefined>;
+  errors: Ref<TErrors | undefined>;
+};
+declare function useParse<TSchema extends StandardSchemaV1, TErrors = StandardErrors>(options: {
+  /**
+   * The input data to validate (plain value, ref, or getter).
+   */
+  input?: unknown;
+  /**
+   * A Standard Schema compatible schema (plain value, ref, or getter).
+   */
+  schema: MaybeRefOrGetter<TSchema>;
+  /**
+   * Error formatter function that transforms raw Standard Schema issues into the desired format.
+   */
+  formatErrors?: ErrorsFormatter<TErrors>;
+}, watchOptions?: WatchOptionsBase): UseParseReturn<TSchema, TErrors>;
+//#endregion
+//#region src/submit.d.ts
+interface UseSubmitReturn<TArgs extends any[], TResult, TErrors> {
+  /**
+   * The form element ref.
+   *
+   * Using it with `<form ref="form">` will enable HTML5 validation on submit.
+   */
+  form: Ref$1<HTMLFormElement | undefined>;
+  /**
+   * The form submit function. Use it like:
+   *
+   * - `<form @submit.prevent="submit">`
+   * - `<button @click="submit">`
+   *
+   * It will:
+   *
+   * - Run HTML5 validation (if the form ref is set).
+   * - Run Standard Schema validation (if the schema is provided).
+   * - Call the `onSubmit` callback (if provided).
+   *
+   * Arguments passed to this function are forwarded to the `onSubmit` callback,
+   * prepended with the (possibly validated) form input (unless using the shortcut variant of `useSubmit`).
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  submit: (...args: TArgs) => Promise<TResult | undefined>;
+  /**
+   * Whether a submission is currently in progress.
+   *
+   * Use this to disable the submit button.
+   *
+   * `useSubmit` will also skip submission if this is already `true`.
+   */
+  submitting: Ref$1<boolean>;
+  /**
+   * Has the form been successfully submitted?
+   *
+   * Feel free to reset. `useSubmit` doesn't depend on this value.
+   */
+  submitted: Ref$1<boolean>;
+  /**
+   * Validation errors.
+   */
+  errors: Ref$1<TErrors | undefined>;
+}
+interface BaseOptions<TErrors> {
+  /**
+   * Error formatter function that transforms raw Standard Schema issues into the desired format.
+   */
+  formatErrors?: ErrorsFormatter<TErrors>;
+  /**
+   * Error callback.
+   *
+   * Called (and awaited) when validation fails or when `errors.value` is set by the `onSubmit` handler.
+   */
+  onErrors?: (errors: TErrors) => any;
+  /**
+   * User-provided ref for the `form` return value.
+   */
+  form?: Ref$1<HTMLFormElement | undefined>;
+  /**
+   * User-provided ref for the `submitting` return value.
+   */
+  submitting?: Ref$1<boolean>;
+  /**
+   * User-provided ref for the `submitted` return value.
+   */
+  submitted?: Ref$1<boolean>;
+  /**
+   * User-provided ref for the `errors` return value.
+   */
+  errors?: Ref$1<TErrors | undefined>;
+}
+type SubmitCallback<Args extends any[], Result> = (...args: Args) => Result | PromiseLike<Result>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input?: never;
+  schema?: never;
+  /**
+   * onSubmit callback.
+   *
+   * Only called if:
+   * - The form is not already being submitted (`submitting.value` is falsy).
+   * - HTML5 validation passes (if enabled).
+   *
+   * Arguments are passed through from the submit function.
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  onSubmit?: SubmitCallback<Args, Result>;
+}): UseSubmitReturn<Args, Result, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ *
+ * Validates the input using Standard Schema.
+ */
+declare function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  /**
+   * The input data: a plain value, ref, or getter.
+   */
+  input: MaybeRefOrGetter$1<TInput>;
+  schema?: never;
+  /**
+   * onSubmit callback.
+   *
+   * Only called if:
+   * - The form is not already being submitted (`submitting.value` is falsy).
+   * - HTML5 validation passes (if enabled).
+   *
+   * The first argument is the form input; the remaining arguments are passed through from the submit function.
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  onSubmit?: SubmitCallback<[TInput, ...TArgs], TResult>;
+}): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ *
+ * Validates the input using Standard Schema.
+ */
+declare function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  /**
+   * The input data to validate (plain value, ref, or getter).
+   */
+  input?: unknown;
+  /**
+   * A Standard Schema compatible schema (plain value, ref, or getter).
+   */
+  schema: MaybeRefOrGetter$1<TSchema>;
+  /**
+   * onSubmit callback.
+   *
+   * Only called if:
+   * - The form is not already being submitted (`submitting.value` is falsy).
+   * - HTML5 validation passes (if enabled).
+   * - Standard Schema validation passes.
+   *
+   * The first argument is the validated input; the remaining arguments are passed through from the submit function.
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  onSubmit?: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>;
+}): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input?: never;
+  schema?: never;
+  onSubmit?: never;
+}, onSubmit: SubmitCallback<Args, Result>): UseSubmitReturn<Args, Result, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input: MaybeRefOrGetter$1<TInput>;
+  schema?: never;
+  onSubmit?: never;
+}, onSubmit: SubmitCallback<[TInput, ...TArgs], TResult>): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input?: unknown;
+  schema: MaybeRefOrGetter$1<TSchema>;
+  onSubmit?: never;
+}, onSubmit: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<TArgs extends any[], TResult>(
+/**
+ * onSubmit callback.
+ *
+ * Only called if:
+ * - The form is not already being submitted (`submitting.value` is falsy).
+ * - HTML5 validation passes (if enabled).
+ *
+ * Arguments are passed through from the submit function.
+ *
+ * While submission is in progress, `submitting` is true.
+ * After successful execution, `submitted` is true.
+ */
+
+onSubmit?: SubmitCallback<TArgs, TResult>): UseSubmitReturn<TArgs, TResult, StandardErrors>;
+//#endregion
+export { ErrorsFormatter, FlatErrors, StandardErrors, UseParseReturn, UseSubmitReturn, flatten, useParse, useSubmit };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.mts

@@ -0,0 +1,252 @@
+import { MaybeRefOrGetter, Ref } from "@vue/reactivity";
+import { MaybeRefOrGetter as MaybeRefOrGetter$1, Ref as Ref$1, WatchOptionsBase } from "@vue/runtime-core";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region src/errors/base.d.ts
+type StandardErrors = readonly StandardSchemaV1.Issue[];
+type ErrorsFormatter<TErrors> = (issues: StandardErrors) => TErrors;
+//#endregion
+//#region src/errors/flatten.d.ts
+/**
+ * The FlatErrors interface, compatible with Valibot.
+ *
+ * TODO: accept Schema as a generic parameter, allow typed errors.
+ */
+interface FlatErrors {
+  /**
+   * Root-level errors.
+   *
+   * Contains error messages from issues without a path (belonging to the root of the schema).
+   */
+  root?: string[];
+  /**
+   * Nested field errors.
+   *
+   * Contains error messages from issues with a path (belonging to nested parts
+   * of the schema), keyed by their dot-notation path.
+   */
+  nested?: Partial<{
+    [key: string]: string[];
+  }>;
+}
+/**
+ * Built-in error formatter that converts Standard Schema issues to FlatErrors format,
+ * compatible with Valibot's flatten() function.
+ */
+declare function flatten(issues: StandardErrors): FlatErrors;
+//#endregion
+//#region src/parse.d.ts
+type UseParseReturn<TSchema extends StandardSchemaV1, TErrors = StandardErrors> = {
+  result: Ref$1<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>;
+  output: Ref$1<StandardSchemaV1.InferOutput<TSchema> | undefined>;
+  errors: Ref$1<TErrors | undefined>;
+};
+declare function useParse<TSchema extends StandardSchemaV1, TErrors = StandardErrors>(options: {
+  /**
+   * The input data to validate (plain value, ref, or getter).
+   */
+  input?: unknown;
+  /**
+   * A Standard Schema compatible schema (plain value, ref, or getter).
+   */
+  schema: MaybeRefOrGetter$1<TSchema>;
+  /**
+   * Error formatter function that transforms raw Standard Schema issues into the desired format.
+   */
+  formatErrors?: ErrorsFormatter<TErrors>;
+}, watchOptions?: WatchOptionsBase): UseParseReturn<TSchema, TErrors>;
+//#endregion
+//#region src/submit.d.ts
+interface UseSubmitReturn<TArgs extends any[], TResult, TErrors> {
+  /**
+   * The form element ref.
+   *
+   * Using it with `<form ref="form">` will enable HTML5 validation on submit.
+   */
+  form: Ref<HTMLFormElement | undefined>;
+  /**
+   * The form submit function. Use it like:
+   *
+   * - `<form @submit.prevent="submit">`
+   * - `<button @click="submit">`
+   *
+   * It will:
+   *
+   * - Run HTML5 validation (if the form ref is set).
+   * - Run Standard Schema validation (if the schema is provided).
+   * - Call the `onSubmit` callback (if provided).
+   *
+   * Arguments passed to this function are forwarded to the `onSubmit` callback,
+   * prepended with the (possibly validated) form input (unless using the shortcut variant of `useSubmit`).
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  submit: (...args: TArgs) => Promise<TResult | undefined>;
+  /**
+   * Whether a submission is currently in progress.
+   *
+   * Use this to disable the submit button.
+   *
+   * `useSubmit` will also skip submission if this is already `true`.
+   */
+  submitting: Ref<boolean>;
+  /**
+   * Has the form been successfully submitted?
+   *
+   * Feel free to reset. `useSubmit` doesn't depend on this value.
+   */
+  submitted: Ref<boolean>;
+  /**
+   * Validation errors.
+   */
+  errors: Ref<TErrors | undefined>;
+}
+interface BaseOptions<TErrors> {
+  /**
+   * Error formatter function that transforms raw Standard Schema issues into the desired format.
+   */
+  formatErrors?: ErrorsFormatter<TErrors>;
+  /**
+   * Error callback.
+   *
+   * Called (and awaited) when validation fails or when `errors.value` is set by the `onSubmit` handler.
+   */
+  onErrors?: (errors: TErrors) => any;
+  /**
+   * User-provided ref for the `form` return value.
+   */
+  form?: Ref<HTMLFormElement | undefined>;
+  /**
+   * User-provided ref for the `submitting` return value.
+   */
+  submitting?: Ref<boolean>;
+  /**
+   * User-provided ref for the `submitted` return value.
+   */
+  submitted?: Ref<boolean>;
+  /**
+   * User-provided ref for the `errors` return value.
+   */
+  errors?: Ref<TErrors | undefined>;
+}
+type SubmitCallback<Args extends any[], Result> = (...args: Args) => Result | PromiseLike<Result>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input?: never;
+  schema?: never;
+  /**
+   * onSubmit callback.
+   *
+   * Only called if:
+   * - The form is not already being submitted (`submitting.value` is falsy).
+   * - HTML5 validation passes (if enabled).
+   *
+   * Arguments are passed through from the submit function.
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  onSubmit?: SubmitCallback<Args, Result>;
+}): UseSubmitReturn<Args, Result, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ *
+ * Validates the input using Standard Schema.
+ */
+declare function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  /**
+   * The input data: a plain value, ref, or getter.
+   */
+  input: MaybeRefOrGetter<TInput>;
+  schema?: never;
+  /**
+   * onSubmit callback.
+   *
+   * Only called if:
+   * - The form is not already being submitted (`submitting.value` is falsy).
+   * - HTML5 validation passes (if enabled).
+   *
+   * The first argument is the form input; the remaining arguments are passed through from the submit function.
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  onSubmit?: SubmitCallback<[TInput, ...TArgs], TResult>;
+}): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ *
+ * Validates the input using Standard Schema.
+ */
+declare function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  /**
+   * The input data to validate (plain value, ref, or getter).
+   */
+  input?: unknown;
+  /**
+   * A Standard Schema compatible schema (plain value, ref, or getter).
+   */
+  schema: MaybeRefOrGetter<TSchema>;
+  /**
+   * onSubmit callback.
+   *
+   * Only called if:
+   * - The form is not already being submitted (`submitting.value` is falsy).
+   * - HTML5 validation passes (if enabled).
+   * - Standard Schema validation passes.
+   *
+   * The first argument is the validated input; the remaining arguments are passed through from the submit function.
+   *
+   * While submission is in progress, `submitting` is true.
+   * After successful execution, `submitted` is true.
+   */
+  onSubmit?: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>;
+}): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input?: never;
+  schema?: never;
+  onSubmit?: never;
+}, onSubmit: SubmitCallback<Args, Result>): UseSubmitReturn<Args, Result, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input: MaybeRefOrGetter<TInput>;
+  schema?: never;
+  onSubmit?: never;
+}, onSubmit: SubmitCallback<[TInput, ...TArgs], TResult>): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(options: BaseOptions<TErrors> & {
+  input?: unknown;
+  schema: MaybeRefOrGetter<TSchema>;
+  onSubmit?: never;
+}, onSubmit: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>): UseSubmitReturn<TArgs, TResult, TErrors>;
+/**
+ * Vue 3 composable for handling form submission.
+ */
+declare function useSubmit<TArgs extends any[], TResult>(
+/**
+ * onSubmit callback.
+ *
+ * Only called if:
+ * - The form is not already being submitted (`submitting.value` is falsy).
+ * - HTML5 validation passes (if enabled).
+ *
+ * Arguments are passed through from the submit function.
+ *
+ * While submission is in progress, `submitting` is true.
+ * After successful execution, `submitted` is true.
+ */
+
+onSubmit?: SubmitCallback<TArgs, TResult>): UseSubmitReturn<TArgs, TResult, StandardErrors>;
+//#endregion
+export { ErrorsFormatter, FlatErrors, StandardErrors, UseParseReturn, UseSubmitReturn, flatten, useParse, useSubmit };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -0,0 +1,112 @@
+import { getDotPath } from "@standard-schema/utils";
+import { ref, toValue } from "@vue/reactivity";
+import { watchEffect } from "@vue/runtime-core";
+
+//#region src/errors/flatten.ts
+/**
+* Built-in error formatter that converts Standard Schema issues to FlatErrors format,
+* compatible with Valibot's flatten() function.
+*/
+function flatten(issues) {
+	const errors = {};
+	for (const issue of issues) {
+		const dotPath = getDotPath(issue);
+		if (dotPath) {
+			errors.nested ??= {};
+			errors.nested[dotPath] ??= [];
+			errors.nested[dotPath].push(issue.message);
+		} else {
+			errors.root ??= [];
+			errors.root.push(issue.message);
+		}
+	}
+	return errors;
+}
+
+//#endregion
+//#region src/parse.ts
+function useParse(options, watchOptions) {
+	const result = ref();
+	const output = ref();
+	const errors = ref();
+	const formatErrors = options.formatErrors ?? ((issues) => issues);
+	function applyResult(r) {
+		result.value = r;
+		if (r.issues) {
+			output.value = void 0;
+			errors.value = formatErrors(r.issues);
+		} else {
+			output.value = r.value;
+			errors.value = void 0;
+		}
+	}
+	watchEffect((onCleanup) => {
+		const schema = toValue(options.schema);
+		const input = toValue(options.input);
+		const resultOrPromise = schema["~standard"].validate(input);
+		if (resultOrPromise instanceof Promise) {
+			let cancelled = false;
+			onCleanup(() => {
+				cancelled = true;
+			});
+			resultOrPromise.then((r) => {
+				if (!cancelled) applyResult(r);
+			});
+		} else applyResult(resultOrPromise);
+	}, watchOptions);
+	return {
+		result,
+		output,
+		errors
+	};
+}
+
+//#endregion
+//#region src/submit.ts
+function useSubmit(optionsOrOnSubmit, externalOnSubmit) {
+	const options = (typeof optionsOrOnSubmit === "function" ? void 0 : optionsOrOnSubmit) ?? {};
+	const onSubmitCallback = typeof optionsOrOnSubmit === "function" ? optionsOrOnSubmit : externalOnSubmit ?? options?.onSubmit;
+	const hasInput = options.input !== void 0;
+	const form = options.form ?? ref();
+	const errors = options.errors ?? ref();
+	const submitting = options.submitting ?? ref(false);
+	const submitted = options.submitted ?? ref(false);
+	const formatErrors = options.formatErrors ?? ((issues) => issues);
+	async function submit(...args) {
+		if (submitting.value) return;
+		submitted.value = false;
+		errors.value = void 0;
+		if (form.value && !form.value.checkValidity()) {
+			form.value.reportValidity();
+			return;
+		}
+		submitting.value = true;
+		try {
+			const input = toValue(options.input);
+			const schema = toValue(options.schema);
+			const parseResult = schema ? await schema["~standard"].validate(input) : void 0;
+			if (parseResult && parseResult.issues) {
+				errors.value = formatErrors(parseResult.issues);
+				await options.onErrors?.(errors.value);
+			} else {
+				const returnValue = await (hasInput || parseResult ? onSubmitCallback?.(parseResult ? parseResult.value : input, ...args) : onSubmitCallback?.(...args));
+				if (errors.value) await options.onErrors?.(errors.value);
+				else submitted.value = true;
+				return returnValue;
+			}
+		} finally {
+			submitting.value = false;
+		}
+	}
+	return {
+		form,
+		submit,
+		submitting,
+		submitted,
+		errors
+	};
+}
+
+//#endregion
+export { flatten, useParse, useSubmit };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/errors/flatten.ts","../src/parse.ts","../src/submit.ts"],"sourcesContent":["import { getDotPath } from \"@standard-schema/utils\"\n\nimport type { StandardErrors } from \"./base\"\n\n/**\n * The FlatErrors interface, compatible with Valibot.\n *\n * TODO: accept Schema as a generic parameter, allow typed errors.\n */\nexport interface FlatErrors {\n  /**\n   * Root-level errors.\n   *\n   * Contains error messages from issues without a path (belonging to the root of the schema).\n   */\n  root?: string[]\n  /**\n   * Nested field errors.\n   *\n   * Contains error messages from issues with a path (belonging to nested parts\n   * of the schema), keyed by their dot-notation path.\n   */\n  nested?: Partial<{\n    [key: string]: string[]\n  }>\n}\n\n/**\n * Built-in error formatter that converts Standard Schema issues to FlatErrors format,\n * compatible with Valibot's flatten() function.\n */\nexport function flatten(issues: StandardErrors): FlatErrors {\n  const errors: FlatErrors = {}\n  for (const issue of issues) {\n    const dotPath = getDotPath(issue)\n    if (dotPath) {\n      errors.nested ??= {}\n      errors.nested[dotPath] ??= []\n      errors.nested[dotPath]!.push(issue.message)\n    } else {\n      errors.root ??= []\n      errors.root.push(issue.message)\n    }\n  }\n\n  return errors\n}\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\"\nimport { ref, toValue } from \"@vue/reactivity\"\nimport type { MaybeRefOrGetter, Ref, WatchOptionsBase } from \"@vue/runtime-core\"\nimport { watchEffect } from \"@vue/runtime-core\"\n\nimport type { ErrorsFormatter, StandardErrors } from \"./errors\"\n\nexport type UseParseReturn<TSchema extends StandardSchemaV1, TErrors = StandardErrors> = {\n  result: Ref<StandardSchemaV1.Result<StandardSchemaV1.InferOutput<TSchema>>>\n  output: Ref<StandardSchemaV1.InferOutput<TSchema> | undefined>\n  errors: Ref<TErrors | undefined>\n}\n\nexport function useParse<TSchema extends StandardSchemaV1, TErrors = StandardErrors>(\n  options: {\n    /**\n     * The input data to validate (plain value, ref, or getter).\n     */\n    input?: unknown\n    /**\n     * A Standard Schema compatible schema (plain value, ref, or getter).\n     */\n    schema: MaybeRefOrGetter<TSchema>\n    /**\n     * Error formatter function that transforms raw Standard Schema issues into the desired format.\n     */\n    formatErrors?: ErrorsFormatter<TErrors>\n  },\n  watchOptions?: WatchOptionsBase,\n): UseParseReturn<TSchema, TErrors> {\n  type Output = StandardSchemaV1.InferOutput<TSchema>\n  const result = ref<StandardSchemaV1.Result<Output>>() as Ref<StandardSchemaV1.Result<Output>>\n  const output = ref<Output>()\n  const errors = ref<TErrors | undefined>()\n  const formatErrors = options.formatErrors ?? ((issues: StandardErrors) => issues as TErrors)\n\n  function applyResult(r: StandardSchemaV1.Result<Output>) {\n    result.value = r\n    if (r.issues) {\n      output.value = undefined\n      errors.value = formatErrors(r.issues)\n    } else {\n      output.value = r.value\n      errors.value = undefined\n    }\n  }\n\n  watchEffect((onCleanup) => {\n    const schema = toValue(options.schema)\n    const input = toValue(options.input)\n    const resultOrPromise = schema[\"~standard\"].validate(input)\n\n    if (resultOrPromise instanceof Promise) {\n      let cancelled = false\n      onCleanup(() => {\n        cancelled = true\n      })\n      resultOrPromise.then((r) => {\n        if (!cancelled) {\n          applyResult(r)\n        }\n      })\n    } else {\n      applyResult(resultOrPromise)\n    }\n  }, watchOptions)\n\n  return { result, output, errors }\n}\n","import type { StandardSchemaV1 } from \"@standard-schema/spec\"\nimport type { MaybeRefOrGetter, Ref } from \"@vue/reactivity\"\nimport { ref, toValue } from \"@vue/reactivity\"\n\nimport type { ErrorsFormatter, StandardErrors } from \"./errors\"\n\nexport interface UseSubmitReturn<TArgs extends any[], TResult, TErrors> {\n  /**\n   * The form element ref.\n   *\n   * Using it with `<form ref=\"form\">` will enable HTML5 validation on submit.\n   */\n  form: Ref<HTMLFormElement | undefined>\n  /**\n   * The form submit function. Use it like:\n   *\n   * - `<form @submit.prevent=\"submit\">`\n   * - `<button @click=\"submit\">`\n   *\n   * It will:\n   *\n   * - Run HTML5 validation (if the form ref is set).\n   * - Run Standard Schema validation (if the schema is provided).\n   * - Call the `onSubmit` callback (if provided).\n   *\n   * Arguments passed to this function are forwarded to the `onSubmit` callback,\n   * prepended with the (possibly validated) form input (unless using the shortcut variant of `useSubmit`).\n   *\n   * While submission is in progress, `submitting` is true.\n   * After successful execution, `submitted` is true.\n   */\n  submit: (...args: TArgs) => Promise<TResult | undefined>\n  /**\n   * Whether a submission is currently in progress.\n   *\n   * Use this to disable the submit button.\n   *\n   * `useSubmit` will also skip submission if this is already `true`.\n   */\n  submitting: Ref<boolean>\n  /**\n   * Has the form been successfully submitted?\n   *\n   * Feel free to reset. `useSubmit` doesn't depend on this value.\n   */\n  submitted: Ref<boolean>\n  /**\n   * Validation errors.\n   */\n  errors: Ref<TErrors | undefined>\n}\n\ninterface BaseOptions<TErrors> {\n  /**\n   * Error formatter function that transforms raw Standard Schema issues into the desired format.\n   */\n  formatErrors?: ErrorsFormatter<TErrors>\n  /**\n   * Error callback.\n   *\n   * Called (and awaited) when validation fails or when `errors.value` is set by the `onSubmit` handler.\n   */\n  onErrors?: (errors: TErrors) => any\n  /**\n   * User-provided ref for the `form` return value.\n   */\n  form?: Ref<HTMLFormElement | undefined>\n  /**\n   * User-provided ref for the `submitting` return value.\n   */\n  submitting?: Ref<boolean>\n  /**\n   * User-provided ref for the `submitted` return value.\n   */\n  submitted?: Ref<boolean>\n  /**\n   * User-provided ref for the `errors` return value.\n   */\n  errors?: Ref<TErrors | undefined>\n}\n\ntype SubmitCallback<Args extends any[], Result> = (\n  ...args: Args\n) => Result | PromiseLike<Result>\n\n//\n// No input.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input?: never\n    schema?: never\n    /**\n     * onSubmit callback.\n     *\n     * Only called if:\n     * - The form is not already being submitted (`submitting.value` is falsy).\n     * - HTML5 validation passes (if enabled).\n     *\n     * Arguments are passed through from the submit function.\n     *\n     * While submission is in progress, `submitting` is true.\n     * After successful execution, `submitted` is true.\n     */\n    onSubmit?: SubmitCallback<Args, Result>\n  },\n): UseSubmitReturn<Args, Result, TErrors>\n\n//\n// Input only (no schema).\n//\n\n/**\n * Vue 3 composable for handling form submission.\n *\n * Validates the input using Standard Schema.\n */\nexport function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    /**\n     * The input data: a plain value, ref, or getter.\n     */\n    input: MaybeRefOrGetter<TInput>\n    schema?: never\n    /**\n     * onSubmit callback.\n     *\n     * Only called if:\n     * - The form is not already being submitted (`submitting.value` is falsy).\n     * - HTML5 validation passes (if enabled).\n     *\n     * The first argument is the form input; the remaining arguments are passed through from the submit function.\n     *\n     * While submission is in progress, `submitting` is true.\n     * After successful execution, `submitted` is true.\n     */\n    onSubmit?: SubmitCallback<[TInput, ...TArgs], TResult>\n  },\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// Schema.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n *\n * Validates the input using Standard Schema.\n */\nexport function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    /**\n     * The input data to validate (plain value, ref, or getter).\n     */\n    input?: unknown\n    /**\n     * A Standard Schema compatible schema (plain value, ref, or getter).\n     */\n    schema: MaybeRefOrGetter<TSchema>\n    /**\n     * onSubmit callback.\n     *\n     * Only called if:\n     * - The form is not already being submitted (`submitting.value` is falsy).\n     * - HTML5 validation passes (if enabled).\n     * - Standard Schema validation passes.\n     *\n     * The first argument is the validated input; the remaining arguments are passed through from the submit function.\n     *\n     * While submission is in progress, `submitting` is true.\n     * After successful execution, `submitted` is true.\n     */\n    onSubmit?: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>\n  },\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// No input, separate submit.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<Args extends unknown[], Result, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input?: never\n    schema?: never\n    onSubmit?: never\n  },\n  onSubmit: SubmitCallback<Args, Result>,\n): UseSubmitReturn<Args, Result, TErrors>\n\n//\n// Input only (no schema), separate submit.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<TInput, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input: MaybeRefOrGetter<TInput>\n    schema?: never\n    onSubmit?: never\n  },\n  onSubmit: SubmitCallback<[TInput, ...TArgs], TResult>,\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// Schema, separate submit.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<TSchema extends StandardSchemaV1, TArgs extends any[], TResult, TErrors = StandardErrors>(\n  options: BaseOptions<TErrors> & {\n    input?: unknown\n    schema: MaybeRefOrGetter<TSchema>\n    onSubmit?: never\n  },\n  onSubmit: SubmitCallback<[StandardSchemaV1.InferOutput<TSchema>, ...TArgs], TResult>,\n): UseSubmitReturn<TArgs, TResult, TErrors>\n\n//\n// No input, callback only.\n//\n\n/**\n * Vue 3 composable for handling form submission.\n */\nexport function useSubmit<TArgs extends any[], TResult>(\n/**\n * onSubmit callback.\n *\n * Only called if:\n * - The form is not already being submitted (`submitting.value` is falsy).\n * - HTML5 validation passes (if enabled).\n *\n * Arguments are passed through from the submit function.\n *\n * While submission is in progress, `submitting` is true.\n * After successful execution, `submitted` is true.\n */\n  onSubmit?: SubmitCallback<TArgs, TResult>,\n): UseSubmitReturn<TArgs, TResult, StandardErrors>\n\n//\n// Implementation.\n//\n\nexport function useSubmit(\n  optionsOrOnSubmit?:\n    | (BaseOptions<unknown> & {\n      input?: unknown\n      schema?: MaybeRefOrGetter<StandardSchemaV1>\n      onSubmit?: SubmitCallback<unknown[], unknown>\n    })\n    | SubmitCallback<unknown[], unknown>,\n  externalOnSubmit?: SubmitCallback<unknown[], unknown>,\n): UseSubmitReturn<unknown[], unknown, unknown> {\n  const options\n    = (typeof optionsOrOnSubmit === \"function\" ? undefined : optionsOrOnSubmit) ?? {}\n  const onSubmitCallback\n    = typeof optionsOrOnSubmit === \"function\" ? optionsOrOnSubmit : externalOnSubmit ?? options?.onSubmit\n  const hasInput = options.input !== undefined\n\n  const form = options.form ?? ref<HTMLFormElement>()\n  const errors = options.errors ?? ref()\n  const submitting = options.submitting ?? ref(false)\n  const submitted = options.submitted ?? ref(false)\n\n  const formatErrors = options.formatErrors ?? ((issues: StandardErrors) => issues)\n\n  async function submit(...args: unknown[]) {\n    if (submitting.value) {\n      return\n    }\n    submitted.value = false\n    errors.value = undefined\n    if (form.value && !form.value.checkValidity()) {\n      form.value.reportValidity()\n      return\n    }\n    submitting.value = true\n    try {\n      const input = toValue(options.input)\n      const schema = toValue(options.schema)\n      const parseResult = schema ? await schema[\"~standard\"].validate(input) : undefined\n      if (parseResult && parseResult.issues) {\n        errors.value = formatErrors(parseResult.issues)\n        await options.onErrors?.(errors.value)\n      } else {\n        const returnValue = await (\n          hasInput || parseResult\n            ? onSubmitCallback?.(parseResult ? parseResult.value : input, ...args)\n            : onSubmitCallback?.(...args)\n        )\n        if (errors.value) {\n          await options.onErrors?.(errors.value)\n        } else {\n          submitted.value = true\n        }\n        return returnValue\n      }\n    } finally {\n      submitting.value = false\n    }\n  }\n\n  return { form, submit, submitting, submitted, errors }\n}\n"],"mappings":";;;;;;;;;AA+BA,SAAgB,QAAQ,QAAoC;CAC1D,MAAM,SAAqB,EAAE;AAC7B,MAAK,MAAM,SAAS,QAAQ;EAC1B,MAAM,UAAU,WAAW,MAAM;AACjC,MAAI,SAAS;AACX,UAAO,WAAW,EAAE;AACpB,UAAO,OAAO,aAAa,EAAE;AAC7B,UAAO,OAAO,SAAU,KAAK,MAAM,QAAQ;SACtC;AACL,UAAO,SAAS,EAAE;AAClB,UAAO,KAAK,KAAK,MAAM,QAAQ;;;AAInC,QAAO;;;;;AChCT,SAAgB,SACd,SAcA,cACkC;CAElC,MAAM,SAAS,KAAsC;CACrD,MAAM,SAAS,KAAa;CAC5B,MAAM,SAAS,KAA0B;CACzC,MAAM,eAAe,QAAQ,kBAAkB,WAA2B;CAE1E,SAAS,YAAY,GAAoC;AACvD,SAAO,QAAQ;AACf,MAAI,EAAE,QAAQ;AACZ,UAAO,QAAQ;AACf,UAAO,QAAQ,aAAa,EAAE,OAAO;SAChC;AACL,UAAO,QAAQ,EAAE;AACjB,UAAO,QAAQ;;;AAInB,cAAa,cAAc;EACzB,MAAM,SAAS,QAAQ,QAAQ,OAAO;EACtC,MAAM,QAAQ,QAAQ,QAAQ,MAAM;EACpC,MAAM,kBAAkB,OAAO,aAAa,SAAS,MAAM;AAE3D,MAAI,2BAA2B,SAAS;GACtC,IAAI,YAAY;AAChB,mBAAgB;AACd,gBAAY;KACZ;AACF,mBAAgB,MAAM,MAAM;AAC1B,QAAI,CAAC,UACH,aAAY,EAAE;KAEhB;QAEF,aAAY,gBAAgB;IAE7B,aAAa;AAEhB,QAAO;EAAE;EAAQ;EAAQ;EAAQ;;;;;AC4LnC,SAAgB,UACd,mBAOA,kBAC8C;CAC9C,MAAM,WACD,OAAO,sBAAsB,aAAa,SAAY,sBAAsB,EAAE;CACnF,MAAM,mBACF,OAAO,sBAAsB,aAAa,oBAAoB,oBAAoB,SAAS;CAC/F,MAAM,WAAW,QAAQ,UAAU;CAEnC,MAAM,OAAO,QAAQ,QAAQ,KAAsB;CACnD,MAAM,SAAS,QAAQ,UAAU,KAAK;CACtC,MAAM,aAAa,QAAQ,cAAc,IAAI,MAAM;CACnD,MAAM,YAAY,QAAQ,aAAa,IAAI,MAAM;CAEjD,MAAM,eAAe,QAAQ,kBAAkB,WAA2B;CAE1E,eAAe,OAAO,GAAG,MAAiB;AACxC,MAAI,WAAW,MACb;AAEF,YAAU,QAAQ;AAClB,SAAO,QAAQ;AACf,MAAI,KAAK,SAAS,CAAC,KAAK,MAAM,eAAe,EAAE;AAC7C,QAAK,MAAM,gBAAgB;AAC3B;;AAEF,aAAW,QAAQ;AACnB,MAAI;GACF,MAAM,QAAQ,QAAQ,QAAQ,MAAM;GACpC,MAAM,SAAS,QAAQ,QAAQ,OAAO;GACtC,MAAM,cAAc,SAAS,MAAM,OAAO,aAAa,SAAS,MAAM,GAAG;AACzE,OAAI,eAAe,YAAY,QAAQ;AACrC,WAAO,QAAQ,aAAa,YAAY,OAAO;AAC/C,UAAM,QAAQ,WAAW,OAAO,MAAM;UACjC;IACL,MAAM,cAAc,OAClB,YAAY,cACR,mBAAmB,cAAc,YAAY,QAAQ,OAAO,GAAG,KAAK,GACpE,mBAAmB,GAAG,KAAK;AAEjC,QAAI,OAAO,MACT,OAAM,QAAQ,WAAW,OAAO,MAAM;QAEtC,WAAU,QAAQ;AAEpB,WAAO;;YAED;AACR,cAAW,QAAQ;;;AAIvB,QAAO;EAAE;EAAM;EAAQ;EAAY;EAAW;EAAQ"}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "vue-form-submit",
+  "type": "module",
+  "version": "5.0.0",
+  "packageManager": "bun@1.3.9",
+  "description": "Vue3 composables for handling form submit with Standard Schema validation support",
+  "author": "Ilya Semenov",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/IlyaSemenov/vue-form-submit.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "lint": "eslint --fix .",
+    "prepare": "lefthook install",
+    "prepublishOnly": "bun run build",
+    "test": "bun test && bun run types",
+    "types": "tsgo"
+  },
+  "peerDependencies": {
+    "@vue/reactivity": "^3",
+    "@vue/runtime-core": "^3"
+  },
+  "dependencies": {
+    "@standard-schema/spec": "^1.0.0",
+    "@standard-schema/utils": "^0.3.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/core": "^0.18.2",
+    "@changesets/cli": "^2.26.2",
+    "@ilyasemenov/eslint-config": "^1.4.2",
+    "@tsconfig/bun": "^1.0.10",
+    "@types/bun": "^1.3.10",
+    "@typescript/native-preview": "^7.0.0-dev.20260311.1",
+    "@vue/reactivity": "^3.4.29",
+    "@vue/runtime-core": "^3.4.29",
+    "eslint": "^9.35.0",
+    "publint": "^0.3.18",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.4.5",
+    "valibot": "^1.1.0",
+    "zod": "^4.1.7"
+  }
+}