attaform 0.27.6 → 0.29.0

package/dist/shared/attaform.BGDV42hI.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.DniawQLP.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.BJGA_UOS.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"attaform.BJGA_UOS.mjs","sources":["../../src/runtime/core/canonical-stringify.ts"],"sourcesContent":["/**\n * Canonical stringify for arbitrary values, shared by the v3 and v4\n * schema fingerprint walkers. Produces a stable string surface for\n * structural equality testing: object keys are sorted, arrays walk in\n * index order, and functions / symbols / cycles collapse to opaque\n * sentinels.\n *\n * This is NOT JSON. The output is not meant to round-trip through\n * `JSON.parse`; it exists purely so two structurally-equal values\n * serialise to the same string and two structurally-different values\n * do not.\n *\n * Cycle detection uses an ancestor-stack add / delete pattern: a\n * reference is only treated as cyclic while it sits on the path from\n * the root being stringified. Without the `delete` on the way back up,\n * two sibling properties pointing at the same object would see the\n * second one falsely labelled `<cyclic>`.\n */\nexport function canonicalStringify(value: unknown, seen: WeakSet<object> = new WeakSet()): string {\n  if (value === null) return 'null'\n  if (value === undefined) return 'undefined'\n  const t = typeof value\n  if (t === 'string') return JSON.stringify(value)\n  if (t === 'number' || t === 'boolean') return String(value)\n  if (t === 'bigint') return `${String(value)}n`\n  if (t === 'function') return 'fn:*'\n  if (t === 'symbol') return 'symbol:*'\n  if (Array.isArray(value)) {\n    if (seen.has(value)) return '<cyclic>'\n    seen.add(value)\n    try {\n      const parts = value.map((v) => canonicalStringify(v, seen))\n      return `[${parts.join(',')}]`\n    } finally {\n      seen.delete(value)\n    }\n  }\n  if (t === 'object') {\n    // `null` already returned above, so the remaining `object` branch is\n    // non-null; narrowing against null again is redundant (eslint's\n    // no-unnecessary-condition rule flags it).\n    const obj = value as Record<string, unknown>\n    if (seen.has(obj)) return '<cyclic>'\n    seen.add(obj)\n    try {\n      if (value instanceof Date) return `date:${value.getTime()}`\n      if (value instanceof RegExp) return `regex:${String(value)}`\n      const entries = Object.entries(obj)\n        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n        .map(([k, v]) => `${JSON.stringify(k)}:${canonicalStringify(v, seen)}`)\n      return `{${entries.join(',')}}`\n    } finally {\n      seen.delete(obj)\n    }\n  }\n  return 'unknown'\n}\n"],"names":[],"mappings":"AAkBO,SAAS,kBAAA,CAAmB,KAAA,EAAgB,IAAA,mBAAwB,IAAI,SAAQ,EAAW;AAChG,EAAA,IAAI,KAAA,KAAU,MAAM,OAAO,MAAA;AAC3B,EAAA,IAAI,KAAA,KAAU,QAAW,OAAO,WAAA;AAChC,EAAA,MAAM,IAAI,OAAO,KAAA;AACjB,EAAA,IAAI,CAAA,KAAM,QAAA,EAAU,OAAO,IAAA,CAAK,UAAU,KAAK,CAAA;AAC/C,EAAA,IAAI,MAAM,QAAA,IAAY,CAAA,KAAM,SAAA,EAAW,OAAO,OAAO,KAAK,CAAA;AAC1D,EAAA,IAAI,MAAM,QAAA,EAAU,OAAO,CAAA,EAAG,MAAA,CAAO,KAAK,CAAC,CAAA,CAAA,CAAA;AAC3C,EAAA,IAAI,CAAA,KAAM,YAAY,OAAO,MAAA;AAC7B,EAAA,IAAI,CAAA,KAAM,UAAU,OAAO,UAAA;AAC3B,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,KAAK,CAAA,EAAG,OAAO,UAAA;AAC5B,IAAA,IAAA,CAAK,IAAI,KAAK,CAAA;AACd,IAAA,IAAI;AACF,MAAA,MAAM,KAAA,GAAQ,MAAM,GAAA,CAAI,CAAC,MAAM,kBAAA,CAAmB,CAAA,EAAG,IAAI,CAAC,CAAA;AAC1D,MAAA,OAAO,CAAA,CAAA,EAAI,KAAA,CAAM,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAAA,IAC5B,CAAA,SAAE;AACA,MAAA,IAAA,CAAK,OAAO,KAAK,CAAA;AAAA,IACnB;AAAA,EACF;AACA,EAAA,IAAI,MAAM,QAAA,EAAU;AAIlB,IAAA,MAAM,GAAA,GAAM,KAAA;AACZ,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,EAAG,OAAO,UAAA;AAC1B,IAAA,IAAA,CAAK,IAAI,GAAG,CAAA;AACZ,IAAA,IAAI;AACF,MAAA,IAAI,iBAAiB,IAAA,EAAM,OAAO,CAAA,KAAA,EAAQ,KAAA,CAAM,SAAS,CAAA,CAAA;AACzD,MAAA,IAAI,iBAAiB,MAAA,EAAQ,OAAO,CAAA,MAAA,EAAS,MAAA,CAAO,KAAK,CAAC,CAAA,CAAA;AAC1D,MAAA,MAAM,UAAU,MAAA,CAAO,OAAA,CAAQ,GAAG,CAAA,CAC/B,KAAK,CAAC,CAAC,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA,KAAO,CAAA,GAAI,CAAA,GAAI,KAAK,CAAA,GAAI,CAAA,GAAI,CAAA,GAAI,CAAE,EAC/C,GAAA,CAAI,CAAC,CAAC,CAAA,EAAG,CAAC,CAAA,KAAM,CAAA,EAAG,IAAA,CAAK,SAAA,CAAU,CAAC,CAAC,CAAA,CAAA,EAAI,mBAAmB,CAAA,EAAG,IAAI,CAAC,CAAA,CAAE,CAAA;AACxE,MAAA,OAAO,CAAA,CAAA,EAAI,OAAA,CAAQ,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAAA,IAC9B,CAAA,SAAE;AACA,MAAA,IAAA,CAAK,OAAO,GAAG,CAAA;AAAA,IACjB;AAAA,EACF;AACA,EAAA,OAAO,SAAA;AACT;;;;"}