attaform 0.18.2 → 0.19.0

package/dist/shared/{attaform.D1gzu2GL.d.mts → attaform.BtBmfLQN.d.mts}

@@ -1,4 +1,4 @@
-import { s as FormKey, ae as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, R as PathKey, Q as Path, am as ValidationError, A as AbstractSchema, ac as ShouldShowErrors, aq as WriteMeta, D as DeepPartial, ar as WriteShape, ak as ValidateOn, W as PersistOptInRegistry, a8 as Segment, f as AttaformDefaults, aj as UseFormReturnType, a6 as RegisterValue } from './attaform.Ca5_6Ky-.mjs';
+import { t as FormKey, ae as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, T as PathKey, S as Path, am as ValidationError, A as AbstractSchema, x as GetDisplayState, aq as WriteMeta, D as DeepPartial, ar as WriteShape, ak as ValidateOn, Y as PersistOptInRegistry, aa as Segment, f as AttaformDefaults, aj as UseFormReturnType, a8 as RegisterValue } from './attaform.C0uGZQ4M.mjs';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -517,19 +517,29 @@ declare const defaultCoercionRules: CoercionRegistry;
  */
 /**
  * Per-path field status. Replaced wholesale (not mutated in place) on
- * every change. Three semantic groups:
+ * every change. Five semantic groups:
  *
  *   - `connected` — is a DOM element registered for this path?
  *   - `focused` / `blurred` — DOM-state flags. `null` while no element
  *     is connected (no DOM means the concepts don't apply); plain
  *     booleans once connected, with the invariant `blurred === !focused`
  *     enforced by `markFocused`.
- *   - `touched` — interaction history, not DOM state. Always a plain
+ *   - `touched` — focus/blur history, not DOM state. Always a plain
  *     boolean: `false` at registration, sticky `true` after first blur,
  *     cleared only by `form.reset()` / `form.resetField(path)`. Persists
  *     across disconnects so v-if'd-away fields don't lose their touched
  *     state on rehide (wizard "show review of touched fields" patterns
  *     rely on this).
+ *   - `interacted` — value-mutation history, not DOM state. Plain
+ *     boolean: `false` at registration, sticky `true` once the user
+ *     issues a value edit through the directive's input listeners
+ *     (never on hydration, default seeding, or programmatic setValue);
+ *     cleared with `touched` by `form.reset()` / `form.resetField(path)`.
+ *   - `blurredAfterInteraction` — the first blur that follows a value
+ *     edit (the field has been edited and then left). Plain boolean,
+ *     sticky `true`. A tab-through blur with no prior edit does NOT set
+ *     it (`interacted` is still false at that blur). Composes
+ *     `interacted` with the departure; drives the default display gate.
  */
 type FieldRecord = {
     readonly path: Path;
@@ -538,6 +548,8 @@ type FieldRecord = {
     readonly focused: boolean | null;
     readonly blurred: boolean | null;
     readonly touched: boolean;
+    readonly interacted: boolean;
+    readonly blurredAfterInteraction: boolean;
 };
 /** Per-path DOM element tracking. Client-only. */
 type ElementRecord = {
@@ -649,15 +661,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      */
     readonly ssr: boolean;
     /**
-     * Resolved `shouldShowErrors` predicate driving `field.showErrors`
-     * and `form.meta.showErrors`. Resolved once at construction via
-     * `resolveShouldShowErrors(options.shouldShowErrors)` so the
-     * field-state computeds don't repeat the boolean-vs-function
-     * branch on every read. Boolean shorthand has already been lifted
-     * to a constant predicate by the time it lands here; `undefined`
-     * config falls through to `defaultShouldShowErrors`.
+     * Resolved `getDisplayState` predicate driving `field.displayState`,
+     * the `show*` booleans, and their `form.meta` rollups. Resolved once
+     * at construction via `resolveGetDisplayState(options.getDisplayState)`;
+     * `undefined` config falls through to `defaultDisplayState`. The
+     * field-state computeds read the resolved function directly on every
+     * read.
      */
-    readonly shouldShowErrors: ShouldShowErrors;
+    readonly getDisplayState: GetDisplayState;
     readonly submitting: Ref<boolean>;
     readonly activeSubmissions: Ref<number>;
     readonly submissionAttempts: Ref<number>;
@@ -831,6 +842,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      */
     setValueAtPath(path: Path, value: unknown, meta?: WriteMeta): boolean;
     getValueAtPath(path: Path): unknown;
+    /**
+     * Stable identity for the array element at `path`. An array element
+     * (numeric last segment) carries its allocated identity token,
+     * maintained by `array-identity.ts` across structural mutations.
+     * Empty for any non-array-element path: a record entry, a
+     * fixed-object field, a container, or the root. Backs `FieldState.key`.
+     */
+    arrayElementKey(path: Path): string;
     reset(nextDefaultValues?: DeepPartial<WriteShape<F>>): void;
     resetField(path: Path): void;
     /**
@@ -894,6 +913,12 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
         readonly instance?: WriteMeta['instance'];
     }): void;
     markTouched(path: Path): void;
+    /**
+     * Flip `interacted: true` on a leaf — the sticky value-mutation flag.
+     * Driven by the directive's input listeners (via the RegisterValue's
+     * `markInteracted`); idempotent, never set by programmatic writes.
+     */
+    markInteracted(path: Path): void;
     /**
      * Walk every active-variant leaf under `segments` and flip
      * `touched: true`. Powers `form.touch(path?)`. Idempotent;
@@ -920,6 +945,14 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * isn't exposed to consumers.
      */
     isPristineAtPath(path: Path): boolean;
+    /**
+     * Whether any tracked array under `path` has changed shape — a reorder,
+     * insert, or removal — relative to 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 can
+     * no longer see the shape change.
+     */
+    hasStructuralChangeUnder(path: Path): boolean;
     getFieldRecord(path: Path): FieldRecord | undefined;
     getOriginalAtPath(path: Path): unknown;
     /**