attaform 0.27.5 → 0.28.0

package/dist/shared/attaform.DRUT703x.d.cts

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-
-/**
- * The Zod v3 schema roots `useForm` accepts. Mirror of the v4
- * `SupportedRootSchema`, expressed in v3's type vocabulary: a
- * fixed-shape `z.object({ … })`, a `z.record(K, V)` dictionary form, or
- * a `z.discriminatedUnion(disc, [...])` variant form.
- *
- * Other roots (a bare `z.union`, a root `z.array`, primitives,
- * `z.map` / `z.set`) are not form roots; wrap them under a key. The
- * adapter's runtime construction rejects them with a legible error.
- *
- * The discriminated-union arm is written with v3's parameter order
- * (`<Discriminator, Options>`), the reverse of v4's; both classes
- * require their arguments, so the arm stays fully applied to avoid the
- * single-major `any`-collapse the v4 alias documents.
- */
-type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord<z.ZodTypeAny, z.ZodTypeAny> | z.ZodDiscriminatedUnion<string, readonly z.ZodDiscriminatedUnionOption<string>[]>;
-
-/**
- * v3 mirror of the Zod v4 `StorageShape`. Per top-level key, default
- * to `z.output<Shape[K]>` (the post-init view — defaults have fired,
- * Zod's own recursion peels nested defaults inside structural
- * containers); fall back to `z.input<Shape[K]>` for transform / pipe
- * carriers (`ZodEffects`, `ZodPipeline`) where storage holds the
- * pre-transform input — transforms only run at submission /
- * validation, not at the write boundary.
- *
- * v3 quirk: `ZodEffects` covers BOTH `.transform()` and
- * `z.preprocess()` at the TS level — v3 doesn't carry a separate
- * preprocess class the way v4 does. Deferring to `z.input` for
- * `ZodEffects` means a top-level `z.preprocess(fn, T)` leaf reads as
- * the preprocess input (commonly `unknown`); reach for the
- * `AbstractSchema` escape hatch if a stronger type is needed.
- * Transforms preserve their pre-transform input shape, which matches
- * storage.
- */
-type StorageShape<S extends z.ZodTypeAny> = S extends z.ZodObject<infer Shape> ? {
-    [K in keyof Shape]-?: Shape[K] extends z.ZodEffects<z.ZodTypeAny> | z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny> ? z.input<Shape[K]> : z.output<Shape[K]>;
-} : z.input<S>;
-
-/**
- * Peel `.optional()` / `.nullable()` / `.default()` / `.refine()` /
- * `.transform()` wrappers off a Zod v3 schema to reach the form root,
- * then return it: a `ZodObject` (fixed-shape form), a `ZodRecord`
- * (dictionary form), or a `ZodDiscriminatedUnion` (variant form).
- * Returns `never` for any other root, which makes the `useForm`
- * projections collapse to `never` so the call fails to typecheck
- * rather than producing a misshapen form type.
- *
- * Used internally by the v3 `useForm` overload to project an arbitrary
- * supported root to its input / output / storage-read shapes.
- */
-type UnwrapZodRoot<T> = T extends z.ZodEffects<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodOptional<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodNullable<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodDefault<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodObject<infer Shape> ? z.ZodObject<Shape> : T extends z.ZodRecord<infer Key, infer Value> ? z.ZodRecord<Key, Value> : T extends z.ZodDiscriminatedUnion<infer Disc, infer Options> ? z.ZodDiscriminatedUnion<Disc, Options> : never;
-
-export type { SupportedRootSchema as S, UnwrapZodRoot as U, StorageShape as a };

package/dist/shared/attaform.DRUT703x.d.ts

@@ -1,56 +0,0 @@
-import { z } from 'zod';
-
-/**
- * The Zod v3 schema roots `useForm` accepts. Mirror of the v4
- * `SupportedRootSchema`, expressed in v3's type vocabulary: a
- * fixed-shape `z.object({ … })`, a `z.record(K, V)` dictionary form, or
- * a `z.discriminatedUnion(disc, [...])` variant form.
- *
- * Other roots (a bare `z.union`, a root `z.array`, primitives,
- * `z.map` / `z.set`) are not form roots; wrap them under a key. The
- * adapter's runtime construction rejects them with a legible error.
- *
- * The discriminated-union arm is written with v3's parameter order
- * (`<Discriminator, Options>`), the reverse of v4's; both classes
- * require their arguments, so the arm stays fully applied to avoid the
- * single-major `any`-collapse the v4 alias documents.
- */
-type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord<z.ZodTypeAny, z.ZodTypeAny> | z.ZodDiscriminatedUnion<string, readonly z.ZodDiscriminatedUnionOption<string>[]>;
-
-/**
- * v3 mirror of the Zod v4 `StorageShape`. Per top-level key, default
- * to `z.output<Shape[K]>` (the post-init view — defaults have fired,
- * Zod's own recursion peels nested defaults inside structural
- * containers); fall back to `z.input<Shape[K]>` for transform / pipe
- * carriers (`ZodEffects`, `ZodPipeline`) where storage holds the
- * pre-transform input — transforms only run at submission /
- * validation, not at the write boundary.
- *
- * v3 quirk: `ZodEffects` covers BOTH `.transform()` and
- * `z.preprocess()` at the TS level — v3 doesn't carry a separate
- * preprocess class the way v4 does. Deferring to `z.input` for
- * `ZodEffects` means a top-level `z.preprocess(fn, T)` leaf reads as
- * the preprocess input (commonly `unknown`); reach for the
- * `AbstractSchema` escape hatch if a stronger type is needed.
- * Transforms preserve their pre-transform input shape, which matches
- * storage.
- */
-type StorageShape<S extends z.ZodTypeAny> = S extends z.ZodObject<infer Shape> ? {
-    [K in keyof Shape]-?: Shape[K] extends z.ZodEffects<z.ZodTypeAny> | z.ZodPipeline<z.ZodTypeAny, z.ZodTypeAny> ? z.input<Shape[K]> : z.output<Shape[K]>;
-} : z.input<S>;
-
-/**
- * Peel `.optional()` / `.nullable()` / `.default()` / `.refine()` /
- * `.transform()` wrappers off a Zod v3 schema to reach the form root,
- * then return it: a `ZodObject` (fixed-shape form), a `ZodRecord`
- * (dictionary form), or a `ZodDiscriminatedUnion` (variant form).
- * Returns `never` for any other root, which makes the `useForm`
- * projections collapse to `never` so the call fails to typecheck
- * rather than producing a misshapen form type.
- *
- * Used internally by the v3 `useForm` overload to project an arbitrary
- * supported root to its input / output / storage-read shapes.
- */
-type UnwrapZodRoot<T> = T extends z.ZodEffects<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodOptional<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodNullable<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodDefault<infer Inner> ? UnwrapZodRoot<Inner> : T extends z.ZodObject<infer Shape> ? z.ZodObject<Shape> : T extends z.ZodRecord<infer Key, infer Value> ? z.ZodRecord<Key, Value> : T extends z.ZodDiscriminatedUnion<infer Disc, infer Options> ? z.ZodDiscriminatedUnion<Disc, Options> : never;
-
-export type { SupportedRootSchema as S, UnwrapZodRoot as U, StorageShape as a };

package/dist/shared/attaform.DYwyM5Cp.d.cts

@@ -1,232 +0,0 @@
-import { z } from 'zod';
-import { G as GenericForm, s as FlatPath, B as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ae as ValidateOnConfig, a as UseFormReturnType } from './attaform.CzL2CZ8U.cjs';
-
-/**
- * The Zod v4 schema roots `useForm` accepts. A fixed-shape
- * `z.object({ … })` is the common case; `z.record(K, V)` admits a
- * dictionary form (a homogeneous map with runtime-known keys);
- * `z.discriminatedUnion(disc, [...])` admits a variant form (one of
- * several object shapes, picked by a discriminator). Each projects to
- * a `GenericForm`-shaped value the form engine drives: an object root
- * descends into its fixed keys, a record root treats its entries as an
- * open live-keyed container, a variant root lifts the active variant's
- * keys into one addressable surface.
- *
- * Other roots (a bare `z.union`, a root `z.array`, primitives,
- * `z.map` / `z.set`) are not form roots; wrap them under a key. The
- * adapter's runtime construction rejects them with a legible error.
- *
- * `z.ZodObject` MUST keep its `z.ZodRawShape` argument, and the
- * discriminated-union arm MUST stay fully applied. The unified entry's
- * v4 overload constrains on `SupportedRootSchema & ZodV4Internals` to
- * keep v3 schemas out (see `../unified/types-zod-major.ts`). In a
- * single-major (v3-only) consumer install, the published `.d.mts`
- * resolves this `z` to v3, where a bare or under-applied Zod class is
- * missing its required arguments and degrades to an `any`-like error
- * type; `any` then absorbs the union and `any & ZodV4Internals`
- * collapses back to `any`, so the marker stops excluding v3 schemas and
- * the read slot poisons to `never`. `z.ZodRecord` carries defaults for
- * both arguments, so it stays concrete in either major.
- * `z.ZodDiscriminatedUnion` does NOT (v3 requires both arguments, and
- * its parameter order is the reverse of v4's), so the arm is written
- * fully applied; the v3-only bundled-types fixture guards it.
- */
-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 `validateAsync` — 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
- *    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`,
- *    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.
- */
-type StorageShape<S> = S extends {
-    _zod: {
-        def: {
-            type: 'object';
-            shape: infer Shape;
-        };
-    };
-} ? {
-    [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.
- */
-type InputIsUnknown<L> = L extends {
-    _zod: {
-        input: infer In;
-    };
-} ? 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.
- */
-type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
-    _zod: {
-        def: {
-            type: 'pipe';
-            in: infer A;
-            out: infer B;
-        };
-    };
-} ? B extends {
-    _zod: {
-        def: {
-            type: 'transform';
-        };
-    };
-} ? StorageShape<A> : L extends {
-    _zod: {
-        output: infer Out;
-    };
-} ? Out : never : L extends {
-    _zod: {
-        def: {
-            type: 'transform';
-        };
-    };
-} ? L extends {
-    _zod: {
-        input: infer In;
-    };
-} ? In : never : L extends {
-    _zod: {
-        output: infer Out;
-    };
-} ? Out : never;
-
-/**
- * Zod v4 adapter entry point. Re-exports the adapter + the useForm
- * wrapper that threads zod-v4-specific schema types through
- * useAbstractForm.
- */
-
-/**
- * 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).
- *
- * ```ts
- * const schema = z.object({
- *   flag: z.string().transform((v) => v.length > 10),
- * })
- * type FlagWriteIn = PathInput<typeof schema, 'flag'> // string
- * ```
- */
-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.
- *
- * ```ts
- * const schema = z.object({
- *   flag: z.string().transform((v) => v.length > 10),
- * })
- * type FlagParsedOut = PathOutput<typeof schema, 'flag'> // boolean
- * ```
- */
-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;
-/**
- * Create a form bound to a Zod v4 schema.
- *
- * ```ts
- * 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: '' },
- * })
- * ```
- *
- * Returns a form API exposing `register`, `values`, `errors`,
- * `fields`, `setValue`, `handleSubmit`, `meta`, field-array
- * helpers, and more. See `UseFormReturnType` for the full
- * surface.
- *
- * For Zod v3, import from `attaform/zod-v3` instead.
- */
-/**
- * `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>>;
-} & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
-
-export { useForm as u };
-export type { PathInput as P, SupportedRootSchema as S, PathOutput as a, StorageShape as b };

package/dist/shared/attaform.Dc1mx48r.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"attaform.Dc1mx48r.mjs","sources":["../../src/runtime/core/zod-shape.ts","../../src/runtime/adapters/unified/use-form.ts","../../src/runtime/adapters/unified/field-meta.ts"],"sourcesContent":["/**\n * Shape detectors for Zod schemas. Used by the unified `attaform/zod`\n * entry's runtime dispatch (`runtime/adapters/unified/use-form.ts`)\n * to route to the v3 or v4 adapter based on the schema's runtime\n * shape. Mirrors the discrimination already used by the v4\n * introspection helper (`adapters/zod-v4/introspect.ts`'s\n * `assertZodVersion`, which reads `def.type`) and the v3 wrapper's\n * legitimate-input branch (`composables/use-form.ts`'s `isZodType`,\n * which reads `_def`).\n *\n * Why this discriminator and not `_zod` / `_def`:\n * - Zod v4 retained `_def` for backward compat — reading `_def` alone\n *   misclassifies v4 schemas as v3.\n * - Zod v4's stable shape is `def.type: string` (lowercase tag like\n *   `'object'`); Zod v3's is `_def.typeName: string` (capitalised tag\n *   like `'ZodObject'`). Both are checked structurally so consumers\n *   who alias one Zod major to a non-standard import path still work.\n */\n\ninterface ZodV4Shape {\n  def: { type: unknown }\n}\n\ninterface ZodV3Shape {\n  _def: { typeName: unknown }\n}\n\n/**\n * Returns true when `value` looks like a Zod schema of either major\n * version. Convenience wrapper around the v3 / v4 detectors.\n */\nexport function isZodSchemaShape(value: unknown): boolean {\n  return isZodV4SchemaShape(value) || isZodV3SchemaShape(value)\n}\n\n/**\n * Returns true when `value` looks like a Zod v4 schema (has\n * `def.type: string`). Used by the unified entry's runtime-dispatch\n * to route to the v4 adapter.\n */\nexport function isZodV4SchemaShape(value: unknown): value is ZodV4Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { def?: unknown }).def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { type?: unknown }).type === 'string'\n}\n\n/**\n * Returns true when `value` looks like a Zod v3 schema (has\n * `_def.typeName: string`). Kept distinct from `isZodV4SchemaShape`\n * because some v4 schemas also expose `_def` for backward compat —\n * the v4 detector wins first in `isZodSchemaShape`.\n */\nexport function isZodV3SchemaShape(value: unknown): value is ZodV3Shape {\n  if (typeof value !== 'object' || value === null) return false\n  const def = (value as { _def?: unknown })._def\n  if (typeof def !== 'object' || def === null) return false\n  return typeof (def as { typeName?: unknown }).typeName === 'string'\n}\n","/**\n * Unified `useForm` for the `attaform/zod` entry. Runtime-dispatches\n * on schema shape: a Zod v4 schema (`def.type` truthy) routes to the\n * v4 adapter; a Zod v3 schema (or any other `AbstractSchema`) routes\n * to the v3 wrapper, which already accepts both Zod v3 input and\n * `AbstractSchema` directly via its built-in shape branch.\n *\n * Type-level dispatch happens via TWO typed overloads — v4 first, v3\n * second — plus an untyped impl. Each overload mirrors the matching\n * direct adapter's signature exactly, so a v4-schema call site pays\n * the same per-call depth cost as importing from `attaform/zod-v4`\n * directly. Overload resolution at concrete call sites commits to one\n * overload immediately on argument shape — no type-level dispatch tax.\n *\n * Tests and other call sites that need the equivalent of\n * `typeof useForm<X>` should reach for the `UseFormReturn<X>` /\n * `UseFormConfig<X>` helpers in `types-api.ts` — instantiation\n * expressions on overloaded functions follow brittle resolution rules,\n * and the helper types give a deterministic projection.\n *\n * This module is the FALLBACK path. Vite consumers see the\n * `attaform/vite` plugin's `resolveId` hook rewrite `attaform/zod`\n * imports to either `attaform/zod-v3` or `attaform/zod-v4` at build\n * time — in that case this dispatch never runs and the consumer\n * bundle ships only the matching adapter. Other bundlers (and\n * non-bundled ESM consumption) hit this dispatch instead, paying a\n * modest size cost for the convenience of a single hello-world import.\n *\n * Power users who want a guaranteed lean bundle on non-Vite tooling\n * can import directly from `attaform/zod-v3` or `attaform/zod-v4` —\n * those subpaths are never rewritten and never load the other\n * adapter.\n */\nimport { InvalidUseFormConfigError } from '../../core/errors'\nimport { isZodV4SchemaShape } from '../../core/zod-shape'\nimport type { ZodV4Internals } from './types-zod-major'\nimport { useForm as useFormV3 } from '../../composables/use-form'\nimport { useForm as useFormV4 } from '../zod-v4'\nimport type {\n  AbstractSchema,\n  FormKey,\n  ValidateOnConfig,\n  UseFormReturnType,\n  UseFormConfiguration,\n} from '../../types/types-api'\nimport type { AcceptableDefaults } from '../../types/types-core'\nimport type { SupportedRootSchema as SupportedRootSchemaV4 } from '../zod-v4/types-root'\nimport type { SupportedRootSchema as SupportedRootSchemaV3 } from '../zod-v3/types-root'\nimport type {\n  V3FormOf,\n  V3OutOf,\n  V3ReadOf,\n  V3SchemaInput,\n  V4FormOf,\n  V4OutOf,\n  V4ReadOf,\n  V4SchemaInput,\n} from './types-projections'\n\n/**\n * Create a form bound to a Zod v4 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * The constraint intersects `ZodV4Internals` (the v4-only `_zod`\n * brand) so a v3 schema can't bind this overload even when `z`\n * resolves to v3 in a single-major consumer install; v3 schemas fall\n * through to the v3 overload below. See `types-zod-major.ts`.\n */\nexport function useForm<\n  Schema extends SupportedRootSchemaV4 & ZodV4Internals,\n  K extends FormKey = FormKey,\n>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V4FormOf<Schema>,\n      V4OutOf<Schema>,\n      AbstractSchema<V4FormOf<Schema>, V4OutOf<Schema>>,\n      // `defaultValues` is Omitted below and re-supplied via the\n      // `AcceptableDefaults` intersection, so this `DefaultValues` slot is\n      // inert. `never` keeps it from re-instantiating the deep\n      // `DefaultValuesInput` cascade here — that redundant instantiation,\n      // across both overloads at a concrete call site, tips the bundled\n      // `.d.ts` into TS2589.\n      never,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'\n  > & {\n    schema: Schema\n    // #422: the `AcceptableDefaults` slot adds the schema's own input\n    // (`V4SchemaInput<Schema>`) as a reflexive escape arm so a generic form\n    // wrapper forwarding `defaultValues` does not trip TS2589 / TS2769.\n    // The arm is redundant at concrete call sites (a schema's input is a\n    // subset of its `DefaultValuesInput`), so concrete checking is\n    // unchanged. The return type never references the slot, so field\n    // inference is preserved through the wrapper. See `AcceptableDefaults`.\n    defaultValues?: AcceptableDefaults<V4FormOf<Schema>, V4SchemaInput<Schema>>\n  } & ValidateOnConfig\n): UseFormReturnType<V4FormOf<Schema>, V4OutOf<Schema>, V4ReadOf<Schema>, K>\n/**\n * Create a form bound to a Zod v3 schema.\n *\n * ```ts\n * import { useForm } from 'attaform/zod'\n * import { z } from 'zod-v3'\n *\n * const form = useForm({\n *   schema: z.object({\n *     username: z.string().min(2, 'At least 2 characters'),\n *     password: z.string().min(8, 'At least 8 characters'),\n *   }),\n * })\n * ```\n *\n * v3 schemas match this overload; v4 schemas hit the v4 overload\n * above first and never reach here.\n */\nexport function useForm<Schema extends SupportedRootSchemaV3, K extends FormKey = FormKey>(\n  configuration: Omit<\n    UseFormConfiguration<\n      V3FormOf<Schema>,\n      V3OutOf<Schema>,\n      AbstractSchema<V3FormOf<Schema>, V3OutOf<Schema>>,\n      // Inert `DefaultValues` slot — see the v4 overload above.\n      never,\n      K\n    >,\n    'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'\n  > & {\n    schema: Schema\n    // #422 — see the v4 overload above for the escape-arm rationale.\n    defaultValues?: AcceptableDefaults<V3FormOf<Schema>, V3SchemaInput<Schema>>\n  } & ValidateOnConfig\n): UseFormReturnType<V3FormOf<Schema>, V3OutOf<Schema>, V3ReadOf<Schema>, K>\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useForm(configuration: any): any {\n  if (\n    configuration === undefined ||\n    configuration === null ||\n    (configuration as { schema?: unknown }).schema === undefined\n  ) {\n    throw new InvalidUseFormConfigError()\n  }\n  const { schema } = configuration as { schema: unknown }\n  if (isZodV4SchemaShape(schema)) {\n    return useFormV4(configuration as Parameters<typeof useFormV4>[0])\n  }\n  return useFormV3(configuration as Parameters<typeof useFormV3>[0])\n}\n","/**\n * Field-metadata write/read API for the unified `attaform/zod` entry.\n *\n * Storage is shared with both adapters via `field-meta-store` — a\n * payload written here is visible to whichever adapter the unified\n * `useForm` dispatches to at runtime, regardless of Zod major. No\n * `zod` runtime import; the type-only `import type` is erased at\n * build, so `attaform/zod` carries no `z.registry` reference even\n * when consumed by a Zod 3 project without the Vite plugin alias.\n *\n * The native v4 chain `schema.register(fieldMeta, payload)` continues\n * to work — Zod 4's `.register()` only calls `.add(this, payload)`\n * structurally, satisfied by the shared store.\n */\nimport type { z } from 'zod'\nimport type { FieldMetaPayload } from '../../core/field-meta'\nimport { fieldMetaStore, getFieldMetaForSchema } from '../../core/field-meta-store'\n\n// Zod v4's `$ZodRegistry` class isn't surfaced under the `z` namespace\n// of the classic external entry, but `z.registry()` returns one — so\n// `ReturnType<typeof z.registry<T>>` resolves to the registry type\n// without needing a direct import. The `import type` keeps the\n// reference type-only; nothing about `z.registry` lands in the bundle.\ntype ZodFieldMetaRegistry = ReturnType<typeof z.registry<FieldMetaPayload>>\n\n/**\n * The shared registry every Attaform-aware Zod schema can register\n * field metadata against, regardless of major. Same instance the v3\n * and v4 adapter entries expose — write in one place, read from\n * any.\n *\n * Cast to Zod 4's `$ZodRegistry<FieldMetaPayload>` so the native\n * `schema.register(fieldMeta, payload)` chain type-checks for v4\n * users; the runtime call only needs `.add` structurally, which the\n * shared store provides.\n */\nexport const fieldMeta = fieldMetaStore as unknown as ZodFieldMetaRegistry\n\n/**\n * Attach `payload` to `schema` in the shared registry and return a\n * clone of `schema` so each call gets its own identity (the registry\n * keys on schema reference, so cloning prevents last-write-wins\n * collisions for sub-schemas reused at multiple paths).\n *\n * Works on both Zod 3 and Zod 4 schemas — branches on the runtime\n * shape of the schema:\n * - Zod 4 schemas expose a public `.clone()` method; we call it.\n * - Zod 3 schemas don't, so we reconstruct via\n *   `new schema.constructor(schema._def)`.\n *\n * Both forms produce a fresh schema with the same effective\n * structure, so the registry slot is unique to this call site.\n */\nexport function withMeta<S>(schema: S, payload: FieldMetaPayload): S {\n  const target = schema as object\n  const existing = getFieldMetaForSchema(target) ?? {}\n  const cloned = cloneSchema(schema)\n  fieldMetaStore.add(cloned as object, { ...existing, ...payload })\n  return cloned\n}\n\nfunction cloneSchema<S>(schema: S): S {\n  const candidate = schema as { clone?: unknown; constructor: unknown; _def: unknown }\n  if (typeof candidate.clone === 'function') {\n    return (candidate.clone as () => S)()\n  }\n  // Zod 3 path: reconstruct via constructor + _def (no public\n  // `.clone()` on v3).\n  const Ctor = candidate.constructor as new (def: unknown) => S\n  return new Ctor(candidate._def)\n}\n"],"names":["useFormV4","useFormV3"],"mappings":";;;;;AAwCO,SAAS,mBAAmB,KAAA,EAAqC;AACtE,EAAA,IAAI,OAAO,KAAA,KAAU,QAAA,IAAY,KAAA,KAAU,MAAM,OAAO,KAAA;AACxD,EAAA,MAAM,MAAO,KAAA,CAA4B,GAAA;AACzC,EAAA,IAAI,OAAO,GAAA,KAAQ,QAAA,IAAY,GAAA,KAAQ,MAAM,OAAO,KAAA;AACpD,EAAA,OAAO,OAAQ,IAA2B,IAAA,KAAS,QAAA;AACrD;;ACqGO,SAAS,QAAQ,aAAA,EAAyB;AAC/C,EAAA,IACE,kBAAkB,MAAA,IAClB,aAAA,KAAkB,IAAA,IACjB,aAAA,CAAuC,WAAW,MAAA,EACnD;AACA,IAAA,MAAM,IAAI,yBAAA,EAA0B;AAAA,EACtC;AACA,EAAA,MAAM,EAAE,QAAO,GAAI,aAAA;AACnB,EAAA,IAAI,kBAAA,CAAmB,MAAM,CAAA,EAAG;AAC9B,IAAA,OAAOA,UAAU,aAAgD,CAAA;AAAA,EACnE;AACA,EAAA,OAAOC,UAAU,aAAgD,CAAA;AACnE;;AC3HO,MAAM,SAAA,GAAY;AAiBlB,SAAS,QAAA,CAAY,QAAW,OAAA,EAA8B;AACnE,EAAA,MAAM,MAAA,GAAS,MAAA;AACf,EAAA,MAAM,QAAA,GAAW,qBAAA,CAAsB,MAAM,CAAA,IAAK,EAAC;AACnD,EAAA,MAAM,MAAA,GAAS,YAAY,MAAM,CAAA;AACjC,EAAA,cAAA,CAAe,IAAI,MAAA,EAAkB,EAAE,GAAG,QAAA,EAAU,GAAG,SAAS,CAAA;AAChE,EAAA,OAAO,MAAA;AACT;AAEA,SAAS,YAAe,MAAA,EAAc;AACpC,EAAA,MAAM,SAAA,GAAY,MAAA;AAClB,EAAA,IAAI,OAAO,SAAA,CAAU,KAAA,KAAU,UAAA,EAAY;AACzC,IAAA,OAAQ,UAAU,KAAA,EAAkB;AAAA,EACtC;AAGA,EAAA,MAAM,OAAO,SAAA,CAAU,WAAA;AACvB,EAAA,OAAO,IAAI,IAAA,CAAK,SAAA,CAAU,IAAI,CAAA;AAChC;;;;"}

package/dist/shared/attaform.DhnPb6nK.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"attaform.DhnPb6nK.mjs","sources":["../../src/core/detect-zod-major.ts"],"sourcesContent":["/**\n * Shared build-time Zod-major detection and adapter-alias resolution for\n * the bundler plugins (`attaform/vite`, `attaform/rollup`,\n * `attaform/esbuild`, `attaform/webpack`, `attaform/rspack`).\n *\n * The unified `attaform/zod` entry — and the bare `attaform` barrel, which\n * re-exports the identical surface — runtime-dispatches between the v3 and\n * v4 adapters, so a bundler that does not rewrite the import ships BOTH.\n * Each plugin rewrites those two specifiers (see\n * {@link REWRITABLE_ZOD_SPECIFIER_FILTER}) to the single matching adapter\n * subpath (`attaform/zod-v3` or `attaform/zod-v4`) based on the Zod major\n * resolved from the consumer's project, so the consumer bundle carries\n * one adapter instead of two. This module holds the detection (pure Node,\n * no bundler API) plus the shared diagnostic copy so every plugin behaves\n * and reads identically.\n *\n * Build-time only: imported by the build-tool entries at `src/*.ts`,\n * never by runtime code, so it never reaches a consumer's browser bundle.\n */\nimport { readFileSync } from 'node:fs'\nimport { fileURLToPath, pathToFileURL } from 'node:url'\nimport { join } from 'node:path'\n\nexport const ZOD_UNIFIED_SPECIFIER = 'attaform/zod'\nexport const ZOD_V3_SPECIFIER = 'attaform/zod-v3'\nexport const ZOD_V4_SPECIFIER = 'attaform/zod-v4'\nexport const ZOD_BARREL_SPECIFIER = 'attaform'\n\n/**\n * The two specifiers a plugin collapses to a single adapter: the explicit\n * unified `attaform/zod` entry AND the bare `attaform` barrel. Both are\n * structurally identical (the barrel re-exports the same\n * `_shared-exports` + `_zod-binding` surface as `attaform/zod`), so both\n * carry the runtime-dispatching `useForm` that pulls in BOTH adapters —\n * and both rewrite to the same single adapter when one Zod major is\n * detected.\n *\n * The rewrite is value-safe: every runtime binding the barrel exports\n * (`useForm`, `fieldMeta`, `withMeta`, plus everything in\n * `_shared-exports`) is also exported by `attaform/zod-v3` and\n * `attaform/zod-v4`, so redirecting bare `attaform` to a pinned adapter\n * can never strand a runtime import. (Type-only exports are erased before\n * this resolve hook runs and are type-checked against the un-rewritten\n * `attaform` specifier, so their per-adapter asymmetry is irrelevant.)\n *\n * The pattern is anchored (`^...$`) so it matches ONLY those two\n * specifiers: the pinned adapters (`attaform/zod-v3`, `attaform/zod-v4`)\n * and every build-tool / other subpath (`attaform/nuxt`, `attaform/vite`,\n * `attaform/abstract`, `attaform/transforms`, ...) pass through untouched.\n * It serves double duty — as esbuild's `onResolve` `filter` (a Go RE2\n * regexp) and, via `.test()`, as the string-match predicate the other\n * plugins call — so the two representations can never diverge.\n */\nexport const REWRITABLE_ZOD_SPECIFIER_FILTER = /^attaform(?:\\/zod)?$/\n\n/**\n * True when `source` is a specifier the plugins rewrite to a single Zod\n * adapter: the bare `attaform` barrel or the explicit `attaform/zod`.\n * Backed by {@link REWRITABLE_ZOD_SPECIFIER_FILTER} so it stays in lockstep\n * with esbuild's filter.\n */\nexport function isRewritableZodSpecifier(source: string): boolean {\n  return REWRITABLE_ZOD_SPECIFIER_FILTER.test(source)\n}\n\nexport type ZodMajorDetection =\n  | { major: 3 }\n  | { major: 4 }\n  | { major: 'missing' }\n  | { major: 'unknown' }\n\n/**\n * Read the consumer's installed Zod major by resolving\n * `zod/package.json` from their project root. ESM resolution\n * (`import.meta.resolve`) is sync and stable on Node 20.6+, follows\n * pnpm symlinks, and works with attaform's ESM-only `exports` map.\n *\n * Returns:\n *  - `{ major: 3 | 4 }` when zod is resolvable AND its `version`\n *    field parses to a known major;\n *  - `{ major: 'missing' }` when zod can't be resolved at all;\n *  - `{ major: 'unknown' }` for any other failure (corrupted\n *    package.json, unexpected version string, monorepo edge case).\n */\nexport function detectZodMajor(consumerRootDir: string): ZodMajorDetection {\n  const consumerURL = pathToFileURL(join(consumerRootDir, 'package.json')).href\n  let resolved: string\n  try {\n    resolved = import.meta.resolve('zod/package.json', consumerURL)\n  } catch {\n    return { major: 'missing' }\n  }\n  try {\n    const pkg = JSON.parse(readFileSync(fileURLToPath(resolved), 'utf8')) as { version?: unknown }\n    const version = pkg.version\n    if (typeof version !== 'string') return { major: 'unknown' }\n    const major = Number.parseInt(version.split('.')[0] ?? '', 10)\n    if (major === 3) return { major: 3 }\n    if (major === 4) return { major: 4 }\n    return { major: 'unknown' }\n  } catch {\n    return { major: 'unknown' }\n  }\n}\n\n/**\n * One-shot latch so a plugin warns about an unclassifiable Zod version\n * only once, however many times its detection runs across a build.\n */\nexport interface ZodDetectionWarnState {\n  warned: boolean\n}\n\nfunction missingZodError(tag: string): string {\n  return (\n    `[${tag}] zod is not installed. attaform requires zod as a peer dependency. ` +\n    'Install `zod@^3` or `zod@^4`, OR pass `attaform({ resolveZodAlias: false })` ' +\n    'to keep the runtime-dispatch unified entry (and silence this check).'\n  )\n}\n\nfunction unclassifiableZodWarning(tag: string): string {\n  return (\n    `[${tag}] Could not classify the installed Zod major (corrupted package.json, ` +\n    'monorepo edge case, or an unexpected version string). Falling through to runtime ' +\n    'dispatch — both Zod adapters will ship in the bundle. ' +\n    'Pass `attaform({ resolveZodAlias: false })` to silence this warning.'\n  )\n}\n\n/**\n * Resolve the rewrite target for the unified `attaform/zod` specifier,\n * shared by every bundler plugin so they diagnose identically:\n *   - returns `attaform/zod-v3` / `attaform/zod-v4` when the consumer's\n *     Zod major is detected;\n *   - returns `null` to leave `attaform/zod` on its runtime-dispatch\n *     entry, either because `resolveZodAlias` is off or because the\n *     version could not be classified (warned once via `warnState`);\n *   - throws when zod is not installed at all, a fatal misconfiguration\n *     the consumer must fix.\n *\n * `tag` brands the diagnostics (`attaform/vite`, `attaform/rollup`, etc).\n * `resolveZodAlias` and `warnState` are supplied by the calling plugin:\n * its consumer-facing default and its per-instance warn latch live at the\n * plugin surface, not here.\n */\nexport function resolveZodAliasTarget(\n  consumerRootDir: string,\n  tag: string,\n  resolveZodAlias: boolean,\n  warnState: ZodDetectionWarnState\n): string | null {\n  if (!resolveZodAlias) return null\n  const detection = detectZodMajor(consumerRootDir)\n  if (detection.major === 'missing') {\n    throw new Error(missingZodError(tag))\n  }\n  if (detection.major === 'unknown') {\n    if (!warnState.warned) {\n      warnState.warned = true\n      console.warn(unclassifiableZodWarning(tag))\n    }\n    return null\n  }\n  return detection.major === 4 ? ZOD_V4_SPECIFIER : ZOD_V3_SPECIFIER\n}\n"],"names":[],"mappings":";;;;AAwBO,MAAM,gBAAA,GAAmB,iBAAA;AACzB,MAAM,gBAAA,GAAmB,iBAAA;AA4BzB,MAAM,+BAAA,GAAkC;AAQxC,SAAS,yBAAyB,MAAA,EAAyB;AAChE,EAAA,OAAO,+BAAA,CAAgC,KAAK,MAAM,CAAA;AACpD;AAqBO,SAAS,eAAe,eAAA,EAA4C;AACzE,EAAA,MAAM,cAAc,aAAA,CAAc,IAAA,CAAK,eAAA,EAAiB,cAAc,CAAC,CAAA,CAAE,IAAA;AACzE,EAAA,IAAI,QAAA;AACJ,EAAA,IAAI;AACF,IAAA,QAAA,GAAW,MAAA,CAAA,IAAA,CAAY,OAAA,CAAQ,kBAAA,EAAoB,WAAW,CAAA;AAAA,EAChE,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,EAAE,OAAO,SAAA,EAAU;AAAA,EAC5B;AACA,EAAA,IAAI;AACF,IAAA,MAAM,GAAA,GAAM,KAAK,KAAA,CAAM,YAAA,CAAa,cAAc,QAAQ,CAAA,EAAG,MAAM,CAAC,CAAA;AACpE,IAAA,MAAM,UAAU,GAAA,CAAI,OAAA;AACpB,IAAA,IAAI,OAAO,OAAA,KAAY,QAAA,EAAU,OAAO,EAAE,OAAO,SAAA,EAAU;AAC3D,IAAA,MAAM,KAAA,GAAQ,MAAA,CAAO,QAAA,CAAS,OAAA,CAAQ,KAAA,CAAM,GAAG,CAAA,CAAE,CAAC,CAAA,IAAK,EAAA,EAAI,EAAE,CAAA;AAC7D,IAAA,IAAI,KAAA,KAAU,CAAA,EAAG,OAAO,EAAE,OAAO,CAAA,EAAE;AACnC,IAAA,IAAI,KAAA,KAAU,CAAA,EAAG,OAAO,EAAE,OAAO,CAAA,EAAE;AACnC,IAAA,OAAO,EAAE,OAAO,SAAA,EAAU;AAAA,EAC5B,CAAA,CAAA,MAAQ;AACN,IAAA,OAAO,EAAE,OAAO,SAAA,EAAU;AAAA,EAC5B;AACF;AAUA,SAAS,gBAAgB,GAAA,EAAqB;AAC5C,EAAA,OACE,IAAI,GAAG,CAAA,2NAAA,CAAA;AAIX;AAEA,SAAS,yBAAyB,GAAA,EAAqB;AACrD,EAAA,OACE,IAAI,GAAG,CAAA,wRAAA,CAAA;AAKX;AAkBO,SAAS,qBAAA,CACd,eAAA,EACA,GAAA,EACA,eAAA,EACA,SAAA,EACe;AACf,EAAA,IAAI,CAAC,iBAAiB,OAAO,IAAA;AAC7B,EAAA,MAAM,SAAA,GAAY,eAAe,eAAe,CAAA;AAChD,EAAA,IAAI,SAAA,CAAU,UAAU,SAAA,EAAW;AACjC,IAAA,MAAM,IAAI,KAAA,CAAM,eAAA,CAAgB,GAAG,CAAC,CAAA;AAAA,EACtC;AACA,EAAA,IAAI,SAAA,CAAU,UAAU,SAAA,EAAW;AACjC,IAAA,IAAI,CAAC,UAAU,MAAA,EAAQ;AACrB,MAAA,SAAA,CAAU,MAAA,GAAS,IAAA;AACnB,MAAA,OAAA,CAAQ,IAAA,CAAK,wBAAA,CAAyB,GAAG,CAAC,CAAA;AAAA,IAC5C;AACA,IAAA,OAAO,IAAA;AAAA,EACT;AACA,EAAA,OAAO,SAAA,CAAU,KAAA,KAAU,CAAA,GAAI,gBAAA,GAAmB,gBAAA;AACpD;;;;"}