attaform 0.18.1 → 0.19.0

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

@@ -1,4 +1,4 @@
-import { F as FormKey, af as SlimPrimitiveKind, C as CoercionEntry, j as CoercionRegistry, G as GenericForm, Y as PathKey, X as Path, V as ValidationError, a as AbstractSchema, d as ShouldShowErrors, ao as WriteMeta, m as DeepPartial, ap as WriteShape, aj as ValidateOn, aw as PersistOptInRegistry, S as Segment, A as AttaformDefaults, b as UseFormReturnType, R as RegisterValue } from './attaform.Dj9mwbaV.js';
+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;
     /**
@@ -1647,5 +1680,5 @@ declare const AttaformErrorCode: {
 };
 type AttaformErrorCode = (typeof AttaformErrorCode)[keyof typeof AttaformErrorCode];
 
-export { AttaformErrorCode as d, createRegistry as p, defaultCoercionRules as q, defineCoercion as r, getRegistryFromApp as s, injectForm as t, injectWizard as u, kAttaformRegistry as v, lazy as w, useRegister as x, useRegistry as y, useWizard as z };
-export type { AttaformRegistry as A, CompiledStep as C, FormStatus as F, InjectWizardInput as I, LazyMarker as L, SSRDetectOptions as S, UseRegisterReturn as U, WizardCtx as W, SerializedFormData as a, AggregateError as b, AnyForm as c, StepSlot as e, UseWizardReturnType as f, WizardCtxForm as g, WizardOnError as h, WizardOnSubmit as i, WizardOptions as j, WizardPersistFn as k, WizardRestoreFn as l, WizardRestoreState as m, WizardStatusesProxy as n, WizardSubmitContext as o };
+export { AttaformErrorCode as b, createRegistry as p, defaultCoercionRules as q, defineCoercion as r, getRegistryFromApp as s, injectForm as t, injectWizard as u, kAttaformRegistry as v, lazy as w, useRegister as x, useRegistry as y, useWizard as z };
+export type { AggregateError as A, CompiledStep as C, FormStatus as F, InjectWizardInput as I, LazyMarker as L, SSRDetectOptions as S, UseRegisterReturn as U, WizardCtx as W, AnyForm as a, AttaformRegistry as c, SerializedFormData as d, StepSlot as e, UseWizardReturnType as f, WizardCtxForm as g, WizardOnError as h, WizardOnSubmit as i, WizardOptions as j, WizardPersistFn as k, WizardRestoreFn as l, WizardRestoreState as m, WizardStatusesProxy as n, WizardSubmitContext as o };