@gusto/embedded-react-sdk 0.43.0 → 0.44.1

package/dist/partner-hook-utils/form/buildFormSchema.js

@@ -1,94 +1,94 @@
 import { z as h } from "zod";
-function I(t, r) {
+function D(e, r) {
   const {
     mode: i,
     requiredFieldsConfig: u = {},
     requiredErrorCode: c = "REQUIRED",
-    excludeFields: l = []
-  } = r, f = new Set(l.map(String)), a = new Set((r.fieldsWithRedactedValues ?? []).map(String)), R = new Set(
-    F(r.optionalFieldsToRequire, i)
-  ), m = {}, d = [], y = [], g = u;
-  for (const [n, s] of Object.entries(t)) {
+    excludeFields: p = []
+  } = r, f = new Set(p.map(String)), a = new Set((r.fieldsWithRedactedValues ?? []).map(String)), m = new Set(
+    x(r.optionalFieldsToRequire, i)
+  ), R = {}, d = [], y = [], g = u;
+  for (const [n, s] of Object.entries(e)) {
     if (f.has(n)) continue;
     y.push(n);
-    const e = g[n] ?? "always";
-    if (m[n] = x(s), !a.has(n)) {
-      const o = R.has(n);
-      typeof e == "function" ? d.push({
+    const t = g[n] ?? "always";
+    if (R[n] = b(s), !a.has(n)) {
+      const o = m.has(n);
+      typeof t == "function" ? d.push({
         name: n,
-        predicate: o ? () => !0 : e
-      }) : (e === "always" || e === i || o) && d.push({ name: n, predicate: () => !0 });
+        predicate: o ? () => !0 : t
+      }) : (t === "always" || t === i || o) && d.push({ name: n, predicate: () => !0 });
     }
   }
-  const q = d.length > 0 || r.superRefine;
-  let p = h.object(m);
-  q && (p = p.superRefine(
+  const w = d.length > 0 || r.superRefine;
+  let l = h.object(R);
+  w && (l = l.superRefine(
     (n, s) => {
-      for (const { name: e, predicate: o } of d)
-        o(n, i) && P(n[e]) && s.addIssue({
+      for (const { name: t, predicate: o } of d)
+        o(n, i) && q(n[t]) && s.addIssue({
           code: h.ZodIssueCode.custom,
-          path: [e],
+          path: [t],
           message: c
         });
       r.superRefine?.(n, s);
     }
   ));
-  const w = C(d, i);
-  function S(n) {
+  const S = P(d, i);
+  function F(n) {
     const s = {};
-    for (const e of y) {
-      const o = g[e] ?? "always";
-      R.has(e) ? s[e] = { name: e, isRequired: !0 } : typeof o == "function" ? s[e] = { name: e, isRequired: n ? o(n, i) : !1 } : s[e] = {
-        name: e,
+    for (const t of y) {
+      const o = g[t] ?? "always";
+      m.has(t) ? s[t] = { name: t, isRequired: !0 } : typeof o == "function" ? s[t] = { name: t, isRequired: n ? o(n, i) : !1 } : s[t] = {
+        name: t,
         isRequired: o === "always" || o === i
-      }, a.has(e) && (s[e].hasRedactedValue = !0);
+      }, a.has(t) && (s[t].hasRedactedValue = !0);
     }
     return s;
   }
   return [
-    p,
-    { getFieldsMetadata: S, predicateDeps: w }
+    l,
+    { getFieldsMetadata: F, predicateDeps: S }
   ];
 }
-function F(t, r) {
-  return t ? (r === "create" ? t.create : t.update) ?? [] : [];
+function x(e, r) {
+  return e ? (r === "create" ? e.create : e.update) ?? [] : [];
 }
-function x(t) {
-  return h.preprocess((r) => r === "" || r === null ? void 0 : r, t.optional());
+function b(e) {
+  return h.preprocess((r) => q(r) ? void 0 : r, e.optional());
 }
-function P(t) {
-  return t == null || typeof t == "string" && t.trim() === "";
+function q(e) {
+  return !!(e == null || typeof e == "string" && e.trim() === "" || typeof e == "number" && Number.isNaN(e));
 }
-function C(t, r) {
+function P(e, r) {
   const i = /* @__PURE__ */ new Set();
-  for (const { predicate: u } of t) {
-    if (E(u)) continue;
-    const c = [], l = new Proxy({}, {
+  for (const { predicate: u } of e) {
+    if (C(u)) continue;
+    const c = [], p = new Proxy({}, {
       get(f, a) {
         typeof a == "string" && c.push(a);
       }
     });
     try {
-      u(l, r);
+      u(p, r);
     } catch {
     }
     for (const f of c) i.add(f);
   }
   return [...i];
 }
-function E(t) {
+function C(e) {
   const r = [], i = new Proxy({}, {
     get(u, c) {
       typeof c == "string" && r.push(c);
     }
   });
   try {
-    t(i, "create");
+    e(i, "create");
   } catch {
   }
   return r.length === 0;
 }
 export {
-  I as buildFormSchema
+  D as buildFormSchema
 };
 //# sourceMappingURL=buildFormSchema.js.map

package/dist/partner-hook-utils/form/buildFormSchema.js.map

@@ -1 +1 @@
-{"version":3,"file":"buildFormSchema.js","sources":["../../../src/partner-hook-utils/form/buildFormSchema.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { FieldMetadata } from '../types'\n\n// ── Types ────────────────────────────────────────────────────────────\n\nexport type FormMode = 'create' | 'update'\n\nexport type RequiredFieldRule<TData = Record<string, unknown>> =\n  | 'create'\n  | 'update'\n  | 'always'\n  | 'never'\n  | ((data: TData, mode: FormMode) => boolean)\n\nexport type RequiredFieldConfig<TSchema extends Record<string, z.ZodType>> = Partial<{\n  [K in keyof TSchema & string]: RequiredFieldRule<{\n    [F in keyof TSchema]: z.infer<TSchema[F]>\n  }>\n}>\n\ntype OptionalOnCreate<TConfig> = {\n  [K in keyof TConfig & string]: TConfig[K] extends 'update' | 'never' ? K : never\n}[keyof TConfig & string]\n\ntype OptionalOnUpdate<TConfig> = {\n  [K in keyof TConfig & string]: TConfig[K] extends 'create' | 'never' ? K : never\n}[keyof TConfig & string]\n\nexport type OptionalFieldsToRequire<TConfig> = {\n  create?: Array<OptionalOnCreate<TConfig>>\n  update?: Array<OptionalOnUpdate<TConfig>>\n}\n\n// ── buildFormSchema ──────────────────────────────────────────────────\n\ninterface BuildFormSchemaOptions<\n  T extends Record<string, z.ZodType>,\n  TConfig extends RequiredFieldConfig<T>,\n> {\n  requiredFieldsConfig?: TConfig\n  requiredErrorCode?: string\n  mode: FormMode\n  optionalFieldsToRequire?: OptionalFieldsToRequire<TConfig>\n  excludeFields?: Array<keyof T & string>\n  /** Fields with existing server-side values that are redacted in the API response\n   *  (e.g. SSN, EIN). These fields remain in the schema for format validation and\n   *  appear in metadata (with `hasRedactedValue: true`) but are exempt from required\n   *  validation — an empty submission is valid because a value already exists. */\n  fieldsWithRedactedValues?: Array<keyof T & string>\n  superRefine?: (data: { [K in keyof T]: z.infer<T[K]> }, ctx: z.RefinementCtx) => void\n}\n\nexport interface FieldsMetadataConfig<T extends Record<string, z.ZodType>> {\n  getFieldsMetadata: (data?: Record<string, unknown>) => Record<keyof T, FieldMetadata>\n  /** Form field names that predicate-based requiredness rules read at runtime. */\n  predicateDeps: string[]\n}\n\ntype FormDataFromValidators<T extends Record<string, z.ZodType>> = {\n  [K in keyof T]: z.infer<T[K]>\n}\n\nexport type BuildFormSchemaResult<T extends Record<string, z.ZodType>> = [\n  schema: z.ZodType<FormDataFromValidators<T>, FormDataFromValidators<T>>,\n  metadataConfig: FieldsMetadataConfig<T>,\n]\n\nexport function buildFormSchema<\n  T extends Record<string, z.ZodType>,\n  TConfig extends RequiredFieldConfig<T>,\n>(fieldValidators: T, options: BuildFormSchemaOptions<T, TConfig>): BuildFormSchemaResult<T> {\n  const {\n    mode,\n    requiredFieldsConfig = {} as Record<string, RequiredFieldRule>,\n    requiredErrorCode = 'REQUIRED',\n    excludeFields = [],\n  } = options\n  const excluded = new Set(excludeFields.map(String))\n  const redacted = new Set((options.fieldsWithRedactedValues ?? []).map(String))\n  const partnerRequired = new Set(\n    resolveOptionalFieldsToRequire(options.optionalFieldsToRequire, mode),\n  )\n\n  const shape: Record<string, z.ZodType> = {}\n  const dynamicRequired: Array<{\n    name: string\n    predicate: (data: Record<string, unknown>, mode: FormMode) => boolean\n  }> = []\n  const includedFieldNames: string[] = []\n  const config = requiredFieldsConfig as Record<string, RequiredFieldRule>\n\n  for (const [name, validator] of Object.entries(fieldValidators)) {\n    if (excluded.has(name)) continue\n    includedFieldNames.push(name)\n\n    const effectiveRule = config[name] ?? 'always'\n\n    shape[name] = makeOptional(validator)\n\n    if (!redacted.has(name)) {\n      const isPartnerRequired = partnerRequired.has(name)\n\n      if (typeof effectiveRule === 'function') {\n        dynamicRequired.push({\n          name,\n          predicate: isPartnerRequired ? () => true : effectiveRule,\n        })\n      } else {\n        const isRequired = effectiveRule === 'always' || effectiveRule === mode || isPartnerRequired\n        if (isRequired) {\n          dynamicRequired.push({ name, predicate: () => true })\n        }\n      }\n    }\n  }\n\n  const hasSuperRefine = dynamicRequired.length > 0 || options.superRefine\n  let schema: z.ZodType = z.object(shape)\n\n  if (hasSuperRefine) {\n    schema = (schema as z.ZodObject).superRefine(\n      (data: Record<string, unknown>, ctx: z.RefinementCtx) => {\n        for (const { name, predicate } of dynamicRequired) {\n          if (predicate(data, mode) && isEmpty(data[name])) {\n            ctx.addIssue({\n              code: z.ZodIssueCode.custom,\n              path: [name],\n              message: requiredErrorCode,\n            })\n          }\n        }\n\n        options.superRefine?.(data as { [K in keyof T]: z.infer<T[K]> }, ctx)\n      },\n    )\n  }\n\n  const predicateDeps = detectPredicateDeps(dynamicRequired, mode)\n\n  function getFieldsMetadata(data?: Record<string, unknown>) {\n    const metadata: Record<string, FieldMetadata> = {}\n\n    for (const name of includedFieldNames) {\n      const effectiveRule = config[name] ?? 'always'\n\n      if (partnerRequired.has(name)) {\n        metadata[name] = { name, isRequired: true }\n      } else if (typeof effectiveRule === 'function') {\n        metadata[name] = { name, isRequired: data ? effectiveRule(data, mode) : false }\n      } else {\n        metadata[name] = {\n          name,\n          isRequired: effectiveRule === 'always' || effectiveRule === mode,\n        }\n      }\n\n      if (redacted.has(name)) {\n        metadata[name].hasRedactedValue = true\n      }\n    }\n\n    return metadata as Record<keyof T, FieldMetadata>\n  }\n\n  // makeOptional wraps fields with z.preprocess, which causes z.input to infer\n  // `unknown`. Cast the schema to carry the original field types so zodResolver\n  // infers correct form data types — consumers don't need per-hook casts.\n  return [\n    schema as z.ZodType<FormDataFromValidators<T>, FormDataFromValidators<T>>,\n    { getFieldsMetadata, predicateDeps },\n  ]\n}\n\n// ── Internal helpers ─────────────────────────────────────────────────\n\nfunction resolveOptionalFieldsToRequire<TConfig>(\n  value: OptionalFieldsToRequire<TConfig> | undefined,\n  mode: FormMode,\n): string[] {\n  if (!value) return []\n  return ((mode === 'create' ? value.create : value.update) ?? []) as string[]\n}\n\nfunction makeOptional(validator: z.ZodType): z.ZodType {\n  return z.preprocess(v => (v === '' || v === null ? undefined : v), validator.optional())\n}\n\nfunction isEmpty(value: unknown): boolean {\n  if (value === undefined || value === null) return true\n  if (typeof value === 'string' && value.trim() === '') return true\n  return false\n}\n\n/**\n * Determines which form field names are read by predicate-based requiredness\n * rules. This enables `useDeriveFieldsMetadata` to watch only the specific\n * fields that predicates depend on, rather than subscribing to every form\n * value change (which defeats react-hook-form's per-field render optimization).\n *\n * Works by running each predicate against a recording Proxy. The Proxy\n * intercepts property access and logs the keys, giving us the dependency list\n * without requiring manual declaration.\n *\n * Limitation: JavaScript short-circuit evaluation (`a && b`) can prevent the\n * Proxy from seeing later operands when earlier ones are falsy. In practice\n * this is acceptable — our predicate rules read a single form value each\n * (e.g. `data => data.adjustForMinimumWage`). Multi-field predicates with\n * equality guards should be expressed as `superRefine` rules instead.\n */\nfunction detectPredicateDeps(\n  dynamicRequired: Array<{\n    name: string\n    predicate: (data: Record<string, unknown>, mode: FormMode) => boolean\n  }>,\n  mode: FormMode,\n): string[] {\n  const deps = new Set<string>()\n\n  for (const { predicate } of dynamicRequired) {\n    if (isConstantPredicate(predicate)) continue\n\n    const accessed: string[] = []\n    const proxy = new Proxy({} as Record<string, unknown>, {\n      get(_target, prop) {\n        if (typeof prop === 'string') accessed.push(prop)\n        return undefined\n      },\n    })\n\n    try {\n      predicate(proxy, mode)\n    } catch {\n      /* Predicate may throw on undefined values — that's fine, we already captured the property accesses */\n    }\n\n    for (const key of accessed) deps.add(key)\n  }\n\n  return [...deps]\n}\n\n/**\n * Static predicates (e.g. `() => true` from 'always' / mode rules / partner\n * overrides) don't access form data, so we skip them during dependency\n * detection. We identify them by running against an empty proxy and checking\n * whether any properties were accessed.\n */\nfunction isConstantPredicate(\n  predicate: (data: Record<string, unknown>, mode: FormMode) => boolean,\n): boolean {\n  const accessed: string[] = []\n  const proxy = new Proxy({} as Record<string, unknown>, {\n    get(_target, prop) {\n      if (typeof prop === 'string') accessed.push(prop)\n      return undefined\n    },\n  })\n  try {\n    predicate(proxy, 'create')\n  } catch {\n    /* ignore */\n  }\n  return accessed.length === 0\n}\n"],"names":["buildFormSchema","fieldValidators","options","mode","requiredFieldsConfig","requiredErrorCode","excludeFields","excluded","redacted","partnerRequired","resolveOptionalFieldsToRequire","shape","dynamicRequired","includedFieldNames","config","name","validator","effectiveRule","makeOptional","isPartnerRequired","hasSuperRefine","schema","z","data","ctx","predicate","isEmpty","predicateDeps","detectPredicateDeps","getFieldsMetadata","metadata","value","v","deps","isConstantPredicate","accessed","proxy","_target","prop","key"],"mappings":"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"}
+{"version":3,"file":"buildFormSchema.js","sources":["../../../src/partner-hook-utils/form/buildFormSchema.ts"],"sourcesContent":["import { z } from 'zod'\nimport type { FieldMetadata } from '../types'\n\n// ── Types ────────────────────────────────────────────────────────────\n\nexport type FormMode = 'create' | 'update'\n\nexport type RequiredFieldRule<TData = Record<string, unknown>> =\n  | 'create'\n  | 'update'\n  | 'always'\n  | 'never'\n  | ((data: TData, mode: FormMode) => boolean)\n\nexport type RequiredFieldConfig<TSchema extends Record<string, z.ZodType>> = Partial<{\n  [K in keyof TSchema & string]: RequiredFieldRule<{\n    [F in keyof TSchema]: z.infer<TSchema[F]>\n  }>\n}>\n\ntype OptionalOnCreate<TConfig> = {\n  [K in keyof TConfig & string]: TConfig[K] extends 'update' | 'never' ? K : never\n}[keyof TConfig & string]\n\ntype OptionalOnUpdate<TConfig> = {\n  [K in keyof TConfig & string]: TConfig[K] extends 'create' | 'never' ? K : never\n}[keyof TConfig & string]\n\nexport type OptionalFieldsToRequire<TConfig> = {\n  create?: Array<OptionalOnCreate<TConfig>>\n  update?: Array<OptionalOnUpdate<TConfig>>\n}\n\n// ── buildFormSchema ──────────────────────────────────────────────────\n\ninterface BuildFormSchemaOptions<\n  T extends Record<string, z.ZodType>,\n  TConfig extends RequiredFieldConfig<T>,\n> {\n  requiredFieldsConfig?: TConfig\n  requiredErrorCode?: string\n  mode: FormMode\n  optionalFieldsToRequire?: OptionalFieldsToRequire<TConfig>\n  excludeFields?: Array<keyof T & string>\n  /** Fields with existing server-side values that are redacted in the API response\n   *  (e.g. SSN, EIN). These fields remain in the schema for format validation and\n   *  appear in metadata (with `hasRedactedValue: true`) but are exempt from required\n   *  validation — an empty submission is valid because a value already exists. */\n  fieldsWithRedactedValues?: Array<keyof T & string>\n  superRefine?: (data: { [K in keyof T]: z.infer<T[K]> }, ctx: z.RefinementCtx) => void\n}\n\nexport interface FieldsMetadataConfig<T extends Record<string, z.ZodType>> {\n  getFieldsMetadata: (data?: Record<string, unknown>) => Record<keyof T, FieldMetadata>\n  /** Form field names that predicate-based requiredness rules read at runtime. */\n  predicateDeps: string[]\n}\n\ntype FormDataFromValidators<T extends Record<string, z.ZodType>> = {\n  [K in keyof T]: z.infer<T[K]>\n}\n\nexport type BuildFormSchemaResult<T extends Record<string, z.ZodType>> = [\n  schema: z.ZodType<FormDataFromValidators<T>, FormDataFromValidators<T>>,\n  metadataConfig: FieldsMetadataConfig<T>,\n]\n\nexport function buildFormSchema<\n  T extends Record<string, z.ZodType>,\n  TConfig extends RequiredFieldConfig<T>,\n>(fieldValidators: T, options: BuildFormSchemaOptions<T, TConfig>): BuildFormSchemaResult<T> {\n  const {\n    mode,\n    requiredFieldsConfig = {} as Record<string, RequiredFieldRule>,\n    requiredErrorCode = 'REQUIRED',\n    excludeFields = [],\n  } = options\n  const excluded = new Set(excludeFields.map(String))\n  const redacted = new Set((options.fieldsWithRedactedValues ?? []).map(String))\n  const partnerRequired = new Set(\n    resolveOptionalFieldsToRequire(options.optionalFieldsToRequire, mode),\n  )\n\n  const shape: Record<string, z.ZodType> = {}\n  const dynamicRequired: Array<{\n    name: string\n    predicate: (data: Record<string, unknown>, mode: FormMode) => boolean\n  }> = []\n  const includedFieldNames: string[] = []\n  const config = requiredFieldsConfig as Record<string, RequiredFieldRule>\n\n  for (const [name, validator] of Object.entries(fieldValidators)) {\n    if (excluded.has(name)) continue\n    includedFieldNames.push(name)\n\n    const effectiveRule = config[name] ?? 'always'\n\n    shape[name] = makeOptional(validator)\n\n    if (!redacted.has(name)) {\n      const isPartnerRequired = partnerRequired.has(name)\n\n      if (typeof effectiveRule === 'function') {\n        dynamicRequired.push({\n          name,\n          predicate: isPartnerRequired ? () => true : effectiveRule,\n        })\n      } else {\n        const isRequired = effectiveRule === 'always' || effectiveRule === mode || isPartnerRequired\n        if (isRequired) {\n          dynamicRequired.push({ name, predicate: () => true })\n        }\n      }\n    }\n  }\n\n  const hasSuperRefine = dynamicRequired.length > 0 || options.superRefine\n  let schema: z.ZodType = z.object(shape)\n\n  if (hasSuperRefine) {\n    schema = (schema as z.ZodObject).superRefine(\n      (data: Record<string, unknown>, ctx: z.RefinementCtx) => {\n        for (const { name, predicate } of dynamicRequired) {\n          if (predicate(data, mode) && isEmpty(data[name])) {\n            ctx.addIssue({\n              code: z.ZodIssueCode.custom,\n              path: [name],\n              message: requiredErrorCode,\n            })\n          }\n        }\n\n        options.superRefine?.(data as { [K in keyof T]: z.infer<T[K]> }, ctx)\n      },\n    )\n  }\n\n  const predicateDeps = detectPredicateDeps(dynamicRequired, mode)\n\n  function getFieldsMetadata(data?: Record<string, unknown>) {\n    const metadata: Record<string, FieldMetadata> = {}\n\n    for (const name of includedFieldNames) {\n      const effectiveRule = config[name] ?? 'always'\n\n      if (partnerRequired.has(name)) {\n        metadata[name] = { name, isRequired: true }\n      } else if (typeof effectiveRule === 'function') {\n        metadata[name] = { name, isRequired: data ? effectiveRule(data, mode) : false }\n      } else {\n        metadata[name] = {\n          name,\n          isRequired: effectiveRule === 'always' || effectiveRule === mode,\n        }\n      }\n\n      if (redacted.has(name)) {\n        metadata[name].hasRedactedValue = true\n      }\n    }\n\n    return metadata as Record<keyof T, FieldMetadata>\n  }\n\n  // makeOptional wraps fields with z.preprocess, which causes z.input to infer\n  // `unknown`. Cast the schema to carry the original field types so zodResolver\n  // infers correct form data types — consumers don't need per-hook casts.\n  return [\n    schema as z.ZodType<FormDataFromValidators<T>, FormDataFromValidators<T>>,\n    { getFieldsMetadata, predicateDeps },\n  ]\n}\n\n// ── Internal helpers ─────────────────────────────────────────────────\n\nfunction resolveOptionalFieldsToRequire<TConfig>(\n  value: OptionalFieldsToRequire<TConfig> | undefined,\n  mode: FormMode,\n): string[] {\n  if (!value) return []\n  return ((mode === 'create' ? value.create : value.update) ?? []) as string[]\n}\n\nfunction makeOptional(validator: z.ZodType): z.ZodType {\n  return z.preprocess(v => (isEmpty(v) ? undefined : v), validator.optional())\n}\n\nfunction isEmpty(value: unknown): boolean {\n  if (value === undefined || value === null) return true\n  if (typeof value === 'string' && value.trim() === '') return true\n  if (typeof value === 'number' && Number.isNaN(value)) return true\n  return false\n}\n\n/**\n * Determines which form field names are read by predicate-based requiredness\n * rules. This enables `useDeriveFieldsMetadata` to watch only the specific\n * fields that predicates depend on, rather than subscribing to every form\n * value change (which defeats react-hook-form's per-field render optimization).\n *\n * Works by running each predicate against a recording Proxy. The Proxy\n * intercepts property access and logs the keys, giving us the dependency list\n * without requiring manual declaration.\n *\n * Limitation: JavaScript short-circuit evaluation (`a && b`) can prevent the\n * Proxy from seeing later operands when earlier ones are falsy. In practice\n * this is acceptable — our predicate rules read a single form value each\n * (e.g. `data => data.adjustForMinimumWage`). Multi-field predicates with\n * equality guards should be expressed as `superRefine` rules instead.\n */\nfunction detectPredicateDeps(\n  dynamicRequired: Array<{\n    name: string\n    predicate: (data: Record<string, unknown>, mode: FormMode) => boolean\n  }>,\n  mode: FormMode,\n): string[] {\n  const deps = new Set<string>()\n\n  for (const { predicate } of dynamicRequired) {\n    if (isConstantPredicate(predicate)) continue\n\n    const accessed: string[] = []\n    const proxy = new Proxy({} as Record<string, unknown>, {\n      get(_target, prop) {\n        if (typeof prop === 'string') accessed.push(prop)\n        return undefined\n      },\n    })\n\n    try {\n      predicate(proxy, mode)\n    } catch {\n      /* Predicate may throw on undefined values — that's fine, we already captured the property accesses */\n    }\n\n    for (const key of accessed) deps.add(key)\n  }\n\n  return [...deps]\n}\n\n/**\n * Static predicates (e.g. `() => true` from 'always' / mode rules / partner\n * overrides) don't access form data, so we skip them during dependency\n * detection. We identify them by running against an empty proxy and checking\n * whether any properties were accessed.\n */\nfunction isConstantPredicate(\n  predicate: (data: Record<string, unknown>, mode: FormMode) => boolean,\n): boolean {\n  const accessed: string[] = []\n  const proxy = new Proxy({} as Record<string, unknown>, {\n    get(_target, prop) {\n      if (typeof prop === 'string') accessed.push(prop)\n      return undefined\n    },\n  })\n  try {\n    predicate(proxy, 'create')\n  } catch {\n    /* ignore */\n  }\n  return accessed.length === 0\n}\n"],"names":["buildFormSchema","fieldValidators","options","mode","requiredFieldsConfig","requiredErrorCode","excludeFields","excluded","redacted","partnerRequired","resolveOptionalFieldsToRequire","shape","dynamicRequired","includedFieldNames","config","name","validator","effectiveRule","makeOptional","isPartnerRequired","hasSuperRefine","schema","z","data","ctx","predicate","isEmpty","predicateDeps","detectPredicateDeps","getFieldsMetadata","metadata","value","v","deps","isConstantPredicate","accessed","proxy","_target","prop","key"],"mappings":";AAmEO,SAASA,EAGdC,GAAoBC,GAAuE;AAC3F,QAAM;AAAA,IACJ,MAAAC;AAAA,IACA,sBAAAC,IAAuB,CAAA;AAAA,IACvB,mBAAAC,IAAoB;AAAA,IACpB,eAAAC,IAAgB,CAAA;AAAA,EAAC,IACfJ,GACEK,IAAW,IAAI,IAAID,EAAc,IAAI,MAAM,CAAC,GAC5CE,IAAW,IAAI,KAAKN,EAAQ,4BAA4B,CAAA,GAAI,IAAI,MAAM,CAAC,GACvEO,IAAkB,IAAI;AAAA,IAC1BC,EAA+BR,EAAQ,yBAAyBC,CAAI;AAAA,EAAA,GAGhEQ,IAAmC,CAAA,GACnCC,IAGD,CAAA,GACCC,IAA+B,CAAA,GAC/BC,IAASV;AAEf,aAAW,CAACW,GAAMC,CAAS,KAAK,OAAO,QAAQf,CAAe,GAAG;AAC/D,QAAIM,EAAS,IAAIQ,CAAI,EAAG;AACxB,IAAAF,EAAmB,KAAKE,CAAI;AAE5B,UAAME,IAAgBH,EAAOC,CAAI,KAAK;AAItC,QAFAJ,EAAMI,CAAI,IAAIG,EAAaF,CAAS,GAEhC,CAACR,EAAS,IAAIO,CAAI,GAAG;AACvB,YAAMI,IAAoBV,EAAgB,IAAIM,CAAI;AAElD,MAAI,OAAOE,KAAkB,aAC3BL,EAAgB,KAAK;AAAA,QACnB,MAAAG;AAAA,QACA,WAAWI,IAAoB,MAAM,KAAOF;AAAA,MAAA,CAC7C,KAEkBA,MAAkB,YAAYA,MAAkBd,KAAQgB,MAEzEP,EAAgB,KAAK,EAAE,MAAAG,GAAM,WAAW,MAAM,IAAM;AAAA,IAG1D;AAAA,EACF;AAEA,QAAMK,IAAiBR,EAAgB,SAAS,KAAKV,EAAQ;AAC7D,MAAImB,IAAoBC,EAAE,OAAOX,CAAK;AAEtC,EAAIS,MACFC,IAAUA,EAAuB;AAAA,IAC/B,CAACE,GAA+BC,MAAyB;AACvD,iBAAW,EAAE,MAAAT,GAAM,WAAAU,EAAA,KAAeb;AAChC,QAAIa,EAAUF,GAAMpB,CAAI,KAAKuB,EAAQH,EAAKR,CAAI,CAAC,KAC7CS,EAAI,SAAS;AAAA,UACX,MAAMF,EAAE,aAAa;AAAA,UACrB,MAAM,CAACP,CAAI;AAAA,UACX,SAASV;AAAA,QAAA,CACV;AAIL,MAAAH,EAAQ,cAAcqB,GAA2CC,CAAG;AAAA,IACtE;AAAA,EAAA;AAIJ,QAAMG,IAAgBC,EAAoBhB,GAAiBT,CAAI;AAE/D,WAAS0B,EAAkBN,GAAgC;AACzD,UAAMO,IAA0C,CAAA;AAEhD,eAAWf,KAAQF,GAAoB;AACrC,YAAMI,IAAgBH,EAAOC,CAAI,KAAK;AAEtC,MAAIN,EAAgB,IAAIM,CAAI,IAC1Be,EAASf,CAAI,IAAI,EAAE,MAAAA,GAAM,YAAY,GAAA,IAC5B,OAAOE,KAAkB,aAClCa,EAASf,CAAI,IAAI,EAAE,MAAAA,GAAM,YAAYQ,IAAON,EAAcM,GAAMpB,CAAI,IAAI,GAAA,IAExE2B,EAASf,CAAI,IAAI;AAAA,QACf,MAAAA;AAAA,QACA,YAAYE,MAAkB,YAAYA,MAAkBd;AAAA,MAAA,GAI5DK,EAAS,IAAIO,CAAI,MACnBe,EAASf,CAAI,EAAE,mBAAmB;AAAA,IAEtC;AAEA,WAAOe;AAAA,EACT;AAKA,SAAO;AAAA,IACLT;AAAA,IACA,EAAE,mBAAAQ,GAAmB,eAAAF,EAAA;AAAA,EAAc;AAEvC;AAIA,SAASjB,EACPqB,GACA5B,GACU;AACV,SAAK4B,KACI5B,MAAS,WAAW4B,EAAM,SAASA,EAAM,WAAW,CAAA,IAD1C,CAAA;AAErB;AAEA,SAASb,EAAaF,GAAiC;AACrD,SAAOM,EAAE,WAAW,CAAAU,MAAMN,EAAQM,CAAC,IAAI,SAAYA,GAAIhB,EAAU,SAAA,CAAU;AAC7E;AAEA,SAASU,EAAQK,GAAyB;AAGxC,SAFI,GAAuBA,KAAU,QACjC,OAAOA,KAAU,YAAYA,EAAM,KAAA,MAAW,MAC9C,OAAOA,KAAU,YAAY,OAAO,MAAMA,CAAK;AAErD;AAkBA,SAASH,EACPhB,GAIAT,GACU;AACV,QAAM8B,wBAAW,IAAA;AAEjB,aAAW,EAAE,WAAAR,EAAA,KAAeb,GAAiB;AAC3C,QAAIsB,EAAoBT,CAAS,EAAG;AAEpC,UAAMU,IAAqB,CAAA,GACrBC,IAAQ,IAAI,MAAM,IAA+B;AAAA,MACrD,IAAIC,GAASC,GAAM;AACjB,QAAI,OAAOA,KAAS,YAAUH,EAAS,KAAKG,CAAI;AAAA,MAElD;AAAA,IAAA,CACD;AAED,QAAI;AACF,MAAAb,EAAUW,GAAOjC,CAAI;AAAA,IACvB,QAAQ;AAAA,IAER;AAEA,eAAWoC,KAAOJ,EAAU,CAAAF,EAAK,IAAIM,CAAG;AAAA,EAC1C;AAEA,SAAO,CAAC,GAAGN,CAAI;AACjB;AAQA,SAASC,EACPT,GACS;AACT,QAAMU,IAAqB,CAAA,GACrBC,IAAQ,IAAI,MAAM,IAA+B;AAAA,IACrD,IAAIC,GAASC,GAAM;AACjB,MAAI,OAAOA,KAAS,YAAUH,EAAS,KAAKG,CAAI;AAAA,IAElD;AAAA,EAAA,CACD;AACD,MAAI;AACF,IAAAb,EAAUW,GAAO,QAAQ;AAAA,EAC3B,QAAQ;AAAA,EAER;AACA,SAAOD,EAAS,WAAW;AAC7B;"}

package/dist/partner-hook-utils/form/composeSubmitHandler.d.ts

@@ -1,18 +1,21 @@
 import { SyntheticEvent } from 'react';
 import { FieldValues, UseFormReturn } from 'react-hook-form';
-import { HookErrorHandling } from '../types';
+import { HookErrorHandling, HookFormInternals } from '../types';
 /**
  * Minimal shape required for a form hook result to participate in `composeSubmitHandler`.
  * Any hook returning `BaseFormHookReady` satisfies this interface.
  *
- * Uses method syntax so TypeScript applies bivariant checking on parameter types,
+ * `formMethods` is declared with method-call syntax (rather than reused from
+ * `HookFormInternals`) so TypeScript applies bivariant parameter checking,
  * allowing hooks with specific form data generics to be passed without casts.
+ * `_fieldElementRegistry` is reused directly since its type doesn't depend on
+ * the form's generic.
  */
 interface ComposableFormHookResult {
     form: {
-        hookFormInternals: {
+        hookFormInternals: Pick<HookFormInternals, '_fieldElementRegistry'> & {
             formMethods: {
-                handleSubmit(onValid: () => void, onInvalid?: () => void): () => Promise<void>;
+                handleSubmit(onValid: () => void, onInvalid?: (errors: Record<string, unknown>) => void): () => Promise<void>;
                 setFocus(name: string): void;
                 formState: {
                     errors: Record<string, unknown>;
@@ -39,8 +42,9 @@ export interface ComposeSubmitHandlerResult {
  * Coordinates validation and submission across multiple form hooks on the same page, and
  * returns aggregated `errorHandling` for those forms so you can drive a single error surface.
  *
- * Validates all forms simultaneously via `handleSubmit()`, then focuses the first invalid
- * field across all forms (in array order). Only calls `onAllValid` when every form passes.
+ * Validates all forms simultaneously via `handleSubmit()`, then focuses the visually first
+ * invalid field across all forms (sorted by `getBoundingClientRect()`). Only calls
+ * `onAllValid` when every form passes.
  *
  * Uses `handleSubmit` rather than `trigger` so that react-hook-form sets
  * `formState.isSubmitted = true`, which enables `reValidateMode` (default: `onChange`).

package/dist/partner-hook-utils/form/composeSubmitHandler.js

@@ -1,40 +1,63 @@
-import { composeErrorHandler as c } from "../composeErrorHandler.js";
-function a(r) {
-  return "handleSubmit" in r && typeof r.handleSubmit == "function";
+import { composeErrorHandler as u } from "../composeErrorHandler.js";
+function f(e) {
+  return "handleSubmit" in e && typeof e.handleSubmit == "function";
 }
-function f(r) {
-  return a(r) ? r : r.form.hookFormInternals.formMethods;
+function h(e) {
+  return f(e) ? e : e.form.hookFormInternals.formMethods;
 }
-function S(r, s) {
-  const n = r.map(f), i = r.filter((e) => !a(e)), l = async (e) => {
-    if (e.preventDefault(), !(await Promise.all(
-      n.map(
-        (t) => new Promise((o) => {
-          t.handleSubmit(
+function g(e) {
+  const i = [];
+  for (const { input: n, formMethods: s, errors: o } of e) {
+    if (f(n)) continue;
+    const t = n.form.hookFormInternals._fieldElementRegistry;
+    if (t)
+      for (const r of Object.keys(o)) {
+        const l = t.get(r);
+        l && i.push({ formMethods: s, name: r, element: l });
+      }
+  }
+  if (i.length > 0) {
+    i.sort((s, o) => {
+      const t = s.element.getBoundingClientRect(), r = o.element.getBoundingClientRect();
+      return t.top - r.top || t.left - r.left;
+    }), i[0].element.focus();
+    return;
+  }
+  for (const { formMethods: n, errors: s } of e) {
+    const o = Object.keys(s)[0];
+    if (o) {
+      n.setFocus(o);
+      return;
+    }
+  }
+}
+function F(e, i) {
+  const n = e.filter((t) => !f(t)), s = async (t) => {
+    t.preventDefault();
+    const r = await Promise.all(
+      e.map(
+        (c) => new Promise((m) => {
+          const a = h(c);
+          a.handleSubmit(
             () => {
-              o(!0);
+              m({ input: c, formMethods: a, valid: !0, errors: {} });
             },
-            () => {
-              o(!1);
+            (d) => {
+              m({ input: c, formMethods: a, valid: !1, errors: d });
             }
           )();
         })
       )
-    )).every(Boolean)) {
-      for (const t of n) {
-        const o = Object.keys(t.formState.errors)[0];
-        if (o) {
-          t.setFocus(o);
-          return;
-        }
-      }
+    );
+    if (!r.every((c) => c.valid)) {
+      g(r);
       return;
     }
-    await s();
-  }, m = c(i);
-  return { handleSubmit: l, errorHandling: m };
+    await i();
+  }, o = u(n);
+  return { handleSubmit: s, errorHandling: o };
 }
 export {
-  S as composeSubmitHandler
+  F as composeSubmitHandler
 };
 //# sourceMappingURL=composeSubmitHandler.js.map

package/dist/partner-hook-utils/form/composeSubmitHandler.js.map

@@ -1 +1 @@
-{"version":3,"file":"composeSubmitHandler.js","sources":["../../../src/partner-hook-utils/form/composeSubmitHandler.ts"],"sourcesContent":["import type { SyntheticEvent } from 'react'\nimport type { FieldValues, UseFormReturn } from 'react-hook-form'\nimport { composeErrorHandler } from '../composeErrorHandler'\nimport type { HookErrorHandling } from '../types'\n\n/**\n * Minimal shape required for a form hook result to participate in `composeSubmitHandler`.\n * Any hook returning `BaseFormHookReady` satisfies this interface.\n *\n * Uses method syntax so TypeScript applies bivariant checking on parameter types,\n * allowing hooks with specific form data generics to be passed without casts.\n */\ninterface ComposableFormHookResult {\n  form: {\n    hookFormInternals: {\n      formMethods: {\n        handleSubmit(onValid: () => void, onInvalid?: () => void): () => Promise<void>\n        setFocus(name: string): void\n        formState: { errors: Record<string, unknown> }\n      }\n    }\n  }\n  errorHandling: HookErrorHandling\n}\n\n/**\n * Accepted input for a single slot of `composeSubmitHandler`'s `forms` array.\n *\n * - SDK form hook results (anything matching `ComposableFormHookResult`) are composed directly.\n * - A raw `react-hook-form` `UseFormReturn<T>` is supported for screen-local auxiliary forms\n *   that don't warrant a dedicated SDK hook. Raw forms contribute validation/focus behavior\n *   but no `errorHandling` (fields surface their own inline errors via react-hook-form).\n */\nexport type ComposeSubmitInput<T extends FieldValues = FieldValues> =\n  | ComposableFormHookResult\n  | UseFormReturn<T>\n\nexport interface ComposeSubmitHandlerResult {\n  handleSubmit: (e: SyntheticEvent) => Promise<void>\n  errorHandling: HookErrorHandling\n}\n\ntype FormMethods = ComposableFormHookResult['form']['hookFormInternals']['formMethods']\n\nfunction isRawUseForm<T extends FieldValues>(\n  input: ComposeSubmitInput<T>,\n): input is UseFormReturn<T> {\n  return 'handleSubmit' in input && typeof input.handleSubmit === 'function'\n}\n\nfunction extractFormMethods<T extends FieldValues>(input: ComposeSubmitInput<T>): FormMethods {\n  if (isRawUseForm(input)) return input as unknown as FormMethods\n  return input.form.hookFormInternals.formMethods\n}\n\n/**\n * Coordinates validation and submission across multiple form hooks on the same page, and\n * returns aggregated `errorHandling` for those forms so you can drive a single error surface.\n *\n * Validates all forms simultaneously via `handleSubmit()`, then focuses the first invalid\n * field across all forms (in array order). Only calls `onAllValid` when every form passes.\n *\n * Uses `handleSubmit` rather than `trigger` so that react-hook-form sets\n * `formState.isSubmitted = true`, which enables `reValidateMode` (default: `onChange`).\n * Without this, errors set by manual `trigger()` calls would never clear as the user types.\n *\n * Each hook passed to `forms` should be initialized with `shouldFocusError: false` so that\n * react-hook-form's built-in per-form focus is disabled and `composeSubmitHandler` can manage\n * cross-form focus instead.\n *\n * The returned `errorHandling` is the same shape every SDK hook returns, so the whole result\n * can be passed back into `composeErrorHandler` when you need to add extra\n * `@gusto/embedded-api` queries or screen-level submit state.\n *\n * @example\n * ```ts\n * const detailsForm = useEmployeeDetailsForm({ employeeId, shouldFocusError: false })\n * const addressForm = useHomeAddressForm({ employeeId, shouldFocusError: false })\n *\n * const { handleSubmit, errorHandling } = composeSubmitHandler(\n *   [detailsForm, addressForm],\n *   async () => {\n *     await detailsForm.actions.onSubmit()\n *     await addressForm.actions.onSubmit()\n *   },\n * )\n *\n * // With extra queries or screen-level submit state:\n * // const errorHandling = composeErrorHandler([submitResult, extraQuery], { submitError, setSubmitError })\n *\n * return <form onSubmit={handleSubmit}>...</form>\n * ```\n */\nexport function composeSubmitHandler<TForms extends readonly FieldValues[]>(\n  forms: readonly [...{ [K in keyof TForms]: ComposeSubmitInput<TForms[K]> }],\n  onAllValid: () => Promise<void>,\n): ComposeSubmitHandlerResult {\n  const formMethodsList = forms.map(extractFormMethods)\n  const errorSources = forms.filter((form): form is ComposableFormHookResult => !isRawUseForm(form))\n\n  const handleSubmit = async (e: SyntheticEvent) => {\n    e.preventDefault()\n\n    const validationResults = await Promise.all(\n      formMethodsList.map(\n        methods =>\n          new Promise<boolean>(resolve => {\n            void methods.handleSubmit(\n              () => {\n                resolve(true)\n              },\n              () => {\n                resolve(false)\n              },\n            )()\n          }),\n      ),\n    )\n\n    const allValid = validationResults.every(Boolean)\n\n    if (!allValid) {\n      for (const methods of formMethodsList) {\n        const firstErrorField = Object.keys(methods.formState.errors)[0]\n        if (firstErrorField) {\n          methods.setFocus(firstErrorField)\n          return\n        }\n      }\n      return\n    }\n\n    await onAllValid()\n  }\n\n  const errorHandling = composeErrorHandler(errorSources)\n\n  return { handleSubmit, errorHandling }\n}\n"],"names":["isRawUseForm","input","extractFormMethods","composeSubmitHandler","forms","onAllValid","formMethodsList","errorSources","form","handleSubmit","methods","resolve","firstErrorField","errorHandling","composeErrorHandler"],"mappings":";AA4CA,SAASA,EACPC,GAC2B;AAC3B,SAAO,kBAAkBA,KAAS,OAAOA,EAAM,gBAAiB;AAClE;AAEA,SAASC,EAA0CD,GAA2C;AAC5F,SAAID,EAAaC,CAAK,IAAUA,IACzBA,EAAM,KAAK,kBAAkB;AACtC;AAwCO,SAASE,EACdC,GACAC,GAC4B;AAC5B,QAAMC,IAAkBF,EAAM,IAAIF,CAAkB,GAC9CK,IAAeH,EAAM,OAAO,CAACI,MAA2C,CAACR,EAAaQ,CAAI,CAAC,GAE3FC,IAAe,OAAO,MAAsB;AAqBhD,QApBA,EAAE,eAAA,GAoBE,EAlBsB,MAAM,QAAQ;AAAA,MACtCH,EAAgB;AAAA,QACd,CAAAI,MACE,IAAI,QAAiB,CAAAC,MAAW;AAC9B,UAAKD,EAAQ;AAAA,YACX,MAAM;AACJ,cAAAC,EAAQ,EAAI;AAAA,YACd;AAAA,YACA,MAAM;AACJ,cAAAA,EAAQ,EAAK;AAAA,YACf;AAAA,UAAA,EACF;AAAA,QACF,CAAC;AAAA,MAAA;AAAA,IACL,GAGiC,MAAM,OAAO,GAEjC;AACb,iBAAWD,KAAWJ,GAAiB;AACrC,cAAMM,IAAkB,OAAO,KAAKF,EAAQ,UAAU,MAAM,EAAE,CAAC;AAC/D,YAAIE,GAAiB;AACnB,UAAAF,EAAQ,SAASE,CAAe;AAChC;AAAA,QACF;AAAA,MACF;AACA;AAAA,IACF;AAEA,UAAMP,EAAA;AAAA,EACR,GAEMQ,IAAgBC,EAAoBP,CAAY;AAEtD,SAAO,EAAE,cAAAE,GAAc,eAAAI,EAAA;AACzB;"}
+{"version":3,"file":"composeSubmitHandler.js","sources":["../../../src/partner-hook-utils/form/composeSubmitHandler.ts"],"sourcesContent":["import type { SyntheticEvent } from 'react'\nimport type { FieldValues, UseFormReturn } from 'react-hook-form'\nimport { composeErrorHandler } from '../composeErrorHandler'\nimport type { HookErrorHandling, HookFormInternals } from '../types'\n\n/**\n * Minimal shape required for a form hook result to participate in `composeSubmitHandler`.\n * Any hook returning `BaseFormHookReady` satisfies this interface.\n *\n * `formMethods` is declared with method-call syntax (rather than reused from\n * `HookFormInternals`) so TypeScript applies bivariant parameter checking,\n * allowing hooks with specific form data generics to be passed without casts.\n * `_fieldElementRegistry` is reused directly since its type doesn't depend on\n * the form's generic.\n */\ninterface ComposableFormHookResult {\n  form: {\n    hookFormInternals: Pick<HookFormInternals, '_fieldElementRegistry'> & {\n      formMethods: {\n        handleSubmit(\n          onValid: () => void,\n          onInvalid?: (errors: Record<string, unknown>) => void,\n        ): () => Promise<void>\n        setFocus(name: string): void\n        formState: { errors: Record<string, unknown> }\n      }\n    }\n  }\n  errorHandling: HookErrorHandling\n}\n\n/**\n * Accepted input for a single slot of `composeSubmitHandler`'s `forms` array.\n *\n * - SDK form hook results (anything matching `ComposableFormHookResult`) are composed directly.\n * - A raw `react-hook-form` `UseFormReturn<T>` is supported for screen-local auxiliary forms\n *   that don't warrant a dedicated SDK hook. Raw forms contribute validation/focus behavior\n *   but no `errorHandling` (fields surface their own inline errors via react-hook-form).\n */\nexport type ComposeSubmitInput<T extends FieldValues = FieldValues> =\n  | ComposableFormHookResult\n  | UseFormReturn<T>\n\ninterface FormValidationResult {\n  input: ComposeSubmitInput\n  formMethods: FormMethods\n  valid: boolean\n  errors: Record<string, unknown>\n}\n\nexport interface ComposeSubmitHandlerResult {\n  handleSubmit: (e: SyntheticEvent) => Promise<void>\n  errorHandling: HookErrorHandling\n}\n\ntype FormMethods = ComposableFormHookResult['form']['hookFormInternals']['formMethods']\n\nfunction isRawUseForm<T extends FieldValues>(\n  input: ComposeSubmitInput<T>,\n): input is UseFormReturn<T> {\n  return 'handleSubmit' in input && typeof input.handleSubmit === 'function'\n}\n\nfunction extractFormMethods<T extends FieldValues>(input: ComposeSubmitInput<T>): FormMethods {\n  if (isRawUseForm(input)) return input as unknown as FormMethods\n  return input.form.hookFormInternals.formMethods\n}\n\n/**\n * Picks the visually first invalid field across all composed forms using live\n * `getBoundingClientRect()` positions, then focuses its DOM element. Falls back\n * to array-order (first form's first error) when no element can be resolved —\n * raw `UseFormReturn` inputs have no registry, and forms rendered without\n * `SDKFormProvider` or a HookField wrapper won't have their fields registered\n * either, so we let react-hook-form's `setFocus` attempt it instead.\n *\n * Consumes `results` (captured from each form's `onInvalid` callback) rather\n * than reading `formState.errors` — the latter is a proxy that returns `{}`\n * when accessed outside a component subscription.\n */\nfunction focusFirstInvalidAcrossForms(results: FormValidationResult[]): void {\n  type Candidate = {\n    formMethods: FormMethods\n    name: string\n    element: HTMLElement\n  }\n  const candidates: Candidate[] = []\n  for (const { input, formMethods, errors } of results) {\n    if (isRawUseForm(input)) continue\n    const registry = input.form.hookFormInternals._fieldElementRegistry\n    if (!registry) continue\n    for (const name of Object.keys(errors)) {\n      const element = registry.get(name)\n      if (element) {\n        candidates.push({ formMethods, name, element })\n      }\n    }\n  }\n\n  if (candidates.length > 0) {\n    candidates.sort((a, b) => {\n      const ar = a.element.getBoundingClientRect()\n      const br = b.element.getBoundingClientRect()\n      return ar.top - br.top || ar.left - br.left\n    })\n    const winner = candidates[0]!\n    // Focus the DOM element directly. Bypasses react-hook-form's `setFocus`,\n    // which depends on `_fields[name]._f.ref` and isn't reliably populated\n    // when fields are rendered through libraries like react-aria-components.\n    winner.element.focus()\n    return\n  }\n\n  for (const { formMethods, errors } of results) {\n    const firstErrorField = Object.keys(errors)[0]\n    if (firstErrorField) {\n      formMethods.setFocus(firstErrorField)\n      return\n    }\n  }\n}\n\n/**\n * Coordinates validation and submission across multiple form hooks on the same page, and\n * returns aggregated `errorHandling` for those forms so you can drive a single error surface.\n *\n * Validates all forms simultaneously via `handleSubmit()`, then focuses the visually first\n * invalid field across all forms (sorted by `getBoundingClientRect()`). Only calls\n * `onAllValid` when every form passes.\n *\n * Uses `handleSubmit` rather than `trigger` so that react-hook-form sets\n * `formState.isSubmitted = true`, which enables `reValidateMode` (default: `onChange`).\n * Without this, errors set by manual `trigger()` calls would never clear as the user types.\n *\n * Each hook passed to `forms` should be initialized with `shouldFocusError: false` so that\n * react-hook-form's built-in per-form focus is disabled and `composeSubmitHandler` can manage\n * cross-form focus instead.\n *\n * The returned `errorHandling` is the same shape every SDK hook returns, so the whole result\n * can be passed back into `composeErrorHandler` when you need to add extra\n * `@gusto/embedded-api` queries or screen-level submit state.\n *\n * @example\n * ```ts\n * const detailsForm = useEmployeeDetailsForm({ employeeId, shouldFocusError: false })\n * const addressForm = useHomeAddressForm({ employeeId, shouldFocusError: false })\n *\n * const { handleSubmit, errorHandling } = composeSubmitHandler(\n *   [detailsForm, addressForm],\n *   async () => {\n *     await detailsForm.actions.onSubmit()\n *     await addressForm.actions.onSubmit()\n *   },\n * )\n *\n * // With extra queries or screen-level submit state:\n * // const errorHandling = composeErrorHandler([submitResult, extraQuery], { submitError, setSubmitError })\n *\n * return <form onSubmit={handleSubmit}>...</form>\n * ```\n */\nexport function composeSubmitHandler<TForms extends readonly FieldValues[]>(\n  forms: readonly [...{ [K in keyof TForms]: ComposeSubmitInput<TForms[K]> }],\n  onAllValid: () => Promise<void>,\n): ComposeSubmitHandlerResult {\n  const errorSources = forms.filter((form): form is ComposableFormHookResult => !isRawUseForm(form))\n\n  const handleSubmit = async (e: SyntheticEvent) => {\n    e.preventDefault()\n\n    const validationResults = await Promise.all(\n      forms.map(\n        input =>\n          new Promise<FormValidationResult>(resolve => {\n            const formMethods = extractFormMethods(input)\n            void formMethods.handleSubmit(\n              () => {\n                resolve({ input, formMethods, valid: true, errors: {} })\n              },\n              errors => {\n                resolve({ input, formMethods, valid: false, errors })\n              },\n            )()\n          }),\n      ),\n    )\n\n    const allValid = validationResults.every(r => r.valid)\n\n    if (!allValid) {\n      focusFirstInvalidAcrossForms(validationResults)\n      return\n    }\n\n    await onAllValid()\n  }\n\n  const errorHandling = composeErrorHandler(errorSources)\n\n  return { handleSubmit, errorHandling }\n}\n"],"names":["isRawUseForm","input","extractFormMethods","focusFirstInvalidAcrossForms","results","candidates","formMethods","errors","registry","name","element","a","b","ar","br","firstErrorField","composeSubmitHandler","forms","onAllValid","errorSources","form","handleSubmit","e","validationResults","resolve","r","errorHandling","composeErrorHandler"],"mappings":";AAyDA,SAASA,EACPC,GAC2B;AAC3B,SAAO,kBAAkBA,KAAS,OAAOA,EAAM,gBAAiB;AAClE;AAEA,SAASC,EAA0CD,GAA2C;AAC5F,SAAID,EAAaC,CAAK,IAAUA,IACzBA,EAAM,KAAK,kBAAkB;AACtC;AAcA,SAASE,EAA6BC,GAAuC;AAM3E,QAAMC,IAA0B,CAAA;AAChC,aAAW,EAAE,OAAAJ,GAAO,aAAAK,GAAa,QAAAC,EAAA,KAAYH,GAAS;AACpD,QAAIJ,EAAaC,CAAK,EAAG;AACzB,UAAMO,IAAWP,EAAM,KAAK,kBAAkB;AAC9C,QAAKO;AACL,iBAAWC,KAAQ,OAAO,KAAKF,CAAM,GAAG;AACtC,cAAMG,IAAUF,EAAS,IAAIC,CAAI;AACjC,QAAIC,KACFL,EAAW,KAAK,EAAE,aAAAC,GAAa,MAAAG,GAAM,SAAAC,GAAS;AAAA,MAElD;AAAA,EACF;AAEA,MAAIL,EAAW,SAAS,GAAG;AACzB,IAAAA,EAAW,KAAK,CAACM,GAAGC,MAAM;AACxB,YAAMC,IAAKF,EAAE,QAAQ,sBAAA,GACfG,IAAKF,EAAE,QAAQ,sBAAA;AACrB,aAAOC,EAAG,MAAMC,EAAG,OAAOD,EAAG,OAAOC,EAAG;AAAA,IACzC,CAAC,GACcT,EAAW,CAAC,EAIpB,QAAQ,MAAA;AACf;AAAA,EACF;AAEA,aAAW,EAAE,aAAAC,GAAa,QAAAC,EAAA,KAAYH,GAAS;AAC7C,UAAMW,IAAkB,OAAO,KAAKR,CAAM,EAAE,CAAC;AAC7C,QAAIQ,GAAiB;AACnB,MAAAT,EAAY,SAASS,CAAe;AACpC;AAAA,IACF;AAAA,EACF;AACF;AAyCO,SAASC,EACdC,GACAC,GAC4B;AAC5B,QAAMC,IAAeF,EAAM,OAAO,CAACG,MAA2C,CAACpB,EAAaoB,CAAI,CAAC,GAE3FC,IAAe,OAAOC,MAAsB;AAChD,IAAAA,EAAE,eAAA;AAEF,UAAMC,IAAoB,MAAM,QAAQ;AAAA,MACtCN,EAAM;AAAA,QACJ,CAAAhB,MACE,IAAI,QAA8B,CAAAuB,MAAW;AAC3C,gBAAMlB,IAAcJ,EAAmBD,CAAK;AAC5C,UAAKK,EAAY;AAAA,YACf,MAAM;AACJ,cAAAkB,EAAQ,EAAE,OAAAvB,GAAO,aAAAK,GAAa,OAAO,IAAM,QAAQ,CAAA,GAAI;AAAA,YACzD;AAAA,YACA,CAAAC,MAAU;AACR,cAAAiB,EAAQ,EAAE,OAAAvB,GAAO,aAAAK,GAAa,OAAO,IAAO,QAAAC,GAAQ;AAAA,YACtD;AAAA,UAAA,EACF;AAAA,QACF,CAAC;AAAA,MAAA;AAAA,IACL;AAKF,QAAI,CAFagB,EAAkB,MAAM,CAAAE,MAAKA,EAAE,KAAK,GAEtC;AACb,MAAAtB,EAA6BoB,CAAiB;AAC9C;AAAA,IACF;AAEA,UAAML,EAAA;AAAA,EACR,GAEMQ,IAAgBC,EAAoBR,CAAY;AAEtD,SAAO,EAAE,cAAAE,GAAc,eAAAK,EAAA;AACzB;"}

package/dist/partner-hook-utils/form/fields/CheckboxHookField.d.ts

@@ -7,4 +7,4 @@ export interface CheckboxHookFieldProps<TErrorCode extends string = never> exten
     validationMessages?: ValidationMessages<TErrorCode>;
     FieldComponent?: ComponentType<CheckboxProps>;
 }
-export declare function CheckboxHookField<TErrorCode extends string>({ name, formHookResult, label, description, validationMessages, FieldComponent, }: CheckboxHookFieldProps<TErrorCode>): import("react/jsx-runtime").JSX.Element;
+export declare function CheckboxHookField<TErrorCode extends string>({ name, formHookResult, label, description, validationMessages, FieldComponent, }: CheckboxHookFieldProps<TErrorCode>): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;

package/dist/partner-hook-utils/form/fields/CheckboxHookField.js

@@ -1,36 +1,40 @@
-import { jsx as c } from "react/jsx-runtime";
+import { jsx as n } from "react/jsx-runtime";
 import { useHookFieldResolution as p } from "../useHookFieldResolution.js";
-import "react-i18next";
+import { withFieldElementRegistry as c } from "./withFieldElementRegistry.js";
 import "classnames";
+import "../../../shared/constants.js";
 import { CheckboxField as u } from "../../../components/Common/Fields/CheckboxField/CheckboxField.js";
-function F({
-  name: o,
-  formHookResult: i,
-  label: r,
-  description: t,
+function h({
+  name: e,
+  formHookResult: o,
+  label: t,
+  description: r,
   validationMessages: s,
   FieldComponent: d
 }) {
-  const { metadata: l, control: a, errorMessage: m } = p(
+  const { metadata: l, control: m, errorMessage: a, fieldElementRegistry: f } = p(
+    e,
     o,
-    i,
     s
-  ), e = l[o];
-  return /* @__PURE__ */ c(
-    u,
-    {
-      name: o,
-      control: a,
-      label: r,
-      description: t,
-      errorMessage: m,
-      isRequired: e?.isRequired,
-      isDisabled: e?.isDisabled,
-      FieldComponent: d
-    }
+  ), i = l[e];
+  return c(
+    f,
+    /* @__PURE__ */ n(
+      u,
+      {
+        name: e,
+        control: m,
+        label: t,
+        description: r,
+        errorMessage: a,
+        isRequired: i?.isRequired,
+        isDisabled: i?.isDisabled,
+        FieldComponent: d
+      }
+    )
   );
 }
 export {
-  F as CheckboxHookField
+  h as CheckboxHookField
 };
 //# sourceMappingURL=CheckboxHookField.js.map

package/dist/partner-hook-utils/form/fields/CheckboxHookField.js.map

@@ -1 +1 @@
-{"version":3,"file":"CheckboxHookField.js","sources":["../../../../src/partner-hook-utils/form/fields/CheckboxHookField.tsx"],"sourcesContent":["import type { ComponentType } from 'react'\nimport { useHookFieldResolution } from '../useHookFieldResolution'\nimport type { BaseFieldProps, ValidationMessages, FormHookResult } from '../../types'\nimport { CheckboxField } from '@/components/Common'\nimport type { CheckboxProps } from '@/components/Common/UI/Checkbox/CheckboxTypes'\n\nexport interface CheckboxHookFieldProps<TErrorCode extends string = never> extends BaseFieldProps {\n  name: string\n  formHookResult?: FormHookResult\n  validationMessages?: ValidationMessages<TErrorCode>\n  FieldComponent?: ComponentType<CheckboxProps>\n}\n\nexport function CheckboxHookField<TErrorCode extends string>({\n  name,\n  formHookResult,\n  label,\n  description,\n  validationMessages,\n  FieldComponent,\n}: CheckboxHookFieldProps<TErrorCode>) {\n  const { metadata, control, errorMessage } = useHookFieldResolution(\n    name,\n    formHookResult,\n    validationMessages,\n  )\n  const fieldMetadata = metadata[name]\n\n  return (\n    <CheckboxField\n      name={name}\n      control={control}\n      label={label}\n      description={description}\n      errorMessage={errorMessage}\n      isRequired={fieldMetadata?.isRequired}\n      isDisabled={fieldMetadata?.isDisabled}\n      FieldComponent={FieldComponent}\n    />\n  )\n}\n"],"names":["CheckboxHookField","name","formHookResult","label","description","validationMessages","FieldComponent","metadata","control","errorMessage","useHookFieldResolution","fieldMetadata","jsx","CheckboxField"],"mappings":";;;;;AAaO,SAASA,EAA6C;AAAA,EAC3D,MAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,OAAAC;AAAA,EACA,aAAAC;AAAA,EACA,oBAAAC;AAAA,EACA,gBAAAC;AACF,GAAuC;AACrC,QAAM,EAAE,UAAAC,GAAU,SAAAC,GAAS,cAAAC,EAAA,IAAiBC;AAAA,IAC1CT;AAAA,IACAC;AAAA,IACAG;AAAA,EAAA,GAEIM,IAAgBJ,EAASN,CAAI;AAEnC,SACE,gBAAAW;AAAA,IAACC;AAAA,IAAA;AAAA,MACC,MAAAZ;AAAA,MACA,SAAAO;AAAA,MACA,OAAAL;AAAA,MACA,aAAAC;AAAA,MACA,cAAAK;AAAA,MACA,YAAYE,GAAe;AAAA,MAC3B,YAAYA,GAAe;AAAA,MAC3B,gBAAAL;AAAA,IAAA;AAAA,EAAA;AAGN;"}
+{"version":3,"file":"CheckboxHookField.js","sources":["../../../../src/partner-hook-utils/form/fields/CheckboxHookField.tsx"],"sourcesContent":["import type { ComponentType } from 'react'\nimport { useHookFieldResolution } from '../useHookFieldResolution'\nimport type { BaseFieldProps, ValidationMessages, FormHookResult } from '../../types'\nimport { withFieldElementRegistry } from './withFieldElementRegistry'\nimport { CheckboxField } from '@/components/Common'\nimport type { CheckboxProps } from '@/components/Common/UI/Checkbox/CheckboxTypes'\n\nexport interface CheckboxHookFieldProps<TErrorCode extends string = never> extends BaseFieldProps {\n  name: string\n  formHookResult?: FormHookResult\n  validationMessages?: ValidationMessages<TErrorCode>\n  FieldComponent?: ComponentType<CheckboxProps>\n}\n\nexport function CheckboxHookField<TErrorCode extends string>({\n  name,\n  formHookResult,\n  label,\n  description,\n  validationMessages,\n  FieldComponent,\n}: CheckboxHookFieldProps<TErrorCode>) {\n  const { metadata, control, errorMessage, fieldElementRegistry } = useHookFieldResolution(\n    name,\n    formHookResult,\n    validationMessages,\n  )\n  const fieldMetadata = metadata[name]\n\n  return withFieldElementRegistry(\n    fieldElementRegistry,\n    <CheckboxField\n      name={name}\n      control={control}\n      label={label}\n      description={description}\n      errorMessage={errorMessage}\n      isRequired={fieldMetadata?.isRequired}\n      isDisabled={fieldMetadata?.isDisabled}\n      FieldComponent={FieldComponent}\n    />,\n  )\n}\n"],"names":["CheckboxHookField","name","formHookResult","label","description","validationMessages","FieldComponent","metadata","control","errorMessage","fieldElementRegistry","useHookFieldResolution","fieldMetadata","withFieldElementRegistry","jsx","CheckboxField"],"mappings":";;;;;;AAcO,SAASA,EAA6C;AAAA,EAC3D,MAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,OAAAC;AAAA,EACA,aAAAC;AAAA,EACA,oBAAAC;AAAA,EACA,gBAAAC;AACF,GAAuC;AACrC,QAAM,EAAE,UAAAC,GAAU,SAAAC,GAAS,cAAAC,GAAc,sBAAAC,MAAyBC;AAAA,IAChEV;AAAA,IACAC;AAAA,IACAG;AAAA,EAAA,GAEIO,IAAgBL,EAASN,CAAI;AAEnC,SAAOY;AAAA,IACLH;AAAA,IACA,gBAAAI;AAAA,MAACC;AAAA,MAAA;AAAA,QACC,MAAAd;AAAA,QACA,SAAAO;AAAA,QACA,OAAAL;AAAA,QACA,aAAAC;AAAA,QACA,cAAAK;AAAA,QACA,YAAYG,GAAe;AAAA,QAC3B,YAAYA,GAAe;AAAA,QAC3B,gBAAAN;AAAA,MAAA;AAAA,IAAA;AAAA,EACF;AAEJ;"}

package/dist/partner-hook-utils/form/fields/DatePickerHookField.d.ts

@@ -9,4 +9,4 @@ export interface DatePickerHookFieldProps<TErrorCode extends string = never> ext
     /** When used inside a modal, pass the modal backdrop ref's element so the calendar popover stacks correctly. */
     portalContainer?: DatePickerProps['portalContainer'];
 }
-export declare function DatePickerHookField<TErrorCode extends string>({ name, formHookResult, label, description, validationMessages, FieldComponent, portalContainer, minDate, maxDate, }: DatePickerHookFieldProps<TErrorCode>): import("react/jsx-runtime").JSX.Element;
+export declare function DatePickerHookField<TErrorCode extends string>({ name, formHookResult, label, description, validationMessages, FieldComponent, portalContainer, minDate, maxDate, }: DatePickerHookFieldProps<TErrorCode>): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;

package/dist/partner-hook-utils/form/fields/DatePickerHookField.js

@@ -1,40 +1,44 @@
-import { jsx as n } from "react/jsx-runtime";
-import { useHookFieldResolution as k } from "../useHookFieldResolution.js";
-import { DatePickerField as p } from "../../../components/Common/Fields/DatePickerField/DatePickerField.js";
-function b({
+import { jsx as p } from "react/jsx-runtime";
+import { useHookFieldResolution as R } from "../useHookFieldResolution.js";
+import { withFieldElementRegistry as k } from "./withFieldElementRegistry.js";
+import { DatePickerField as D } from "../../../components/Common/Fields/DatePickerField/DatePickerField.js";
+function x({
   name: e,
-  formHookResult: o,
-  label: r,
-  description: t,
+  formHookResult: t,
+  label: o,
+  description: r,
   validationMessages: s,
   FieldComponent: d,
-  portalContainer: a,
-  minDate: l,
-  maxDate: c
+  portalContainer: l,
+  minDate: a,
+  maxDate: m
 }) {
-  const { metadata: u, control: f, errorMessage: m } = k(
+  const { metadata: f, control: n, errorMessage: c, fieldElementRegistry: u } = R(
     e,
-    o,
+    t,
     s
-  ), i = u[e];
-  return /* @__PURE__ */ n(
-    p,
-    {
-      name: e,
-      control: f,
-      label: r,
-      description: t,
-      errorMessage: m,
-      isRequired: i?.isRequired,
-      isDisabled: i?.isDisabled,
-      FieldComponent: d,
-      portalContainer: a,
-      minDate: l,
-      maxDate: c
-    }
+  ), i = f[e];
+  return k(
+    u,
+    /* @__PURE__ */ p(
+      D,
+      {
+        name: e,
+        control: n,
+        label: o,
+        description: r,
+        errorMessage: c,
+        isRequired: i?.isRequired,
+        isDisabled: i?.isDisabled,
+        FieldComponent: d,
+        portalContainer: l,
+        minDate: a,
+        maxDate: m
+      }
+    )
   );
 }
 export {
-  b as DatePickerHookField
+  x as DatePickerHookField
 };
 //# sourceMappingURL=DatePickerHookField.js.map

package/dist/partner-hook-utils/form/fields/DatePickerHookField.js.map

@@ -1 +1 @@
-{"version":3,"file":"DatePickerHookField.js","sources":["../../../../src/partner-hook-utils/form/fields/DatePickerHookField.tsx"],"sourcesContent":["import type { ComponentType } from 'react'\nimport { useHookFieldResolution } from '../useHookFieldResolution'\nimport type { BaseFieldProps, ValidationMessages, FormHookResult } from '../../types'\nimport { DatePickerField } from '@/components/Common/Fields/DatePickerField'\nimport type { DatePickerProps } from '@/components/Common/UI/DatePicker/DatePickerTypes'\n\nexport interface DatePickerHookFieldProps<TErrorCode extends string = never>\n  extends BaseFieldProps, Pick<DatePickerProps, 'portalContainer' | 'minDate' | 'maxDate'> {\n  name: string\n  formHookResult?: FormHookResult\n  validationMessages?: ValidationMessages<TErrorCode>\n  FieldComponent?: ComponentType<DatePickerProps>\n  /** When used inside a modal, pass the modal backdrop ref's element so the calendar popover stacks correctly. */\n  portalContainer?: DatePickerProps['portalContainer']\n}\n\nexport function DatePickerHookField<TErrorCode extends string>({\n  name,\n  formHookResult,\n  label,\n  description,\n  validationMessages,\n  FieldComponent,\n  portalContainer,\n  minDate,\n  maxDate,\n}: DatePickerHookFieldProps<TErrorCode>) {\n  const { metadata, control, errorMessage } = useHookFieldResolution(\n    name,\n    formHookResult,\n    validationMessages,\n  )\n  const fieldMetadata = metadata[name]\n\n  return (\n    <DatePickerField\n      name={name}\n      control={control}\n      label={label}\n      description={description}\n      errorMessage={errorMessage}\n      isRequired={fieldMetadata?.isRequired}\n      isDisabled={fieldMetadata?.isDisabled}\n      FieldComponent={FieldComponent}\n      portalContainer={portalContainer}\n      minDate={minDate}\n      maxDate={maxDate}\n    />\n  )\n}\n"],"names":["DatePickerHookField","name","formHookResult","label","description","validationMessages","FieldComponent","portalContainer","minDate","maxDate","metadata","control","errorMessage","useHookFieldResolution","fieldMetadata","jsx","DatePickerField"],"mappings":";;;AAgBO,SAASA,EAA+C;AAAA,EAC7D,MAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,OAAAC;AAAA,EACA,aAAAC;AAAA,EACA,oBAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,iBAAAC;AAAA,EACA,SAAAC;AAAA,EACA,SAAAC;AACF,GAAyC;AACvC,QAAM,EAAE,UAAAC,GAAU,SAAAC,GAAS,cAAAC,EAAA,IAAiBC;AAAA,IAC1CZ;AAAA,IACAC;AAAA,IACAG;AAAA,EAAA,GAEIS,IAAgBJ,EAAST,CAAI;AAEnC,SACE,gBAAAc;AAAA,IAACC;AAAA,IAAA;AAAA,MACC,MAAAf;AAAA,MACA,SAAAU;AAAA,MACA,OAAAR;AAAA,MACA,aAAAC;AAAA,MACA,cAAAQ;AAAA,MACA,YAAYE,GAAe;AAAA,MAC3B,YAAYA,GAAe;AAAA,MAC3B,gBAAAR;AAAA,MACA,iBAAAC;AAAA,MACA,SAAAC;AAAA,MACA,SAAAC;AAAA,IAAA;AAAA,EAAA;AAGN;"}
+{"version":3,"file":"DatePickerHookField.js","sources":["../../../../src/partner-hook-utils/form/fields/DatePickerHookField.tsx"],"sourcesContent":["import type { ComponentType } from 'react'\nimport { useHookFieldResolution } from '../useHookFieldResolution'\nimport type { BaseFieldProps, ValidationMessages, FormHookResult } from '../../types'\nimport { withFieldElementRegistry } from './withFieldElementRegistry'\nimport { DatePickerField } from '@/components/Common/Fields/DatePickerField'\nimport type { DatePickerProps } from '@/components/Common/UI/DatePicker/DatePickerTypes'\n\nexport interface DatePickerHookFieldProps<TErrorCode extends string = never>\n  extends BaseFieldProps, Pick<DatePickerProps, 'portalContainer' | 'minDate' | 'maxDate'> {\n  name: string\n  formHookResult?: FormHookResult\n  validationMessages?: ValidationMessages<TErrorCode>\n  FieldComponent?: ComponentType<DatePickerProps>\n  /** When used inside a modal, pass the modal backdrop ref's element so the calendar popover stacks correctly. */\n  portalContainer?: DatePickerProps['portalContainer']\n}\n\nexport function DatePickerHookField<TErrorCode extends string>({\n  name,\n  formHookResult,\n  label,\n  description,\n  validationMessages,\n  FieldComponent,\n  portalContainer,\n  minDate,\n  maxDate,\n}: DatePickerHookFieldProps<TErrorCode>) {\n  const { metadata, control, errorMessage, fieldElementRegistry } = useHookFieldResolution(\n    name,\n    formHookResult,\n    validationMessages,\n  )\n  const fieldMetadata = metadata[name]\n\n  return withFieldElementRegistry(\n    fieldElementRegistry,\n    <DatePickerField\n      name={name}\n      control={control}\n      label={label}\n      description={description}\n      errorMessage={errorMessage}\n      isRequired={fieldMetadata?.isRequired}\n      isDisabled={fieldMetadata?.isDisabled}\n      FieldComponent={FieldComponent}\n      portalContainer={portalContainer}\n      minDate={minDate}\n      maxDate={maxDate}\n    />,\n  )\n}\n"],"names":["DatePickerHookField","name","formHookResult","label","description","validationMessages","FieldComponent","portalContainer","minDate","maxDate","metadata","control","errorMessage","fieldElementRegistry","useHookFieldResolution","fieldMetadata","withFieldElementRegistry","jsx","DatePickerField"],"mappings":";;;;AAiBO,SAASA,EAA+C;AAAA,EAC7D,MAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,OAAAC;AAAA,EACA,aAAAC;AAAA,EACA,oBAAAC;AAAA,EACA,gBAAAC;AAAA,EACA,iBAAAC;AAAA,EACA,SAAAC;AAAA,EACA,SAAAC;AACF,GAAyC;AACvC,QAAM,EAAE,UAAAC,GAAU,SAAAC,GAAS,cAAAC,GAAc,sBAAAC,MAAyBC;AAAA,IAChEb;AAAA,IACAC;AAAA,IACAG;AAAA,EAAA,GAEIU,IAAgBL,EAAST,CAAI;AAEnC,SAAOe;AAAA,IACLH;AAAA,IACA,gBAAAI;AAAA,MAACC;AAAA,MAAA;AAAA,QACC,MAAAjB;AAAA,QACA,SAAAU;AAAA,QACA,OAAAR;AAAA,QACA,aAAAC;AAAA,QACA,cAAAQ;AAAA,QACA,YAAYG,GAAe;AAAA,QAC3B,YAAYA,GAAe;AAAA,QAC3B,gBAAAT;AAAA,QACA,iBAAAC;AAAA,QACA,SAAAC;AAAA,QACA,SAAAC;AAAA,MAAA;AAAA,IAAA;AAAA,EACF;AAEJ;"}

package/dist/partner-hook-utils/form/fields/NumberInputHookField.d.ts

@@ -10,4 +10,4 @@ export interface NumberInputHookFieldProps<TErrorCode extends string = never> ex
     validationMessages?: ValidationMessages<TErrorCode>;
     FieldComponent?: ComponentType<NumberInputProps>;
 }
-export declare function NumberInputHookField<TErrorCode extends string>({ name, formHookResult, label, description, format, min, max, validationMessages, FieldComponent, }: NumberInputHookFieldProps<TErrorCode>): import("react/jsx-runtime").JSX.Element;
+export declare function NumberInputHookField<TErrorCode extends string>({ name, formHookResult, label, description, format, min, max, validationMessages, FieldComponent, }: NumberInputHookFieldProps<TErrorCode>): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;