formstand 0.8.0 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,152 @@
 
 ## Unreleased
 
+## 0.9.0 — 2026-07-10
+
+### Fixed
+
+- `validateFields` no longer fabricates a "required" error for a field
+  whose required ancestor is `undefined` (the field-scoped fast path parsed
+  the leaf against undefined where the full-form parse keys the error at the
+  ancestor) — sync and async agreed again. `slotAtPath` now checks the
+  container at each step.
+- `useVariantField` keeps its type guard for **optional/nullable**
+  discriminated unions (a missing `NonNullable` let the nullish member
+  collapse `keyof` to `never` and leak every key, including the
+  discriminant).
+- `devtools` is active only in non-production builds
+  (`NODE_ENV !== "production"`), so opting in during development never
+  streams a shipped form's state to an end user with the extension.
+- `parseDateText` accepts calendar years under 100 (the Date constructor
+  maps 0–99 to 1900–1999; the literal year is forced back on).
+- `DateField` / `dateInputProps` preserve the existing value's time-of-day,
+  so re-picking the same day on a timestamped value is no longer spuriously
+  dirty (and changing the day keeps the time).
+- `parsePath`'s cached segment array is frozen — it is shared across callers
+  now, so external mutation throws instead of corrupting the cache.
+- `useVariantField` docs the write-gating contract (gate variant-field
+  writes on the discriminant, like rendering).
+
+### Added
+
+- `useVariantField(form, unionPath, field)`: typed access to the
+  variant-specific fields of a `z.discriminatedUnion` — the ones
+  `FieldPath` omits because they exist in only some union members (the
+  discriminant stays a common key, bound with plain `useField`). Typed as
+  the field's value across the variants that declare it, widened with
+  `| undefined`; a non-variant field or the discriminant itself is a
+  compile error. `createFormHooks` gains a bound `use{Name}VariantField`.
+- `persistForm(form, { key })`: the autosave recipe as a first-class
+  helper — debounced JSON drafts to any `{ getItem, setItem, removeItem }`
+  storage, draft auto-apply on start (`adopt` rebases clean, `restore`
+  loads dirty, `manual` waits for you), `clear()` that also cancels
+  pending writes, and guarded storage access throughout.
+- Redux DevTools: `createForm(schema, { devtools: "checkout" })` connects
+  the form's store to the extension via zustand's middleware — every write
+  named, inspectable, and time-travelable. Off by default and inert
+  without the extension.
+- Hot-path performance (the 2026-07 review's efficiency findings, no API
+  changes): `parsePath` is memoized (every field subscription re-parsed
+  its path per store notification); `validateFields` parses just the
+  requested subschemas when they're extractable — cross-field rules still
+  force the full parse, because extraction bails on refined levels — so a
+  wizard step stops paying for the whole schema per click; `diff()`/
+  `dirtyFields()` deep-compare each node once instead of once per ancestor
+  level; `focusFirstError` runs its focusability DOM walks only on
+  name-matched candidates instead of every named control in the document.
+- Dates are a first-class field kind: `DateField` (an `<input type="date">`
+  bound to Date-typed paths) joins the shipped components, with
+  `dateInputProps` / `dateToInputText` / `parseDateText` exported for
+  custom markup and UI-kit adapters. Local calendar-date semantics
+  throughout (never `toISOString()` — June 1 stays June 1 west of UTC),
+  the `emptyValue` round-trip on clear, and rollover rejection
+  (`2026-02-31` is invalid, not March 3).
+
+### CI (no package changes)
+
+- Dependabot triage: esbuild pinned to the patched 0.28.1 line via npm
+  overrides in the root and cli (dev-server advisories), scoped to spare
+  vitepress 1.x's nested vite-5 toolchain (esbuild 0.28 can't downlevel to
+  vite 5's browser targets). The remaining vitepress-nested alerts are
+  dismissed as tolerable risk — local docs dev/build only — with the
+  VitePress 2 migration tracked on the roadmap as the real fix.
+- Workflows declare least-privilege GITHUB_TOKEN permissions (CodeQL:
+  actions/missing-workflow-permissions).
+
+### Docs & examples (no package changes)
+
+- The Schema builder gains a **Paste a TypeScript type** mode: paste an
+  interface or type alias and the same in-browser emitters generate the
+  form — no TypeScript compiler in the bundle, a focused ~250-line parser
+  covers the CLI's type-mode subset (string/number/boolean/Date, arrays,
+  nested objects, string-literal unions, optional/nullable) and degrades
+  the rest to a text field with a TODO. Both input modes share one emit
+  path.
+- ROADMAP.md: a living plan for the library and the CLI — the 0.9/cli-0.6
+  cycle (dates as a first-class field kind, hot-path performance,
+  DevTools, CLI config + watch), the next tier, the parking lot, and the
+  review's deferred cleanup items.
+- The theme is one preference across the docs site and the playground:
+  the playground stores its light/dark choice under VitePress's own
+  localStorage key (same origin), so flipping either surface's toggle
+  follows you to the other.
+- The demo body caps at a readable 760px measure; legitimately wide demos
+  (Perf's grid, the Schema builder, the Invoice table) opt out via an
+  explicit WIDE_DEMOS set.
+- The demo card gets a real header: group eyebrow, title, a one-line
+  description of what each demo shows (exhaustive over the tab keys, like
+  the group map), and the View state / View code toggles plus a copy-link
+  button as a right-aligned action cluster — shell chrome separated from
+  demo content by a hairline. The nav groups show demo counts, and the
+  mobile bottom sheet gains its own Close button (the header toggles sit
+  behind it).
+
+- Mobile playground shell: a top app bar (menu / title / controls), the
+  demo list as an off-canvas drawer that closes on pick, and the View
+  state / View code panel as a bottom sheet — all CSS-driven, desktop
+  layout unchanged.
+- Light theme: a toggle in the app bar (and sidebar on desktop), defaulting
+  to the OS preference and persisted per browser. One variable palette in
+  styles.css drives the shell; the MUI bridge and the shadcn scope follow
+  the same html[data-theme] switch. Terminal/code surfaces deliberately
+  stay dark in both themes.
+- The GitHub link in the shell shows the repo's star count (best-effort,
+  cached per session, skipped under tests).
+
+## formstand-cli 0.6.0 — 2026-07-10
+
+- Discriminated unions (`z.discriminatedUnion`) at a field position: the
+  generator emits a discriminant select plus per-variant conditional
+  blocks, binding variant fields through the library's `useVariantField`
+  (single-file) or bound `use{Name}VariantField` (module layout) — fully
+  typed, no casts. All six emit paths (plain/mui/shadcn × single-file/
+  module) typecheck against the real helper. Initial values pick the
+  first variant; the schema round-trips. Nested-in-section unions,
+  unions in array rows, and non-scalar variant fields keep a TODO.
+- Nested-array row extraction (`--layout module`): an array inside a
+  section object, or an array inside an array row, now generates its own
+  Row/Rows component pair with a bound `useFieldArray` on the template
+  path (two numeric holes for arrays-in-rows,
+  `contacts.${parentIndex}.phones.${index}.number`) instead of a TODO
+  comment. One extraction level per array — deeper nesting keeps a TODO.
+- `formstand.config.ts` (also `.mts`/`.js`/`.mjs`, or `--config <file>`):
+  project defaults for `ui`/`layout`/`sections`/`columns`, written with the
+  typed `defineConfig` export. Precedence is flags > config > built-ins,
+  and config typos fail as loudly as flag typos.
+- `--watch`: regenerate whenever the input file changes (requires
+  `--out`; reruns overwrite their own output). Watches the parent
+  directory so editors that save via rename don't kill the watcher.
+- A kind × optional × nullable matrix test pins `emitInitialValues` and
+  `blankNeedsCast` agreement in both directions: the no-cast combos must
+  typecheck with the checked annotation, and every cast combo is proven
+  to genuinely need it.
+- Date fields emit real bindings instead of a text input with a cast and
+  a TODO: `DateField` (plain), `muiDateFieldProps` (MUI `type="date"`
+  TextField with a floated label), `shadcnDateInputProps` (shadcn Input).
+  `DATE_CAST` and the per-backend date TODOs are gone from generated
+  output — forms with dates submit successfully out of the box. Requires
+  formstand ≥ 0.9 for date fields.
+
 ## 0.8.0 — 2026-07-10
 
 #### Fixed (2026-07 full-repo review)
@@ -105,6 +251,14 @@
   The benchmark writes `field0` instead of the mid-grid field, so the
   change is visible without scrolling.
 
+## formstand-cli 0.5.3 — 2026-07-10
+
+### Fixed
+
+- Emitted string literals escape U+2028/U+2029 (JSON.stringify leaves the
+  JS line separators raw — a syntax error for pre-ES2019 parsers of the
+  GENERATED file, and CodeQL's js/bad-code-sanitization).
+
 ## formstand-cli 0.5.2 — 2026-07-10
 
 #### Fixed (2026-07 full-repo review)

package/README.md

@@ -429,7 +429,8 @@ form.handleSubmit(async (data) => {
 
 See [CONTRIBUTING.md](./CONTRIBUTING.md) — note the repo has three
 independent npm roots (`.`, `examples/`, `cli/`), and the root test suite
-needs `examples/` installed.
+needs `examples/` installed. Where the project is headed lives in
+[ROADMAP.md](./ROADMAP.md).
 
 ## License
 

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var vanilla = require('zustand/vanilla');
+var middleware = require('zustand/middleware');
 var zod = require('zod');
 var react = require('react');
 var jsxRuntime = require('react/jsx-runtime');
@@ -87,7 +88,18 @@ var isIndexSegment = (s) => {
   const n = Number(s);
   return Number.isInteger(n) && n >= 0 && String(n) === s;
 };
-var parsePath = (path) => path === "" ? [] : path.split(".").map((s) => isIndexSegment(s) ? Number(s) : s);
+var PARSE_CACHE_MAX = 4096;
+var parseCache = /* @__PURE__ */ new Map();
+var parsePath = (path) => {
+  const cached = parseCache.get(path);
+  if (cached !== void 0) return cached;
+  const segments = Object.freeze(
+    path === "" ? [] : path.split(".").map((s) => isIndexSegment(s) ? Number(s) : s)
+  );
+  if (parseCache.size >= PARSE_CACHE_MAX) parseCache.clear();
+  parseCache.set(path, segments);
+  return segments;
+};
 var isPlainRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 var readSegment = (obj, segment) => {
   if (obj == null) return void 0;
@@ -100,8 +112,9 @@ var getAtPath = (obj, path) => parsePath(path).reduce(readSegment, obj);
 var slotAtPath = (obj, path) => {
   const walked = parsePath(path).reduce(
     (acc, segment) => {
-      const outOfBounds = typeof segment === "number" && (Array.isArray(acc.current) ? segment >= acc.current.length : !isPlainRecord(acc.current));
-      return !acc.ok || outOfBounds ? { ok: false, current: void 0 } : { ok: true, current: readSegment(acc.current, segment) };
+      const container = acc.current;
+      const addressable = typeof segment === "number" ? Array.isArray(container) ? segment < container.length : isPlainRecord(container) : isPlainRecord(container);
+      return !acc.ok || !addressable ? { ok: false, current: void 0 } : { ok: true, current: readSegment(container, segment) };
     },
     { ok: true, current: obj }
   );
@@ -265,7 +278,7 @@ var releaseAncestorEntries = (map, path) => {
   return kept.length === entries.length ? map : Object.fromEntries(kept);
 };
 var dirtyPathsOf = (values, initial, prefix) => {
-  if (valuesEqual(values, initial)) return [];
+  if (Object.is(values, initial)) return [];
   if (isPlainObject(values) && isPlainObject(initial)) {
     const keys = /* @__PURE__ */ new Set([...Object.keys(values), ...Object.keys(initial)]);
     const childPaths = [...keys].flatMap(
@@ -275,9 +288,11 @@ var dirtyPathsOf = (values, initial, prefix) => {
         prefix === "" ? k : `${prefix}.${k}`
       )
     );
-    return childPaths.length > 0 ? childPaths : [prefix];
+    if (childPaths.length > 0) return childPaths;
+    const sameKeySet = Object.keys(values).length === Object.keys(initial).length && Object.keys(values).every((k) => Object.hasOwn(initial, k));
+    return sameKeySet ? [] : [prefix];
   }
-  return [prefix];
+  return valuesEqual(values, initial) ? [] : [prefix];
 };
 var FORM_SEQ_KEY = "__form__";
 var SUBMIT_SEQ_KEY = "__submit__";
@@ -339,7 +354,18 @@ var createForm = (schema, options) => {
     mode: initialMode,
     reValidateMode: initialReValidateMode
   };
-  const store = vanilla.createStore(() => initial);
+  const store = options.devtools === void 0 || options.devtools === false ? vanilla.createStore(() => initial) : vanilla.createStore()(
+    middleware.devtools(() => initial, {
+      name: typeof options.devtools === "string" ? options.devtools : "formstand",
+      // Non-production only, matching zustand's own devtools default:
+      // opting in during development must NOT stream every keystroke to
+      // an end user who happens to have the extension installed, where
+      // a module-singleton form's unbounded time-travel history is a
+      // real memory + serialization cost. Guarded for environments
+      // without process (a bundler defines NODE_ENV in real dev).
+      enabled: typeof process !== "undefined" && process.env?.["NODE_ENV"] !== "production"
+    })
+  );
   const commitFullPass = (state, next) => errorChannels(state, {
     schemaErrors: reuseErrorRefs(next, state.schemaErrors)
   });
@@ -368,7 +394,38 @@ var createForm = (schema, options) => {
       return result.kind === "pending" ? result.promise.then((r) => r.kind === "valid") : result.kind === "valid";
     }
     try {
-      const result = validateSync(schema, store.getState().values);
+      const values = store.getState().values;
+      const scopes = paths.map((path) => ({
+        path,
+        scope: fieldScopeFor(path, values)
+      }));
+      if (scopes.every(
+        ({ scope }) => scope.kind === "skip" || scope.kind === "parse" && scope.viaSubschema
+      )) {
+        const merged = scopes.reduce(
+          (acc, { path, scope }) => scope.kind === "skip" ? acc : {
+            ...acc,
+            ...scopeSettledResult(
+              validateSync(scope.schema, scope.value),
+              path,
+              true
+            )
+          },
+          {}
+        );
+        store.setState((state) => ({
+          ...state,
+          ...errorChannels(state, {
+            schemaErrors: reuseErrorRefs(
+              mergeScopedErrors(state.schemaErrors, merged, paths),
+              state.schemaErrors
+            ),
+            serverErrors: omitScope(state.serverErrors, paths)
+          })
+        }));
+        return Object.values(merged).flat().length === 0;
+      }
+      const result = validateSync(schema, values);
       const fullErrors = result.kind === "invalid" ? result.errors : emptyErrors;
       store.setState((state) => ({
         ...state,
@@ -968,6 +1025,74 @@ var shouldValidateOn = (trigger, mode, reValidateMode, submitAttempted, touched
       return true;
   }
 };
+
+// src/core/persist.ts
+var defaultStorage = () => {
+  try {
+    return typeof globalThis.localStorage === "undefined" ? null : globalThis.localStorage;
+  } catch {
+    return null;
+  }
+};
+var persistForm = (form, options) => {
+  const storage = options.storage ?? defaultStorage();
+  const debounceMs = options.debounceMs ?? 300;
+  const apply = options.apply ?? "adopt";
+  const applyDraft = (values) => apply === "restore" ? form.setValues(values) : form.adoptValues(values);
+  const restore = () => {
+    try {
+      const raw = storage === null ? null : storage.getItem(options.key);
+      if (raw === null) return false;
+      applyDraft(JSON.parse(raw));
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const writeDraft = (values) => {
+    try {
+      storage?.setItem(options.key, JSON.stringify(values));
+    } catch {
+    }
+  };
+  const timerRef = {
+    current: null
+  };
+  const cancelPending = () => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+  };
+  if (apply !== "manual") {
+    restore();
+  }
+  const unsubscribe = form.watchValues((values) => {
+    cancelPending();
+    if (debounceMs === 0) {
+      writeDraft(values);
+    } else {
+      timerRef.current = setTimeout(() => {
+        timerRef.current = null;
+        writeDraft(values);
+      }, debounceMs);
+    }
+  });
+  return Object.freeze({
+    restore,
+    clear: () => {
+      cancelPending();
+      try {
+        storage?.removeItem(options.key);
+      } catch {
+      }
+    },
+    dispose: () => {
+      cancelPending();
+      unsubscribe();
+    }
+  });
+};
 var useForm = (schema, options) => {
   const formRef = react.useRef(null);
   if (formRef.current === null) {
@@ -1130,6 +1255,14 @@ function useField(form, pathArg, options) {
     [slice, emptyValue, setValue, setTouched, setError, clearError, validate, validateAsync2, onBlur]
   );
 }
+
+// src/react/useVariantField.ts
+function useVariantField(form, unionPath, field) {
+  return useField(
+    form,
+    `${unionPath}.${field}`
+  );
+}
 var EMPTY_ID_STATE = { items: [], ids: [], counter: 0 };
 var EMPTY_ITEMS = [];
 var reconcileIds = (prev, nextItems) => {
@@ -1271,6 +1404,11 @@ var capitalize = (name) => name.length === 0 ? name : name.charAt(0).toUpperCase
 var createFormHooks = (form, name) => {
   const structural = form;
   const useBoundField = (path, options) => useField(structural, path, options);
+  const useBoundVariantField = (unionPath, field) => useVariantField(
+    structural,
+    unionPath,
+    field
+  );
   const useBoundFieldArray = (path) => useFieldArray(structural, path);
   const useBoundSelector = (selector) => useFormSelector(structural, selector);
   const useBoundSelectorShallow = (selector) => useFormSelectorShallow(structural, selector);
@@ -1282,6 +1420,7 @@ var createFormHooks = (form, name) => {
   const prefix = capitalize(name ?? "");
   return {
     [`use${prefix}Field`]: useBoundField,
+    [`use${prefix}VariantField`]: useBoundVariantField,
     [`use${prefix}FieldArray`]: useBoundFieldArray,
     [`use${prefix}Selector`]: useBoundSelector,
     [`use${prefix}SelectorShallow`]: useBoundSelectorShallow,
@@ -1326,6 +1465,48 @@ var numberInputProps = (field) => ({
   },
   onBlur: field.onBlur
 });
+var dateToInputText = (value) => {
+  if (value === void 0 || value === null || Number.isNaN(value.getTime())) {
+    return "";
+  }
+  const pad = (part) => String(part).padStart(2, "0");
+  return `${String(value.getFullYear()).padStart(4, "0")}-${pad(value.getMonth() + 1)}-${pad(value.getDate())}`;
+};
+var parseDateText = (text) => {
+  if (text.trim() === "") return { kind: "empty" };
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(text);
+  if (match === null) return { kind: "invalid" };
+  const [, year, month, day] = match;
+  const y = Number(year);
+  const date = new Date(y, Number(month) - 1, Number(day));
+  if (y < 100) date.setFullYear(y);
+  return date.getFullYear() === y && date.getMonth() === Number(month) - 1 && date.getDate() === Number(day) ? { kind: "date", value: date } : { kind: "invalid" };
+};
+var dateInputProps = (field) => ({
+  type: "date",
+  name: field.path,
+  value: dateToInputText(field.value),
+  "aria-invalid": ariaInvalid(field),
+  onChange: (e) => {
+    const parsed = parseDateText(e.target.value);
+    if (parsed.kind !== "date") {
+      field.setValue(field.emptyValue);
+      return;
+    }
+    const current = field.value;
+    const next = current instanceof Date && !Number.isNaN(current.getTime()) ? new Date(
+      parsed.value.getFullYear(),
+      parsed.value.getMonth(),
+      parsed.value.getDate(),
+      current.getHours(),
+      current.getMinutes(),
+      current.getSeconds(),
+      current.getMilliseconds()
+    ) : parsed.value;
+    field.setValue(next);
+  },
+  onBlur: field.onBlur
+});
 var checkboxProps = (field) => ({
   type: "checkbox",
   name: field.path,
@@ -1380,6 +1561,33 @@ var TextField = ({
     /* @__PURE__ */ jsxRuntime.jsx(ErrorText, { id: errorId, error: field.error })
   ] });
 };
+var DateField = ({
+  form,
+  path,
+  label,
+  min,
+  max,
+  ref
+}) => {
+  const id = react.useId();
+  const errorId = `${id}-error`;
+  const field = useField(form, path);
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "zf-field", children: [
+    label !== void 0 ? /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "zf-label", children: label }) : null,
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "input",
+      {
+        id,
+        ref,
+        ...dateInputProps(field),
+        min,
+        max,
+        "aria-describedby": hasError(field.error) ? errorId : void 0
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(ErrorText, { id: errorId, error: field.error })
+  ] });
+};
 var IDLE_EDIT = { raw: null, pushed: void 0 };
 var useNumberInput = (field) => {
   const [edit, setEdit] = react.useState(IDLE_EDIT);
@@ -1509,13 +1717,12 @@ var SelectField = ({
 };
 
 // src/react/focusError.ts
-var focusableControls = (scope) => [
+var namedControls = (scope) => [
   ...scope.querySelectorAll(
     "input[name], select[name], textarea[name]"
   )
-].filter(
-  (el) => !el.matches(':disabled, [type="hidden"]') && el.closest("dialog:not([open])") === null
-);
+];
+var isFocusCandidate = (el) => !el.matches(':disabled, [type="hidden"]') && el.closest("dialog:not([open])") === null;
 var holdsFocus = (el) => {
   const rootNode = el.getRootNode();
   const active = rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : document.activeElement;
@@ -1535,20 +1742,21 @@ var focusFirstError = (errors, root) => {
     (k) => k !== "" && (errors[k]?.length ?? 0) > 0
   );
   const hasRootError = (errors[""]?.length ?? 0) > 0;
-  const controls = focusableControls(scope);
-  const fieldMatches = controls.filter(
-    (el) => nameMatchesAny(el, erroredPaths)
-  );
+  const controls = namedControls(scope);
+  const fieldMatches = controls.filter((el) => nameMatchesAny(el, erroredPaths)).filter(isFocusCandidate);
   const rootFallbackApplies = hasRootError && (root !== void 0 || document.querySelectorAll("form").length <= 1);
-  const candidates = fieldMatches.length > 0 ? fieldMatches : rootFallbackApplies ? controls : [];
+  const candidates = fieldMatches.length > 0 ? fieldMatches : rootFallbackApplies ? controls.filter(isFocusCandidate) : [];
   return focusFirstOf(candidates);
 };
 var focusField = (path, root) => {
-  const controls = focusableControls(root ?? document);
-  return path === "" ? (root !== void 0 || document.querySelectorAll("form").length <= 1) && focusFirstOf(controls) : focusFirstOf(controls.filter((el) => nameMatchesAny(el, [path])));
+  const controls = namedControls(root ?? document);
+  return path === "" ? (root !== void 0 || document.querySelectorAll("form").length <= 1) && focusFirstOf(controls.filter(isFocusCandidate)) : focusFirstOf(
+    controls.filter((el) => nameMatchesAny(el, [path])).filter(isFocusCandidate)
+  );
 };
 
 exports.CheckboxField = CheckboxField;
+exports.DateField = DateField;
 exports.NumberField = NumberField;
 exports.SelectField = SelectField;
 exports.TextField = TextField;
@@ -1556,6 +1764,8 @@ exports.checkboxProps = checkboxProps;
 exports.createForm = createForm;
 exports.createFormContext = createFormContext;
 exports.createFormHooks = createFormHooks;
+exports.dateInputProps = dateInputProps;
+exports.dateToInputText = dateToInputText;
 exports.emptyValueForSchema = emptyValueForSchema;
 exports.flattenIssues = flattenIssues;
 exports.focusField = focusField;
@@ -1564,8 +1774,10 @@ exports.getAtPath = getAtPath;
 exports.isAsyncRequiredError = isAsyncRequiredError;
 exports.numberInputProps = numberInputProps;
 exports.numberToInputText = numberToInputText;
+exports.parseDateText = parseDateText;
 exports.parseNumberText = parseNumberText;
 exports.parsePath = parsePath;
+exports.persistForm = persistForm;
 exports.selectProps = selectProps;
 exports.setAtPath = setAtPath;
 exports.shouldValidateOn = shouldValidateOn;
@@ -1580,6 +1792,7 @@ exports.useIsDirty = useIsDirty;
 exports.useIsSubmitting = useIsSubmitting;
 exports.useIsValid = useIsValid;
 exports.useSubmitCount = useSubmitCount;
+exports.useVariantField = useVariantField;
 exports.validateAsync = validateAsync;
 exports.validateSync = validateSync;
 //# sourceMappingURL=index.cjs.map