attaform 0.31.0 → 0.31.1

package/dist/shared/{attaform.DAo0QBmS.d.mts → attaform.CYlF4P6X.d.mts}

@@ -1,4 +1,4 @@
-import { G as GenericForm, F as FormKey, a as UseFormReturnType, _ as RegisterValue, v as Path, w as PathKey, aq as DisplayCtx, ar as GetDisplayState, as as DisplayMachine, at as FieldRecord, au as ErrorCell, ac as ValidationError, av as OriginalsRecord, A as AbstractSchema, ag as WriteMeta, d as DeepPartial, ah as WriteShape, aw as AttaformDomBinding, ax as TransformAbortHolder } from './attaform.DZnrDrNb.mjs';
+import { G as GenericForm, F as FormKey, a as UseFormReturnType, _ as RegisterValue, v as Path, w as PathKey, aq as DisplayCtx, ar as GetDisplayState, as as DisplayMachine, at as FieldRecord, au as ErrorCell, ac as ValidationError, av as OriginalsRecord, A as AbstractSchema, ag as WriteMeta, d as DeepPartial, ah as WriteShape, aw as StructureSnapshot, ax as AttaformDomBinding, ay as TransformAbortHolder } from './attaform.i13OEHJF.mjs';
 import { Ref, ComputedRef, ShallowRef, App, InjectionKey, Plugin } from 'vue';
 
 /** Options accepted by `injectForm` in place of a bare key string. */
@@ -286,6 +286,13 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     readonly pathSweep: DynamicPathSweep;
     readonly formKey: FormKey;
     readonly form: Ref<F>;
+    /**
+     * Per-path field records: one per leaf from construction, and one per
+     * container, the root (`[]`) included, once a directive binds to it or a
+     * write takes leaves away beneath it. A container's own record holds the
+     * stamp of that write and the interaction history of the descendants it
+     * took; see `stampContainers` and `foldInteractionHistory`.
+     */
     readonly fields: Map<PathKey, FieldRecord>;
     /**
      * The tagged error store: one cell per error-bearing path, each segregating
@@ -641,6 +648,19 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * empty is skipped.
      */
     restoreErrorCells(entries: ReadonlyArray<readonly [PathKey, ErrorCell]>): void;
+    /**
+     * The per-element bookkeeping as it stands, for a history position to put
+     * back with its value (see `StructureSnapshot`). The entries are copied,
+     * and the records they hold are never mutated in place, so the snapshot
+     * stays detached from the live store.
+     */
+    captureStructure(): StructureSnapshot;
+    /**
+     * Put a `captureStructure()` back, before the value it was taken with is
+     * restored, so the write that restores it compares each row against its
+     * own baseline. Every reading it can change is woken.
+     */
+    restoreStructure(snapshot: StructureSnapshot): void;
     /**
      * Merged read of the cell at `path`, in schema -> blank -> user order:
      * structural validation first, the synthesized blank entry between, user
@@ -729,18 +749,19 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * insert or removal) against its construction / reset baseline. The
      * structural half of `dirty`: per-element baselines travel with their
      * element across a mutation, so a positional value comparison alone cannot
-     * see the shape change.
+     * see the shape change. `key` is the canonical key of `path`.
      */
-    hasStructuralChangeUnder(path: Path): boolean;
+    hasStructuralChangeUnder(path: Path, key: PathKey): boolean;
     /**
-     * Whether a baseline-present container under `path` was replaced wholesale
-     * by a non-container (`setValue('profile', undefined)` and the like) and is
-     * still absent. The other half of removal-driven `dirty`: every leaf in such
-     * a subtree vanishes at once, so neither the present-leaf walk nor the array
-     * tracker sees the loss. Self-filters by current liveness, so a refilled
-     * path stops counting.
+     * Whether a path under `path` that held a real baseline value was removed
+     * and is still absent: a dropped key, an emptied container, a row a
+     * wholesale write took away. The other half of removal-driven `dirty`: the
+     * present-leaf walk never visits an absent leaf, and the array tracker
+     * follows only array lengths and orders. A path a later write brought back
+     * stops counting, and the present-leaf walk judges it instead. `key` is the
+     * canonical key of `path`.
      */
-    hasRemovedSubtreeUnder(path: Path): boolean;
+    hasRemovedSubtreeUnder(path: Path, key: PathKey): boolean;
     getFieldRecord(path: Path): FieldRecord | undefined;
     /**
      * Cancel every in-flight field-level validation run: clear the timers of

package/dist/shared/{attaform.C4shmwyJ.mjs → attaform.CdA9bfRv.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.CdZIEf7_.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.BhtAZysa.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {