attaform 0.17.0 → 0.17.2

package/dist/shared/attaform.CuE-bS1C.d.mts

@@ -0,0 +1,165 @@
+import { z } from 'zod';
+import { G as GenericForm, s as FlatPath, B as NestedType, U as UseFormConfiguration, b as AbstractSchema, D as DeepPartial, c as DefaultValuesShape, ag as ValidateOnConfig, d as UseFormReturnType } from './attaform.C_5aB6EQ.mjs';
+
+/**
+ * The shape `form.values.<key>` returns at runtime.
+ *
+ * Per leaf:
+ *
+ * 1. `z.preprocess(fn, inner)` — compiles to `ZodPipe<ZodTransform, inner>`.
+ *    The preprocess fn fires at the write boundary (synthesized into
+ *    `setValue`), so storage holds whatever `inner` stores. Recurse
+ *    `StorageShape` on `inner` so a defaulted leaf inside `inner` still
+ *    reads `T` (not `T | undefined`).
+ *
+ * 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` for the same reason.
+ *
+ *    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.
+ *
+ * Recursion: the alias calls itself on the non-transform side of a
+ * pipe so the inner shape gets the same per-key storage treatment as
+ * the top level. Without it, an inner `.default(...)` inside a
+ * transformed object would peel back to `T | undefined` (the broad
+ * input contract). Recursion only fires for pipe leaves — most leaves
+ * skip it.
+ *
+ * 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>;
+type StorageLeaf<L> = L extends {
+    _zod: {
+        def: {
+            type: 'pipe';
+            in: infer A;
+            out: infer B;
+        };
+    };
+} ? A extends {
+    _zod: {
+        def: {
+            type: 'transform';
+        };
+    };
+} ? StorageShape<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.process()` 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.
+ */
+declare function useForm<Schema extends z.ZodObject>(configuration: Omit<UseFormConfiguration<z.input<Schema> extends GenericForm ? z.input<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never, AbstractSchema<z.input<Schema> extends GenericForm ? z.input<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never>, DeepPartial<DefaultValuesShape<z.input<Schema> extends GenericForm ? z.input<Schema> : never>>>, 'schema' | 'validateOn' | 'debounceMs'> & {
+    schema: Schema;
+} & ValidateOnConfig): UseFormReturnType<z.input<Schema> extends GenericForm ? z.input<Schema> : never, z.output<Schema> extends GenericForm ? z.output<Schema> : never, StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never>;
+
+export { useForm as u };
+export type { PathInput as P, StorageShape as S, PathOutput as a };

package/dist/shared/{attaform.D6Q5ZP8L.mjs → attaform.Drt6fivF.mjs}

@@ -1,6 +1,6 @@
 import { merge, set, isFunction, cloneDeep } from 'lodash-es';
 import { z } from 'zod';
-import { g as getAtPath, s as slimKindOf, A as AttaformErrorCode, h as humanize, e as useAbstractForm } from './attaform.BT55rDNN.mjs';
+import { g as getAtPath, s as slimKindOf, A as AttaformErrorCode, h as humanize, e as useAbstractForm } from './attaform.B3ZaPIzS.mjs';
 import { c as canonicalizePath } from './attaform.h1sq3BFu.mjs';
 import { f as fieldMetaStore, g as getFieldMetaForSchema } from './attaform.D13GMFgK.mjs';
 import { a as AttaformError, _ as __DEV__, b as InvalidUseFormConfigError } from './attaform.CIEQgJnM.mjs';
@@ -651,6 +651,14 @@ function zodAdapter(zodSchema) {
         const peeled = unwrapStructuralLeafV3(leaf);
         return getDefaultValuesFromZodSchema(peeled, true, _formKey);
       },
+      getEmptyValueAtPath(path) {
+        if (path.length === 0) {
+          return getDefaultValuesFromZodSchema(_zodSchema, false, _formKey);
+        }
+        const leaf = walkV3ToLeafSchema(_zodSchema, path);
+        if (!leaf) return void 0;
+        return getDefaultValuesFromZodSchema(leaf, false, _formKey);
+      },
       arrayShapeAtPath(path) {
         if (path.length === 0) return void 0;
         const leaf = walkV3ToLeafSchema(_zodSchema, path);
@@ -1569,16 +1577,20 @@ function useForm(configuration) {
   const abstractSchema = isZodType(schema) ? zodAdapter(schema) : schema;
   return useAbstractForm({
     ...configuration,
-    // The v3 adapter widens the read-side type through
-    // `TypeWithNullableDynamicKeys<Schema>` (records/arrays/DUs get
-    // `| undefined` markers); useAbstractForm's parameter expects the
-    // exact `GetValueFormType` (defaults to `Form`). The runtime
-    // accepts the widened shape unchanged — cast across the gap so
-    // the structural disagreement doesn't reach the caller.
+    // `zodAdapter`'s constraint on its third generic is
+    // `GetValueFormType extends TypeWithNullableDynamicKeys<FormSchema>`,
+    // and `Schema` at this implementation overload is only constrained
+    // by `extends z.ZodSchema<unknown>` — too loose for
+    // `z.output<UnwrapZodObject<typeof schema>>` to resolve concretely.
+    // Pass `TypeWithNullableDynamicKeys<typeof schema>` here purely to
+    // satisfy the adapter's constraint at the structural-cast layer.
+    // The PUBLIC signature's `GetValueFormType` default (line 67) is
+    // what consumers see — that's `z.output<UnwrapZodObject<Schema>>`,
+    // matching the docstring promise. Runtime is unaffected either way.
     schema: abstractSchema,
     defaultValues: configuration.defaultValues
   });
 }
 
 export { fieldMeta as f, isZodSchemaType as i, useForm as u, withMeta as w, zodAdapter as z };
-//# sourceMappingURL=attaform.D6Q5ZP8L.mjs.map
+//# sourceMappingURL=attaform.Drt6fivF.mjs.map