attaform 0.24.1 → 0.24.2

package/dist/shared/{attaform.4zesozTg.d.mts → attaform.BjiHiYAZ.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, D as DefaultValuesInput, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.DBhrKb2j.mjs';
+import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.DUc6cetN.js';
 
 /**
  * The shape `form.values.<key>` returns at runtime.
@@ -223,8 +223,9 @@ type PathOutput<Schema extends z.ZodType, Path extends string> = z.output<Schema
 type FormOf<Schema extends SupportedRootSchema> = z.input<Schema> extends GenericForm ? z.input<Schema> : never;
 type OutOf<Schema extends SupportedRootSchema> = z.output<Schema> extends GenericForm ? z.output<Schema> : never;
 type ReadOf<Schema extends SupportedRootSchema> = StorageShape<Schema> extends GenericForm ? StorageShape<Schema> : never;
-declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, DefaultValuesInput<FormOf<Schema>>, K>, 'schema' | 'validateOn' | 'debounceMs'> & {
+declare function useForm<Schema extends SupportedRootSchema, K extends FormKey = FormKey>(configuration: Omit<UseFormConfiguration<FormOf<Schema>, OutOf<Schema>, AbstractSchema<FormOf<Schema>, OutOf<Schema>>, never, K>, 'schema' | 'validateOn' | 'debounceMs' | 'defaultValues'> & {
     schema: Schema;
+    defaultValues?: AcceptableDefaults<FormOf<Schema>, z.input<Schema>>;
 } & ValidateOnConfig): UseFormReturnType<FormOf<Schema>, OutOf<Schema>, ReadOf<Schema>, K>;
 
 export { useForm as u };

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

@@ -916,6 +916,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;
@@ -3902,6 +3906,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;
@@ -4091,6 +4096,7 @@ function createFormStore(options) {
   const schemaErrors = vue.reactive(/* @__PURE__ */ new Map());
   const userErrors = vue.reactive(/* @__PURE__ */ new Map());
   const originals = vue.reactive(/* @__PURE__ */ new Map());
+  const removedSubtrees = /* @__PURE__ */ new Set();
   const initialTransientList = hydration?.blankPaths ?? options.initialBlankPaths ?? [];
   const blankPaths = vue.reactive(/* @__PURE__ */ new Set());
   const originalBlankPaths = /* @__PURE__ */ new Set();
@@ -4576,6 +4582,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);
@@ -4588,6 +4597,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(paths.canonicalizePath(path).key);
+      }
     }
     const effectiveModeAfterWrite = meta?.instance?.validateOn ?? fieldValidationMode;
     if (effectiveModeAfterWrite === "change") {
@@ -5121,6 +5134,7 @@ function createFormStore(options) {
     rebuildAuthoredPaths(resetSource, next);
     applyFormReplacement(next);
     arrayIdentity.rebaselineAll();
+    removedSubtrees.clear();
     originals.clear();
     diffAndApply({}, next, [], (patch) => {
       if (patch.kind !== "added") return;
@@ -5257,6 +5271,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(paths.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 = paths.segmentsForPathKey(key);
+      if (segments === null) continue;
+      if (!paths.isPathPrefix(prefix, segments)) continue;
+      if (isContainer(getAtPath(vue.toRaw(form.value), segments))) continue;
+      return true;
+    }
+    return false;
+  }
   function getFieldRecord(path) {
     const { key } = paths.canonicalizePath(path);
     return fields.get(key);
@@ -5352,6 +5386,7 @@ function createFormStore(options) {
     isPristineAtPath,
     isPristineAtPathByKey,
     hasStructuralChangeUnder,
+    hasRemovedSubtreeUnder,
     getFieldRecord,
     getOriginalAtPath,
     getFirstErrorElement,
@@ -7087,4 +7122,4 @@ exports.unset = unset;
 exports.useAbstractForm = useAbstractForm;
 exports.useRegister = useRegister;
 exports.useWizard = useWizard;
-//# sourceMappingURL=attaform.DRQjF16I.cjs.map
+//# sourceMappingURL=attaform.Bos7wVZw.cjs.map