attaform 0.20.2 → 0.21.0

package/dist/shared/attaform.CQN9R62B.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attaform.CQN9R62B.cjs","sources":["../../src/runtime/core/canonical-stringify.ts"],"sourcesContent":["/**\n * Canonical stringify for arbitrary values, shared by the v3 and v4\n * schema fingerprint walkers. Produces a stable string surface for\n * structural equality testing: object keys are sorted, arrays walk in\n * index order, and functions / symbols / cycles collapse to opaque\n * sentinels.\n *\n * This is NOT JSON. The output is not meant to round-trip through\n * `JSON.parse`; it exists purely so two structurally-equal values\n * serialise to the same string and two structurally-different values\n * do not.\n *\n * Cycle detection uses an ancestor-stack add / delete pattern: a\n * reference is only treated as cyclic while it sits on the path from\n * the root being stringified. Without the `delete` on the way back up,\n * two sibling properties pointing at the same object would see the\n * second one falsely labelled `<cyclic>`.\n */\nexport function canonicalStringify(value: unknown, seen: WeakSet<object> = new WeakSet()): string {\n  if (value === null) return 'null'\n  if (value === undefined) return 'undefined'\n  const t = typeof value\n  if (t === 'string') return JSON.stringify(value)\n  if (t === 'number' || t === 'boolean') return String(value)\n  if (t === 'bigint') return `${String(value)}n`\n  if (t === 'function') return 'fn:*'\n  if (t === 'symbol') return 'symbol:*'\n  if (Array.isArray(value)) {\n    if (seen.has(value)) return '<cyclic>'\n    seen.add(value)\n    try {\n      const parts = value.map((v) => canonicalStringify(v, seen))\n      return `[${parts.join(',')}]`\n    } finally {\n      seen.delete(value)\n    }\n  }\n  if (t === 'object') {\n    // `null` already returned above, so the remaining `object` branch is\n    // non-null; narrowing against null again is redundant (eslint's\n    // no-unnecessary-condition rule flags it).\n    const obj = value as Record<string, unknown>\n    if (seen.has(obj)) return '<cyclic>'\n    seen.add(obj)\n    try {\n      if (value instanceof Date) return `date:${value.getTime()}`\n      if (value instanceof RegExp) return `regex:${String(value)}`\n      const entries = Object.entries(obj)\n        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))\n        .map(([k, v]) => `${JSON.stringify(k)}:${canonicalStringify(v, seen)}`)\n      return `{${entries.join(',')}}`\n    } finally {\n      seen.delete(obj)\n    }\n  }\n  return 'unknown'\n}\n"],"names":[],"mappings":";;AAkBO,SAAS,kBAAA,CAAmB,KAAA,EAAgB,IAAA,mBAAwB,IAAI,SAAQ,EAAW;AAChG,EAAA,IAAI,KAAA,KAAU,MAAM,OAAO,MAAA;AAC3B,EAAA,IAAI,KAAA,KAAU,QAAW,OAAO,WAAA;AAChC,EAAA,MAAM,IAAI,OAAO,KAAA;AACjB,EAAA,IAAI,CAAA,KAAM,QAAA,EAAU,OAAO,IAAA,CAAK,UAAU,KAAK,CAAA;AAC/C,EAAA,IAAI,MAAM,QAAA,IAAY,CAAA,KAAM,SAAA,EAAW,OAAO,OAAO,KAAK,CAAA;AAC1D,EAAA,IAAI,MAAM,QAAA,EAAU,OAAO,CAAA,EAAG,MAAA,CAAO,KAAK,CAAC,CAAA,CAAA,CAAA;AAC3C,EAAA,IAAI,CAAA,KAAM,YAAY,OAAO,MAAA;AAC7B,EAAA,IAAI,CAAA,KAAM,UAAU,OAAO,UAAA;AAC3B,EAAA,IAAI,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxB,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,KAAK,CAAA,EAAG,OAAO,UAAA;AAC5B,IAAA,IAAA,CAAK,IAAI,KAAK,CAAA;AACd,IAAA,IAAI;AACF,MAAA,MAAM,KAAA,GAAQ,MAAM,GAAA,CAAI,CAAC,MAAM,kBAAA,CAAmB,CAAA,EAAG,IAAI,CAAC,CAAA;AAC1D,MAAA,OAAO,CAAA,CAAA,EAAI,KAAA,CAAM,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAAA,IAC5B,CAAA,SAAE;AACA,MAAA,IAAA,CAAK,OAAO,KAAK,CAAA;AAAA,IACnB;AAAA,EACF;AACA,EAAA,IAAI,MAAM,QAAA,EAAU;AAIlB,IAAA,MAAM,GAAA,GAAM,KAAA;AACZ,IAAA,IAAI,IAAA,CAAK,GAAA,CAAI,GAAG,CAAA,EAAG,OAAO,UAAA;AAC1B,IAAA,IAAA,CAAK,IAAI,GAAG,CAAA;AACZ,IAAA,IAAI;AACF,MAAA,IAAI,iBAAiB,IAAA,EAAM,OAAO,CAAA,KAAA,EAAQ,KAAA,CAAM,SAAS,CAAA,CAAA;AACzD,MAAA,IAAI,iBAAiB,MAAA,EAAQ,OAAO,CAAA,MAAA,EAAS,MAAA,CAAO,KAAK,CAAC,CAAA,CAAA;AAC1D,MAAA,MAAM,UAAU,MAAA,CAAO,OAAA,CAAQ,GAAG,CAAA,CAC/B,KAAK,CAAC,CAAC,CAAC,CAAA,EAAG,CAAC,CAAC,CAAA,KAAO,CAAA,GAAI,CAAA,GAAI,KAAK,CAAA,GAAI,CAAA,GAAI,CAAA,GAAI,CAAE,EAC/C,GAAA,CAAI,CAAC,CAAC,CAAA,EAAG,CAAC,CAAA,KAAM,CAAA,EAAG,IAAA,CAAK,SAAA,CAAU,CAAC,CAAC,CAAA,CAAA,EAAI,mBAAmB,CAAA,EAAG,IAAI,CAAC,CAAA,CAAE,CAAA;AACxE,MAAA,OAAO,CAAA,CAAA,EAAI,OAAA,CAAQ,IAAA,CAAK,GAAG,CAAC,CAAA,CAAA,CAAA;AAAA,IAC9B,CAAA,SAAE;AACA,MAAA,IAAA,CAAK,OAAO,GAAG,CAAA;AAAA,IACjB;AAAA,EACF;AACA,EAAA,OAAO,SAAA;AACT;;;;"}

package/dist/shared/{attaform.sWm8B15V.d.mts → attaform.CRsXyy-Y.d.ts}

@@ -1,4 +1,4 @@
-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, f as AttaformDefaults, aj as UseFormReturnType, a8 as RegisterValue } from './attaform.99cfHcIt.mjs';
+import { v as FormKey, V as PathKey, m as DisplayCtx, z as GetDisplayState, n as DisplayMachine, ag as SlimPrimitiveKind, C as CoercionEntry, g as CoercionRegistry, G as GenericForm, U as Path, ao as ValidationError, A as AbstractSchema, as as WriteMeta, D as DeepPartial, at as WriteShape, am as ValidateOn, _ as PersistOptInRegistry, f as AttaformDefaults, al as UseFormReturnType, aa as RegisterValue } from './attaform.B1nyO4ec.js';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -455,6 +455,68 @@ type UseWizardReturnType<S extends ReadonlyArray<StepSlot> = ReadonlyArray<StepS
     readonly reset: () => void;
 };
 
+/**
+ * Per-form display engine: owns the clock and the timers that the pure
+ * `getDisplayState` reducer policy needs, so the reducer itself stays a
+ * deterministic `(prev, ctx) => next` function.
+ *
+ * It keeps a `Map` of the machines that are still *active* (a spinner is
+ * showing, a verdict is being held, or a `reviewAt` deadline is pending),
+ * a single reactive `tick` ref, and a single `setTimeout` aimed at the
+ * nearest `reviewAt` across every active field. When a field-state
+ * computed reads `resolve`, it subscribes to `tick`; when the timer
+ * fires, `tick` bumps and every dependent computed re-runs the reducer,
+ * so a field whose deadline elapsed transitions (verdict → spinner, or
+ * spinner → settled verdict) without any per-field watcher.
+ *
+ * Eviction: a machine is dropped once it reaches a terminal *idle* state
+ * with no pending review. Error / success / pending machines are retained
+ * so the reducer can hold the prior verdict under the show-delay window of
+ * the *next* validation streak (no success → idle → success flicker). The
+ * retained set is bounded by the rendered non-idle fields; none of them
+ * arm a timer, so retention costs memory, never CPU.
+ *
+ * Untrusted reducer: `getDisplayState` is consumer-overridable, so the
+ * engine treats the returned `reviewAt` as untrusted. A non-finite deadline
+ * (NaN / ±Infinity from a custom predicate's bad arithmetic) is ignored
+ * rather than handed to `setTimeout`, where it coerces to 0 and spins; an
+ * over-large finite deadline is clamped below the 32-bit `setTimeout`
+ * overflow; and the timer refuses to re-arm for the exact deadline it just
+ * fired, so a predicate re-emitting a fixed or past `reviewAt` can't drive an
+ * infinite fire loop. None of these arise from the library default, which
+ * always advances its deadline or drops it.
+ *
+ * Background tabs: `setTimeout` is throttled to >= 1s while a tab is hidden,
+ * so a min-visible hold can overshoot. A `visibilitychange` listener bumps
+ * the clock on return to the foreground, so any overdue deadline resolves at
+ * once instead of lingering.
+ *
+ * SSR: no clock, no timers, no listener. With `now` frozen and nothing
+ * validating at render, the reducer returns the plain verdict (never
+ * pending) and the engine stores nothing, so the server HTML and the
+ * client's first render agree — no hydration mismatch on the display
+ * projection.
+ */
+type DisplayEngine = {
+    /**
+     * Resolve a path's next `DisplayMachine`. Subscribes the calling
+     * computed to the engine clock, threads the path's previous machine
+     * through `reducer`, persists or evicts the result, and re-arms the
+     * single timer to the nearest deadline.
+     */
+    resolve(key: PathKey, ctx: DisplayCtx, reducer: GetDisplayState): DisplayMachine;
+    /** Drop every retained machine and cancel the timer (used by `reset()`). */
+    clear(): void;
+    /** Tear down for good: `clear()` plus detaching the visibility listener. */
+    dispose(): void;
+    /** Introspection for tests: count of retained machines. */
+    size(): number;
+    /** Introspection for tests: whether a path currently has a retained machine. */
+    has(key: PathKey): boolean;
+    /** Introspection for tests: whether a deadline timer is currently armed. */
+    hasTimer(): boolean;
+};
+
 /**
  * Schema-driven coercion of user-typed DOM values at the v-register
  * directive layer. When the slim schema declares a numeric or
@@ -669,6 +731,16 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * read.
      */
     readonly getDisplayState: GetDisplayState;
+    /**
+     * Per-form display engine: owns the clock and the single timer the timed
+     * `getDisplayState` reducer policy needs, keeping the reducer itself a
+     * pure `(prev, ctx) => next` function. The field-state computeds route
+     * every `displayState` read through `displayEngine.resolve(...)`, which
+     * threads the path's previous machine, persists or evicts the result, and
+     * re-arms the nearest-deadline timer. Constructed once at form
+     * construction; torn down via `registerCleanup` on store eviction.
+     */
+    readonly displayEngine: DisplayEngine;
     readonly submitting: Ref<boolean>;
     readonly activeSubmissions: Ref<number>;
     readonly submissionAttempts: Ref<number>;
@@ -838,6 +910,28 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * computed only re-runs when the count for ITS key changes.
      */
     readonly fieldValidationCounts: Map<PathKey, number>;
+    /**
+     * Per-path `Date.now()` stamp marking when the field's LATEST validation
+     * run started, re-anchored on every run start (every increment), deleted
+     * on the `→ 0` edge. The display reducer reads it as `ctx.validatingSince`
+     * to time the anti-flash spinner, which measures `now - validatingSince`:
+     * re-anchoring on each run means a burst of keystrokes (each aborting the
+     * prior run and starting a new one) keeps pushing the stamp forward, so the
+     * spinner stays suppressed until the user pauses rather than surfacing
+     * mid-typing. Anchoring only at the streak start would pin it to the first
+     * keystroke, because with `debounceMs: 0` the aborted run's decrement lands
+     * after the next run's increment and the count never returns to 0 between
+     * fast keystrokes. The field-state container walk takes the descendant-min
+     * so a row spinner anchors at its earliest still-active leaf. Runtime-only,
+     * never hydrated, like the counts. REACTIVE: the display computed reads this
+     * (as `ctx.validatingSince`) but not the `validating` flag, and a long
+     * validation that settles with an unchanged verdict (same error, still
+     * invalid) leaves `errors` / `valid` untouched — so a non-reactive map would
+     * leave a held `pending` spinner stranded after the run ends, until some
+     * unrelated reactive change happened to re-run the computed. Reactivity ties
+     * the computed to both the streak start (set) and end (delete).
+     */
+    readonly fieldValidatingSince: Map<PathKey, number>;
     /**
      * Replace the form value wholesale. Optional `meta` is forwarded to
      * every `onFormChange` listener so they can decide whether THIS write