attaform 0.24.4 → 0.26.0

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

@@ -1,6 +1,6 @@
 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.DwsfkfSY.mjs';
-import { R as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER } from './attaform.WvcckZMD.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) {
   if (key === "__proto__") {
@@ -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) {
@@ -2018,11 +2080,11 @@ function applyInvalidSubmitPolicy(state, formInstanceId, policy) {
     return;
   }
   if (policy === "focus-first-error") {
-    target.element.focus();
+    target.element.focus({ focusVisible: true });
     return;
   }
   target.element.scrollIntoView();
-  target.element.focus({ preventScroll: true });
+  target.element.focus({ preventScroll: true, focusVisible: true });
 }
 
 const warnedRejections = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
@@ -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;
       },
@@ -3227,7 +3291,7 @@ function buildFormApi(state, formInstanceId, options = {}) {
   const focusFirstError = (options2) => {
     const target = state.getFirstErrorElement(formInstanceId);
     if (target === null) return false;
-    target.element.focus(options2);
+    target.element.focus({ focusVisible: true, ...options2 });
     return true;
   };
   const scrollToFirstError = (options2) => {
@@ -5364,10 +5428,7 @@ function createFormStore(options) {
       if (elementToFormInstance.get(entry.element) !== formInstanceId) continue;
       if (!entry.element.isConnected) continue;
       if (entry.element.offsetParent === null) continue;
-      const { key } = canonicalizePath(entry.path);
-      const hasSchemaErr = (schemaErrors.get(key)?.length ?? 0) > 0;
-      const hasUserErr = (userErrors.get(key)?.length ?? 0) > 0;
-      if (!hasSchemaErr && !hasUserErr) continue;
+      if (getErrorsForPath(entry.path).length === 0) continue;
       return { path: entry.path, element: entry.element };
     }
     return null;
@@ -5947,7 +6008,7 @@ function resolveState(key, registry) {
   if (key !== void 0) {
     const stored = registry.forms.get(key);
     if (stored === void 0) {
-      warnMiss$1(`no form registered for key '${key}'`, registry.ssr);
+      warnMiss$1(`no form registered for key '${key}'`, registry.ssr, registry.forms);
       return null;
     }
     return stored;
@@ -5957,12 +6018,22 @@ function resolveState(key, registry) {
   warnIfAmbientProviderHadDuplicates();
   return ambient;
 }
-function warnMiss$1(detail, ssr) {
+function availableKeysHint$1(forms) {
+  const addressable = [...forms.keys()].filter((key) => !key.startsWith(RESERVED_KEY_PREFIX));
+  if (addressable.length === 0) return void 0;
+  return `Registered keys: ${addressable.map((key) => `'${key}'`).join(", ")}.`;
+}
+function warnMiss$1(detail, ssr, forms) {
   if (!__DEV__ || ssr) return;
   const frame = captureUserCallSite();
-  console.warn(
-    `[attaform] injectForm: ${detail}. Returning null.` + (frame !== void 0 ? ` ${frame}` : "")
+  const parts = [`[attaform] injectForm: ${detail}. Returning null.`];
+  const keys = availableKeysHint$1(forms);
+  if (keys !== void 0) parts.push(keys);
+  parts.push(
+    `A form created by a child or sibling component is not registered until that component's own setup runs, which happens after this point. Lift its useForm({ key }) call to a common ancestor, or read the form after mount.`
   );
+  if (frame !== void 0) parts.push(frame);
+  console.warn(parts.join(" "));
 }
 function warnIfAmbientProviderHadDuplicates() {
   if (!__DEV__ || ambientProvideHistory === null) return;
@@ -6222,6 +6293,9 @@ function asStatusSource(form) {
 function asSubmissionSource(form) {
   return form;
 }
+function asHandleSubmitSource(form) {
+  return form;
+}
 function useWizard(options) {
   const rawSteps = Array.isArray(options.steps) ? options.steps : [];
   if (rawSteps.length === 0 && __DEV__) {
@@ -6316,6 +6390,7 @@ function useWizard(options) {
     }
   };
   function resolveSlot(slot, index, ctx) {
+    if (slot === void 0 || slot === null) return void 0;
     if (typeof slot === "string") {
       return getOrBuildNoop(slot);
     }
@@ -6331,7 +6406,7 @@ function useWizard(options) {
     return void 0;
   }
   function resolveSlotResult(result) {
-    if (result === void 0) return void 0;
+    if (result === void 0 || result === null) return void 0;
     if (typeof result === "string") {
       return getOrBuildNoop(result);
     }
@@ -6399,6 +6474,50 @@ function useWizard(options) {
     const first = list[0];
     return first === void 0 ? void 0 : first.form;
   });
+  watch(compiledSteps, (list, prevList) => {
+    const key = activeKey.value;
+    if (key === "") return;
+    if (list.some((step) => step.key === key)) return;
+    if (list.length === 0) {
+      activeKey.value = "";
+      return;
+    }
+    const oldIndex = prevList.findIndex((step) => step.key === key);
+    const slid = list[oldIndex < 0 ? 0 : Math.min(oldIndex, list.length - 1)];
+    if (slid !== void 0) activeKey.value = slid.key;
+  });
+  const activeFormFacade = new Proxy({}, {
+    get(_target, prop) {
+      const form = activeForm.value;
+      if (form === void 0) return void 0;
+      if (prop === "handleSubmit") {
+        const lateBound = (onValid, onInvalid) => {
+          return (event) => {
+            const current = activeForm.value;
+            if (current === void 0) return Promise.resolve();
+            return asHandleSubmitSource(current).handleSubmit(onValid, onInvalid)(event);
+          };
+        };
+        return lateBound;
+      }
+      return Reflect.get(form, prop, form);
+    },
+    has(_target, prop) {
+      const form = activeForm.value;
+      return form === void 0 ? false : Reflect.has(form, prop);
+    },
+    ownKeys(_target) {
+      const form = activeForm.value;
+      return form === void 0 ? [] : Reflect.ownKeys(form);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+      const form = activeForm.value;
+      if (form === void 0) return void 0;
+      const descriptor = Reflect.getOwnPropertyDescriptor(form, prop);
+      if (descriptor === void 0) return void 0;
+      return { ...descriptor, configurable: true };
+    }
+  });
   const isFinalStep = computed(() => {
     const list = compiledSteps.value;
     const idx = activeIndex.value;
@@ -6763,6 +6882,39 @@ function useWizard(options) {
     const target = list[idx + 1];
     moveTo(target.key);
   }
+  async function tryNext() {
+    if (submitting.value) {
+      if (__DEV__) {
+        console.warn(`[attaform] wizard.tryNext(): blocked while a submit is in flight.`);
+      }
+      return false;
+    }
+    const list = compiledSteps.value;
+    if (list.length === 0) {
+      if (__DEV__) {
+        console.warn(`[attaform] wizard.tryNext(): wizard has no compiled steps; no-op.`);
+      }
+      return false;
+    }
+    const idx = activeIndex.value;
+    if (idx < 0 || idx >= list.length - 1) {
+      if (__DEV__) {
+        console.warn(
+          `[attaform] wizard.tryNext(): already on the final step ("${activeKey.value}"). Use wizard.handleSubmit() to submit.`
+        );
+      }
+      return false;
+    }
+    const form = activeForm.value;
+    if (form === void 0) return false;
+    let advanced = false;
+    await asHandleSubmitSource(form).handleSubmit(() => {
+      const before = activeKey.value;
+      next();
+      advanced = activeKey.value !== before;
+    })();
+    return advanced;
+  }
   function back() {
     if (submitting.value) {
       if (__DEV__) {
@@ -6899,20 +7051,13 @@ function useWizard(options) {
         const final = isFinalStep.value;
         const list = compiledSteps.value;
         const results = /* @__PURE__ */ new Map();
-        if (final) {
-          await Promise.all(
-            list.map(async (step) => {
-              registry.forms.get(step.key)?.clearUserErrors();
-              const result = await processOne(step.form);
-              results.set(step.key, result);
-            })
-          );
-        } else {
-          const active = activeForm.value;
-          registry.forms.get(active.key)?.clearUserErrors();
-          const result = await processOne(active);
-          results.set(active.key, result);
-        }
+        await Promise.all(
+          list.map(async (step) => {
+            registry.forms.get(step.key)?.clearUserErrors();
+            const result = await processOne(step.form);
+            results.set(step.key, result);
+          })
+        );
         for (const key of results.keys()) {
           const store = registry.forms.get(key);
           if (store !== void 0) {
@@ -6947,14 +7092,7 @@ function useWizard(options) {
             }
             return;
           }
-          if (final) {
-            done.value = true;
-          } else {
-            recordDeparture(currentKey);
-            const idx = activeIndex.value;
-            const target = list[idx + 1];
-            if (target !== void 0) moveTo(target.key);
-          }
+          done.value = true;
         } else {
           await focusFirstWizardError(errors);
           if (onError !== void 0) {
@@ -7004,13 +7142,14 @@ function useWizard(options) {
     next,
     back,
     goTo,
+    tryNext,
     handleSubmit,
     reset,
     get currentStep() {
       return currentStep.value;
     },
     get activeForm() {
-      return activeForm.value;
+      return activeForm.value === void 0 ? void 0 : activeFormFacade;
     },
     get activeIndex() {
       return activeIndex.value;
@@ -7142,6 +7281,9 @@ function warnMiss(detail, ssr, hint) {
   const frame = captureUserCallSite();
   const parts = [`[attaform] injectWizard: ${detail}. Returning null.`];
   if (hint !== void 0) parts.push(hint);
+  parts.push(
+    `A wizard created by a child or sibling component is not registered until that component's own setup runs, which happens after this point. Lift its useWizard({ key }) call to a common ancestor, or read the wizard after mount.`
+  );
   if (frame !== void 0) parts.push(frame);
   console.warn(parts.join(" "));
 }
@@ -7164,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.iJ4y3sHU.mjs.map
+//# sourceMappingURL=attaform.BoYqnIPI.mjs.map