@gusto/embedded-react-sdk 0.38.0 → 0.40.0

package/dist/index.js

@@ -1,31 +1,107 @@
-import * as r from "./components/Company/index.js";
-import * as o from "./components/Contractor/index.js";
+import * as o from "./components/Company/index.js";
+import * as r from "./components/Contractor/index.js";
 import * as e from "./components/Employee/index.js";
-import * as t from "./components/InformationRequests/index.js";
-import * as i from "./components/Payroll/index.js";
-import * as m from "./components/UNSTABLE_TimeOff/index.js";
-import { ApiProvider as a } from "./contexts/ApiProvider/ApiProvider.js";
-import { componentEvents as f } from "./shared/constants.js";
-import { SDKInternalError as d, normalizeToSDKError as v } from "./types/sdkError.js";
-import { GustoApiProvider as u, GustoProvider as P } from "./contexts/GustoProvider/GustoProvider.js";
-import { GustoProviderCustomUIAdapter as E } from "./contexts/GustoProvider/GustoProviderCustomUIAdapter.js";
-import { ObservabilityProvider as b } from "./contexts/ObservabilityProvider/ObservabilityProvider.js";
-import { useObservability as C } from "./contexts/ObservabilityProvider/useObservability.js";
+import * as m from "./components/InformationRequests/index.js";
+import * as t from "./components/Payroll/index.js";
+import * as p from "./components/UNSTABLE_TimeOff/index.js";
+import * as a from "./components/Employee/exports/employeeOnboarding.js";
+import * as s from "./components/Employee/exports/employeeManagement.js";
+import * as i from "./components/Company/exports/companyOnboarding.js";
+import * as d from "./components/Contractor/exports/contractorOnboarding.js";
+import { ApiProvider as f } from "./contexts/ApiProvider/ApiProvider.js";
+import { componentEvents as c } from "./shared/constants.js";
+import { SDKInternalError as F, normalizeToSDKError as S } from "./types/sdkError.js";
+import { composeErrorHandler as y } from "./partner-hook-utils/composeErrorHandler.js";
+import { collectErrors as P } from "./partner-hook-utils/collectErrors.js";
+import { useCompensationForm as b } from "./components/Employee/Compensation/shared/useCompensationForm/useCompensationForm.js";
+import { CompensationErrorCodes as A, createCompensationSchema as k } from "./components/Employee/Compensation/shared/useCompensationForm/compensationSchema.js";
+import { useEmployeeDetailsForm as v } from "./components/Employee/Profile/shared/useEmployeeDetailsForm/useEmployeeDetailsForm.js";
+import { EmployeeDetailsErrorCodes as O, createEmployeeDetailsSchema as R } from "./components/Employee/Profile/shared/useEmployeeDetailsForm/employeeDetailsSchema.js";
+import { useWorkAddressForm as M } from "./components/Employee/Profile/shared/useWorkAddressForm/useWorkAddressForm.js";
+import { WorkAddressErrorCodes as $, createWorkAddressSchema as G } from "./components/Employee/Profile/shared/useWorkAddressForm/workAddressSchema.js";
+import { useHomeAddressForm as T } from "./components/Employee/Profile/shared/useHomeAddressForm/useHomeAddressForm.js";
+import { HomeAddressErrorCodes as W, createHomeAddressSchema as w } from "./components/Employee/Profile/shared/useHomeAddressForm/homeAddressSchema.js";
+import { useSignEmployeeForm as L } from "./components/Employee/DocumentSigner/shared/useSignEmployeeForm/useSignEmployeeForm.js";
+import { MAX_PREPARERS as X, PREPARER_FIELDS_BY_INDEX as q, SignEmployeeFormErrorCodes as z, createSignEmployeeFormSchema as Y, preparerFieldName as j } from "./components/Employee/DocumentSigner/shared/useSignEmployeeForm/signEmployeeFormSchema.js";
+import { usePayScheduleForm as Q } from "./components/Company/PaySchedule/shared/usePayScheduleForm/usePayScheduleForm.js";
+import { PayScheduleErrorCodes as Z, createPayScheduleSchema as oo } from "./components/Company/PaySchedule/shared/usePayScheduleForm/payScheduleSchema.js";
+import { useSignCompanyForm as eo } from "./components/Company/DocumentSigner/shared/useSignCompanyForm/useSignCompanyForm.js";
+import { SignCompanyFormErrorCodes as to, createSignCompanyFormSchema as po } from "./components/Company/DocumentSigner/shared/useSignCompanyForm/signCompanyFormSchema.js";
+import { CheckboxHookField as so } from "./partner-hook-utils/form/fields/CheckboxHookField.js";
+import { DatePickerHookField as no } from "./partner-hook-utils/form/fields/DatePickerHookField.js";
+import { FormFieldsMetadataProvider as fo } from "./partner-hook-utils/form/FormFieldsMetadataProvider.js";
+import { GustoApiProvider as co, GustoProvider as Eo } from "./contexts/GustoProvider/GustoProvider.js";
+import { GustoProviderCustomUIAdapter as So } from "./contexts/GustoProvider/GustoProviderCustomUIAdapter.js";
+import { NumberInputHookField as yo } from "./partner-hook-utils/form/fields/NumberInputHookField.js";
+import { ObservabilityProvider as Po } from "./contexts/ObservabilityProvider/ObservabilityProvider.js";
+import { RadioGroupHookField as bo } from "./partner-hook-utils/form/fields/RadioGroupHookField.js";
+import { SDKFormProvider as Ao } from "./partner-hook-utils/form/SDKFormProvider.js";
+import { SelectHookField as Ho } from "./partner-hook-utils/form/fields/SelectHookField.js";
+import { SwitchHookField as Do } from "./partner-hook-utils/form/fields/SwitchHookField.js";
+import { TextInputHookField as Ro } from "./partner-hook-utils/form/fields/TextInputHookField.js";
+import { composeSubmitHandler as Mo } from "./partner-hook-utils/form/composeSubmitHandler.js";
+import { useDeriveFieldsMetadata as $o } from "./partner-hook-utils/form/useDeriveFieldsMetadata.js";
+import { useFieldErrorMessage as No } from "./partner-hook-utils/form/useFieldErrorMessage.js";
+import { useObservability as Ko } from "./contexts/ObservabilityProvider/useObservability.js";
+import { withOptions as wo } from "./partner-hook-utils/form/withOptions.js";
 export {
-  a as ApiProvider,
-  r as Company,
-  o as Contractor,
+  f as ApiProvider,
+  so as CheckboxHookField,
+  o as Company,
+  i as CompanyOnboarding,
+  A as CompensationErrorCodes,
+  r as Contractor,
+  d as ContractorOnboarding,
+  no as DatePickerHookField,
   e as Employee,
-  u as GustoApiProvider,
-  P as GustoProvider,
-  E as GustoProviderCustomUIAdapter,
-  t as InformationRequests,
-  b as ObservabilityProvider,
-  i as Payroll,
-  d as SDKInternalError,
-  m as UNSTABLE_TimeOff,
-  f as componentEvents,
-  v as normalizeToSDKError,
-  C as useObservability
+  O as EmployeeDetailsErrorCodes,
+  s as EmployeeManagement,
+  a as EmployeeOnboarding,
+  fo as FormFieldsMetadataProvider,
+  co as GustoApiProvider,
+  Eo as GustoProvider,
+  So as GustoProviderCustomUIAdapter,
+  W as HomeAddressErrorCodes,
+  m as InformationRequests,
+  X as MAX_PREPARERS,
+  yo as NumberInputHookField,
+  Po as ObservabilityProvider,
+  q as PREPARER_FIELDS_BY_INDEX,
+  Z as PayScheduleErrorCodes,
+  t as Payroll,
+  bo as RadioGroupHookField,
+  Ao as SDKFormProvider,
+  F as SDKInternalError,
+  Ho as SelectHookField,
+  to as SignCompanyFormErrorCodes,
+  z as SignEmployeeFormErrorCodes,
+  Do as SwitchHookField,
+  Ro as TextInputHookField,
+  p as UNSTABLE_TimeOff,
+  $ as WorkAddressErrorCodes,
+  P as collectErrors,
+  c as componentEvents,
+  y as composeErrorHandler,
+  Mo as composeSubmitHandler,
+  k as createCompensationSchema,
+  R as createEmployeeDetailsSchema,
+  w as createHomeAddressSchema,
+  oo as createPayScheduleSchema,
+  po as createSignCompanyFormSchema,
+  Y as createSignEmployeeFormSchema,
+  G as createWorkAddressSchema,
+  S as normalizeToSDKError,
+  j as preparerFieldName,
+  b as useCompensationForm,
+  $o as useDeriveFieldsMetadata,
+  v as useEmployeeDetailsForm,
+  No as useFieldErrorMessage,
+  T as useHomeAddressForm,
+  Ko as useObservability,
+  Q as usePayScheduleForm,
+  eo as useSignCompanyForm,
+  L as useSignEmployeeForm,
+  M as useWorkAddressForm,
+  wo as withOptions
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/partner-hook-utils/collectErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectErrors.js","sources":["../../src/partner-hook-utils/collectErrors.ts"],"sourcesContent":["import { type SDKError, normalizeToSDKError } from '@/types/sdkError'\n\ninterface QueryWithError {\n  error: Error | null\n}\n\nexport function collectErrors(queries: QueryWithError[], submitError: SDKError | null): SDKError[] {\n  const queryErrors = queries\n    .filter((q): q is QueryWithError & { error: Error } => q.error != null)\n    .map(q => normalizeToSDKError(q.error))\n\n  if (submitError) {\n    queryErrors.push(submitError)\n  }\n\n  return queryErrors\n}\n"],"names":["collectErrors","queries","submitError","queryErrors","q","normalizeToSDKError"],"mappings":";AAMO,SAASA,EAAcC,GAA2BC,GAA0C;AACjG,QAAMC,IAAcF,EACjB,OAAO,CAACG,MAA8CA,EAAE,SAAS,IAAI,EACrE,IAAI,CAAAA,MAAKC,EAAoBD,EAAE,KAAK,CAAC;AAExC,SAAIF,KACFC,EAAY,KAAKD,CAAW,GAGvBC;AACT;"}

package/dist/partner-hook-utils/composeErrorHandler.d.ts

@@ -0,0 +1,24 @@
+import { UseQueryResult } from '@tanstack/react-query';
+import { HookErrorHandling } from './types';
+import { SDKError } from '../types/sdkError';
+type QueryWithRefetch = Pick<UseQueryResult, 'error' | 'refetch'>;
+/**
+ * Submit-side error state to merge with query errors. From `useBaseSubmit`, destructure
+ * `{ error: submitError, setError: setSubmitError }` and pass `{ submitError, setSubmitError }`.
+ */
+export type SubmitStateForErrorHandling = {
+    submitError: SDKError | null;
+    setSubmitError: (error: SDKError | null) => void;
+};
+export type MixedErrorSource = QueryWithRefetch | {
+    errorHandling: HookErrorHandling;
+};
+/**
+ * Composes `HookErrorHandling` from React Query results, optional submit state from `useBaseSubmit`,
+ * and/or nested SDK hook results that expose `errorHandling`.
+ *
+ * Pairs with `composeSubmitHandler` by name: this composes **error state and recovery**; it is not a
+ * submit callback.
+ */
+export declare function composeErrorHandler(sources: MixedErrorSource[], submitState?: SubmitStateForErrorHandling): HookErrorHandling;
+export {};

package/dist/partner-hook-utils/composeErrorHandler.js

@@ -0,0 +1,30 @@
+import { collectErrors as t } from "./collectErrors.js";
+function u(l) {
+  return "errorHandling" in l;
+}
+function a(l, e) {
+  const n = [], o = [];
+  for (const r of l)
+    u(r) ? o.push(r.errorHandling) : n.push(r);
+  const i = o.flatMap((r) => r.errors);
+  let s;
+  if (o.length === 0)
+    s = t(n, e?.submitError ?? null);
+  else {
+    const r = t(n, null);
+    s = [...i, ...r], e?.submitError && s.push(e.submitError);
+  }
+  return { errors: s, retryQueries: () => {
+    for (const r of o)
+      r.retryQueries();
+    n.filter((r) => r.error != null).forEach((r) => void r.refetch());
+  }, clearSubmitError: () => {
+    for (const r of o)
+      r.clearSubmitError();
+    e?.setSubmitError(null);
+  } };
+}
+export {
+  a as composeErrorHandler
+};
+//# sourceMappingURL=composeErrorHandler.js.map

package/dist/partner-hook-utils/composeErrorHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"composeErrorHandler.js","sources":["../../src/partner-hook-utils/composeErrorHandler.ts"],"sourcesContent":["import type { UseQueryResult } from '@tanstack/react-query'\nimport { collectErrors } from './collectErrors'\nimport type { HookErrorHandling } from './types'\nimport type { SDKError } from '@/types/sdkError'\n\ntype QueryWithRefetch = Pick<UseQueryResult, 'error' | 'refetch'>\n\n/**\n * Submit-side error state to merge with query errors. From `useBaseSubmit`, destructure\n * `{ error: submitError, setError: setSubmitError }` and pass `{ submitError, setSubmitError }`.\n */\nexport type SubmitStateForErrorHandling = {\n  submitError: SDKError | null\n  setSubmitError: (error: SDKError | null) => void\n}\n\nexport type MixedErrorSource = QueryWithRefetch | { errorHandling: HookErrorHandling }\n\nfunction isHookResultWithErrorHandling(\n  source: MixedErrorSource,\n): source is { errorHandling: HookErrorHandling } {\n  return 'errorHandling' in source\n}\n\n/**\n * Composes `HookErrorHandling` from React Query results, optional submit state from `useBaseSubmit`,\n * and/or nested SDK hook results that expose `errorHandling`.\n *\n * Pairs with `composeSubmitHandler` by name: this composes **error state and recovery**; it is not a\n * submit callback.\n */\nexport function composeErrorHandler(\n  sources: MixedErrorSource[],\n  submitState?: SubmitStateForErrorHandling,\n): HookErrorHandling {\n  const queries: QueryWithRefetch[] = []\n  const errorHandlingsFromNestedHooks: HookErrorHandling[] = []\n\n  for (const source of sources) {\n    if (isHookResultWithErrorHandling(source)) {\n      errorHandlingsFromNestedHooks.push(source.errorHandling)\n    } else {\n      queries.push(source)\n    }\n  }\n\n  const nestedErrors = errorHandlingsFromNestedHooks.flatMap(handling => handling.errors)\n\n  let errors: SDKError[]\n  if (errorHandlingsFromNestedHooks.length === 0) {\n    errors = collectErrors(queries, submitState?.submitError ?? null)\n  } else {\n    const standaloneQueryErrors = collectErrors(queries, null)\n    errors = [...nestedErrors, ...standaloneQueryErrors]\n    if (submitState?.submitError) {\n      errors.push(submitState.submitError)\n    }\n  }\n\n  const retryQueries = () => {\n    for (const handling of errorHandlingsFromNestedHooks) {\n      handling.retryQueries()\n    }\n    queries.filter(q => q.error != null).forEach(q => void q.refetch())\n  }\n\n  const clearSubmitError = () => {\n    for (const handling of errorHandlingsFromNestedHooks) {\n      handling.clearSubmitError()\n    }\n    submitState?.setSubmitError(null)\n  }\n\n  return { errors, retryQueries, clearSubmitError }\n}\n"],"names":["isHookResultWithErrorHandling","source","composeErrorHandler","sources","submitState","queries","errorHandlingsFromNestedHooks","nestedErrors","handling","errors","collectErrors","standaloneQueryErrors","q"],"mappings":";AAkBA,SAASA,EACPC,GACgD;AAChD,SAAO,mBAAmBA;AAC5B;AASO,SAASC,EACdC,GACAC,GACmB;AACnB,QAAMC,IAA8B,CAAA,GAC9BC,IAAqD,CAAA;AAE3D,aAAWL,KAAUE;AACnB,IAAIH,EAA8BC,CAAM,IACtCK,EAA8B,KAAKL,EAAO,aAAa,IAEvDI,EAAQ,KAAKJ,CAAM;AAIvB,QAAMM,IAAeD,EAA8B,QAAQ,CAAAE,MAAYA,EAAS,MAAM;AAEtF,MAAIC;AACJ,MAAIH,EAA8B,WAAW;AAC3C,IAAAG,IAASC,EAAcL,GAASD,GAAa,eAAe,IAAI;AAAA,OAC3D;AACL,UAAMO,IAAwBD,EAAcL,GAAS,IAAI;AACzD,IAAAI,IAAS,CAAC,GAAGF,GAAc,GAAGI,CAAqB,GAC/CP,GAAa,eACfK,EAAO,KAAKL,EAAY,WAAW;AAAA,EAEvC;AAgBA,SAAO,EAAE,QAAAK,GAAQ,cAdI,MAAM;AACzB,eAAWD,KAAYF;AACrB,MAAAE,EAAS,aAAA;AAEX,IAAAH,EAAQ,OAAO,CAAAO,MAAKA,EAAE,SAAS,IAAI,EAAE,QAAQ,CAAAA,MAAK,KAAKA,EAAE,QAAA,CAAS;AAAA,EACpE,GAS+B,kBAPN,MAAM;AAC7B,eAAWJ,KAAYF;AACrB,MAAAE,EAAS,iBAAA;AAEX,IAAAJ,GAAa,eAAe,IAAI;AAAA,EAClC,EAE+B;AACjC;"}

package/dist/{components/UNSTABLE_Hooks → partner-hook-utils}/form/FormFieldsMetadataContext.d.ts

@@ -1,5 +1,5 @@
-import { FieldsMetadata } from '../../../types/sdkHooks';
-import { SDKError } from '../../../types/sdkError';
+import { FieldsMetadata } from '../types';
+import { SDKError } from '../../types/sdkError';
 export interface FormFieldsMetadataContextValue {
     metadata: FieldsMetadata;
     errors: SDKError[];

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

@@ -0,0 +1 @@
+{"version":3,"file":"FormFieldsMetadataContext.js","sources":["../../../src/partner-hook-utils/form/FormFieldsMetadataContext.ts"],"sourcesContent":["import { createContext, useContext } from 'react'\nimport type { FieldsMetadata } from '../types'\nimport type { SDKError } from '@/types/sdkError'\n\nexport interface FormFieldsMetadataContextValue {\n  metadata: FieldsMetadata\n  errors: SDKError[]\n}\n\nexport const FormFieldsMetadataContext = createContext<FormFieldsMetadataContextValue | null>(null)\n\nexport function useFormFieldsMetadataContext(): FormFieldsMetadataContextValue | null {\n  return useContext(FormFieldsMetadataContext)\n}\n"],"names":["FormFieldsMetadataContext","createContext","useFormFieldsMetadataContext","useContext"],"mappings":";AASO,MAAMA,IAA4BC,EAAqD,IAAI;AAE3F,SAASC,IAAsE;AACpF,SAAOC,EAAWH,CAAyB;AAC7C;"}

package/dist/{components/UNSTABLE_Hooks → partner-hook-utils}/form/FormFieldsMetadataProvider.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from 'react';
-import { FieldMetadata, FieldMetadataWithOptions } from '../../../types/sdkHooks';
-import { SDKError } from '../../../types/sdkError';
+import { FieldMetadata, FieldMetadataWithOptions } from '../types';
+import { SDKError } from '../../types/sdkError';
 interface FormFieldsMetadataProviderProps {
     metadata: Record<string, FieldMetadata | FieldMetadataWithOptions>;
     errors: SDKError[];

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

@@ -0,0 +1 @@
+{"version":3,"file":"FormFieldsMetadataProvider.js","sources":["../../../src/partner-hook-utils/form/FormFieldsMetadataProvider.tsx"],"sourcesContent":["import type { ReactNode } from 'react'\nimport type { FieldMetadata, FieldMetadataWithOptions } from '../types'\nimport { FormFieldsMetadataContext } from './FormFieldsMetadataContext'\nimport type { SDKError } from '@/types/sdkError'\n\ninterface FormFieldsMetadataProviderProps {\n  metadata: Record<string, FieldMetadata | FieldMetadataWithOptions>\n  errors: SDKError[]\n  children: ReactNode\n}\n\nexport function FormFieldsMetadataProvider({\n  metadata,\n  errors,\n  children,\n}: FormFieldsMetadataProviderProps) {\n  return (\n    <FormFieldsMetadataContext.Provider value={{ metadata, errors }}>\n      {children}\n    </FormFieldsMetadataContext.Provider>\n  )\n}\n"],"names":["FormFieldsMetadataProvider","metadata","errors","children","jsx","FormFieldsMetadataContext"],"mappings":";;AAWO,SAASA,EAA2B;AAAA,EACzC,UAAAC;AAAA,EACA,QAAAC;AAAA,EACA,UAAAC;AACF,GAAoC;AAClC,SACE,gBAAAC,EAACC,EAA0B,UAA1B,EAAmC,OAAO,EAAE,UAAAJ,GAAU,QAAAC,KACpD,UAAAC,GACH;AAEJ;"}

package/dist/{components/UNSTABLE_Hooks → partner-hook-utils}/form/SDKFormProvider.d.ts

@@ -1,7 +1,7 @@
 import { ReactNode } from 'react';
 import { FieldValues } from 'react-hook-form';
-import { FieldMetadata, FieldMetadataWithOptions, HookFormInternals } from '../../../types/sdkHooks';
-import { SDKError } from '../../../types/sdkError';
+import { FieldMetadata, FieldMetadataWithOptions, HookFormInternals } from '../types';
+import { SDKError } from '../../types/sdkError';
 interface SDKFormProviderProps<TFormData extends FieldValues = FieldValues, TFieldsMetadata extends {
     [K in keyof TFieldsMetadata]: FieldMetadata | FieldMetadataWithOptions;
 } = Record<string, FieldMetadata | FieldMetadataWithOptions>> {

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

@@ -0,0 +1 @@
+{"version":3,"file":"SDKFormProvider.js","sources":["../../../src/partner-hook-utils/form/SDKFormProvider.tsx"],"sourcesContent":["import { type ReactNode, useEffect } from 'react'\nimport type { FieldPath, FieldValues } from 'react-hook-form'\nimport { FormProvider } from 'react-hook-form'\nimport type { FieldMetadata, FieldMetadataWithOptions, HookFormInternals } from '../types'\nimport { FormFieldsMetadataProvider } from './FormFieldsMetadataProvider'\nimport type { SDKError, SDKFieldError } from '@/types/sdkError'\n\nfunction useSyncFieldErrors<\n  TFormData extends FieldValues,\n  TFieldsMetadata extends {\n    [K in keyof TFieldsMetadata]: FieldMetadata | FieldMetadataWithOptions\n  },\n>(\n  fieldErrors: SDKFieldError[],\n  form: {\n    fieldsMetadata: TFieldsMetadata\n    hookFormInternals: HookFormInternals<TFormData>\n  },\n) {\n  const { fieldsMetadata } = form\n  const { setError } = form.hookFormInternals.formMethods\n\n  useEffect(() => {\n    if (!fieldErrors.length) return\n    const knownFields = new Set(Object.keys(fieldsMetadata))\n    for (const fieldError of fieldErrors) {\n      if (knownFields.has(fieldError.field)) {\n        setError(fieldError.field as FieldPath<TFormData>, {\n          type: 'custom',\n          message: fieldError.message,\n        })\n      }\n    }\n  }, [fieldErrors, setError, fieldsMetadata])\n}\n\ninterface SDKFormProviderProps<\n  TFormData extends FieldValues = FieldValues,\n  TFieldsMetadata extends {\n    [K in keyof TFieldsMetadata]: FieldMetadata | FieldMetadataWithOptions\n  } = Record<string, FieldMetadata | FieldMetadataWithOptions>,\n> {\n  formHookResult: {\n    errorHandling: { errors: SDKError[] }\n    form: {\n      fieldsMetadata: TFieldsMetadata\n      hookFormInternals: HookFormInternals<TFormData>\n    }\n  }\n  children: ReactNode\n}\n\nexport function SDKFormProvider<\n  TFormData extends FieldValues = FieldValues,\n  TFieldsMetadata extends {\n    [K in keyof TFieldsMetadata]: FieldMetadata | FieldMetadataWithOptions\n  } = Record<string, FieldMetadata | FieldMetadataWithOptions>,\n>({ formHookResult, children }: SDKFormProviderProps<TFormData, TFieldsMetadata>) {\n  const { errorHandling, form } = formHookResult\n  const allFieldErrors = errorHandling.errors.flatMap(e => e.fieldErrors)\n  useSyncFieldErrors(allFieldErrors, form)\n\n  return (\n    <FormFieldsMetadataProvider metadata={form.fieldsMetadata} errors={errorHandling.errors}>\n      <FormProvider {...form.hookFormInternals.formMethods}>{children}</FormProvider>\n    </FormFieldsMetadataProvider>\n  )\n}\n"],"names":["useSyncFieldErrors","fieldErrors","form","fieldsMetadata","setError","useEffect","knownFields","fieldError","SDKFormProvider","formHookResult","children","errorHandling","allFieldErrors","e","jsx","FormFieldsMetadataProvider","FormProvider"],"mappings":";;;;AAOA,SAASA,EAMPC,GACAC,GAIA;AACA,QAAM,EAAE,gBAAAC,MAAmBD,GACrB,EAAE,UAAAE,EAAA,IAAaF,EAAK,kBAAkB;AAE5C,EAAAG,EAAU,MAAM;AACd,QAAI,CAACJ,EAAY,OAAQ;AACzB,UAAMK,IAAc,IAAI,IAAI,OAAO,KAAKH,CAAc,CAAC;AACvD,eAAWI,KAAcN;AACvB,MAAIK,EAAY,IAAIC,EAAW,KAAK,KAClCH,EAASG,EAAW,OAA+B;AAAA,QACjD,MAAM;AAAA,QACN,SAASA,EAAW;AAAA,MAAA,CACrB;AAAA,EAGP,GAAG,CAACN,GAAaG,GAAUD,CAAc,CAAC;AAC5C;AAkBO,SAASK,EAKd,EAAE,gBAAAC,GAAgB,UAAAC,KAA8D;AAChF,QAAM,EAAE,eAAAC,GAAe,MAAAT,EAAA,IAASO,GAC1BG,IAAiBD,EAAc,OAAO,QAAQ,CAAAE,MAAKA,EAAE,WAAW;AACtE,SAAAb,EAAmBY,GAAgBV,CAAI,GAGrC,gBAAAY,EAACC,GAAA,EAA2B,UAAUb,EAAK,gBAAgB,QAAQS,EAAc,QAC/E,UAAA,gBAAAG,EAACE,KAAc,GAAGd,EAAK,kBAAkB,aAAc,UAAAQ,GAAS,GAClE;AAEJ;"}

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

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import { FieldMetadata } from '../types';
+export type FormMode = 'create' | 'update';
+export type RequiredFieldRule<TData = Record<string, unknown>> = 'create' | 'update' | 'always' | 'never' | ((data: TData, mode: FormMode) => boolean);
+export type RequiredFieldConfig<TSchema extends Record<string, z.ZodType>> = Partial<{
+    [K in keyof TSchema & string]: RequiredFieldRule<{
+        [F in keyof TSchema]: z.infer<TSchema[F]>;
+    }>;
+}>;
+type OptionalOnCreate<TConfig> = {
+    [K in keyof TConfig & string]: TConfig[K] extends 'update' | 'never' ? K : never;
+}[keyof TConfig & string];
+type OptionalOnUpdate<TConfig> = {
+    [K in keyof TConfig & string]: TConfig[K] extends 'create' | 'never' ? K : never;
+}[keyof TConfig & string];
+export type OptionalFieldsToRequire<TConfig> = {
+    create?: Array<OptionalOnCreate<TConfig>>;
+    update?: Array<OptionalOnUpdate<TConfig>>;
+};
+interface BuildFormSchemaOptions<T extends Record<string, z.ZodType>, TConfig extends RequiredFieldConfig<T>> {
+    requiredFieldsConfig?: TConfig;
+    requiredErrorCode?: string;
+    mode: FormMode;
+    optionalFieldsToRequire?: OptionalFieldsToRequire<TConfig>;
+    excludeFields?: Array<keyof T & string>;
+    /** Fields with existing server-side values that are redacted in the API response
+     *  (e.g. SSN, EIN). These fields remain in the schema for format validation and
+     *  appear in metadata (with `hasRedactedValue: true`) but are exempt from required
+     *  validation — an empty submission is valid because a value already exists. */
+    fieldsWithRedactedValues?: Array<keyof T & string>;
+    superRefine?: (data: {
+        [K in keyof T]: z.infer<T[K]>;
+    }, ctx: z.RefinementCtx) => void;
+}
+export interface FieldsMetadataConfig<T extends Record<string, z.ZodType>> {
+    getFieldsMetadata: (data?: Record<string, unknown>) => Record<keyof T, FieldMetadata>;
+    /** Form field names that predicate-based requiredness rules read at runtime. */
+    predicateDeps: string[];
+}
+type FormDataFromValidators<T extends Record<string, z.ZodType>> = {
+    [K in keyof T]: z.infer<T[K]>;
+};
+export type BuildFormSchemaResult<T extends Record<string, z.ZodType>> = [
+    schema: z.ZodType<FormDataFromValidators<T>, FormDataFromValidators<T>>,
+    metadataConfig: FieldsMetadataConfig<T>
+];
+export declare function buildFormSchema<T extends Record<string, z.ZodType>, TConfig extends RequiredFieldConfig<T>>(fieldValidators: T, options: BuildFormSchemaOptions<T, TConfig>): BuildFormSchemaResult<T>;
+export {};

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

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

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

@@ -0,0 +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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"}

package/dist/{components/UNSTABLE_Hooks → partner-hook-utils}/form/composeSubmitHandler.d.ts

@@ -1,4 +1,6 @@
 import { SyntheticEvent } from 'react';
+import { FieldValues, UseFormReturn } from 'react-hook-form';
+import { HookErrorHandling } from '../types';
 /**
  * Minimal shape required for a form hook result to participate in `composeSubmitHandler`.
  * Any hook returning `BaseFormHookReady` satisfies this interface.
@@ -18,9 +20,24 @@ interface ComposableFormHookResult {
             };
         };
     };
+    errorHandling: HookErrorHandling;
 }
 /**
- * Coordinates validation and submission across multiple form hooks on the same page.
+ * Accepted input for a single slot of `composeSubmitHandler`'s `forms` array.
+ *
+ * - SDK form hook results (anything matching `ComposableFormHookResult`) are composed directly.
+ * - A raw `react-hook-form` `UseFormReturn<T>` is supported for screen-local auxiliary forms
+ *   that don't warrant a dedicated SDK hook. Raw forms contribute validation/focus behavior
+ *   but no `errorHandling` (fields surface their own inline errors via react-hook-form).
+ */
+export type ComposeSubmitInput<T extends FieldValues = FieldValues> = ComposableFormHookResult | UseFormReturn<T>;
+export interface ComposeSubmitHandlerResult {
+    handleSubmit: (e: SyntheticEvent) => Promise<void>;
+    errorHandling: HookErrorHandling;
+}
+/**
+ * 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.
@@ -33,12 +50,16 @@ interface ComposableFormHookResult {
  * react-hook-form's built-in per-form focus is disabled and `composeSubmitHandler` can manage
  * cross-form focus instead.
  *
+ * The returned `errorHandling` is the same shape every SDK hook returns, so the whole result
+ * can be passed back into `composeErrorHandler` when you need to add extra
+ * `@gusto/embedded-api` queries or screen-level submit state.
+ *
  * @example
  * ```ts
  * const detailsForm = useEmployeeDetailsForm({ employeeId, shouldFocusError: false })
  * const addressForm = useHomeAddressForm({ employeeId, shouldFocusError: false })
  *
- * const handleSubmit = composeSubmitHandler(
+ * const { handleSubmit, errorHandling } = composeSubmitHandler(
  *   [detailsForm, addressForm],
  *   async () => {
  *     await detailsForm.actions.onSubmit()
@@ -46,8 +67,13 @@ interface ComposableFormHookResult {
  *   },
  * )
  *
+ * // With extra queries or screen-level submit state:
+ * // const errorHandling = composeErrorHandler([submitResult, extraQuery], { submitError, setSubmitError })
+ *
  * return <form onSubmit={handleSubmit}>...</form>
  * ```
  */
-export declare function composeSubmitHandler(forms: ComposableFormHookResult[], onAllValid: () => Promise<void>): (e: SyntheticEvent) => Promise<void>;
+export declare function composeSubmitHandler<TForms extends readonly FieldValues[]>(forms: readonly [...{
+    [K in keyof TForms]: ComposeSubmitInput<TForms[K]>;
+}], onAllValid: () => Promise<void>): ComposeSubmitHandlerResult;
 export {};

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

@@ -0,0 +1,40 @@
+import { composeErrorHandler as c } from "../composeErrorHandler.js";
+function a(r) {
+  return "handleSubmit" in r && typeof r.handleSubmit == "function";
+}
+function f(r) {
+  return a(r) ? r : r.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(
+            () => {
+              o(!0);
+            },
+            () => {
+              o(!1);
+            }
+          )();
+        })
+      )
+    )).every(Boolean)) {
+      for (const t of n) {
+        const o = Object.keys(t.formState.errors)[0];
+        if (o) {
+          t.setFocus(o);
+          return;
+        }
+      }
+      return;
+    }
+    await s();
+  }, m = c(i);
+  return { handleSubmit: l, errorHandling: m };
+}
+export {
+  S as composeSubmitHandler
+};
+//# sourceMappingURL=composeSubmitHandler.js.map

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

@@ -0,0 +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;"}

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

@@ -0,0 +1 @@
+export {};

package/dist/{components/UNSTABLE_Hooks → partner-hook-utils}/form/fields/CheckboxHookField.d.ts

@@ -1,9 +1,9 @@
 import { ComponentType } from 'react';
-import { BaseFieldProps, ValidationMessages, BaseFormHookReady } from '../../../../types/sdkHooks';
-import { CheckboxProps } from '../../../Common/UI/Checkbox/CheckboxTypes';
+import { BaseFieldProps, ValidationMessages, FormHookResult } from '../../types';
+import { CheckboxProps } from '../../../components/Common/UI/Checkbox/CheckboxTypes';
 export interface CheckboxHookFieldProps<TErrorCode extends string = never> extends BaseFieldProps {
     name: string;
-    formHookResult?: BaseFormHookReady;
+    formHookResult?: FormHookResult;
     validationMessages?: ValidationMessages<TErrorCode>;
     FieldComponent?: ComponentType<CheckboxProps>;
 }

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

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

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

@@ -0,0 +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;"}