attaform 0.25.0 → 0.26.0

package/dist/shared/{attaform.BkUzunyB.cjs → attaform.Du9RZp8m.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.3heDHayA.cjs');
+const paths = require('./attaform.BPl-ECRT.cjs');
 const registerProtocol = require('./attaform.ZXZ6dH72.cjs');
 
 function safeAssign(target, key, value) {
@@ -584,7 +584,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 {
@@ -792,6 +803,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,
@@ -970,6 +986,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,
@@ -1008,6 +1030,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 = {
@@ -1043,7 +1066,8 @@ function decorateWithDerivedProps(base, state, getFormMetaBase, key, validatingS
     showPending: displayState === "pending",
     showSuccess: displayState === "success",
     showIdle: displayState === "idle",
-    firstError
+    firstError,
+    firstOwnError
   };
 }
 function aggregateErrorsAt(state, prefix) {
@@ -1412,17 +1436,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
@@ -1606,6 +1628,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "elements",
   "updatedAt",
   "errors",
+  "ownErrors",
   "validating",
   "valid",
   "transforming",
@@ -1617,6 +1640,7 @@ const FIELD_STATE_KEYS = /* @__PURE__ */ new Set([
   "showSuccess",
   "showIdle",
   "firstError",
+  "firstOwnError",
   "path",
   "id",
   "aria",
@@ -1758,6 +1782,32 @@ function walk$1(value, basePath, schema, snapshotFieldStateAt) {
 }
 
 const warnedNoScopeStores = paths.__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) => paths.normalizeErrorInput(item, void 0, formKey, AttaformErrorCode.SubmitError)
+      ),
+      messageless: false
+    };
+  }
+  if (isErrorInputLike(err)) {
+    return {
+      entries: [paths.normalizeErrorInput(err, void 0, formKey, AttaformErrorCode.SubmitError)],
+      messageless: false
+    };
+  }
+  return {
+    entries: [paths.normalizeErrorInput({}, void 0, formKey, AttaformErrorCode.SubmitError)],
+    messageless: true
+  };
+}
 function buildProcessForm(state, formInstanceId, options = {}) {
   const invalidPolicy = options.onInvalidSubmit ?? "focus-first-error";
   function validate(pathInput) {
@@ -1939,13 +1989,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 paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
-            }
-          }
           return;
         }
         if (state.submissionGeneration.value === genAtEntry) {
@@ -1955,6 +1998,25 @@ function buildProcessForm(state, formInstanceId, options = {}) {
       } catch (err) {
         if (state.submissionGeneration.value === genAtEntry) {
           state.submitError.value = paths.toError(err);
+          if (!(err instanceof paths.SubmitErrorHandlerError)) {
+            const { entries, messageless } = deriveSubmitErrors(err, state.formKey);
+            const byPath = /* @__PURE__ */ new Map();
+            for (const entry of entries) {
+              const { key } = paths.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 (paths.__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) {
@@ -2816,6 +2878,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
       get errors() {
         return rootBase().errors;
       },
+      get ownErrors() {
+        return rootBase().ownErrors;
+      },
       get validating() {
         return rootBase().validating;
       },
@@ -2979,28 +3044,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);
@@ -3012,12 +3055,17 @@ function buildFormApi(state, formInstanceId, options = {}) {
       const { segments, key } = paths.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,
+        paths.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(
+      paths.normalizeErrorInputs(resolved, void 0, state.formKey, AttaformErrorCode.UserError)
+    );
   }
   function clearErrors(path) {
     if (path === void 0) {
@@ -3112,6 +3160,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
@@ -3150,6 +3209,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;
       },
@@ -7264,4 +7328,4 @@ exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.BkUzunyB.cjs.map
+//# sourceMappingURL=attaform.Du9RZp8m.cjs.map