attaform 0.24.0 → 0.24.2

package/dist/shared/{attaform.CuBdtfbe.mjs → attaform.BI7M3wK8.mjs}

@@ -1,5 +1,6 @@
 import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, toRaw, reactive, watch, markRaw, triggerRef, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope, nextTick } from 'vue';
-import { o as pathsEqual, j as isPathPrefix, _ as __DEV__, f as canonicalizePath, s as segmentsForPathKey, q as keyForSegments, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, r as INTERACTIVE_TAG_NAMES, R as ROOT_PATH, w as coerceToPathKey, a as InvalidUseFormConfigError, x as ensureAttaformInstalled, u as useRegistry, y as kFormContext, z as kFormInstanceId, d as ReservedFormKeyError, B as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER, m as kAttaformWizardActiveStepResolver, C as kAttaformAncestorWizard } from './attaform.Df-s8j1X.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 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.C0au8oXd.mjs';
+import { R as REGISTER_OWNER_MARKER, V as V_REGISTER_MARKER } from './attaform.WvcckZMD.mjs';
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -913,6 +914,10 @@ function buildContainerFieldStateBase(state, segments, key, formInstanceId) {
     pristine = false;
     dirty = true;
   }
+  if (!dirty && state.hasRemovedSubtreeUnder(segments)) {
+    pristine = false;
+    dirty = true;
+  }
   const errors = aggregateErrorsAt(state, segments);
   const revealedDescendantError = errors.length > 0 && errors.some((e) => {
     const ePath = e.path;
@@ -1919,6 +1924,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 SubmitErrorHandlerError("User-provided onError threw", { cause });
+            }
+          }
+          return;
+        }
         if (state.submissionGeneration.value === genAtEntry) {
           state.submitted.value = true;
         }
@@ -3886,6 +3904,7 @@ function mergeObjectKeys(target, source, path, schema) {
   return out;
 }
 
+const isContainer = (value) => Array.isArray(value) || isPlainRecord(value);
 function isHydratedFieldRecord(value) {
   if (typeof value !== "object" || value === null) return false;
   const r = value;
@@ -4075,6 +4094,7 @@ function createFormStore(options) {
   const schemaErrors = reactive(/* @__PURE__ */ new Map());
   const userErrors = reactive(/* @__PURE__ */ new Map());
   const originals = reactive(/* @__PURE__ */ new Map());
+  const removedSubtrees = /* @__PURE__ */ new Set();
   const initialTransientList = hydration?.blankPaths ?? options.initialBlankPaths ?? [];
   const blankPaths = reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
@@ -4560,6 +4580,9 @@ function createFormStore(options) {
       return true;
     }
     const oldArrayLength = Array.isArray(currentValue) ? currentValue.length : 0;
+    if (meta?.arrayOp === void 0 && Array.isArray(value) && Array.isArray(currentValue)) {
+      arrayIdentity.realign(path);
+    }
     applyTargetedWrite(path, completedValue, meta);
     if (meta?.arrayOp !== void 0) {
       const remap = remapForOp(meta.arrayOp, oldArrayLength);
@@ -4572,6 +4595,10 @@ function createFormStore(options) {
     } else if (Array.isArray(value) && Array.isArray(currentValue)) {
       variantMemory.clearUnderPath(path);
       arrayIdentity.realign(path);
+    } else if (isContainer(currentValue) && !isContainer(value)) {
+      if (subtreeHadRealBaseline(path, currentValue)) {
+        removedSubtrees.add(canonicalizePath(path).key);
+      }
     }
     const effectiveModeAfterWrite = meta?.instance?.validateOn ?? fieldValidationMode;
     if (effectiveModeAfterWrite === "change") {
@@ -5105,6 +5132,7 @@ function createFormStore(options) {
     rebuildAuthoredPaths(resetSource, next);
     applyFormReplacement(next);
     arrayIdentity.rebaselineAll();
+    removedSubtrees.clear();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
       if (patch.kind !== "added") return;
@@ -5241,6 +5269,26 @@ function createFormStore(options) {
   function hasStructuralChangeUnder(path) {
     return arrayIdentity.hasStructuralChangeUnder(path);
   }
+  function subtreeHadRealBaseline(prefix, removedValue) {
+    let had = false;
+    diffAndApply(removedValue, void 0, prefix, (patch) => {
+      if (had || patch.kind !== "removed") return;
+      const record = originals.get(canonicalizePath(patch.path).key);
+      if (record?.value !== void 0) had = true;
+    });
+    return had;
+  }
+  function hasRemovedSubtreeUnder(prefix) {
+    if (removedSubtrees.size === 0) return false;
+    for (const key of removedSubtrees) {
+      const segments = segmentsForPathKey(key);
+      if (segments === null) continue;
+      if (!isPathPrefix(prefix, segments)) continue;
+      if (isContainer(getAtPath(toRaw(form.value), segments))) continue;
+      return true;
+    }
+    return false;
+  }
   function getFieldRecord(path) {
     const { key } = canonicalizePath(path);
     return fields.get(key);
@@ -5336,6 +5384,7 @@ function createFormStore(options) {
     isPristineAtPath,
     isPristineAtPathByKey,
     hasStructuralChangeUnder,
+    hasRemovedSubtreeUnder,
     getFieldRecord,
     getOriginalAtPath,
     getFirstErrorElement,
@@ -6736,6 +6785,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 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") {
@@ -6798,6 +6871,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 SubmitErrorHandlerError("User-provided onError threw", { cause });
+              }
+            }
+            return;
+          }
           if (final) {
             done.value = true;
           } else {
@@ -6807,20 +6892,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 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);
@@ -7028,4 +7100,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.CuBdtfbe.mjs.map
+//# sourceMappingURL=attaform.BI7M3wK8.mjs.map