attaform 0.21.0 → 0.21.1

package/dist/shared/{attaform.BK1RE2ha.d.ts → attaform.Duecg2NO.d.mts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, s as FlatPath, P as NestedType, v as FormKey, ak as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, an as ValidateOnConfig, al as UseFormReturnType } from './attaform.B1nyO4ec.js';
+import { G as GenericForm, s as FlatPath, P as NestedType, v as FormKey, al as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, ao as ValidateOnConfig, am as UseFormReturnType } from './attaform.D0dWZsJt.mjs';
 
 /**
  * The shape `form.values.<key>` returns at runtime.
@@ -143,7 +143,7 @@ type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema>
 /**
  * Type produced at `Path` after the full parse pipeline — the schema's
  * `z.output<Schema>` shape at that path. Matches the `data` payload of
- * `form.process()` and the value handed to `handleSubmit`'s callback.
+ * `form.parse()` and the value handed to `handleSubmit`'s callback.
  *
  * ```ts
  * const schema = z.object({

package/dist/shared/{attaform.BDIEq9qP.d.cts → attaform.FudOcHaa.d.cts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, s as FlatPath, P as NestedType, v as FormKey, ak as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, an as ValidateOnConfig, al as UseFormReturnType } from './attaform.B1nyO4ec.cjs';
+import { G as GenericForm, s as FlatPath, P as NestedType, v as FormKey, al as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, ao as ValidateOnConfig, am as UseFormReturnType } from './attaform.D0dWZsJt.cjs';
 
 /**
  * The shape `form.values.<key>` returns at runtime.
@@ -143,7 +143,7 @@ type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema>
 /**
  * Type produced at `Path` after the full parse pipeline — the schema's
  * `z.output<Schema>` shape at that path. Matches the `data` payload of
- * `form.process()` and the value handed to `handleSubmit`'s callback.
+ * `form.parse()` and the value handed to `handleSubmit`'s callback.
  *
  * ```ts
  * const schema = z.object({

package/dist/shared/{attaform.BQ6drorq.d.mts → attaform.MtrpT6Ki.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { G as GenericForm, s as FlatPath, P as NestedType, v as FormKey, ak as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, an as ValidateOnConfig, al as UseFormReturnType } from './attaform.B1nyO4ec.mjs';
+import { G as GenericForm, s as FlatPath, P as NestedType, v as FormKey, al as UseFormConfiguration, A as AbstractSchema, j as DefaultValuesInput, ao as ValidateOnConfig, am as UseFormReturnType } from './attaform.D0dWZsJt.js';
 
 /**
  * The shape `form.values.<key>` returns at runtime.
@@ -143,7 +143,7 @@ type PathInput<Schema extends z.ZodType, Path extends string> = z.input<Schema>
 /**
  * Type produced at `Path` after the full parse pipeline — the schema's
  * `z.output<Schema>` shape at that path. Matches the `data` payload of
- * `form.process()` and the value handed to `handleSubmit`'s callback.
+ * `form.parse()` and the value handed to `handleSubmit`'s callback.
  *
  * ```ts
  * const schema = z.object({

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

@@ -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.js';
+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, ap as ValidationError, A as AbstractSchema, at as WriteMeta, D as DeepPartial, au as WriteShape, aj as TransformAbortHolder, an as ValidateOn, _ as PersistOptInRegistry, f as AttaformDefaults, am as UseFormReturnType, aa as RegisterValue } from './attaform.D0dWZsJt.mjs';
 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;
@@ -751,7 +759,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 +940,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 +1140,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`

package/dist/shared/{attaform.PnqML3xW.cjs → attaform.S-pYLSo4.cjs}

@@ -1,8 +1,8 @@
 'use strict';
 
-const injectWizard = require('./attaform.BUszFoKq.cjs');
-const paths = require('./attaform.BA3vRDos.cjs');
-const walkFieldMeta = require('./attaform._rsCZy2j.cjs');
+const injectWizard = require('./attaform.ClXwitZj.cjs');
+const paths = require('./attaform.D32WwKk6.cjs');
+const walkFieldMeta = require('./attaform.CICFZ1iS.cjs');
 const zod = require('zod');
 
 const fieldMeta = walkFieldMeta.fieldMetaStore;
@@ -1302,4 +1302,4 @@ exports.unwrapPipe = unwrapPipe;
 exports.useForm = useForm;
 exports.withMeta = withMeta;
 exports.zodV4Adapter = zodV4Adapter;
-//# sourceMappingURL=attaform.PnqML3xW.cjs.map
+//# sourceMappingURL=attaform.S-pYLSo4.cjs.map