attaform 0.26.0 → 0.27.0

package/dist/shared/{attaform.B71rfNL5.d.mts → attaform.CpXHK60W.d.cts}

@@ -1,5 +1,37 @@
 import { z } from 'zod';
-import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.DBNjHgNj.mjs';
+import { G as GenericForm, s as FlatPath, B as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ae as ValidateOnConfig, a as UseFormReturnType } from './attaform.C3WnCDXz.cjs';
+
+/**
+ * The Zod v4 schema roots `useForm` accepts. A fixed-shape
+ * `z.object({ … })` is the common case; `z.record(K, V)` admits a
+ * dictionary form (a homogeneous map with runtime-known keys);
+ * `z.discriminatedUnion(disc, [...])` admits a variant form (one of
+ * several object shapes, picked by a discriminator). Each projects to
+ * a `GenericForm`-shaped value the form engine drives: an object root
+ * descends into its fixed keys, a record root treats its entries as an
+ * open live-keyed container, a variant root lifts the active variant's
+ * keys into one addressable surface.
+ *
+ * Other roots (a bare `z.union`, a root `z.array`, primitives,
+ * `z.map` / `z.set`) are not form roots; wrap them under a key. The
+ * adapter's runtime construction rejects them with a legible error.
+ *
+ * `z.ZodObject` MUST keep its `z.ZodRawShape` argument, and the
+ * discriminated-union arm MUST stay fully applied. The unified entry's
+ * v4 overload constrains on `SupportedRootSchema & ZodV4Internals` to
+ * keep v3 schemas out (see `../unified/types-zod-major.ts`). In a
+ * single-major (v3-only) consumer install, the published `.d.mts`
+ * resolves this `z` to v3, where a bare or under-applied Zod class is
+ * missing its required arguments and degrades to an `any`-like error
+ * type; `any` then absorbs the union and `any & ZodV4Internals`
+ * collapses back to `any`, so the marker stops excluding v3 schemas and
+ * the read slot poisons to `never`. `z.ZodRecord` carries defaults for
+ * both arguments, so it stays concrete in either major.
+ * `z.ZodDiscriminatedUnion` does NOT (v3 requires both arguments, and
+ * its parameter order is the reverse of v4's), so the arm is written
+ * fully applied; the v3-only bundled-types fixture guards it.
+ */
+type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord | z.ZodDiscriminatedUnion<readonly z.ZodObject<z.ZodRawShape>[], string>;
 
 /**
  * The shape `form.values.<key>` returns at runtime.
@@ -120,38 +152,6 @@ type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
     };
 } ? Out : never;
 
-/**
- * The Zod v4 schema roots `useForm` accepts. A fixed-shape
- * `z.object({ … })` is the common case; `z.record(K, V)` admits a
- * dictionary form (a homogeneous map with runtime-known keys);
- * `z.discriminatedUnion(disc, [...])` admits a variant form (one of
- * several object shapes, picked by a discriminator). Each projects to
- * a `GenericForm`-shaped value the form engine drives: an object root
- * descends into its fixed keys, a record root treats its entries as an
- * open live-keyed container, a variant root lifts the active variant's
- * keys into one addressable surface.
- *
- * Other roots (a bare `z.union`, a root `z.array`, primitives,
- * `z.map` / `z.set`) are not form roots; wrap them under a key. The
- * adapter's runtime construction rejects them with a legible error.
- *
- * `z.ZodObject` MUST keep its `z.ZodRawShape` argument, and the
- * discriminated-union arm MUST stay fully applied. The unified entry's
- * v4 overload constrains on `SupportedRootSchema & ZodV4Internals` to
- * keep v3 schemas out (see `../unified/types-zod-major.ts`). In a
- * single-major (v3-only) consumer install, the published `.d.mts`
- * resolves this `z` to v3, where a bare or under-applied Zod class is
- * missing its required arguments and degrades to an `any`-like error
- * type; `any` then absorbs the union and `any & ZodV4Internals`
- * collapses back to `any`, so the marker stops excluding v3 schemas and
- * the read slot poisons to `never`. `z.ZodRecord` carries defaults for
- * both arguments, so it stays concrete in either major.
- * `z.ZodDiscriminatedUnion` does NOT (v3 requires both arguments, and
- * its parameter order is the reverse of v4's), so the arm is written
- * fully applied; the v3-only bundled-types fixture guards it.
- */
-type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord | z.ZodDiscriminatedUnion<readonly z.ZodObject<z.ZodRawShape>[], string>;
-
 /**
  * Zod v4 adapter entry point. Re-exports the adapter + the useForm
  * wrapper that threads zod-v4-specific schema types through

package/dist/shared/{attaform.BFfY7HRI.d.cts → attaform.CvVYOvZF.d.mts}

@@ -1,5 +1,37 @@
 import { z } from 'zod';
-import { G as GenericForm, u as FlatPath, O as NestedType, F as FormKey, U as UseFormConfiguration, a as AbstractSchema, ar as AcceptableDefaults, af as ValidateOnConfig, b as UseFormReturnType } from './attaform.DBNjHgNj.cjs';
+import { G as GenericForm, s as FlatPath, B as NestedType, F as FormKey, U as UseFormConfiguration, A as AbstractSchema, aq as AcceptableDefaults, ae as ValidateOnConfig, a as UseFormReturnType } from './attaform.C3WnCDXz.mjs';
+
+/**
+ * The Zod v4 schema roots `useForm` accepts. A fixed-shape
+ * `z.object({ … })` is the common case; `z.record(K, V)` admits a
+ * dictionary form (a homogeneous map with runtime-known keys);
+ * `z.discriminatedUnion(disc, [...])` admits a variant form (one of
+ * several object shapes, picked by a discriminator). Each projects to
+ * a `GenericForm`-shaped value the form engine drives: an object root
+ * descends into its fixed keys, a record root treats its entries as an
+ * open live-keyed container, a variant root lifts the active variant's
+ * keys into one addressable surface.
+ *
+ * Other roots (a bare `z.union`, a root `z.array`, primitives,
+ * `z.map` / `z.set`) are not form roots; wrap them under a key. The
+ * adapter's runtime construction rejects them with a legible error.
+ *
+ * `z.ZodObject` MUST keep its `z.ZodRawShape` argument, and the
+ * discriminated-union arm MUST stay fully applied. The unified entry's
+ * v4 overload constrains on `SupportedRootSchema & ZodV4Internals` to
+ * keep v3 schemas out (see `../unified/types-zod-major.ts`). In a
+ * single-major (v3-only) consumer install, the published `.d.mts`
+ * resolves this `z` to v3, where a bare or under-applied Zod class is
+ * missing its required arguments and degrades to an `any`-like error
+ * type; `any` then absorbs the union and `any & ZodV4Internals`
+ * collapses back to `any`, so the marker stops excluding v3 schemas and
+ * the read slot poisons to `never`. `z.ZodRecord` carries defaults for
+ * both arguments, so it stays concrete in either major.
+ * `z.ZodDiscriminatedUnion` does NOT (v3 requires both arguments, and
+ * its parameter order is the reverse of v4's), so the arm is written
+ * fully applied; the v3-only bundled-types fixture guards it.
+ */
+type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord | z.ZodDiscriminatedUnion<readonly z.ZodObject<z.ZodRawShape>[], string>;
 
 /**
  * The shape `form.values.<key>` returns at runtime.
@@ -120,38 +152,6 @@ type StorageLeaf<L> = InputIsUnknown<L> extends true ? unknown : L extends {
     };
 } ? Out : never;
 
-/**
- * The Zod v4 schema roots `useForm` accepts. A fixed-shape
- * `z.object({ … })` is the common case; `z.record(K, V)` admits a
- * dictionary form (a homogeneous map with runtime-known keys);
- * `z.discriminatedUnion(disc, [...])` admits a variant form (one of
- * several object shapes, picked by a discriminator). Each projects to
- * a `GenericForm`-shaped value the form engine drives: an object root
- * descends into its fixed keys, a record root treats its entries as an
- * open live-keyed container, a variant root lifts the active variant's
- * keys into one addressable surface.
- *
- * Other roots (a bare `z.union`, a root `z.array`, primitives,
- * `z.map` / `z.set`) are not form roots; wrap them under a key. The
- * adapter's runtime construction rejects them with a legible error.
- *
- * `z.ZodObject` MUST keep its `z.ZodRawShape` argument, and the
- * discriminated-union arm MUST stay fully applied. The unified entry's
- * v4 overload constrains on `SupportedRootSchema & ZodV4Internals` to
- * keep v3 schemas out (see `../unified/types-zod-major.ts`). In a
- * single-major (v3-only) consumer install, the published `.d.mts`
- * resolves this `z` to v3, where a bare or under-applied Zod class is
- * missing its required arguments and degrades to an `any`-like error
- * type; `any` then absorbs the union and `any & ZodV4Internals`
- * collapses back to `any`, so the marker stops excluding v3 schemas and
- * the read slot poisons to `never`. `z.ZodRecord` carries defaults for
- * both arguments, so it stays concrete in either major.
- * `z.ZodDiscriminatedUnion` does NOT (v3 requires both arguments, and
- * its parameter order is the reverse of v4's), so the arm is written
- * fully applied; the v3-only bundled-types fixture guards it.
- */
-type SupportedRootSchema = z.ZodObject<z.ZodRawShape> | z.ZodRecord | z.ZodDiscriminatedUnion<readonly z.ZodObject<z.ZodRawShape>[], string>;
-
 /**
  * Zod v4 adapter entry point. Re-exports the adapter + the useForm
  * wrapper that threads zod-v4-specific schema types through

package/dist/shared/{attaform.BoYqnIPI.mjs → attaform.CyQxTOdX.mjs}

@@ -1,6 +1,6 @@
 import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, nextTick, warn, readonly, toRaw, reactive, watch, markRaw, triggerRef, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, onBeforeMount, onBeforeUpdate, onMounted, effectScope } from 'vue';
-import { n as pathsEqual, j as isPathPrefix, _ as __DEV__, f as canonicalizePath, s as segmentsForPathKey, o as keyForSegments, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, q as normalizeErrorInput, r as INTERACTIVE_TAG_NAMES, R as ROOT_PATH, w as normalizeErrorInputs, x as coerceToPathKey, a as InvalidUseFormConfigError, y as ensureAttaformInstalled, u as useRegistry, z as kFormContext, B as kFormInstanceId, d as ReservedFormKeyError, l as kAttaformWizardActiveStepResolver, C as kAttaformAncestorWizard } from './attaform.DGhIix5D.mjs';
-import { R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.Vp2-CWZB.mjs';
+import { n as pathsEqual, k as isPathPrefix, _ as __DEV__, f as canonicalizePath, s as segmentsForPathKey, o as keyForSegments, b as ROOT_PATH_KEY, S as SubmitErrorHandlerError, t as toError, q as normalizeErrorInput, w as INTERACTIVE_TAG_NAMES, R as ROOT_PATH, x as normalizeErrorInputs, y as coerceToPathKey, a as InvalidUseFormConfigError, z as ensureAttaformInstalled, u as useRegistry, B as kFormContext, C as kFormInstanceId, d as ReservedFormKeyError, m as kAttaformWizardActiveStepResolver, E as kAttaformAncestorWizard } from './attaform.Da8EdI2t.mjs';
+import { R as REGISTER_OWNER_MARKER, b as V_REGISTER_MARKER } from './attaform.KvlEedlF.mjs';
 
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
@@ -29,7 +29,7 @@ function safeOwnHas(target, key) {
   return Object.prototype.hasOwnProperty.call(target, key);
 }
 
-const NOT_FOUND = Symbol("NOT_FOUND");
+const NOT_FOUND = /* @__PURE__ */ Symbol("NOT_FOUND");
 function descendStep(value, segment) {
   if (value === null || value === void 0) return NOT_FOUND;
   if (typeof value !== "object") return NOT_FOUND;
@@ -432,7 +432,7 @@ function applyChangedKeys(target, source, arrayOpPath, currentPath) {
   const targetIsArray = Array.isArray(target);
   const sourceIsArray = Array.isArray(source);
   if (targetIsArray !== sourceIsArray) return false;
-  const ROOT_SENTINEL = Symbol.for("attaform.applyChangedKeys.rootMismatch");
+  const ROOT_SENTINEL = /* @__PURE__ */ Symbol.for("attaform.applyChangedKeys.rootMismatch");
   const changedFirstSegments = /* @__PURE__ */ new Set();
   diffAndApply(target, source, [], (patch) => {
     if (patch.path.length === 0) {
@@ -2357,7 +2357,7 @@ function coerceValue(value, accepted, elementAccepted, index) {
 
 const warnedMultiRootHosts = /* @__PURE__ */ new Set();
 const EMPTY_TRANSFORMS = Object.freeze([]);
-const attaformListenersSymbol = Symbol.for("attaform:focus-listeners");
+const attaformListenersSymbol = /* @__PURE__ */ Symbol.for("attaform:focus-listeners");
 function attachFocusListeners(state, segments, element, instanceMeta) {
   const target = element;
   if (target[attaformListenersSymbol] !== void 0) return;
@@ -2547,7 +2547,7 @@ function buildRegister(state, formInstanceId, instanceConfig) {
   };
 }
 
-const unset = Symbol.for("attaform/unset");
+const unset = /* @__PURE__ */ Symbol.for("attaform/unset");
 function isUnset(value) {
   return value === unset;
 }
@@ -3455,6 +3455,33 @@ function buildFormApi(state, formInstanceId, options = {}) {
   return api;
 }
 
+function captureUserCallSite() {
+  const raw = new Error().stack;
+  if (typeof raw !== "string") return void 0;
+  const lines = raw.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    const frame = lines[i];
+    if (frame === void 0) continue;
+    if (/attaform[/-]forms?/i.test(frame)) continue;
+    if (/\bforms\.[A-Za-z0-9_-]+\.m?js\b/.test(frame)) continue;
+    const trimmed = frame.trim();
+    if (trimmed.length === 0) continue;
+    return shortenSourceFrame(trimmed);
+  }
+  return void 0;
+}
+function shortenSourceFrame(frame) {
+  const match = /(?:^|\s|\()([^\s()]+):(\d+):\d+\)?$/.exec(frame);
+  if (match === null) return frame;
+  const [, urlOrPath, line] = match;
+  if (urlOrPath === void 0 || line === void 0) return frame;
+  let path = urlOrPath;
+  path = path.replace(/^[a-z]+:\/\/[^/]+\//i, "");
+  path = path.replace(/^_nuxt\//, "");
+  path = path.replace(/^\//, "");
+  return `(${path}:${line})`;
+}
+
 const IDLE = Object.freeze({ display: "idle" });
 const MAX_DELAY = 2147483647;
 function createDisplayEngine(ssr) {
@@ -5535,33 +5562,6 @@ function createFormStore(options) {
   };
 }
 
-function captureUserCallSite() {
-  const raw = new Error().stack;
-  if (typeof raw !== "string") return void 0;
-  const lines = raw.split("\n");
-  for (let i = 1; i < lines.length; i++) {
-    const frame = lines[i];
-    if (frame === void 0) continue;
-    if (/attaform[/-]forms?/i.test(frame)) continue;
-    if (/\bforms\.[A-Za-z0-9_-]+\.m?js\b/.test(frame)) continue;
-    const trimmed = frame.trim();
-    if (trimmed.length === 0) continue;
-    return shortenSourceFrame(trimmed);
-  }
-  return void 0;
-}
-function shortenSourceFrame(frame) {
-  const match = /(?:^|\s|\()([^\s()]+):(\d+):\d+\)?$/.exec(frame);
-  if (match === null) return frame;
-  const [, urlOrPath, line] = match;
-  if (urlOrPath === void 0 || line === void 0) return frame;
-  let path = urlOrPath;
-  path = path.replace(/^[a-z]+:\/\/[^/]+\//i, "");
-  path = path.replace(/^_nuxt\//, "");
-  path = path.replace(/^\//, "");
-  return `(${path}:${line})`;
-}
-
 function getComputedSchema(formKey, schemaOrCallback, options) {
   if (typeof schemaOrCallback === "function") return schemaOrCallback(formKey, options);
   return schemaOrCallback;
@@ -6148,7 +6148,7 @@ function warnNoParentRV(instance) {
   );
 }
 
-const LAZY_BRAND = Symbol.for("attaform/wizard-lazy");
+const LAZY_BRAND = /* @__PURE__ */ Symbol.for("attaform/wizard-lazy");
 function lazy(resolve) {
   return { [LAZY_BRAND]: true, resolve };
 }
@@ -7305,5 +7305,24 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, DEFAULT_TIMINGS as D, injectWizard as a, isUnset as b, useRegister as c, useWizard as d, defaultCoercionRules as e, defaultDisplayState as f, defineCoercion as g, useAbstractForm as h, injectForm as i, isPlainRecord as j, safeAssign as k, lazy as l, makeDefaultDisplayState as m, slimKindOf as n, humanize as o, getAtPath as p, setAtPath as q, safeOwnRead as s, unset as u };
-//# sourceMappingURL=attaform.BoYqnIPI.mjs.map
+function escapeForInlineScript(json) {
+  return json.replace(/[<>&\u2028\u2029]/g, (char) => {
+    switch (char) {
+      case "<":
+        return "\\u003c";
+      case ">":
+        return "\\u003e";
+      case "&":
+        return "\\u0026";
+      case "\u2028":
+        return "\\u2028";
+      case "\u2029":
+        return "\\u2029";
+      default:
+        return char;
+    }
+  });
+}
+
+export { AttaformErrorCode as A, DEFAULT_TIMINGS as D, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, escapeForInlineScript as e, isUnset as f, useAbstractForm as g, useRegister as h, injectForm as i, useWizard as j, isPlainRecord as k, lazy as l, makeDefaultDisplayState as m, safeAssign as n, slimKindOf as o, humanize as p, getAtPath as q, setAtPath as r, safeOwnRead as s, unset as u };
+//# sourceMappingURL=attaform.CyQxTOdX.mjs.map