attaform 0.21.0 → 0.21.2

package/dist/shared/{attaform.7lzO9pdM.d.mts → attaform.BGf_J22U.d.ts}

@@ -1,4 +1,4 @@
-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.mjs';
+import { F as FormKey, _ as PathKey, p as DisplayCtx, d as GetDisplayState, q as DisplayMachine, Z as Path, ah as SlimPrimitiveKind, C as CoercionEntry, j as CoercionRegistry, G as GenericForm, V as ValidationError, a as AbstractSchema, aq as WriteMeta, m as DeepPartial, ar as WriteShape, ay as TransformAbortHolder, al as ValidateOn, az as PersistOptInRegistry, A as AttaformDefaults, b as UseFormReturnType, c as RegisterValue } from './attaform.ory-3WhV.js';
 import { Ref, ComputedRef, App, InjectionKey } from 'vue';
 
 /**
@@ -414,6 +414,13 @@ type WizardForms<S> = FormsRecordOf<S> & Readonly<Record<FormKey, AnyForm>>;
  *  - `submissionAttempts` — count of `wizard.handleSubmit` invocations
  *                    (success or failure). Always bumps, including on
  *                    noop-form steps.
+ *  - `submitError` — the error thrown by the most recent
+ *                    `wizard.handleSubmit` callback (or its `onError`),
+ *                    coerced to a real `Error`. Mirrors
+ *                    `form.meta.submitError`: cleared at submit entry and
+ *                    by `reset()`, parked here rather than re-thrown, so
+ *                    the handler resolves and never manufactures a
+ *                    `window` unhandledrejection. `null` on success.
  *  - `visited`     — append-only breadcrumb of navigated step keys.
  *                    `back()` does not pop; the trail is the audit
  *                    log, not the back-stack.
@@ -447,6 +454,7 @@ type UseWizardReturnType<S extends ReadonlyArray<StepSlot> = ReadonlyArray<StepS
     readonly done: boolean;
     readonly submitting: boolean;
     readonly submissionAttempts: number;
+    readonly submitError: Error | null;
     readonly visited: readonly FormKey[];
     readonly next: () => Promise<void>;
     readonly back: () => void;
@@ -517,66 +525,6 @@ type DisplayEngine = {
     hasTimer(): boolean;
 };
 
-/**
- * Schema-driven coercion of user-typed DOM values at the v-register
- * directive layer. When the slim schema declares a numeric or
- * boolean type at a path, the directive coerces incoming string
- * values (`'25'` → `25`, `'true'` → `true`) before the slim-primitive
- * gate sees the write — making the schema authoritative for storage
- * shape and freeing consumers from sprinkling `.number` modifiers
- * across templates.
- *
- * Coercion is consumer-extensible: a `CoercionRegistry` is just an
- * `Array<CoercionEntry>` keyed at config time by `(input, output)`
- * `SlimPrimitiveKind` literals. The library ships
- * `defaultCoercionRules` (string→number, string→boolean) and
- * `defineCoercion` for type-narrowed authoring; consumers spread the
- * defaults to extend or supply their own array to replace.
- *
- * Coercion applies ONLY to user-typed DOM values flowing through
- * the directive's assigner. Programmatic writes (`form.setValue`,
- * `setValueWithInternalPath`) bypass coercion — they're authoritative
- * writes whose strict typing is on the caller. This mirrors the
- * `transforms` pipeline's user-input-only contract.
- */
-
-/**
- * Type-narrowing helper for authoring entries. At runtime it's
- * identity; at compile time it preserves the `input` / `output`
- * literal types so `transform`'s parameter is narrowed to the
- * runtime type instead of widening to `SlimRuntimeOf<SlimPrimitiveKind>`.
- *
- * Without this helper, authoring `{ input: 'string', output:
- * 'number', transform: (s) => ... }` against the broader
- * `CoercionEntry` widens `s` to `string | number | boolean | ...`,
- * forcing a cast in every transform body. `defineCoercion` is the
- * opaque-free idiom.
- */
-declare function defineCoercion<I extends SlimPrimitiveKind, O extends SlimPrimitiveKind>(entry: CoercionEntry<I, O>): CoercionEntry<I, O>;
-/**
- * Internal index built from a `CoercionRegistry` at config-resolve
- * time. Keyed by `${input}->${output}` for O(1) per-keystroke
- * dispatch. The authoring shape (array, ergonomic, type-narrowing-
- * friendly) and the dispatch shape (Map, fast) decouple cleanly.
- */
-type CoercionIndex = ReadonlyMap<`${SlimPrimitiveKind}->${SlimPrimitiveKind}`, CoercionEntry>;
-/**
- * The library's built-in registry. Two cells: string→number and
- * string→boolean. Re-exported so consumers can spread it when
- * supplying a custom registry that extends defaults.
- */
-declare const defaultCoercionRules: CoercionRegistry;
-
-/**
- * Per-form closure state — the single store owned by each `useForm` call.
- * Bundles the form value, the summary record, element references, field
- * state, the meta tracker, and the error stores under one keyed-by-
- * `(formKey, path)` instance so cross-form DOM state cannot collide.
- *
- * This is NOT a singleton. Each call to `useForm` creates its own FormStore
- * instance and holds onto it via closure. The registry provides SSR
- * hydration; otherwise the state is per-component-per-form.
- */
 /**
  * Per-path field status. Replaced wholesale (not mutated in place) on
  * every change. Five semantic groups:
@@ -635,6 +583,57 @@ type OriginalsRecord = {
     readonly segments: Path;
     readonly value: unknown;
 };
+
+/**
+ * Schema-driven coercion of user-typed DOM values at the v-register
+ * directive layer. When the slim schema declares a numeric or
+ * boolean type at a path, the directive coerces incoming string
+ * values (`'25'` → `25`, `'true'` → `true`) before the slim-primitive
+ * gate sees the write — making the schema authoritative for storage
+ * shape and freeing consumers from sprinkling `.number` modifiers
+ * across templates.
+ *
+ * Coercion is consumer-extensible: a `CoercionRegistry` is just an
+ * `Array<CoercionEntry>` keyed at config time by `(input, output)`
+ * `SlimPrimitiveKind` literals. The library ships
+ * `defaultCoercionRules` (string→number, string→boolean) and
+ * `defineCoercion` for type-narrowed authoring; consumers spread the
+ * defaults to extend or supply their own array to replace.
+ *
+ * Coercion applies ONLY to user-typed DOM values flowing through
+ * the directive's assigner. Programmatic writes (`form.setValue`,
+ * `setValueWithInternalPath`) bypass coercion — they're authoritative
+ * writes whose strict typing is on the caller. This mirrors the
+ * `transforms` pipeline's user-input-only contract.
+ */
+
+/**
+ * Type-narrowing helper for authoring entries. At runtime it's
+ * identity; at compile time it preserves the `input` / `output`
+ * literal types so `transform`'s parameter is narrowed to the
+ * runtime type instead of widening to `SlimRuntimeOf<SlimPrimitiveKind>`.
+ *
+ * Without this helper, authoring `{ input: 'string', output:
+ * 'number', transform: (s) => ... }` against the broader
+ * `CoercionEntry` widens `s` to `string | number | boolean | ...`,
+ * forcing a cast in every transform body. `defineCoercion` is the
+ * opaque-free idiom.
+ */
+declare function defineCoercion<I extends SlimPrimitiveKind, O extends SlimPrimitiveKind>(entry: CoercionEntry<I, O>): CoercionEntry<I, O>;
+/**
+ * Internal index built from a `CoercionRegistry` at config-resolve
+ * time. Keyed by `${input}->${output}` for O(1) per-keystroke
+ * dispatch. The authoring shape (array, ergonomic, type-narrowing-
+ * friendly) and the dispatch shape (Map, fast) decouple cleanly.
+ */
+type CoercionIndex = ReadonlyMap<`${SlimPrimitiveKind}->${SlimPrimitiveKind}`, CoercionEntry>;
+/**
+ * The library's built-in registry. Two cells: string→number and
+ * string→boolean. Re-exported so consumers can spread it when
+ * supplying a custom registry that extends defaults.
+ */
+declare const defaultCoercionRules: CoercionRegistry;
+
 type FormStore<F extends GenericForm, G extends GenericForm = F> = {
     readonly formKey: FormKey;
     readonly form: Ref<F>;
@@ -751,7 +750,7 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * alongside the rest of the submission surface.
      */
     readonly submitted: Ref<boolean>;
-    readonly submitError: Ref<unknown>;
+    readonly submitError: Ref<Error | null>;
     readonly departAttempts: Ref<number>;
     /**
      * `true` while a function-form `defaultValues` factory is in flight.
@@ -932,6 +931,39 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * the computed to both the streak start (set) and end (delete).
      */
     readonly fieldValidatingSince: Map<PathKey, number>;
+    /**
+     * Per-path counter of in-flight async-transform runs (the async
+     * branch of the `register({ transforms })` pipeline). `> 0` drives
+     * `field.transforming` / `field.busy`. Counter, not flag, for the
+     * same overlap reason as `fieldValidationCounts`, except a superseding
+     * input releases the prior run synchronously before incrementing the
+     * new one — so the count is the live in-flight depth at the path
+     * (effectively 0 or 1). Reactive Map, like the validation counters.
+     */
+    readonly fieldTransformCounts: Map<PathKey, number>;
+    /**
+     * Per-path `ssr ? 0 : Date.now()` stamp marking when the path's latest
+     * async transform opened; the display reducer reads it (as
+     * `ctx.transformingSince`) to time the gated busy spinner. Mirrors
+     * `fieldValidatingSince` exactly: re-anchored on each run start,
+     * deleted on the `→ 0` edge, reactive for the held-spinner reason.
+     */
+    readonly fieldTransformingSince: Map<PathKey, number>;
+    /**
+     * Per-path latest async-transform failure (a rejected transform, or a
+     * resolved value the write gate refused), surfaced as
+     * `field.transformError`. Cleared when a fresh run opens at the path
+     * and on `reset()`. A channel separate from validation `errors`.
+     */
+    readonly transformErrors: Map<PathKey, Error | null>;
+    /**
+     * Form-wide count of in-flight async-transform runs. Drives the
+     * `settleTransforms` quiescence guard and the `handleSubmit` drain
+     * barrier. `Math.max(0, …)`-clamped on release so a doubled decrement
+     * (a run's own `endTransform` after a synchronous cancel release)
+     * can't drive it negative.
+     */
+    readonly activeTransforms: Ref<number>;
     /**
      * Replace the form value wholesale. Optional `meta` is forwarded to
      * every `onFormChange` listener so they can decide whether THIS write
@@ -1099,6 +1131,41 @@ type FormStore<F extends GenericForm, G extends GenericForm = F> = {
      * at entry (submit validation is authoritative) and by `reset()`.
      */
     cancelFieldValidation(): void;
+    /**
+     * Open an async-transform run at `key` — bump the run token, increment
+     * the in-flight counters, stamp `transformingSince`, clear any prior
+     * `transformError`, register `holder` for later abort. Returns the run
+     * token. See `InternalRegisterValue.beginTransform`.
+     */
+    beginTransform(key: PathKey, holder: TransformAbortHolder): number;
+    /** `true` while `token` is the live async-transform run at `key`. */
+    isCurrentTransform(key: PathKey, token: number): boolean;
+    /**
+     * Close the run `token` at `key`: release the counters (no-op if the
+     * run was already released by a supersede / cancel) and flush settled
+     * `settleTransforms` waiters.
+     */
+    endTransform(key: PathKey, token: number): void;
+    /** Record a per-field normalization failure at `key` (`field.transformError`). */
+    setTransformError(key: PathKey, err: Error): void;
+    /**
+     * Abort + release every in-flight async-transform run (all paths) and
+     * clear `transformErrors`. Mirrors `cancelFieldValidation`; called by
+     * `reset()` and store teardown.
+     */
+    cancelTransforms(): void;
+    /**
+     * Path-scoped counterpart to `cancelTransforms`: abort + release only
+     * the runs at-or-under `prefix`, clearing their `transformError`.
+     * Called by `resetField`.
+     */
+    cancelTransformsUnder(prefix: Path): void;
+    /**
+     * Resolve once async transforms are quiescent — globally (`path`
+     * omitted) or at-or-under `path`. Resolve-never-reject. See
+     * `UseFormReturnType.settleTransforms`.
+     */
+    settleTransforms(path?: string | Path): Promise<void>;
     /**
      * Kick off (or schedule) a field-level validation run for `path`. Pass
      * `path = []` to cover the whole form; `applySchemaErrorsForSubtree`
@@ -1782,5 +1849,5 @@ declare const AttaformErrorCode: {
 };
 type AttaformErrorCode = (typeof AttaformErrorCode)[keyof typeof AttaformErrorCode];
 
-export { AttaformErrorCode as a, 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 { AnyForm as A, CompiledStep as C, FormStatus as F, InjectWizardInput as I, LazyMarker as L, SSRDetectOptions as S, UseRegisterReturn as U, WizardAggregateError as W, AttaformRegistry as b, SerializedFormData as c, StepSlot as d, UseWizardReturnType as e, WizardCtx 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 c, 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, WizardAggregateError as W, SerializedFormData as a, AnyForm as b, StepSlot as d, UseWizardReturnType as e, WizardCtx 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.BnK_bfcb.mjs → attaform.BVeLgfEh.mjs}

@@ -1,6 +1,6 @@
-import { i as getAtPath, x as slimKindOf, w as setAtPath, j as humanize, B as useAbstractForm } from './attaform.DSqO6Db7.mjs';
-import { a as AttaformError, _ as __DEV__, j as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.Y_Mgg0Yp.mjs';
-import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, w as walkPathSegments, d as deriveDefaultWalk, m as mergeDeep, c as createAbstractSchema, b as getFieldMetaPathMap } from './attaform.r3PePkDR.mjs';
+import { t as getAtPath, h as slimKindOf, v as setAtPath, E as humanize, r as useAbstractForm } from './attaform.CTheKoTc.mjs';
+import { b as AttaformError, _ as __DEV__, a as canonicalizePath, d as InvalidUseFormConfigError } from './attaform.DP-u7_tk.mjs';
+import { f as fieldMetaStore, g as getFieldMetaForSchema, a as getFieldMetaListForSchema, s as slimPrimitivesWalk, w as walkPathSegments, d as deriveDefaultWalk, m as mergeDeep, c as createAbstractSchema, b as getFieldMetaPathMap } from './attaform.D6GYGshL.mjs';
 import { z } from 'zod';
 
 const fieldMeta = fieldMetaStore;
@@ -581,6 +581,9 @@ function carryChecks(rebuilt, original, stripConfig) {
     ...checks
   );
 }
+function unhandledZodKind(fnName, kind) {
+  throw new Error(`${fnName}: unhandled ZodKind '${kind}'`);
+}
 function stripRefinements(schema) {
   const kind = kindOf(schema);
   switch (kind) {
@@ -680,10 +683,8 @@ function stripRefinements(schema) {
     case "symbol":
     case "function":
       return schema;
-    default: {
-      const _exhaustive = kind;
-      throw new Error(`stripRefinements: unhandled ZodKind '${_exhaustive}'`);
-    }
+    default:
+      return unhandledZodKind("stripRefinements", kind);
   }
 }
 function stripAsyncChecks(schema) {
@@ -808,10 +809,8 @@ function stripAsyncChecks(schema) {
       case "symbol":
       case "function":
         return s;
-      default: {
-        const _exhaustive = kind;
-        throw new Error(`stripAsyncChecks: unhandled ZodKind '${_exhaustive}'`);
-      }
+      default:
+        return unhandledZodKind("stripAsyncChecks", kind);
     }
   }
   return recurse(schema);
@@ -957,10 +956,8 @@ function walkSlim(schema, stripConfig, maxDepth, lazyDepth) {
     case "transform":
     case "file":
       return schema;
-    default: {
-      const _exhaustive = kind;
-      throw new Error(`getSlimSchema: unhandled ZodKind '${_exhaustive}'`);
-    }
+    default:
+      return unhandledZodKind("getSlimSchema", kind);
   }
 }
 
@@ -1274,5 +1271,5 @@ function useForm(configuration) {
   });
 }
 
-export { UnsupportedSchemaError as U, assertZodVersion as a, getCatchDefault as b, getChecks as c, getDefaultValue as d, getDiscriminatedOptions as e, fieldMeta as f, getArrayElement as g, getDiscriminator as h, getEnumValues as i, getIntersectionLeft as j, getIntersectionRight as k, getLiteralValues as l, getObjectShape as m, getRecordKeyType as n, getRecordValueType as o, getSetValueType as p, getTupleItems as q, getUnionOptions as r, kindOf as s, unwrapLazy as t, unwrapInner as u, unwrapPipe as v, useForm as w, withMeta as x, zodV4Adapter as z };
-//# sourceMappingURL=attaform.BnK_bfcb.mjs.map
+export { UnsupportedSchemaError as U, assertZodVersion as a, getIntersectionRight as b, unwrapLazy as c, unwrapInner as d, unwrapPipe as e, fieldMeta as f, getIntersectionLeft as g, getDiscriminator as h, getDiscriminatedOptions as i, getUnionOptions as j, kindOf as k, getRecordKeyType as l, getRecordValueType as m, getTupleItems as n, getSetValueType as o, getArrayElement as p, getObjectShape as q, getEnumValues as r, getLiteralValues as s, getChecks as t, useForm as u, getCatchDefault as v, withMeta as w, getDefaultValue as x, zodV4Adapter as z };
+//# sourceMappingURL=attaform.BVeLgfEh.mjs.map