attaform 0.18.1 → 0.19.0

package/dist/shared/{attaform.iTqxvl-P.d.mts → attaform.BTpuvGec.d.ts}

@@ -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.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.js';
 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 };

package/dist/shared/{attaform.BqK_L4gK.cjs → attaform.BqEfHpVB.cjs}

@@ -818,6 +818,9 @@ function setAssignFunction(el, vnode, value) {
   }
   el[assignKey] = getModelAssigner(el, vnode, value);
 }
+function noteInteraction(value) {
+  if (isRegisterValue(value)) value.markInteracted();
+}
 const vRegisterText = {
   created(el, { value, modifiers: { lazy, trim, number } }, vnode) {
     const castToNumber = number === true || vnode.props?.["type"] === "number";
@@ -829,6 +832,7 @@ const vRegisterText = {
       if (shouldBailListener(el)) return;
       const target = e.target;
       if (target === null || target.composing) return;
+      noteInteraction(value);
       let domValue = el.value;
       if (trim === true && lazy === true) {
         domValue = domValue.trim();
@@ -960,6 +964,7 @@ const vRegisterCheckbox = {
     setAssignFunction(el, vnode, value);
     addEventListener(el, "change", () => {
       if (shouldBailListener(el)) return;
+      noteInteraction(value);
       const modelValue = value.innerRef.value ?? [];
       const explicitValueRequired = true;
       const rawElementValue = getValue(el, explicitValueRequired);
@@ -1057,6 +1062,7 @@ const vRegisterRadio = {
     setAssignFunction(el, vnode, value);
     addEventListener(el, "change", () => {
       if (shouldBailListener(el)) return;
+      noteInteraction(value);
       el[assignKey]?.(getValue(el));
       if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
         const currentModel = value.innerRef.value;
@@ -1105,6 +1111,7 @@ const vRegisterSelect = {
     const isSetModel = isSet(value.innerRef.value);
     addEventListener(el, "change", () => {
       if (shouldBailListener(el)) return;
+      noteInteraction(value);
       const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map((o) => number === true ? looseToNumber(getValue(o)) : getValue(o));
       const wrote = el[assignKey]?.(
         el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
@@ -1219,11 +1226,83 @@ function getCheckboxValue(el, checked) {
 }
 const SUPPORTED_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
 const warnedUnsupportedElements = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
+const MANAGED_ARIA_ATTRS = [
+  "aria-invalid",
+  "aria-busy",
+  "aria-required",
+  "aria-describedby"
+];
+const ariaLockKey = Symbol.for("attaform:aria-locks");
+const ariaScopeKey = Symbol.for("attaform:aria-scope");
+const EMPTY_ARIA_LOCKS = /* @__PURE__ */ new Set();
+function mergeAriaLocks(el, vnode) {
+  let locks = el[ariaLockKey];
+  if (locks === void 0) {
+    locks = /* @__PURE__ */ new Set();
+    el[ariaLockKey] = locks;
+  }
+  const props = vnode.props;
+  if (props !== null) {
+    for (const attr of MANAGED_ARIA_ATTRS) {
+      if (attr in props) locks.add(attr);
+    }
+  }
+  return locks;
+}
+function setAriaAttr(el, attr, value) {
+  if (value === null) el.removeAttribute(attr);
+  else el.setAttribute(attr, value);
+}
+function resolveAriaValue(attr, rv, ds) {
+  switch (attr) {
+    case "aria-invalid":
+      return ds === "error" ? "true" : null;
+    case "aria-busy":
+      return ds === "pending" ? "true" : null;
+    case "aria-required":
+      return rv.isRequired === true ? "true" : null;
+    case "aria-describedby":
+      return ds === "error" && rv.aria?.errorId !== void 0 ? rv.aria.errorId : null;
+    default:
+      return null;
+  }
+}
+function applyAria(el, rv) {
+  if (rv.ariaEnabled !== true || rv.ariaDisplayState === void 0) return;
+  const locks = el[ariaLockKey] ?? EMPTY_ARIA_LOCKS;
+  const ds = rv.ariaDisplayState.value;
+  for (const attr of MANAGED_ARIA_ATTRS) {
+    if (!locks.has(attr)) setAriaAttr(el, attr, resolveAriaValue(attr, rv, ds));
+  }
+}
+function setupAria(el, rv, vnode) {
+  if (rv.ariaEnabled !== true || rv.ariaDisplayState === void 0) return;
+  mergeAriaLocks(el, vnode);
+  applyAria(el, rv);
+  const displayState = rv.ariaDisplayState;
+  const scope = vue.effectScope(true);
+  scope.run(() => {
+    vue.watch(displayState, () => applyAria(el, rv), { flush: "post" });
+  });
+  el[ariaScopeKey] = () => scope.stop();
+}
+function teardownAria(el) {
+  const stop = el[ariaScopeKey];
+  if (stop === void 0) return;
+  stop();
+  delete el[ariaScopeKey];
+  const locks = el[ariaLockKey] ?? EMPTY_ARIA_LOCKS;
+  for (const attr of MANAGED_ARIA_ATTRS) {
+    if (!locks.has(attr)) el.removeAttribute(attr);
+  }
+  delete el[ariaLockKey];
+}
 const vRegisterDynamic = {
   created(el, binding, vnode) {
     syncPersistOptIn(el, binding.value, void 0, vnode.props?.["type"]);
     syncMultiTabOptOut(binding.value, void 0);
     callModelHook(el, binding, vnode, null, "created");
+    if (isRegisterValue(binding.value)) setupAria(el, binding.value, vnode);
     if (__DEV__ && warnedUnsupportedElements !== null && !SUPPORTED_TAGS.has(el.tagName) && !warnedUnsupportedElements.has(el)) {
       void vue.nextTick(() => {
         if (warnedUnsupportedElements.has(el)) return;
@@ -1247,12 +1326,28 @@ const vRegisterDynamic = {
     syncMultiTabOptOut(binding.value, binding.oldValue);
     syncElementRegistration(el, binding.value, binding.oldValue);
     callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+    const ariaEl = el;
+    const value = binding.value;
+    if (!isRegisterValue(value) || value.ariaEnabled !== true || value.ariaDisplayState === void 0) {
+      teardownAria(ariaEl);
+    } else {
+      const old = binding.oldValue;
+      const pathChanged = !isRegisterValue(old) || old.path !== value.path;
+      if (pathChanged) {
+        teardownAria(ariaEl);
+        setupAria(ariaEl, value, vnode);
+      } else {
+        mergeAriaLocks(ariaEl, vnode);
+        applyAria(ariaEl, value);
+      }
+    }
   },
   updated(el, binding, vnode, prevVNode) {
     callModelHook(el, binding, vnode, prevVNode, "updated");
   },
   beforeUnmount(el, { value }) {
     removeTrackedListeners(el);
+    teardownAria(el);
     if (isRegisterValue(value)) {
       value.persistOptIns.removeAllFor(getOrAssignElementId(el));
       value.unmarkNoSync?.();
@@ -1262,6 +1357,28 @@ const vRegisterDynamic = {
     delete el.composing;
     delete el._assigning;
     delete el[assignKey];
+  },
+  // The lifecycle hooks above don't run on the server (Vue skips
+  // directive lifecycle during SSR), so emit the same aria attributes
+  // here from the SSR-time gated display state. Honors authored attrs
+  // (vnode-level lockout) and the ariaEnabled gate, touches no DOM, and
+  // shares `resolveAriaValue` with the client path. Ids are SSR-stable
+  // (formInstanceId derives from Vue's useId), so a server-rendered
+  // describedby matches the client after hydration.
+  getSSRProps(binding, vnode) {
+    const rv = binding.value;
+    if (!isRegisterValue(rv) || rv.ariaEnabled !== true || rv.ariaDisplayState === void 0) {
+      return void 0;
+    }
+    const props = vnode?.props ?? null;
+    const ds = rv.ariaDisplayState.value;
+    const out = {};
+    for (const attr of MANAGED_ARIA_ATTRS) {
+      if (props !== null && attr in props) continue;
+      const value = resolveAriaValue(attr, rv, ds);
+      if (value !== null) out[attr] = value;
+    }
+    return out;
   }
 };
 function isBlankFileValue(value) {
@@ -1307,6 +1424,7 @@ const vRegisterFile = {
       value.setValueWithInternalPath(blankShape, { blank: true });
     }
     addEventListener(input, "change", () => {
+      noteInteraction(value);
       const next = readFilesFromInput(input);
       const blank = isBlankFileValue(next);
       value.setValueWithInternalPath(next, blank ? { blank: true } : void 0);
@@ -1548,4 +1666,4 @@ exports.segmentsForPathKey = segmentsForPathKey;
 exports.useRegister = useRegister;
 exports.useRegistry = useRegistry;
 exports.vRegister = vRegister;
-//# sourceMappingURL=attaform.BqK_L4gK.cjs.map
+//# sourceMappingURL=attaform.BqEfHpVB.cjs.map