attaform 0.25.0 → 0.26.0

package/dist/shared/{attaform.B3cgZE3c.d.ts → attaform.Be5otUVw.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.i_LA3X9o.js';
+import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.DBNjHgNj.js';
 
 /**
  * The shape `form.values.<key>` returns at runtime.

package/dist/shared/{attaform.DK3xUBkj.mjs → attaform.BoYqnIPI.mjs}

@@ -1,5 +1,5 @@
 import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, nextTick, warn, readonly, toRaw, reactive, watch, markRaw, triggerRef, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope } from 'vue';
-import { n as pathsEqual, j as isPathPrefix, _ as __DEV__, f as canonicalizePath, s as segmentsForPathKey, o as keyForSegments, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, q as INTERACTIVE_TAG_NAMES, R as ROOT_PATH, r as coerceToPathKey, a as InvalidUseFormConfigError, w as ensureAttaformInstalled, u as useRegistry, x as kFormContext, y as kFormInstanceId, d as ReservedFormKeyError, l as kAttaformWizardActiveStepResolver, z as kAttaformAncestorWizard } from './attaform.CqwcTExO.mjs';
+import { n as pathsEqual, j as isPathPrefix, _ as __DEV__, f as canonicalizePath, s as segmentsForPathKey, o as keyForSegments, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, q as normalizeErrorInput, r as INTERACTIVE_TAG_NAMES, R as ROOT_PATH, w as normalizeErrorInputs, x as coerceToPathKey, a as InvalidUseFormConfigError, y as ensureAttaformInstalled, u as useRegistry, z as kFormContext, B as kFormInstanceId, d as ReservedFormKeyError, l as kAttaformWizardActiveStepResolver, C as kAttaformAncestorWizard } from './attaform.DGhIix5D.mjs';
 import { R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.Vp2-CWZB.mjs';
 
 function safeAssign(target, key, value) {
@@ -582,7 +582,18 @@ const AttaformErrorCode = {
    * produced `ValidationError` carrying a stable, branchable identifier.
    * Override it per error by passing your own `code` (`api:…`, `auth:…`).
    */
-  UserError: "atta:user-error"
+  UserError: "atta:user-error",
+  /**
+   * Stamped on a `ValidationError` synthesized from a throw or rejection
+   * out of a `handleSubmit` `onSubmit` callback. The raw error also lands
+   * on `form.meta.submitError` (a raw-`Error` inspection channel); this
+   * code marks the copy piped into the user-error layer so the failure
+   * also surfaces on `form.errors` / `meta.ownErrors` / `firstOwnError`
+   * where the UI already reads. A throw carrying its own `path` / `code`
+   * keeps them; a bare `Error` or a non-Error throw defaults here at the
+   * form-level path `[]`.
+   */
+  SubmitError: "atta:submit-error"
 };
 function makeBlankRequiredError(segments, formKey) {
   return {
@@ -790,6 +801,11 @@ function buildLeafFieldStateBase(state, segments, key, formInstanceId) {
     elements: elementsArr,
     updatedAt: record?.updatedAt ?? null,
     errors,
+    // A leaf has no descendants, so its own-bucket errors ARE its subtree
+    // errors. Reuse the same array reference: referential `ownErrors ===
+    // errors`, and no second read of the whole-form `derivedBlankErrors`
+    // map (preserves the P3 blank-reactivity optimization above).
+    ownErrors: errors,
     validating,
     valid,
     transforming,
@@ -968,6 +984,12 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
       elements: EMPTY_ELEMENTS,
       updatedAt,
       errors,
+      // The container's OWN bucket only (this exact path), excluding every
+      // descendant that `errors` rolls up: a cross-field `.refine()` here,
+      // or `setErrors` pinned at this node. The same raw union the leaf
+      // builds from the three stores; the container already depends on all
+      // three via `aggregateErrorsAt`, so there's no new reactivity cost.
+      ownErrors: state.getErrorsForPath(segments),
       validating,
       valid,
       transforming,
@@ -1006,6 +1028,7 @@ function buildContainerFieldState(state, segments, key, formInstanceId, getFormM
 }
 function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingSince, transformingSince, revealedDescendantError, isRoot, getDisplayState) {
   const firstError = base.errors[0];
+  const firstOwnError = base.ownErrors[0];
   const predicate = getDisplayState ?? state.getDisplayState;
   const formMeta = getFormMetaBase();
   const ctx = {
@@ -1041,7 +1064,8 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     showPending: displayState === "pending",
     showSuccess: displayState === "success",
     showIdle: displayState === "idle",
-    firstError
+    firstError,
+    firstOwnError
   };
 }
 function aggregateErrorsAt(state, prefix) {
@@ -1410,17 +1434,15 @@ function buildErrorsProxy(state) {
     // shared `aggregateErrorsAt` helper that `form.meta.errors` and
     // `form.fields(path).errors` also use, so the surfaces never drift.
     //
-    // The root is the one carve-out. An EXPLICIT root path
-    // (`errors([])`) returns ONLY the global `[]` bucket (root
-    // `.refine()`, hydration failures, `setErrors`) via
-    // `getErrorsForPath`, giving consumers a dedicated channel for
-    // global messages undiluted by field errors. The no-arg `errors()`
-    // instead resolves the FULL aggregate through `resolveRootCall`
-    // below (identical to `meta.errors`).
-    resolveCallTarget: (path) => path.length === 0 ? state.getErrorsForPath([]) : aggregateErrorsAt(state, path),
+    // The root is uniform with every other path: `errors([])` is the
+    // subtree aggregate at `[]`, which is the whole form, identical to
+    // the no-arg `errors()` and to `meta.errors`. The root `[]` bucket
+    // alone (root `.refine()`, hydration failures, path-less
+    // `setErrors`) is read through `meta.ownErrors` / `meta.firstOwnError`,
+    // the dedicated own-bucket accessor, not a call-form carve-out.
+    resolveCallTarget: (path) => aggregateErrorsAt(state, path),
     // No-arg `errors()` = the whole-form aggregate, matching
-    // `meta.errors`. Distinct from `errors([])` (global bucket only);
-    // see `resolveCallTarget`.
+    // `meta.errors` and `errors([])`. All three are the same aggregate.
     resolveRootCall: () => aggregateErrorsAt(state, []),
     // Enumeration unions the live form-data keys at this path with the
     // first-child segments drawn from every error store. Without the
@@ -1604,6 +1626,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "elements",
   "updatedAt",
   "errors",
+  "ownErrors",
   "validating",
   "valid",
   "transforming",
@@ -1615,6 +1638,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "showSuccess",
   "showIdle",
   "firstError",
+  "firstOwnError",
   "path",
   "id",
   "aria",
@@ -1756,6 +1780,32 @@ function walk$1(value, basePath, schema, snapshotFieldStateAt) {
 }
 
 const warnedNoScopeStores = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+function isErrorInputLike(value) {
+  if (value instanceof Error) return true;
+  if (typeof value !== "object" || value === null) return false;
+  const shape = value;
+  return typeof shape.message === "string" && shape.message.length > 0 || Array.isArray(shape.path);
+}
+function deriveSubmitErrors(err, formKey) {
+  if (Array.isArray(err) && err.length > 0 && err.every(isErrorInputLike)) {
+    return {
+      entries: err.map(
+        (item) => normalizeErrorInput(item, void 0, formKey, AttaformErrorCode.SubmitError)
+      ),
+      messageless: false
+    };
+  }
+  if (isErrorInputLike(err)) {
+    return {
+      entries: [normalizeErrorInput(err, void 0, formKey, AttaformErrorCode.SubmitError)],
+      messageless: false
+    };
+  }
+  return {
+    entries: [normalizeErrorInput({}, void 0, formKey, AttaformErrorCode.SubmitError)],
+    messageless: true
+  };
+}
 function buildProcessForm(state, formInstanceId, options = {}) {
   const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
   function validate(pathInput) {
@@ -1937,13 +1987,6 @@ function buildProcessForm(state, formInstanceId, options = {}) {
           if (state.submissionGeneration.value === genAtEntry) {
             applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
           }
-          if (onError !== void 0) {
-            try {
-              await onError(Array.from(state.userErrors.values()).flat());
-            } catch (cause) {
-              throw new SubmitErrorHandlerError("User-provided onError threw", { cause });
-            }
-          }
           return;
         }
         if (state.submissionGeneration.value === genAtEntry) {
@@ -1953,6 +1996,25 @@ function buildProcessForm(state, formInstanceId, options = {}) {
       } catch (err) {
         if (state.submissionGeneration.value === genAtEntry) {
           state.submitError.value = toError(err);
+          if (!(err instanceof SubmitErrorHandlerError)) {
+            const { entries, messageless } = deriveSubmitErrors(err, state.formKey);
+            const byPath = /* @__PURE__ */ new Map();
+            for (const entry of entries) {
+              const { key } = canonicalizePath(entry.path);
+              const bucket = byPath.get(key);
+              if (bucket === void 0) byPath.set(key, { segments: entry.path, entries: [entry] });
+              else bucket.entries.push(entry);
+            }
+            for (const { segments, entries: bucket } of byPath.values()) {
+              state.setUserErrorsForPath(segments, bucket);
+            }
+            applyInvalidSubmitPolicy(state, formInstanceId, invalidPolicy);
+            if (__DEV__ && messageless) {
+              console.warn(
+                "[attaform] handleSubmit callback threw a non-Error value; throw an Error or a ValidationError ({ message, path? }) so the failure surfaces with a usable message."
+              );
+            }
+          }
         }
       } finally {
         if (!validationSettled) {
@@ -2814,6 +2876,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       get errors() {
         return rootBase().errors;
       },
+      get ownErrors() {
+        return rootBase().ownErrors;
+      },
       get validating() {
         return rootBase().validating;
       },
@@ -2977,28 +3042,6 @@ function buildFormApi(state, formInstanceId, options = {}) {
     return true;
   }
   const errorsProxy = buildErrorsProxy(state);
-  function normalizeErrorInput(item, scope) {
-    if (item instanceof Error) {
-      return {
-        message: item.message.length > 0 ? item.message : "Unknown error",
-        path: scope !== void 0 ? [...scope] : [],
-        formKey: state.formKey,
-        code: AttaformErrorCode.UserError
-      };
-    }
-    const entry = {
-      message: typeof item.message === "string" && item.message.length > 0 ? item.message : "Unknown error",
-      path: scope !== void 0 ? [...scope] : Array.isArray(item.path) ? [...item.path] : [],
-      formKey: state.formKey,
-      code: typeof item.code === "string" && item.code.length > 0 ? item.code : AttaformErrorCode.UserError
-    };
-    if (item.data !== void 0) entry.data = item.data;
-    return entry;
-  }
-  function normalizeErrorInputs(input, scope) {
-    const items = Array.isArray(input) ? input : [input];
-    return items.map((item) => normalizeErrorInput(item, scope));
-  }
   function flattenUserErrors() {
     const all = [];
     for (const errs of state.userErrors.values()) all.push(...errs);
@@ -3010,12 +3053,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
       const { segments, key } = canonicalizePath(arg1);
       const input2 = arg2;
       const resolved2 = typeof input2 === "function" ? input2((state.userErrors.get(key) ?? []).slice()) : input2;
-      state.setUserErrorsForPath(segments, normalizeErrorInputs(resolved2, segments));
+      state.setUserErrorsForPath(
+        segments,
+        normalizeErrorInputs(resolved2, segments, state.formKey, AttaformErrorCode.UserError)
+      );
       return;
     }
     const input = arg1;
     const resolved = typeof input === "function" ? input(flattenUserErrors()) : input;
-    state.setAllUserErrors(normalizeErrorInputs(resolved, void 0));
+    state.setAllUserErrors(
+      normalizeErrorInputs(resolved, void 0, state.formKey, AttaformErrorCode.UserError)
+    );
   }
   function clearErrors(path) {
     if (path === void 0) {
@@ -3110,6 +3158,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
       // keep the explicit form-level computation for the gate.
       valid,
       errors: metaErrors,
+      // The root `[]` bucket alone: form-level errors from a root
+      // `.refine()` or a path-less `setErrors`, excluding every field error
+      // that `errors` (the whole-form aggregate) rolls up. This is the
+      // banner accessor. Mirrors `rootFieldState` rather than taking a
+      // dedicated computed: `getFieldState([])` routes a container root
+      // through `getErrorsForPath([])` and a primitive root through its own
+      // bucket, and both equal the root bucket, so the root field state is
+      // already the single source of truth.
+      get ownErrors() {
+        return rootFieldState.value.ownErrors;
+      },
       // Whole-form transforming mirrors the global `activeTransforms`
       // counter ORed with any per-leaf transform in flight (the root
       // rollup), exactly as `validating` composes its lifecycle and
@@ -3148,6 +3207,11 @@ function buildFormApi(state, formInstanceId, options = {}) {
       get firstError() {
         return rootFieldState.value.firstError;
       },
+      // `ownErrors[0]`: the form's first top-level error. Pair it with
+      // `ownErrors` for the form-level banner.
+      get firstOwnError() {
+        return rootFieldState.value.firstOwnError;
+      },
       get path() {
         return rootFieldState.value.path;
       },
@@ -7242,4 +7306,4 @@ function warnIfAmbientWizardProviderHadDuplicates() {
 }
 
 export { AttaformErrorCode as A, DEFAULT_TIMINGS as D, injectWizard as a, isUnset as b, useRegister as c, useWizard as d, defaultCoercionRules as e, defaultDisplayState as f, defineCoercion as g, useAbstractForm as h, injectForm as i, isPlainRecord as j, safeAssign as k, lazy as l, makeDefaultDisplayState as m, slimKindOf as n, humanize as o, getAtPath as p, setAtPath as q, safeOwnRead as s, unset as u };
-//# sourceMappingURL=attaform.DK3xUBkj.mjs.map
+//# sourceMappingURL=attaform.BoYqnIPI.mjs.map