attaform 0.24.4 → 0.26.0

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

@@ -1,8 +1,8 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.CAVK56f8.cjs');
-const registerProtocol = require('./attaform.CjdepGnw.cjs');
+const paths = require('./attaform.BPl-ECRT.cjs');
+const registerProtocol = require('./attaform.ZXZ6dH72.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -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) {
@@ -2020,11 +2082,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 = paths.__DEV__ ? /* @__PURE__ */ new WeakMap() : null;
@@ -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;
       },
@@ -3229,7 +3293,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) => {
@@ -5366,10 +5430,7 @@ function createFormStore(options) {
       if (elementToFormInstance.get(entry.element) !== formInstanceId) continue;
       if (!entry.element.isConnected) continue;
       if (entry.element.offsetParent === null) continue;
-      const { key } = paths.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;
@@ -5949,7 +6010,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;
@@ -5959,12 +6020,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 (!paths.__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 (!paths.__DEV__ || ambientProvideHistory === null) return;
@@ -6224,6 +6295,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 && paths.__DEV__) {
@@ -6318,6 +6392,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);
     }
@@ -6333,7 +6408,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);
     }
@@ -6401,6 +6476,50 @@ function useWizard(options) {
     const first = list[0];
     return first === void 0 ? void 0 : first.form;
   });
+  vue.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 = vue.computed(() => {
     const list = compiledSteps.value;
     const idx = activeIndex.value;
@@ -6765,6 +6884,39 @@ function useWizard(options) {
     const target = list[idx + 1];
     moveTo(target.key);
   }
+  async function tryNext() {
+    if (submitting.value) {
+      if (paths.__DEV__) {
+        console.warn(`[attaform] wizard.tryNext(): blocked while a submit is in flight.`);
+      }
+      return false;
+    }
+    const list = compiledSteps.value;
+    if (list.length === 0) {
+      if (paths.__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 (paths.__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 (paths.__DEV__) {
@@ -6901,20 +7053,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) {
@@ -6949,14 +7094,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) {
@@ -7006,13 +7144,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;
@@ -7144,6 +7283,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(" "));
 }
@@ -7186,4 +7328,4 @@ exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.Buedl_UL.cjs.map
+//# sourceMappingURL=attaform.Du9RZp8m.cjs.map