attaform 0.29.0 → 0.30.1

package/dist/shared/{attaform.D1fnTifF.mjs → attaform.D_pt1gOj.mjs}

@@ -1,7 +1,7 @@
-import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, m as mergeDeep, f as fixStructuralDefaults, d as deriveDefaultWalk, a as getFieldMetaListForSchema } from './attaform.B0dKL8ST.mjs';
-import { p as getAtPath, q as humanize, h as useAbstractForm } from './attaform.CZMAYwSK.mjs';
-import { c as callConsumerSchemaFn } from './attaform.Cvao8bW5.mjs';
-import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CZYt_5N_.mjs';
+import { w as walkPathSegments, s as slimPrimitivesWalk, c as createAbstractSchema, a as createSharedSchemaStore, b as buildFieldMetaPathMap, g as getFieldMetaForSchema, f as fixStructuralDefaults, m as mergeDeep, d as deriveDefaultWalk, e as getFieldMetaListForSchema } from './attaform.DRsANMok.mjs';
+import { h as getAtPath, j as humanize, c as useAbstractForm } from './attaform.BIWicztt.mjs';
+import { c as callConsumerFn } from './attaform.8mfKZCwH.mjs';
+import { A as AttaformError, e as canonicalizePath, a as InvalidUseFormConfigError } from './attaform.CdZIEf7_.mjs';
 
 function isZodSchemaType(schema, expectedType) {
   if (typeof schema !== "object" || schema === null) return false;
@@ -127,22 +127,29 @@ function getTupleItems(schema) {
   const def = readDef(schema);
   return def?.items ?? [];
 }
+function readOptionList(options) {
+  if (options === void 0) return [];
+  if (options instanceof Map) return [...options.values()];
+  return [...options];
+}
 function getUnionOptions(schema) {
-  const def = readDef(schema);
-  return def?.options ?? [];
+  return readOptionList(readDef(schema)?.options);
 }
 function getDiscriminatedOptions(schema) {
-  const def = readDef(schema);
-  return def?.options ?? [];
+  return readOptionList(readDef(schema)?.options);
 }
 function getDiscriminator(schema) {
   const def = readDef(schema);
   return def?.discriminator;
 }
 function getDiscriminatedOptionsMap(schema) {
-  const map = readDef(schema)?.optionsMap;
+  const def = readDef(schema);
+  const map = def?.optionsMap ?? def?.options;
   return map instanceof Map ? map : void 0;
 }
+function discriminatedOptionsAreMapped(schema) {
+  return readDef(schema)?.options instanceof Map;
+}
 function getIntersectionLeft(schema) {
   const def = readDef(schema);
   return def?.left;
@@ -299,11 +306,7 @@ function unwrapLazy(schema) {
   const def = readDef(schema);
   const getter = def?.getter;
   if (typeof getter !== "function") return void 0;
-  return callConsumerSchemaFn(() => getter(), void 0);
-}
-function getLazyGetter(schema) {
-  const def = readDef(schema);
-  return typeof def?.getter === "function" ? def.getter : void 0;
+  return callConsumerFn(() => getter(), void 0);
 }
 function getLiteralValues(schema) {
   const def = readDef(schema);
@@ -320,15 +323,13 @@ function getDefaultValue(schema) {
   const def = readDef(schema);
   const thunk = def?.defaultValue;
   if (typeof thunk !== "function") return void 0;
-  return callConsumerSchemaFn(() => thunk(), void 0);
+  return callConsumerFn(() => thunk(), void 0);
 }
 function getCatchDefault(schema) {
   const def = readDef(schema);
   const cv = def?.catchValue;
   if (typeof cv !== "function") return void 0;
-  return callConsumerSchemaFn(
-    () => cv({ error: null, input: void 0 }),
-    void 0);
+  return callConsumerFn(() => cv({ error: null, input: void 0 }), void 0);
 }
 function hasCatchValue(schema) {
   const def = readDef(schema);
@@ -445,7 +446,6 @@ const V3_INTROSPECTOR = {
   // Walker accessors (D2 / D3 / D5).
   getArrayElement,
   getSetValueType,
-  getRecordKeyType,
   getRecordValueType,
   getMapKeyType: (schema) => kindOf(schema) === "map" ? getMapKeyType(schema) : void 0,
   getMapValueType: (schema) => kindOf(schema) === "map" ? getMapValueType(schema) : void 0,
@@ -463,7 +463,6 @@ const V3_INTROSPECTOR = {
   unwrapPipeIn,
   unwrapPipeOut,
   unwrapLazy,
-  getLazyGetter,
   getDefaultValue,
   getCatchDefault,
   hasCatchValue
@@ -599,22 +598,22 @@ function rebuildDiscriminatedUnion(original, options) {
       if (replacement !== void 0) optionsMap.set(value, replacement);
     }
   }
+  if (discriminatedOptionsAreMapped(original)) {
+    return rebuildWithDef(original, { options: optionsMap });
+  }
   return rebuildWithDef(original, { options, optionsMap });
 }
 function rebuildEffects(original, source, effect) {
   return rebuildWithDef(original, { schema: source, effect });
 }
 
-function stripAsyncChecks(schema) {
-  return walkEffects(schema, "strip");
-}
 function wrapAsyncSafeRefinements(schema) {
-  return walkEffects(schema, "wrap");
+  return walkEffects(schema);
 }
 function isThenable(value) {
   return value !== null && (typeof value === "object" || typeof value === "function") && typeof value.then === "function";
 }
-function walkEffects(schema, policy) {
+function walkEffects(schema) {
   const seen = /* @__PURE__ */ new WeakSet();
   function recurse(s) {
     const candidate = s;
@@ -624,7 +623,6 @@ function walkEffects(schema, policy) {
     if (isZodSchemaType(s, "ZodEffects")) {
       const inner = unwrapEffectsSource(s);
       if (inner === void 0) return s;
-      if (policy === "strip") return recurse(inner);
       const effect = getEffect(s);
       const rebuiltInner = recurse(inner);
       const original = effect?.["refinement"];
@@ -797,18 +795,18 @@ function zodAdapter(zodSchema) {
       `[attaform] AF15 attaform.dev/e/af15 '${name}'`
     );
   }
-  return (formKey, options) => createAbstractSchema(
+  return (_formKey, options) => sharedV3Schemas(
     zodSchema,
-    V3_INTROSPECTOR,
-    buildV3Services(options.maxRecursionDepth),
-    formKey,
-    options
+    options.maxRecursionDepth,
+    () => createAbstractSchema(
+      zodSchema,
+      V3_INTROSPECTOR,
+      buildV3Services(options.maxRecursionDepth),
+      options
+    )
   );
 }
-async function lazyFingerprint(schema) {
-  const { fingerprintZodSchema } = await import('../chunks/fingerprint.mjs');
-  return fingerprintZodSchema(schema);
-}
+const sharedV3Schemas = createSharedSchemaStore();
 const syncSafeCache = /* @__PURE__ */ new WeakMap();
 function syncSafe(schema) {
   const cached = syncSafeCache.get(schema);
@@ -829,19 +827,14 @@ function buildV3Services(maxRecursionDepth) {
     return normalizeIssuePaths(issues, schema, data, maxRecursionDepth, peelAllV3Wrappers);
   };
   return {
-    fingerprint: (schema) => lazyFingerprint(schema),
     getNestedSchemasAtPath: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
-    // v3 pre-strips refinements / defaults / wrappers off the root for
-    // slim-mode walks — `getSlimPrimitiveTypesAtPath` and
-    // `getSchemasAtPath` both consume this variant so the yielded
-    // candidates reflect the slim shape.
-    // The slim-root projection is gone (size-teardown P7): the shared
-    // path walker peels wrappers / effects inline, so the slim and
-    // unstripped walks coincide — same aliasing v4 always had.
+    // The shared path walker peels wrappers and effects inline, so the
+    // slim and unstripped walks coincide and the root needs no slim
+    // projection of its own. Same aliasing v4 has.
     getNestedSchemasInSlimMode: (schema, path, maxRecursionDepth2) => getNestedZodSchemasAtPath(schema, path, maxRecursionDepth2),
     slimPrimitivesOf: (schema, _maxRecursionDepth) => slimPrimitivesV3(schema),
-    deriveDefault: (schema, useDefault, _maxRecursionDepth, formKey) => getDefaultValuesFromZodSchema(schema, useDefault, formKey),
-    runStrictGetDefaults: (schema, config, formKey, maxRecursionDepth2) => runStrictGetDefaultsV3(schema, config, formKey, maxRecursionDepth2),
+    deriveDefault: (schema, useDefault) => getDefaultValuesFromZodSchema(schema, useDefault),
+    runGetDefaults: (schema, config, maxRecursionDepth2) => runGetDefaultsV3(schema, config, maxRecursionDepth2),
     unwrapStructuralWrappers: (schema) => unwrapStructuralLeafV3(schema),
     unwrapToDiscriminatedUnion: (schema) => unwrapToDiscriminatedUnion(schema),
     peelAllWrappers: (schema) => peelAllV3Wrappers(schema),
@@ -856,15 +849,14 @@ function buildV3Services(maxRecursionDepth) {
       const result = await schema.safeParseAsync(data);
       return result.success ? { success: true, data: result.data } : { success: false, issues: refileIssues(schema, data, result.error.issues) };
     },
-    // v3 returns the full recursive AbstractSchema for sub-schemas (the
-    // historical shape) — `getSchemasAtPath` consumers may probe any
-    // method on the result. The factory call rebuilds the full surface
-    // against the sub-schema with its own per-form caches.
-    makeSubSchema: (sub, formKey, maxRecursionDepth2) => createAbstractSchema(
+    // A `getSchemasAtPath` consumer may probe any method on the result,
+    // so a sub-schema comes back as a full recursive AbstractSchema: the
+    // factory call rebuilds the whole surface against it, with its own
+    // per-form caches.
+    makeSubSchema: (sub, maxRecursionDepth2) => createAbstractSchema(
       sub,
       V3_INTROSPECTOR,
       buildV3Services(maxRecursionDepth2),
-      formKey,
       { maxRecursionDepth: maxRecursionDepth2 }
     )
   };
@@ -880,17 +872,16 @@ function zodIssuesToValidationErrors(issues) {
     }
     validationErrors.push({
       message: issue.message,
-      // `ValidationError.path` is `(string | number)[]` per the
-      // public type. v3's `issue.path` is the same in the standard
-      // case, but a custom check via `ctx.addIssue({ path: [...] })`
-      // can smuggle a Symbol through — the public surface promised
-      // strings/numbers, so coerce defensively to keep the contract.
-      // Mirrors v4's behaviour at the same site.
+      // `ValidationError.path` is `(string | number)[]` publicly, and
+      // v3's `issue.path` matches in the standard case, but a custom
+      // check calling `ctx.addIssue({ path: [...] })` can smuggle a
+      // Symbol through. Coerce to keep the promise. v4 does the same
+      // here.
       //
-      // Adapter-side paths stay schema-relative — the validation
-      // pipeline in `create-form-store.ts` prepends the parent path
-      // to absolutise, then routes form-level (absolute path length 0)
-      // entries to the empty-string bucket at storage time.
+      // Adapter-side paths stay schema-RELATIVE: the validation pipeline
+      // in `core/create-form-store.ts` prepends the parent path to
+      // absolutise, then routes form-level entries, those whose absolute
+      // path is empty, to the empty-string bucket at storage time.
       path: coercePathSegments(issue.path),
       code
     });
@@ -922,10 +913,10 @@ function unwrapStructuralLeafV3(schema) {
   return current;
 }
 function isStructuralV3Kind(schema) {
-  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type — keep
-  // peeling at the next iteration.
-  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+). Each wraps a single inner
-  // schema with no structural impact — `peelV3Wrappers` resolves them.
+  return isZodSchemaType(schema, "ZodObject") || isZodSchemaType(schema, "ZodArray") || isZodSchemaType(schema, "ZodRecord") || isZodSchemaType(schema, "ZodTuple") || isZodSchemaType(schema, "ZodUnion") || isZodSchemaType(schema, "ZodDiscriminatedUnion") || // Wrappers that themselves resolve to a structural type; keep
+  // peeling next iteration.
+  isZodSchemaType(schema, "ZodOptional") || isZodSchemaType(schema, "ZodNullable") || isZodSchemaType(schema, "ZodDefault") || isZodSchemaType(schema, "ZodEffects") || // Newer transparent wrappers (v3.23+), each wrapping one inner
+  // schema with no structural impact. `peelV3Wrappers` resolves them.
   isZodSchemaType(schema, "ZodPipeline") || isZodSchemaType(schema, "ZodReadonly") || isZodSchemaType(schema, "ZodBranded");
 }
 function peelV3Wrappers(schema) {
@@ -1077,16 +1068,8 @@ function peelAllV3Wrappers(schema) {
   }
   return current;
 }
-function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues, formKey) {
-  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64, {
-    unsupportedKindFallback: (schema) => {
-      const kindName = schema.constructor?.name ?? "unknown";
-      console.warn(
-        `[attaform] AF13 attaform.dev/e/af13 '${kindName}' on '${formKey}'`
-      );
-      return null;
-    }
-  });
+function getDefaultValuesFromZodSchema(formSchema, useDefaultSchemaValues) {
+  return deriveDefaultWalk(formSchema, useDefaultSchemaValues, V3_INTROSPECTOR, 64);
 }
 function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
   const lastSegment = path.length === 0 ? "" : path[path.length - 1];
@@ -1117,92 +1100,51 @@ function resolveFieldMetaAtPathV3(rootSchema, path, maxRecursionDepth) {
     meta: Object.freeze({ ...payload ?? {} })
   };
 }
-function runStrictGetDefaultsV3(rootSchema, config, formKey, maxRecursionDepth) {
+function runGetDefaultsV3(rootSchema, config, maxRecursionDepth) {
   const defaultValuesWithoutConstraints = getDefaultValuesFromZodSchema(
     rootSchema,
-    config.useDefaultSchemaValues,
-    formKey
+    config.useDefaultSchemaValues
   );
-  const rawDefaultValues = mergeDeep(defaultValuesWithoutConstraints, config.constraints);
-  if ((config.strict ?? true) !== false) {
-    if (containsAsyncTransform(rootSchema)) {
-      return {
-        data: rawDefaultValues,
-        errors: void 0,
-        success: true,
-        formKey
-      };
-    }
-    try {
-      const strictResult = syncSafe(rootSchema).safeParse(rawDefaultValues);
-      if (strictResult.success) {
-        return {
-          data: rawDefaultValues,
-          errors: void 0,
-          success: true,
-          formKey
-        };
-      }
-      return {
-        data: rawDefaultValues,
-        errors: zodIssuesToValidationErrors(strictResult.error.issues),
-        success: false,
-        formKey
-      };
-    } catch (err) {
-      const isAsyncDetect = err instanceof Error && err.message.includes("Async refinement encountered");
-      if (isAsyncDetect) {
-        try {
-          const strippedResult = syncSafe(stripAsyncChecks(rootSchema)).safeParse(rawDefaultValues);
-          if (strippedResult.success) {
-            return {
-              data: rawDefaultValues,
-              errors: void 0,
-              success: true,
-              formKey
-            };
-          }
-          return {
-            data: rawDefaultValues,
-            errors: zodIssuesToValidationErrors(strippedResult.error.issues),
-            success: false,
-            formKey
-          };
-        } catch {
-          return {
-            data: rawDefaultValues,
-            errors: void 0,
-            success: true,
-            formKey
-          };
-        }
-      }
-      return {
-        data: rawDefaultValues,
-        errors: void 0,
-        success: true,
-        formKey
-      };
-    }
-  }
-  const fixed = fixStructuralDefaults(
+  const rawDefaultValues = config.constraints === void 0 ? defaultValuesWithoutConstraints : fixStructuralDefaults(
     rootSchema,
-    rawDefaultValues,
+    mergeDeep(defaultValuesWithoutConstraints, config.constraints),
     config.useDefaultSchemaValues,
     maxRecursionDepth,
     {
       intro: V3_INTROSPECTOR,
       slimPrimitivesOf: (s) => slimPrimitivesV3(s),
-      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault, formKey),
+      deriveDefault: (s, useDefault) => getDefaultValuesFromZodSchema(s, useDefault),
       unwrapToDiscriminatedUnion: (s) => unwrapToDiscriminatedUnion(s)
     }
-  );
-  return {
-    data: fixed.data,
-    errors: void 0,
-    success: true,
-    formKey
-  };
+  ).data;
+  if (containsAsyncTransform(rootSchema)) {
+    return {
+      data: rawDefaultValues,
+      errors: void 0,
+      success: true
+    };
+  }
+  try {
+    const parseResult = syncSafe(rootSchema).safeParse(rawDefaultValues);
+    if (parseResult.success) {
+      return {
+        data: rawDefaultValues,
+        errors: void 0,
+        success: true
+      };
+    }
+    return {
+      data: rawDefaultValues,
+      errors: zodIssuesToValidationErrors(parseResult.error.issues),
+      success: false
+    };
+  } catch {
+    return {
+      data: rawDefaultValues,
+      errors: void 0,
+      success: true
+    };
+  }
 }
 
 function useForm(configuration) {

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

@@ -0,0 +1,42 @@
+import { App } from 'vue';
+import { ao as RegisterModelDynamicCustomDirective } from './attaform.Br8EBn5B.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 };

package/dist/shared/{attaform.D0x-qSXm.mjs → attaform.WiGdIqgx.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.CZYt_5N_.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.CdZIEf7_.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {
@@ -17,7 +17,6 @@ const kFormContext = /* @__PURE__ */ Symbol.for("attaform:form-context");
 const kFormInstanceId = /* @__PURE__ */ Symbol.for("attaform:form-instance-id");
 function createRegistry(options = {}) {
   const ssr = detectSSR(options);
-  const defaults = Object.freeze({ ...options.defaults ?? {} });
   const forms = shallowReactive(/* @__PURE__ */ new Map());
   const wizards = shallowReactive(/* @__PURE__ */ new Map());
   const pendingHydration = shallowReactive(/* @__PURE__ */ new Map());
@@ -102,7 +101,6 @@ function createRegistry(options = {}) {
     wizards,
     pendingHydration,
     ssr,
-    defaults,
     trackConsumer,
     trackWizardConsumer,
     enqueuePrefetch,

package/dist/shared/{attaform.BK0cgu2K.mjs → attaform.ZYn2ahzJ.mjs}

@@ -756,9 +756,9 @@ function injectPreamble(element, captured) {
     ),
     exp,
     modifiers: [],
-    // Reuse the host element's source location so any runtime error
-    // in the synthesized expression points at the consumer's template
-    // line, not at the dummyLoc that pre-fix was line 0.
+    // The host element's source location, so a runtime error in the
+    // synthesized expression points at the consumer's template line
+    // rather than at line 0.
     loc: element.loc
   };
   element.props.unshift(directive);