attaform 0.30.0 → 0.31.0

package/dist/shared/{attaform.Rc9u4Vfw.d.mts → attaform.CRVe8s82.d.mts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ac as ValidateOnConfig, a as UseFormReturnType } from './attaform.bKLzMU0o.mjs';
+import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, ap as AcceptableDefaults, ab as ValidateOnConfig, a as UseFormReturnType } from './attaform.DZnrDrNb.mjs';
 
 /**
  * The Zod v4 schema roots `useForm` accepts. A fixed-shape
@@ -34,60 +34,54 @@ import { G as GenericForm, l as FlatPath, s as NestedType, F as FormKey, U as Us
 type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord | z.ZodDiscriminatedUnion<readonly z.ZodObject<z.ZodRawShape>[], string>;
 
 /**
- * The shape `form.values.<key>` returns at runtime.
- *
- * Per leaf:
- *
- * 1. Schema-side input normalizers — `z.preprocess(fn, inner)` AND
- *    `z.coerce.X()`. Zod v4 represents these differently
- *    (`ZodPipe<ZodTransform, inner>` for preprocess; a primitive
- *    with `def.coerce === true` for coerce), but they share the
- *    same type-level marker: `_zod.input` is `unknown`. The
- *    normalizer runs at parse time, NOT at the write boundary, so
- *    storage holds the consumer's raw input and the type collapses
- *    to `unknown` to match. Reach the typed value via
- *    `handleSubmit`, `validate`, or `parse` — they re-parse
- *    storage through the wrapper.
- *
- * 2. `inner.transform(fn)` — compiles to `ZodPipe<inner, ZodTransform>`.
- *    Transforms fire at submit / validate, NOT at the write boundary,
- *    so storage holds whatever `inner` stores. Recurse `StorageShape`
- *    on `inner` so a defaulted leaf inside `inner` still reads `T`
- *    (not `T | undefined`).
- *
- *    A bare top-level `ZodTransform` (no `in` schema) reads
- *    `_zod.input` directly — there's no inner to recurse into.
- *
- * 3. Codec / generic pipe — neither side is a transform. Read
- *    `_zod.output`. Codecs aren't write-boundary-synthesized, so the
+ * The shape `form.values.<key>` returns at runtime. Four cases per leaf:
+ *
+ * 1. A schema-side input normalizer, meaning `z.preprocess(fn, inner)`
+ *    or `z.coerce.X()`. v4 represents the two differently, a
+ *    `ZodPipe<ZodTransform, inner>` against a primitive with
+ *    `def.coerce === true`, but they share one type-level marker:
+ *    `_zod.input` is `unknown`. The normalizer runs at PARSE time, not
+ *    at the write boundary, so storage holds the consumer's raw input
+ *    and the type collapses to `unknown` to match. `handleSubmit`,
+ *    `validate` and `parse` re-parse storage through the wrapper, so
+ *    the typed value is reachable there.
+ *
+ * 2. `inner.transform(fn)`, which compiles to `ZodPipe<inner,
+ *    ZodTransform>`. A transform fires at submit or validate, not at the
+ *    write boundary, so storage holds whatever `inner` stores.
+ *    `StorageShape` recurses on `inner`, so a defaulted leaf inside it
+ *    still reads `T` rather than `T | undefined`. A bare top-level
+ *    `ZodTransform`, with no `in` schema, reads `_zod.input` directly,
+ *    having no inner to recurse into.
+ *
+ * 3. A codec or generic pipe, where neither side is a transform: read
+ *    `_zod.output`. A codec is not write-boundary-synthesized, so the
  *    post-parse view is the only honest storage type.
  *
- * 4. Everything else (defaults, catch, readonly, optional, primitives,
- *    nested objects) — read `_zod.output`. Defaults and catches fire
- *    at parse time, so the post-init view is what storage holds.
- *    Nested objects delegate to Zod's own recursion on `_zod.output`,
+ * 4. Everything else, defaults, catch, readonly, optional, primitives
+ *    and nested objects: read `_zod.output`. Defaults and catches fire
+ *    at parse time, so the post-init view is what storage holds, and a
+ *    nested object delegates to Zod's own recursion on `_zod.output`,
  *    which peels nested defaults inside structural containers.
  *
- * Detection order: case 1 wins via the `_zod.input` IsUnknown check
- * before the pipe/transform cascade fires, so wrapped variants like
- * `z.coerce.number().optional()` (input = `unknown | undefined` →
- * collapses to `unknown`) and `z.preprocess(fn, z.object(...))` (input
- * = `unknown`) both land on `unknown` without descending. The IsAny
- * filter keeps `z.any()` from being mistaken for coerce.
- *
- * Implementation note: direct `_zod` property access mirrors Zod's
- * own `$InferObjectOutput` / `$InferObjectInput`, which read
- * `T[k]['_zod']['output']` / `T[k]['_zod']['input']` directly rather
- * than wrapping in the top-level `output<T>` / `input<T>` conditional.
- * Wrapping per key spawns a fresh conditional instantiation for every
- * key; Volar's web-worker checker collapses that per-key walk to
- * `any` once the schema is non-trivial. Property access has no
- * conditional and resolves cleanly under the same budget.
- *
- * Shape access also goes through `_zod.def.shape` rather than
- * `infer Shape from z.ZodObject<Shape>` — the latter collapses to the
- * `$ZodShape` upper bound in the same worker because of
- * `z.ZodObject`'s `out Shape` covariance markers.
+ * Case 1 wins first, on the `_zod.input` IsUnknown check, before the
+ * pipe and transform cascade can fire. So `z.coerce.number().optional()`
+ * (input `unknown | undefined`, collapsing to `unknown`) and
+ * `z.preprocess(fn, z.object(...))` (input `unknown`) both land on
+ * `unknown` without descending, while the IsAny filter keeps `z.any()`
+ * from being read as coerce.
+ *
+ * The direct `_zod` property access is deliberate, and matches Zod's own
+ * `$InferObjectOutput` / `$InferObjectInput`, which read
+ * `T[k]['_zod']['output']` rather than wrapping in the top-level
+ * `output<T>` conditional. Wrapping per key spawns a fresh conditional
+ * instantiation for every key, and Volar's web-worker checker collapses
+ * that per-key walk to `any` once the schema is non-trivial. Property
+ * access has no conditional and resolves cleanly on the same budget.
+ * Shape access goes through `_zod.def.shape` for the same reason: `infer
+ * Shape from z.ZodObject<Shape>` collapses to the `$ZodShape` upper
+ * bound in that worker, because of `z.ZodObject`'s `out Shape`
+ * covariance markers.
  */
 type StorageShape<S> = S extends {
     _zod: {
@@ -100,10 +94,10 @@ type StorageShape<S> = S extends {
     [K in keyof Shape]-?: StorageLeaf<Shape[K]>;
 } : StorageLeaf<S>;
 /**
- * Detects a schema whose `_zod.input` is `unknown` — the marker both
- * `z.preprocess(fn, _)` and `z.coerce.X()` share in Zod v4. Excludes
- * `any` via the canonical `0 extends 1 & T` test so `z.any()` leaves
- * fall through to the cascade below and keep their `any` typing.
+ * Detect a schema whose `_zod.input` is `unknown`, the marker
+ * `z.preprocess(fn, _)` and `z.coerce.X()` share in v4. `any` is
+ * excluded through the canonical `0 extends 1 & T` test, so a `z.any()`
+ * leaf falls through to the cascade below and keeps its `any`.
  */
 type InputIsUnknown<L> = L extends {
     _zod: {
@@ -111,12 +105,11 @@ type InputIsUnknown<L> = L extends {
     };
 } ? 0 extends 1 & In ? false : unknown extends In ? true : false : false;
 /**
- * Implementation-detail per-leaf branching for `StorageShape`.
- * Exported so the bundled `.d.ts` carries a single alias body —
- * every leaf of a Zod object schema otherwise re-emits the full
- * pipe / transform / default conditional ladder, which compounds
- * badly with multiple complex schemas in the same scope. Consumers
- * should reach for `StorageShape` instead.
+ * The per-leaf branching behind `StorageShape`. It is exported so the
+ * bundled `.d.ts` carries ONE alias body: otherwise every leaf of a Zod
+ * object re-emits the full pipe / transform / default conditional
+ * ladder, which compounds badly once several complex schemas share a
+ * scope. Reach for `StorageShape` instead.
  */
 type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
     _zod: {
@@ -159,10 +152,10 @@ type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
  */
 
 /**
- * Type of the value accepted at `Path` for `setValue` / `defaultValues`
- * — the schema's `z.input<Schema>` shape at that path. Matches what
- * `form.values.X` returns at runtime (the honest input view storage
- * holds before transforms run).
+ * What `setValue` and `defaultValues` accept at `Path`: the schema's
+ * `z.input<Schema>` shape there. It matches what `form.values.X` returns
+ * at runtime, storage holding the honest input view until transforms
+ * run.
  *
  * ```ts
  * const schema = z.object({
@@ -173,9 +166,9 @@ type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
  */
 type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema> extends GenericForm ? Path extends FlatPath<z.input<Schema>> ? NestedType<z.input<Schema>, Path> : never : never;
 /**
- * Type produced at `Path` after the full parse pipeline — the schema's
- * `z.output<Schema>` shape at that path. Matches the `data` payload of
- * `form.parse()` and the value handed to `handleSubmit`'s callback.
+ * What `Path` holds after the full parse pipeline: the schema's
+ * `z.output<Schema>` shape there. It matches `form.parse()`'s `data` and
+ * the value `handleSubmit`'s callback receives.
  *
  * ```ts
  * const schema = z.object({
@@ -185,6 +178,19 @@ type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema>
  * ```
  */
 type PathOutput<Schema extends z.ZodType, Path extends string> = z.output<Schema> extends GenericForm ? Path extends FlatPath<z.output<Schema>> ? NestedType<z.output<Schema>, Path> : never : never;
+/**
+ * Factor the three identical-shape conditionals out of `useForm`'s public
+ * signature, so the bundled `.d.ts` carries one alias per shape instead
+ * of re-inlining `z.input<Schema> extends GenericForm ? z.input<Schema>
+ * : never` four times. That inlining is what produces TS2589 ("Type
+ * instantiation is excessively deep") at a consumer call site holding a
+ * discriminated union, a transform pipe, or a deep `.register()` chain.
+ * Each alias computes once per `Schema` instantiation, and downstream
+ * generics ride it rather than re-evaluating the conditional.
+ */
+type FormOf<Schema extends SupportedRootSchema> = z.input<Schema> extends GenericForm ? z.input<Schema> : never;
+type OutOf<Schema extends SupportedRootSchema> = z.output<Schema> extends GenericForm ? z.output<Schema> : never;
+type ReadOf<Schema extends SupportedRootSchema> = StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never;
 /**
  * Create a form bound to a Zod v4 schema.
  *
@@ -192,37 +198,19 @@ type PathOutput<Schema extends z.ZodType, Path extends string> = z.output<Schema
  * import { useForm } from 'attaform/zod'
  * import { z } from 'zod'
  *
- * const form = useForm({
- *   schema: z.object({
- *     email: z.email(),
- *     password: z.string().min(8),
- *   }),
- *   defaultValues: { email: '' },
+ * const schema = z.object({
+ *   email: z.email(),
+ *   password: z.string().min(8),
  * })
- * ```
  *
- * Returns a form API exposing `register`, `values`, `errors`,
- * `fields`, `setValue`, `handleSubmit`, `meta`, field-array
- * helpers, and more. See `UseFormReturnType` for the full
- * surface.
+ * const form = useForm({ schema, defaultValues: { email: '' } })
+ * ```
  *
- * For Zod v3, import from `attaform/zod-v3` instead.
+ * The returned form carries `register`, `values`, `errors`, `fields`,
+ * `setValue`, `handleSubmit`, `meta` and the field-array helpers; see
+ * `UseFormReturnType` for the whole surface. For Zod v3, import from
+ * `attaform/zod-v3`.
  */
-/**
- * `FormOf` / `OutOf` / `ReadOf` factor the three identical-shape
- * conditionals out of `useForm`'s public signature. The bundled
- * `.d.ts` then carries one alias per shape rather than re-inlining
- * `z.input<Schema> extends GenericForm ? z.input<Schema> : never`
- * four times — which is what produces TS2589 ("Type instantiation
- * is excessively deep") on consumer call sites with complex schemas
- * (discriminated unions, transform pipes, deep `.register()` chains).
- * Each alias is computed once per `Schema` instantiation; downstream
- * generics ride on the alias rather than re-evaluating the
- * conditional from scratch.
- */
-type FormOf<Schema extends SupportedRootSchema> = z.input<Schema> extends GenericForm ? z.input<Schema> : never;
-type OutOf<Schema extends SupportedRootSchema> = z.output<Schema> extends GenericForm ? z.output<Schema> : never;
-type ReadOf<Schema extends SupportedRootSchema> = StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never;
 declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
     defaultValues?: AcceptableDefaults<FormOf<Schema>, z.input<Schema>>;

package/dist/shared/attaform.D9RqPgGu.d.mts

@@ -0,0 +1,42 @@
+import { App } from 'vue';
+import { an as RegisterModelDynamicCustomDirective } from './attaform.DZnrDrNb.mjs';
+
+/**
+ * The `v-register` directive. Bind a form field to a native input, select,
+ * textarea, checkbox or radio:
+ *
+ * ```vue
+ * <input v-register="form.register('email')" />
+ * <select v-register="form.register('country')">
+ *   <option value="us">US</option>
+ *   <option value="uk">UK</option>
+ * </select>
+ * ```
+ *
+ * The binding strategy follows the element's `tagName` and `type`. Delivered by
+ * the Vite and Nuxt plugins' compile-time binding, or by
+ * `installVRegister(app)` everywhere else. Most consumers never import it
+ * directly; it is exposed for integrations that wire directives by hand.
+ */
+declare const vRegister: RegisterModelDynamicCustomDirective;
+/**
+ * Register the `v-register` directive app-wide. The one-line setup for an app
+ * whose templates are compiled without Attaform's Vite or Nuxt plugin: a
+ * webpack-family bundler, a no-build page, or runtime-compiled templates.
+ *
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { installVRegister } from 'attaform/directive'
+ *
+ * const app = createApp(App)
+ * installVRegister(app)
+ * ```
+ *
+ * Vite and Nuxt consumers do not call this; their build plugin binds each
+ * template's `v-register` at compile time. Idempotent: a second call for the
+ * same app is a no-op, and a directive the consumer registered under the same
+ * name is left in place.
+ */
+declare function installVRegister(app: App): void;
+
+export { installVRegister as i, vRegister as v };