attaform 0.24.0 → 0.24.1

package/dist/shared/{attaform.GJbSmwLB.d.ts → attaform.DBhrKb2j.d.cts}

@@ -2002,9 +2002,11 @@ type AttaformDefaults = {
  */
 type OnSubmit<Form extends GenericForm> = (form: Form) => void | Promise<void>;
 /**
- * Callback invoked by `handleSubmit` when validation fails. Receives
- * the full list of errors. Bind this when you want to react to
- * submit failures explicitly (alongside or instead of the
+ * Callback invoked by `handleSubmit` on a failed submit. Fires when
+ * client validation fails AND when the submit callback leaves errors in
+ * the user-error layer (the `setErrors(...); return` server-rejection
+ * pattern). Receives the full list of errors. Bind this when you want to
+ * react to submit failures explicitly (alongside or instead of the
  * automatic `onInvalidSubmit` UI nudge).
  */
 type OnError = (error: ValidationError[]) => void | Promise<void>;
@@ -3649,10 +3651,14 @@ type FormMeta<F = unknown> = FieldState<F> & {
      *
      * The submit handler does NOT re-throw — its returned promise always
      * resolves, so binding it to `@submit.prevent` never manufactures a
-     * `window` unhandledrejection. This is the single channel for "the
-     * submit failed", read the same way in templates and after an
-     * imperative `await submit()`. Like `hydrateError`, it stays distinct
-     * from the curated user-error store: render it where you choose:
+     * `window` unhandledrejection. This is the channel for an UNEXPECTED
+     * submit failure (a thrown exception or rejected promise), read the
+     * same way in templates and after an imperative `await submit()`. An
+     * EXPECTED rejection handled the documented way (`setErrors(...)` then
+     * `return`, no throw) surfaces through the error store and `onError`
+     * instead, leaving `submitError` `null`. Like `hydrateError`, it stays
+     * distinct from the curated user-error store: render it where you
+     * choose:
      *
      * ```vue
      * <p v-if="form.meta.submitError">{{ form.meta.submitError.message }}</p>
@@ -3669,11 +3675,18 @@ type FormMeta<F = unknown> = FieldState<F> & {
      */
     readonly errorCount: number;
     /**
-     * `true` once a `handleSubmit` callback has resolved without
-     * throwing. Independent of `submissionAttempts` — a failed submit
-     * (validation failure or callback rejection) increments attempts but
-     * leaves `submitted` at `false`. Templates read it as "the form has
-     * been submitted successfully at least once."
+     * `true` once a `handleSubmit` callback has resolved without throwing
+     * AND left no errors behind. Independent of `submissionAttempts` — a
+     * failed submit (validation failure, callback rejection, or a callback
+     * that calls `setErrors` and returns) increments attempts but leaves
+     * `submitted` at `false`. Templates read it as "the form has been
+     * submitted successfully at least once."
+     *
+     * The error check is scoped to the user-error layer (`setErrors` /
+     * `clearErrors`): the documented server-rejection pattern
+     * (`setErrors(response.errors); return`) is a failed submit, so it does
+     * not flip `submitted`. A background async refinement that writes a
+     * schema error mid-submit does not retroactively fail it.
      *
      * Cleared by `form.reset()` alongside `submissionAttempts` and
      * `submitError`. For "the user has attempted a submit," read

package/dist/shared/{attaform.GJbSmwLB.d.cts → attaform.DBhrKb2j.d.mts}

@@ -2002,9 +2002,11 @@ type AttaformDefaults = {
  */
 type OnSubmit<Form extends GenericForm> = (form: Form) => void | Promise<void>;
 /**
- * Callback invoked by `handleSubmit` when validation fails. Receives
- * the full list of errors. Bind this when you want to react to
- * submit failures explicitly (alongside or instead of the
+ * Callback invoked by `handleSubmit` on a failed submit. Fires when
+ * client validation fails AND when the submit callback leaves errors in
+ * the user-error layer (the `setErrors(...); return` server-rejection
+ * pattern). Receives the full list of errors. Bind this when you want to
+ * react to submit failures explicitly (alongside or instead of the
  * automatic `onInvalidSubmit` UI nudge).
  */
 type OnError = (error: ValidationError[]) => void | Promise<void>;
@@ -3649,10 +3651,14 @@ type FormMeta<F = unknown> = FieldState<F> & {
      *
      * The submit handler does NOT re-throw — its returned promise always
      * resolves, so binding it to `@submit.prevent` never manufactures a
-     * `window` unhandledrejection. This is the single channel for "the
-     * submit failed", read the same way in templates and after an
-     * imperative `await submit()`. Like `hydrateError`, it stays distinct
-     * from the curated user-error store: render it where you choose:
+     * `window` unhandledrejection. This is the channel for an UNEXPECTED
+     * submit failure (a thrown exception or rejected promise), read the
+     * same way in templates and after an imperative `await submit()`. An
+     * EXPECTED rejection handled the documented way (`setErrors(...)` then
+     * `return`, no throw) surfaces through the error store and `onError`
+     * instead, leaving `submitError` `null`. Like `hydrateError`, it stays
+     * distinct from the curated user-error store: render it where you
+     * choose:
      *
      * ```vue
      * <p v-if="form.meta.submitError">{{ form.meta.submitError.message }}</p>
@@ -3669,11 +3675,18 @@ type FormMeta<F = unknown> = FieldState<F> & {
      */
     readonly errorCount: number;
     /**
-     * `true` once a `handleSubmit` callback has resolved without
-     * throwing. Independent of `submissionAttempts` — a failed submit
-     * (validation failure or callback rejection) increments attempts but
-     * leaves `submitted` at `false`. Templates read it as "the form has
-     * been submitted successfully at least once."
+     * `true` once a `handleSubmit` callback has resolved without throwing
+     * AND left no errors behind. Independent of `submissionAttempts` — a
+     * failed submit (validation failure, callback rejection, or a callback
+     * that calls `setErrors` and returns) increments attempts but leaves
+     * `submitted` at `false`. Templates read it as "the form has been
+     * submitted successfully at least once."
+     *
+     * The error check is scoped to the user-error layer (`setErrors` /
+     * `clearErrors`): the documented server-rejection pattern
+     * (`setErrors(response.errors); return`) is a failed submit, so it does
+     * not flip `submitted`. A background async refinement that writes a
+     * schema error mid-submit does not retroactively fail it.
      *
      * Cleared by `form.reset()` alongside `submissionAttempts` and
      * `submitError`. For "the user has attempted a submit," read

package/dist/shared/{attaform.GJbSmwLB.d.mts → attaform.DBhrKb2j.d.ts}

@@ -2002,9 +2002,11 @@ type AttaformDefaults = {
  */
 type OnSubmit<Form extends GenericForm> = (form: Form) => void | Promise<void>;
 /**
- * Callback invoked by `handleSubmit` when validation fails. Receives
- * the full list of errors. Bind this when you want to react to
- * submit failures explicitly (alongside or instead of the
+ * Callback invoked by `handleSubmit` on a failed submit. Fires when
+ * client validation fails AND when the submit callback leaves errors in
+ * the user-error layer (the `setErrors(...); return` server-rejection
+ * pattern). Receives the full list of errors. Bind this when you want to
+ * react to submit failures explicitly (alongside or instead of the
  * automatic `onInvalidSubmit` UI nudge).
  */
 type OnError = (error: ValidationError[]) => void | Promise<void>;
@@ -3649,10 +3651,14 @@ type FormMeta<F = unknown> = FieldState<F> & {
      *
      * The submit handler does NOT re-throw — its returned promise always
      * resolves, so binding it to `@submit.prevent` never manufactures a
-     * `window` unhandledrejection. This is the single channel for "the
-     * submit failed", read the same way in templates and after an
-     * imperative `await submit()`. Like `hydrateError`, it stays distinct
-     * from the curated user-error store: render it where you choose:
+     * `window` unhandledrejection. This is the channel for an UNEXPECTED
+     * submit failure (a thrown exception or rejected promise), read the
+     * same way in templates and after an imperative `await submit()`. An
+     * EXPECTED rejection handled the documented way (`setErrors(...)` then
+     * `return`, no throw) surfaces through the error store and `onError`
+     * instead, leaving `submitError` `null`. Like `hydrateError`, it stays
+     * distinct from the curated user-error store: render it where you
+     * choose:
      *
      * ```vue
      * <p v-if="form.meta.submitError">{{ form.meta.submitError.message }}</p>
@@ -3669,11 +3675,18 @@ type FormMeta<F = unknown> = FieldState<F> & {
      */
     readonly errorCount: number;
     /**
-     * `true` once a `handleSubmit` callback has resolved without
-     * throwing. Independent of `submissionAttempts` — a failed submit
-     * (validation failure or callback rejection) increments attempts but
-     * leaves `submitted` at `false`. Templates read it as "the form has
-     * been submitted successfully at least once."
+     * `true` once a `handleSubmit` callback has resolved without throwing
+     * AND left no errors behind. Independent of `submissionAttempts` — a
+     * failed submit (validation failure, callback rejection, or a callback
+     * that calls `setErrors` and returns) increments attempts but leaves
+     * `submitted` at `false`. Templates read it as "the form has been
+     * submitted successfully at least once."
+     *
+     * The error check is scoped to the user-error layer (`setErrors` /
+     * `clearErrors`): the documented server-rejection pattern
+     * (`setErrors(response.errors); return`) is a failed submit, so it does
+     * not flip `submitted`. A background async refinement that writes a
+     * schema error mid-submit does not retroactively fail it.
      *
      * Cleared by `form.reset()` alongside `submissionAttempts` and
      * `submitError`. For "the user has attempted a submit," read

package/dist/shared/{attaform.C42wL7EJ.cjs → attaform.DRQjF16I.cjs}

@@ -1,7 +1,8 @@
 'use strict';
 
 const vue = require('vue');
-const paths = require('./attaform.DwkU0oY9.cjs');
+const paths = require('./attaform.B7UdTs_o.cjs');
+const registerProtocol = require('./attaform.CjdepGnw.cjs');
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -1921,6 +1922,19 @@ function buildProcessForm(state, formInstanceId, options = {}) {
           state.clearSchemaErrors();
         }
         await onSubmit(merged.data);
+        if (state.userErrors.size > 0) {
+          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) {
           state.submitted.value = true;
         }
@@ -5923,7 +5937,7 @@ function useRegister() {
       const dirs = instance.vnode.dirs;
       if (dirs !== null && dirs !== void 0) {
         for (const dir of dirs) {
-          const marked = dir.dir?.[paths.V_REGISTER_MARKER];
+          const marked = dir.dir?.[registerProtocol.V_REGISTER_MARKER];
           if (marked === true) {
             capturedRegisterValue.value = dir.value;
             break;
@@ -5939,7 +5953,7 @@ function useRegister() {
   vue.onMounted(() => {
     const el = instance.vnode.el;
     if (el !== null && el !== void 0 && typeof el === "object") {
-      el[paths.REGISTER_OWNER_MARKER] = true;
+      el[registerProtocol.REGISTER_OWNER_MARKER] = true;
     }
     if (capturedRegisterValue.value === void 0) {
       warnNoParentRV(instance);
@@ -6738,6 +6752,30 @@ function useWizard(options) {
     }
     return out;
   }
+  function collectCallbackErrors(keys) {
+    const out = [];
+    for (const key of keys) {
+      const store = registry.forms.get(key);
+      if (store === void 0) continue;
+      for (const errs of store.userErrors.values()) {
+        for (const err of errs) out.push(toWizardAggregateError(err, key));
+      }
+    }
+    return out;
+  }
+  async function focusFirstWizardError(errors) {
+    if (options.focusFirstError === false) return;
+    const firstFailedKey = errors[0]?.formKey;
+    if (firstFailedKey === void 0 || !isCompiledKey(firstFailedKey)) return;
+    moveTo(firstFailedKey);
+    await vue.nextTick();
+    const failedForm = formsRecord.value[firstFailedKey];
+    if (failedForm === void 0) return;
+    const failedSource = asSubmissionSource(failedForm);
+    if (typeof failedSource.applyInvalidSubmitPolicy === "function") {
+      failedSource.applyInvalidSubmitPolicy();
+    }
+  }
   function handleSubmit(onSubmit, onError) {
     return async function submitHandler(event) {
       if (event !== void 0 && typeof event.preventDefault === "function") {
@@ -6800,6 +6838,18 @@ function useWizard(options) {
           }
           const ctx = buildSubmitContext(valuesMap, currentKey, final);
           await onSubmit(ctx);
+          const callbackErrors = collectCallbackErrors(results.keys());
+          if (callbackErrors.length > 0) {
+            await focusFirstWizardError(callbackErrors);
+            if (onError !== void 0) {
+              try {
+                await onError(callbackErrors);
+              } catch (cause) {
+                throw new paths.SubmitErrorHandlerError("User-provided onError threw", { cause });
+              }
+            }
+            return;
+          }
           if (final) {
             done.value = true;
           } else {
@@ -6809,20 +6859,7 @@ function useWizard(options) {
             if (target !== void 0) moveTo(target.key);
           }
         } else {
-          if (options.focusFirstError !== false) {
-            const firstFailedKey = errors[0]?.formKey;
-            if (firstFailedKey !== void 0 && isCompiledKey(firstFailedKey)) {
-              moveTo(firstFailedKey);
-              await vue.nextTick();
-              const failedForm = formsRecord.value[firstFailedKey];
-              if (failedForm !== void 0) {
-                const failedSource = asSubmissionSource(failedForm);
-                if (typeof failedSource.applyInvalidSubmitPolicy === "function") {
-                  failedSource.applyInvalidSubmitPolicy();
-                }
-              }
-            }
-          }
+          await focusFirstWizardError(errors);
           if (onError !== void 0) {
             try {
               await onError(errors);
@@ -7050,4 +7087,4 @@ exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.C42wL7EJ.cjs.map
+//# sourceMappingURL=attaform.DRQjF16I.cjs.map