npm - @gusto/embedded-react-sdk - Versions diffs - 0.50.0 → 0.51.0 - Mend

@gusto/embedded-react-sdk 0.50.0 → 0.51.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (985) hide show

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

@@ -32,7 +32,7 @@ export type MixedErrorSource = QueryWithRefetch | {
  * Merges multiple error sources into a single {@link HookErrorHandling}.
  *
  * @remarks
- * Accepts any mix of `@gusto/embedded-api-v-2025-11-15` React Query results and SDK hook
+ * Accepts any mix of `@gusto/embedded-api-v-2026-02-01` React Query results and SDK hook
  * results that already expose an `errorHandling` object (including the value returned by
  * {@link composeSubmitHandler}). Query errors are normalized to `SDKError`, nested hook
  * errors are flattened in, and an optional submit-state argument adds a submit error to
@@ -54,7 +54,7 @@ export type MixedErrorSource = QueryWithRefetch | {
  * @example
  * ```tsx
  * import { composeErrorHandler, useEmployeeDetailsForm } from '@gusto/embedded-react-sdk'
- * import { useEmployeeFormsList } from '@gusto/embedded-api-v-2025-11-15/react-query/employeeFormsList'
+ * import { useEmployeeFormsList } from '@gusto/embedded-api-v-2026-02-01/react-query/employeeFormsList'
  *
  * function EmployeeProfileView({ companyId, employeeId }: { companyId: string; employeeId: string }) {
  *   const employeeDetails = useEmployeeDetailsForm({ companyId, employeeId })

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

	@@ -1 +1 @@
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 into a composed {@link HookErrorHandling}.\n \n @remarks\n * Pass to {@link composeErrorHandler} when a screen has its own submit state outside of\n * any SDK form hook, so submit errors appear in the same error surface as query errors\n * and can be cleared together with `clearSubmitError`.\n \n @public\n /\nexport type SubmitStateForErrorHandling = {\n /* The current submit error, or `null` when cleared. /\n submitError: SDKError \| null\n /* Sets or clears the submit error. /\n setSubmitError: (error: SDKError \| null) => void\n}\n\n/\n Accepted input shape for {@link composeErrorHandler}: either a React Query result\n * (anything with `error` and `refetch`) or another SDK hook result that exposes\n * an `errorHandling` object.\n \n @public\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 Merges multiple error sources into a single {@link HookErrorHandling}.\n \n @remarks\n * Accepts any mix of `@gusto/embedded-api-v-~~2025~~-11-15` React Query results and SDK hook\n * results that already expose an `errorHandling` object (including the value returned by\n * {@link composeSubmitHandler}). Query errors are normalized to `SDKError`, nested hook\n * errors are flattened in, and an optional submit-state argument adds a submit error to\n * the same list.\n \n The returned `retryQueries` refetches every failed query and delegates into each nested\n * hook so their retries fire too. `clearSubmitError` clears the optional submit state and\n * delegates into each nested hook.\n \n Pairs with {@link composeSubmitHandler} by name only — this composes error state and\n * recovery, not a submit callback.\n \n @param sources - Error sources to merge. Each entry is either a React Query result or\n * an object with an `errorHandling` property.\n * @param submitState - Optional screen-level submit state to fold into the result.\n * @returns A single `HookErrorHandling` covering every source.\n * @public\n \n @example\n * ```tsx\n * import { composeErrorHandler, useEmployeeDetailsForm } from '@gusto/embedded-react-sdk'\n * import { useEmployeeFormsList } from '@gusto/embedded-api-v-~~2025~~-11-15/react-query/employeeFormsList'\n \n function EmployeeProfileView({ companyId, employeeId }: { companyId: string; employeeId: string }) {\n * const employeeDetails = useEmployeeDetailsForm({ companyId, employeeId })\n * const formsListQuery = useEmployeeFormsList({ employeeId })\n \n const errorHandling = composeErrorHandler([employeeDetails, formsListQuery])\n \n if (errorHandling.errors.length > 0) {\n * return (\n * <div role=\"alert\">\n * {errorHandling.errors.map((error, i) => (\n * <p key={i}>{error.message}</p>\n * ))}\n * <button onClick={errorHandling.retryQueries}>Retry</button>\n * </div>\n * )\n * }\n \n return null\n * }\n * ```\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":";AAiCA,SAASA,EACPC,GACgD;AAChD,SAAO,mBAAmBA;AAC5B;AAmDO,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,MAAA;AAAK,MAAKA,EAAE,QAAA;AAAA,KAAS;AAAA,EACpE,GAS+B,kBAPN,MAAM;AAC7B,eAAWJ,KAAYF;AACrB,MAAAE,EAAS,iBAAA;AAEX,IAAAJ,GAAa,eAAe,IAAI;AAAA,EAClC,EAE+B;AACjC;"}
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 into a composed {@link HookErrorHandling}.\n \n @remarks\n * Pass to {@link composeErrorHandler} when a screen has its own submit state outside of\n * any SDK form hook, so submit errors appear in the same error surface as query errors\n * and can be cleared together with `clearSubmitError`.\n \n @public\n /\nexport type SubmitStateForErrorHandling = {\n /* The current submit error, or `null` when cleared. /\n submitError: SDKError \| null\n /* Sets or clears the submit error. /\n setSubmitError: (error: SDKError \| null) => void\n}\n\n/\n Accepted input shape for {@link composeErrorHandler}: either a React Query result\n * (anything with `error` and `refetch`) or another SDK hook result that exposes\n * an `errorHandling` object.\n \n @public\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 Merges multiple error sources into a single {@link HookErrorHandling}.\n \n @remarks\n * Accepts any mix of `@gusto/embedded-api-v-2026-02-01` React Query results and SDK hook\n * results that already expose an `errorHandling` object (including the value returned by\n * {@link composeSubmitHandler}). Query errors are normalized to `SDKError`, nested hook\n * errors are flattened in, and an optional submit-state argument adds a submit error to\n * the same list.\n \n The returned `retryQueries` refetches every failed query and delegates into each nested\n * hook so their retries fire too. `clearSubmitError` clears the optional submit state and\n * delegates into each nested hook.\n \n Pairs with {@link composeSubmitHandler} by name only — this composes error state and\n * recovery, not a submit callback.\n \n @param sources - Error sources to merge. Each entry is either a React Query result or\n * an object with an `errorHandling` property.\n * @param submitState - Optional screen-level submit state to fold into the result.\n * @returns A single `HookErrorHandling` covering every source.\n * @public\n \n @example\n * ```tsx\n * import { composeErrorHandler, useEmployeeDetailsForm } from '@gusto/embedded-react-sdk'\n * import { useEmployeeFormsList } from '@gusto/embedded-api-v-2026-02-01/react-query/employeeFormsList'\n \n function EmployeeProfileView({ companyId, employeeId }: { companyId: string; employeeId: string }) {\n * const employeeDetails = useEmployeeDetailsForm({ companyId, employeeId })\n * const formsListQuery = useEmployeeFormsList({ employeeId })\n \n const errorHandling = composeErrorHandler([employeeDetails, formsListQuery])\n \n if (errorHandling.errors.length > 0) {\n * return (\n * <div role=\"alert\">\n * {errorHandling.errors.map((error, i) => (\n * <p key={i}>{error.message}</p>\n * ))}\n * <button onClick={errorHandling.retryQueries}>Retry</button>\n * </div>\n * )\n * }\n \n return null\n * }\n * ```\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":";AAiCA,SAASA,EACPC,GACgD;AAChD,SAAO,mBAAmBA;AAC5B;AAmDO,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,MAAA;AAAK,MAAKA,EAAE,QAAA;AAAA,KAAS;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/partner-hook-utils/form/FormFieldsMetadataContext.js CHANGED Viewed

@@ -1,7 +1,7 @@
-import { useContext as t, createContext as e } from "react";
-const o = e(null);
+import { createContext as t, useContext as e } from "react";
+const o = t(null);
 function r() {
-  return t(o);
+  return e(o);
 }
 export {
   o as FormFieldsMetadataContext,

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

@@ -29,9 +29,17 @@ export type RequiredFieldConfig<TSchema extends Record<string, z.ZodType>> = Par
     }>;
 }>;
 /**
- * Union of field names in `TConfig` whose base rule is `'update'` or `'never'`
- * — i.e. fields that are optional on create and therefore eligible to be
- * promoted to required in create mode.
+ * A predicate (value-conditional) requiredness rule. Matches any function
+ * signature so predicate rules are recognized regardless of their parameter or
+ * return types. Such fields are never statically required in a given mode, so
+ * they're eligible for promotion — see {@link OptionalOnCreate}.
+ */
+type PredicateRule = (...args: never[]) => unknown;
+/**
+ * Union of field names in `TConfig` that are not statically required in create
+ * mode and are therefore eligible to be promoted to required in create mode:
+ * fields whose base rule is `'update'`, `'never'`, or a predicate. Promoting a
+ * predicate field upgrades it from conditionally required to always required.
  *
  * The template-literal wrapper \`\` `${...}` \`\` is intentional: wrapping a
  * conditional-mapped-type index access in a template literal forces TypeScript
@@ -42,24 +50,26 @@ export type RequiredFieldConfig<TSchema extends Record<string, z.ZodType>> = Par
  * resolved concrete union (e.g. `"stateWcCovered" | "twoPercentShareholder"`).
  */
 type OptionalOnCreate<TConfig> = `${{
-    [K in keyof TConfig & string]: TConfig[K] extends 'update' | 'never' ? K : never;
+    [K in keyof TConfig & string]: TConfig[K] extends 'update' | 'never' | PredicateRule ? K : never;
 }[keyof TConfig & string]}`;
 /**
- * Union of field names in `TConfig` whose base rule is `'create'` or `'never'`
- * — i.e. fields that are optional on update and therefore eligible to be
- * promoted to required in update mode.
+ * Union of field names in `TConfig` that are not statically required in update
+ * mode and are therefore eligible to be promoted to required in update mode:
+ * fields whose base rule is `'create'`, `'never'`, or a predicate.
  *
  * See {@link OptionalOnCreate} for why the template-literal wrapper is here.
  */
 type OptionalOnUpdate<TConfig> = `${{
-    [K in keyof TConfig & string]: TConfig[K] extends 'create' | 'never' ? K : never;
+    [K in keyof TConfig & string]: TConfig[K] extends 'create' | 'never' | PredicateRule ? K : never;
 }[keyof TConfig & string]}`;
 /**
  * Per-mode list of optional fields a caller can promote to required.
  *
  * Only fields whose base rule allows the override appear in the `create` /
  * `update` arrays — fields that are already required in a given mode are
- * excluded from that mode's list at the type level.
+ * excluded from that mode's list at the type level. Value-conditional
+ * (predicate) fields are eligible in both modes; listing one promotes it from
+ * conditionally required to always required for that mode.
  *
  * @typeParam TConfig - The {@link RequiredFieldConfig} that constrains which fields are eligible.
  * @internal

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

	@@ -1 +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\n/*\n Form lifecycle mode used to vary requiredness and validation rules.\n \n @internal\n /\ntype FormMode = 'create' \| 'update'\n\n/\n Per-field requiredness rule.\n \n String values apply requiredness in a fixed mode (`'always'`, `'create'`,\n * `'update'`, or `'never'`). A function form receives the current form data\n * and mode so requiredness can depend on other field values at runtime.\n \n @typeParam TData - The shape of the form data passed to predicate rules.\n * @internal\n /\ntype RequiredFieldRule<TData = Record<string, unknown>> =\n 'create' \| 'update' \| 'always' \| 'never' \| ((data: TData, mode: FormMode) => boolean)\n\n/\n Mapping from each field name in a schema to its {@link RequiredFieldRule}.\n \n @typeParam TSchema - The map of field names to their Zod validators.\n * @internal\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\n/\n Union of field names in `TConfig` whose base rule is `'update'` or `'never'`\n * — i.e. fields that are optional on create and therefore eligible to be\n * promoted to required in create mode.\n \n The template-literal wrapper \\`\\` `${...}` \\`\\` is intentional: wrapping a\n * conditional-mapped-type index access in a template literal forces TypeScript\n * to eagerly evaluate and materialize the string union rather than deferring\n * it. Without the wrapper, TypeScript preserves the alias name in hover\n * tooltips and generated docs (`OptionalOnCreate<{ ... }>`), making the type\n * opaque to callers. With it, both IntelliSense and TypeDoc display the\n * resolved concrete union (e.g. `\"stateWcCovered\" \| \"twoPercentShareholder\"`).\n /\ntype OptionalOnCreate<TConfig> = `${{\n [K in keyof TConfig & string]: TConfig[K] extends 'update' \| 'never' ? K : never\n}[keyof TConfig & string]}`\n\n/\n Union of field names in `TConfig` whose base rule is `'create'` or `'never'`\n * — i.e. fields that are optional on update and therefore eligible to be\n * promoted to required in update mode.\n \n See {@link OptionalOnCreate} for why the template-literal wrapper is here.\n /\ntype OptionalOnUpdate<TConfig> = `${{\n [K in keyof TConfig & string]: TConfig[K] extends 'create' \| 'never' ? K : never\n}[keyof TConfig & string]}`\n\n/\n Per-mode list of optional fields a caller can promote to required.\n \n Only fields whose base rule allows the override appear in the `create` /\n * `update` arrays — fields that are already required in a given mode are\n * excluded from that mode's list at the type level.\n \n @typeParam TConfig - The {@link RequiredFieldConfig} that constrains which fields are eligible.\n * @internal\n * @interface\n /\nexport type OptionalFieldsToRequire<TConfig> = {\n /* Fields that can be required in create mode /\n create?: Array<OptionalOnCreate<TConfig>>\n /* Fields that can be required in update mode /\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 /\n Fields that don't apply and should be dropped from required validation.\n \n An array removes the fields at build time — they're absent from the\n * schema shape entirely (use when applicability is fixed by a config flag).\n \n A function is evaluated against the values under validation, so a field\n * can flip in/out of applicability as other values change. The field stays in\n * the schema (validated as optional) but its required check is skipped while\n * the function reports it as excluded.\n /\n excludeFields?:\n \| Array<keyof T & string>\n \| ((data: { [K in keyof T]: z.infer<T[K]> }, mode: FormMode) => 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\n/\n Companion config returned alongside a built schema, used to derive per-field\n * metadata and to identify which form values predicate-based rules depend on.\n \n @typeParam T - The map of field names to their Zod validators.\n * @internal\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\n/\n Tuple returned by {@link buildFormSchema}: the composed Zod schema followed\n * by its {@link FieldsMetadataConfig}.\n \n @typeParam T - The map of field names to their Zod validators.\n * @internal\n /\nexport type BuildFormSchemaResult<T extends Record<string, z.ZodType>> = [\n schema: z.ZodType<FormDataFromValidators<T>, FormDataFromValidators<T>>,\n metadataConfig: FieldsMetadataConfig<T>,\n]\n\n/\n Composes a Zod object schema and matching metadata config from a map of\n * per-field validators, applying mode-aware requiredness rules.\n \n @remarks\n * Every field is wrapped to coerce empty strings, `null`, `undefined`, and\n * `NaN` to `undefined` before validation, so blank inputs surface as missing\n * rather than as type-mismatch errors. Required-field checks run in a\n * `superRefine` pass that emits an issue keyed by `requiredErrorCode` (defaults\n * to `REQUIRED`) for each unfilled required field.\n \n Fields listed in `fieldsWithRedactedValues` remain in the schema for format\n * validation and appear in metadata with `hasRedactedValue: true`, but are\n * exempt from required-field validation because a server-side value already\n * exists.\n \n @typeParam T - The map of field names to their Zod validators.\n * @typeParam TConfig - The shape of the requiredness configuration.\n * @param fieldValidators - Map from field name to the validator that runs when a value is present.\n * @param options - Mode, required-field config, redaction list, and optional `superRefine`.\n * @returns A {@link BuildFormSchemaResult} tuple: the schema and its metadata config.\n * @internal\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 // The array form removes fields at build time; the function form is resolved\n // per-validation in the superRefine pass below.\n const excludeFieldsFn = typeof excludeFields === 'function' ? excludeFields : undefined\n const staticExcluded = new Set((Array.isArray(excludeFields) ? 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 (staticExcluded.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 const typedData = data as FormDataFromValidators<T>\n const excludedNow = excludeFieldsFn\n ? new Set(excludeFieldsFn(typedData, mode).map(String))\n : undefined\n\n for (const { name, predicate } of dynamicRequired) {\n if (excludedNow?.has(name)) continue\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?.(typedData, 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","excludeFieldsFn","staticExcluded","redacted","partnerRequired","resolveOptionalFieldsToRequire","shape","dynamicRequired","includedFieldNames","config","name","validator","effectiveRule","makeOptional","isPartnerRequired","hasSuperRefine","schema","z","data","ctx","typedData","excludedNow","predicate","isEmpty","predicateDeps","detectPredicateDeps","getFieldsMetadata","metadata","value","v","deps","isConstantPredicate","accessed","proxy","_target","prop","key"],"mappings":";AAuKO,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,GAGEK,IAAkB,OAAOD,KAAkB,aAAaA,IAAgB,QACxEE,IAAiB,IAAI,KAAK,MAAM,QAAQF,CAAa,IAAIA,IAAgB,CAAA,GAAI,IAAI,MAAM,CAAC,GACxFG,IAAW,IAAI,KAAKP,EAAQ,4BAA4B,CAAA,GAAI,IAAI,MAAM,CAAC,GACvEQ,IAAkB,IAAI;AAAA,IAC1BC,EAA+BT,EAAQ,yBAAyBC,CAAI;AAAA,EAAA,GAGhES,IAAmC,CAAA,GACnCC,IAGD,CAAA,GACCC,IAA+B,CAAA,GAC/BC,IAASX;AAEf,aAAW,CAACY,GAAMC,CAAS,KAAK,OAAO,QAAQhB,CAAe,GAAG;AAC/D,QAAIO,EAAe,IAAIQ,CAAI,EAAG;AAC9B,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,MAAkBf,KAAQiB,MAEzEP,EAAgB,KAAK,EAAE,MAAAG,GAAM,WAAW,MAAM,IAAM;AAAA,IAG1D;AAAA,EACF;AAEA,QAAMK,IAAiBR,EAAgB,SAAS,KAAKX,EAAQ;AAC7D,MAAIoB,IAAoBC,EAAE,OAAOX,CAAK;AAEtC,EAAIS,MACFC,IAAUA,EAAuB;AAAA,IAC/B,CAACE,GAA+BC,MAAyB;AACvD,YAAMC,IAAYF,GACZG,IAAcpB,IAChB,IAAI,IAAIA,EAAgBmB,GAAWvB,CAAI,EAAE,IAAI,MAAM,CAAC,IACpD;AAEJ,iBAAW,EAAE,MAAAa,GAAM,WAAAY,EAAA,KAAef;AAChC,QAAIc,GAAa,IAAIX,CAAI,KACrBY,EAAUJ,GAAMrB,CAAI,KAAK0B,EAAQL,EAAKR,CAAI,CAAC,KAC7CS,EAAI,SAAS;AAAA,UACX,MAAMF,EAAE,aAAa;AAAA,UACrB,MAAM,CAACP,CAAI;AAAA,UACX,SAASX;AAAA,QAAA,CACV;AAIL,MAAAH,EAAQ,cAAcwB,GAAWD,CAAG;AAAA,IACtC;AAAA,EAAA;AAIJ,QAAMK,IAAgBC,EAAoBlB,GAAiBV,CAAI;AAE/D,WAAS6B,EAAkBR,GAAgC;AACzD,UAAMS,IAA0C,CAAA;AAEhD,eAAWjB,KAAQF,GAAoB;AACrC,YAAMI,IAAgBH,EAAOC,CAAI,KAAK;AAEtC,MAAIN,EAAgB,IAAIM,CAAI,IAC1BiB,EAASjB,CAAI,IAAI,EAAE,MAAAA,GAAM,YAAY,GAAA,IAC5B,OAAOE,KAAkB,aAClCe,EAASjB,CAAI,IAAI,EAAE,MAAAA,GAAM,YAAYQ,IAAON,EAAcM,GAAMrB,CAAI,IAAI,GAAA,IAExE8B,EAASjB,CAAI,IAAI;AAAA,QACf,MAAAA;AAAA,QACA,YAAYE,MAAkB,YAAYA,MAAkBf;AAAA,MAAA,GAI5DM,EAAS,IAAIO,CAAI,MACnBiB,EAASjB,CAAI,EAAE,mBAAmB;AAAA,IAEtC;AAEA,WAAOiB;AAAA,EACT;AAKA,SAAO;AAAA,IACLX;AAAA,IACA,EAAE,mBAAAU,GAAmB,eAAAF,EAAA;AAAA,EAAc;AAEvC;AAIA,SAASnB,EACPuB,GACA/B,GACU;AACV,SAAK+B,KACI/B,MAAS,WAAW+B,EAAM,SAASA,EAAM,WAAW,CAAA,IAD1C,CAAA;AAErB;AAEA,SAASf,EAAaF,GAAiC;AACrD,SAAOM,EAAE,WAAW,CAAAY,MAAMN,EAAQM,CAAC,IAAI,SAAYA,GAAIlB,EAAU,SAAA,CAAU;AAC7E;AAEA,SAASY,EAAQK,GAAyB;AAGxC,SAFI,GAAuBA,KAAU,QACjC,OAAOA,KAAU,YAAYA,EAAM,KAAA,MAAW,MAC9C,OAAOA,KAAU,YAAY,OAAO,MAAMA,CAAK;AAErD;AAkBA,SAASH,EACPlB,GAIAV,GACU;AACV,QAAMiC,wBAAW,IAAA;AAEjB,aAAW,EAAE,WAAAR,EAAA,KAAef,GAAiB;AAC3C,QAAIwB,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,GAAOpC,CAAI;AAAA,IACvB,QAAQ;AAAA,IAER;AAEA,eAAWuC,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;"}
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\n/*\n Form lifecycle mode used to vary requiredness and validation rules.\n \n @internal\n /\ntype FormMode = 'create' \| 'update'\n\n/\n Per-field requiredness rule.\n \n String values apply requiredness in a fixed mode (`'always'`, `'create'`,\n * `'update'`, or `'never'`). A function form receives the current form data\n * and mode so requiredness can depend on other field values at runtime.\n \n @typeParam TData - The shape of the form data passed to predicate rules.\n * @internal\n /\ntype RequiredFieldRule<TData = Record<string, unknown>> =\n 'create' \| 'update' \| 'always' \| 'never' \| ((data: TData, mode: FormMode) => boolean)\n\n/\n Mapping from each field name in a schema to its {@link RequiredFieldRule}.\n \n @typeParam TSchema - The map of field names to their Zod validators.\n * @internal\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\n/\n A predicate (value-conditional) requiredness rule. Matches any function\n * signature so predicate rules are recognized regardless of their parameter or\n * return types. Such fields are never statically required in a given mode, so\n * they're eligible for promotion — see {@link OptionalOnCreate}.\n /\ntype PredicateRule = (...args: never[]) => unknown\n\n/\n Union of field names in `TConfig` that are not statically required in create\n * mode and are therefore eligible to be promoted to required in create mode:\n * fields whose base rule is `'update'`, `'never'`, or a predicate. Promoting a\n * predicate field upgrades it from conditionally required to always required.\n \n The template-literal wrapper \\`\\` `${...}` \\`\\` is intentional: wrapping a\n * conditional-mapped-type index access in a template literal forces TypeScript\n * to eagerly evaluate and materialize the string union rather than deferring\n * it. Without the wrapper, TypeScript preserves the alias name in hover\n * tooltips and generated docs (`OptionalOnCreate<{ ... }>`), making the type\n * opaque to callers. With it, both IntelliSense and TypeDoc display the\n * resolved concrete union (e.g. `\"stateWcCovered\" \| \"twoPercentShareholder\"`).\n /\ntype OptionalOnCreate<TConfig> = `${{\n [K in keyof TConfig & string]: TConfig[K] extends 'update' \| 'never' \| PredicateRule ? K : never\n}[keyof TConfig & string]}`\n\n/\n Union of field names in `TConfig` that are not statically required in update\n * mode and are therefore eligible to be promoted to required in update mode:\n * fields whose base rule is `'create'`, `'never'`, or a predicate.\n \n See {@link OptionalOnCreate} for why the template-literal wrapper is here.\n /\ntype OptionalOnUpdate<TConfig> = `${{\n [K in keyof TConfig & string]: TConfig[K] extends 'create' \| 'never' \| PredicateRule ? K : never\n}[keyof TConfig & string]}`\n\n/\n Per-mode list of optional fields a caller can promote to required.\n \n Only fields whose base rule allows the override appear in the `create` /\n * `update` arrays — fields that are already required in a given mode are\n * excluded from that mode's list at the type level. Value-conditional\n * (predicate) fields are eligible in both modes; listing one promotes it from\n * conditionally required to always required for that mode.\n \n @typeParam TConfig - The {@link RequiredFieldConfig} that constrains which fields are eligible.\n * @internal\n * @interface\n /\nexport type OptionalFieldsToRequire<TConfig> = {\n /* Fields that can be required in create mode /\n create?: Array<OptionalOnCreate<TConfig>>\n /* Fields that can be required in update mode /\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 /\n Fields that don't apply and should be dropped from required validation.\n \n An array removes the fields at build time — they're absent from the\n * schema shape entirely (use when applicability is fixed by a config flag).\n \n A function is evaluated against the values under validation, so a field\n * can flip in/out of applicability as other values change. The field stays in\n * the schema (validated as optional) but its required check is skipped while\n * the function reports it as excluded.\n /\n excludeFields?:\n \| Array<keyof T & string>\n \| ((data: { [K in keyof T]: z.infer<T[K]> }, mode: FormMode) => 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\n/\n Companion config returned alongside a built schema, used to derive per-field\n * metadata and to identify which form values predicate-based rules depend on.\n \n @typeParam T - The map of field names to their Zod validators.\n * @internal\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\n/\n Tuple returned by {@link buildFormSchema}: the composed Zod schema followed\n * by its {@link FieldsMetadataConfig}.\n \n @typeParam T - The map of field names to their Zod validators.\n * @internal\n /\nexport type BuildFormSchemaResult<T extends Record<string, z.ZodType>> = [\n schema: z.ZodType<FormDataFromValidators<T>, FormDataFromValidators<T>>,\n metadataConfig: FieldsMetadataConfig<T>,\n]\n\n/\n Composes a Zod object schema and matching metadata config from a map of\n * per-field validators, applying mode-aware requiredness rules.\n \n @remarks\n * Every field is wrapped to coerce empty strings, `null`, `undefined`, and\n * `NaN` to `undefined` before validation, so blank inputs surface as missing\n * rather than as type-mismatch errors. Required-field checks run in a\n * `superRefine` pass that emits an issue keyed by `requiredErrorCode` (defaults\n * to `REQUIRED`) for each unfilled required field.\n \n Fields listed in `fieldsWithRedactedValues` remain in the schema for format\n * validation and appear in metadata with `hasRedactedValue: true`, but are\n * exempt from required-field validation because a server-side value already\n * exists.\n \n @typeParam T - The map of field names to their Zod validators.\n * @typeParam TConfig - The shape of the requiredness configuration.\n * @param fieldValidators - Map from field name to the validator that runs when a value is present.\n * @param options - Mode, required-field config, redaction list, and optional `superRefine`.\n * @returns A {@link BuildFormSchemaResult} tuple: the schema and its metadata config.\n * @internal\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 // The array form removes fields at build time; the function form is resolved\n // per-validation in the superRefine pass below.\n const excludeFieldsFn = typeof excludeFields === 'function' ? excludeFields : undefined\n const staticExcluded = new Set((Array.isArray(excludeFields) ? 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 (staticExcluded.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 const typedData = data as FormDataFromValidators<T>\n const excludedNow = excludeFieldsFn\n ? new Set(excludeFieldsFn(typedData, mode).map(String))\n : undefined\n\n for (const { name, predicate } of dynamicRequired) {\n if (excludedNow?.has(name)) continue\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?.(typedData, 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","excludeFieldsFn","staticExcluded","redacted","partnerRequired","resolveOptionalFieldsToRequire","shape","dynamicRequired","includedFieldNames","config","name","validator","effectiveRule","makeOptional","isPartnerRequired","hasSuperRefine","schema","z","data","ctx","typedData","excludedNow","predicate","isEmpty","predicateDeps","detectPredicateDeps","getFieldsMetadata","metadata","value","v","deps","isConstantPredicate","accessed","proxy","_target","prop","key"],"mappings":"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"}

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

@@ -68,7 +68,7 @@ export interface ComposeSubmitHandlerResult {
  *
  * The returned `errorHandling` is the same shape every SDK hook returns, so the whole result
  * can be passed back into {@link composeErrorHandler} when you need to add extra
- * `@gusto/embedded-api-v-2025-11-15` queries or screen-level submit state.
+ * `@gusto/embedded-api-v-2026-02-01` queries or screen-level submit state.
  *
  * @typeParam TForms - Tuple of form value shapes, one per slot of `forms`.
  * @param forms - Form hook results and/or raw `UseFormReturn` instances to coordinate.

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

	@@ -1 +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, 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 @remarks\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 \n @typeParam T - The shape of the form values when a raw `UseFormReturn` is passed.\n * @internal\n /\nexport type ComposeSubmitInput<T extends FieldValues = FieldValues> =\n ComposableFormHookResult \| UseFormReturn<T>\n\ninterface FormValidationResult {\n input: ComposeSubmitInput\n formMethods: FormMethods\n valid: boolean\n errors: Record<string, unknown>\n}\n\n/\n Result returned by {@link composeSubmitHandler}: a single submit handler that\n * coordinates validation across the composed forms, and aggregated error state.\n \n @public\n /\nexport interface ComposeSubmitHandlerResult {\n /* Submit handler to pass to a form's `onSubmit`. Validates all composed forms before calling `onAllValid`. /\n handleSubmit: (e: SyntheticEvent) => Promise<void>\n /* Aggregated error state across all composed SDK form hooks. Pass to {@link composeErrorHandler} for screen-level error surfaces. /\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.\n \n @remarks\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 {@link composeErrorHandler} when you need to add extra\n * `@gusto/embedded-api-v-2025-11-15` queries or screen-level submit state.\n \n @typeParam TForms - Tuple of form value shapes, one per slot of `forms`.\n * @param forms - Form hook results and/or raw `UseFormReturn` instances to coordinate.\n * @param onAllValid - Async callback invoked once every form has passed validation.\n * @returns A {@link ComposeSubmitHandlerResult} with a unified `handleSubmit` and aggregated `errorHandling`.\n * @public\n \n @example\n * ```tsx\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 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":";AAoEA,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;AA4CO,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;"}
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, 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 @remarks\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 \n @typeParam T - The shape of the form values when a raw `UseFormReturn` is passed.\n * @internal\n /\nexport type ComposeSubmitInput<T extends FieldValues = FieldValues> =\n ComposableFormHookResult \| UseFormReturn<T>\n\ninterface FormValidationResult {\n input: ComposeSubmitInput\n formMethods: FormMethods\n valid: boolean\n errors: Record<string, unknown>\n}\n\n/\n Result returned by {@link composeSubmitHandler}: a single submit handler that\n * coordinates validation across the composed forms, and aggregated error state.\n \n @public\n /\nexport interface ComposeSubmitHandlerResult {\n /* Submit handler to pass to a form's `onSubmit`. Validates all composed forms before calling `onAllValid`. /\n handleSubmit: (e: SyntheticEvent) => Promise<void>\n /* Aggregated error state across all composed SDK form hooks. Pass to {@link composeErrorHandler} for screen-level error surfaces. /\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.\n \n @remarks\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 {@link composeErrorHandler} when you need to add extra\n * `@gusto/embedded-api-v-2026-02-01` queries or screen-level submit state.\n \n @typeParam TForms - Tuple of form value shapes, one per slot of `forms`.\n * @param forms - Form hook results and/or raw `UseFormReturn` instances to coordinate.\n * @param onAllValid - Async callback invoked once every form has passed validation.\n * @returns A {@link ComposeSubmitHandlerResult} with a unified `handleSubmit` and aggregated `errorHandling`.\n * @public\n \n @example\n * ```tsx\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 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":";AAoEA,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;AA4CO,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/index.d.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-import "./types/i18next.d.ts"
 export { TextInputHookField, type TextInputHookFieldProps } from './TextInputHookField';
 export { SelectHookField, type SelectHookFieldProps } from './SelectHookField';
 export { CheckboxHookField, type CheckboxHookFieldProps } from './CheckboxHookField';

package/dist/partner-hook-utils/form/index.d.ts CHANGED Viewed

@@ -1,10 +1,6 @@
-import "./types/i18next.d.ts"
 export type { FieldMetadata, FieldMetadataWithOptions, FieldsMetadata, ValidationMessages, BaseFieldProps, HookFieldProps, } from '../types';
-export { withOptions } from './withOptions';
 export type { FormFieldsMetadataContextValue } from './FormFieldsMetadataContext';
 export { FormFieldsMetadataProvider } from './FormFieldsMetadataProvider';
 export { SDKFormProvider } from './SDKFormProvider';
-export { useDeriveFieldsMetadata } from './useDeriveFieldsMetadata';
-export { useFieldErrorMessage } from './useFieldErrorMessage';
 export { composeSubmitHandler } from './composeSubmitHandler';
 export { TextInputHookField, type TextInputHookFieldProps, SelectHookField, type SelectHookFieldProps, CheckboxHookField, type CheckboxHookFieldProps, NumberInputHookField, type NumberInputHookFieldProps, DatePickerHookField, type DatePickerHookFieldProps, RadioGroupHookField, type RadioGroupHookFieldProps, type SharedFieldLayoutProps, type SharedHorizontalFieldLayoutProps, type TextInputProps, type SelectProps, type SelectOption, type CheckboxProps, type NumberInputProps, type DatePickerProps, type RadioGroupProps, type RadioGroupOption, SwitchHookField, type SwitchHookFieldProps, type SwitchProps, } from './fields';

package/dist/partner-hook-utils/form/withFlags.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { FieldMetadata } from '../types';
+/**
+ * Apply presentation flags (e.g. `isDisabled`) to a base {@link FieldMetadata}
+ * entry while preserving the `FieldMetadata` type.
+ *
+ * @remarks
+ * Use when building the `fieldsMetadata` returned by a custom form hook to
+ * override flags on an entry derived from `useDeriveFieldsMetadata`. A bare
+ * object spread (`{ ...base, isDisabled }`) widens the entry to an anonymous
+ * object type; routing it through this helper keeps it typed as
+ * {@link FieldMetadata} so the hook's inferred metadata type stays precise.
+ *
+ * @param base - The existing field metadata entry to extend.
+ * @param flags - Presentation flags to override on the entry.
+ * @returns The merged entry, typed as {@link FieldMetadata}.
+ * @internal
+ */
+export declare function withFlags(base: FieldMetadata, flags: Partial<FieldMetadata>): FieldMetadata;

package/dist/partner-hook-utils/form/withFlags.js ADDED Viewed

@@ -0,0 +1,7 @@
+function r(t, n) {
+  return { ...t, ...n };
+}
+export {
+  r as withFlags
+};
+//# sourceMappingURL=withFlags.js.map

package/dist/partner-hook-utils/form/withFlags.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"withFlags.js","sources":["../../../src/partner-hook-utils/form/withFlags.ts"],"sourcesContent":["import type { FieldMetadata } from '../types'\n\n/**\n * Apply presentation flags (e.g. `isDisabled`) to a base {@link FieldMetadata}\n * entry while preserving the `FieldMetadata` type.\n *\n * @remarks\n * Use when building the `fieldsMetadata` returned by a custom form hook to\n * override flags on an entry derived from `useDeriveFieldsMetadata`. A bare\n * object spread (`{ ...base, isDisabled }`) widens the entry to an anonymous\n * object type; routing it through this helper keeps it typed as\n * {@link FieldMetadata} so the hook's inferred metadata type stays precise.\n *\n * @param base - The existing field metadata entry to extend.\n * @param flags - Presentation flags to override on the entry.\n * @returns The merged entry, typed as {@link FieldMetadata}.\n * @internal\n */\nexport function withFlags(base: FieldMetadata, flags: Partial<FieldMetadata>): FieldMetadata {\n return { ...base, ...flags }\n}\n"],"names":["withFlags","base","flags"],"mappings":"AAkBO,SAASA,EAAUC,GAAqBC,GAA8C;AAC3F,SAAO,EAAE,GAAGD,GAAM,GAAGC,EAAA;AACvB;"}

package/dist/partner-hook-utils/index.d.ts CHANGED Viewed

@@ -1,4 +1,3 @@
-import "./types/i18next.d.ts"
 export * from './types';
 export { composeErrorHandler, type MixedErrorSource, type SubmitStateForErrorHandling, } from './composeErrorHandler';
 export { collectErrors } from './collectErrors';

package/dist/partner-hook-utils/types.d.ts CHANGED Viewed

@@ -21,6 +21,8 @@ export interface FieldMetadata {
     isDisabled?: boolean;
     /** Whether the server returned a redacted placeholder instead of the real value. */
     hasRedactedValue?: boolean;
+    /** Placeholder text a hook supplies for the field (e.g. a masked value to display while the input is empty). */
+    placeholder?: string;
     /** ISO date string lower bound for date picker fields. Set by hooks; consumed by DatePickerHookField. */
     minDate?: string | null;
     /** ISO date string upper bound for date picker fields. Set by hooks; consumed by DatePickerHookField. */
@@ -216,11 +218,12 @@ export interface BaseHookReady<TData extends Record<string, unknown> = Record<st
  * parsed values (or `undefined` if invalid).
  *
  * @typeParam TFieldsMetadata - Shape of the per-field metadata exposed by the hook.
- * @typeParam TFormData - Shape of the form values managed by react-hook-form.
+ * @typeParam TFormData - Shape of the form values managed by react-hook-form (the resolver input / `TFieldValues`).
  * @typeParam TFields - Shape of the pre-bound `Fields` component map.
+ * @typeParam TFormOutputs - Shape of the values produced once the schema parses on submit (the resolver output / `TTransformedValues`). Defaults to `TFormData`, which holds whenever the form's input and parsed-output shapes coincide; pass it explicitly when a schema transform makes them diverge.
  * @public
  */
-export interface BaseFormHookReady<TFieldsMetadata extends FieldsMetadata = FieldsMetadata, TFormData extends FieldValues = FieldValues, TFields extends object = Record<string, unknown>> {
+export interface BaseFormHookReady<TFieldsMetadata extends FieldsMetadata = FieldsMetadata, TFormData extends FieldValues = FieldValues, TFields extends object = Record<string, unknown>, TFormOutputs = TFormData> {
     /** Always `false` in this branch; discriminates from {@link HookLoadingResult}. */
     isLoading: false;
     /** Hook-specific data payload; shape is narrowed by each concrete hook. */
@@ -239,7 +242,7 @@ export interface BaseFormHookReady<TFieldsMetadata extends FieldsMetadata = Fiel
         Fields: TFields;
         fieldsMetadata: TFieldsMetadata;
         hookFormInternals: HookFormInternals<TFormData>;
-        getFormSubmissionValues: () => Record<string, unknown> | undefined;
+        getFormSubmissionValues: () => TFormOutputs | undefined;
     };
 }
 /**

package/dist/shared/constants.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-import { ContractorOnboardingStatus1 } from '@gusto/embedded-api-v-2025-11-15/models/components/contractor';
+import { ContractorOnboardingStatus1 } from '@gusto/embedded-api-v-2026-02-01/models/components/contractor';
 /**
  * Event keys emitted by employee-related components.
  *
@@ -203,6 +203,7 @@ export declare const contractorEvents: {
     readonly CONTRACTOR_INVITE_CONTRACTOR: "contractor/invite/selfOnboarding";
     readonly CONTRACTOR_ONBOARDING_CONTINUE: "contractor/onboarding/continue";
     readonly CONTRACTOR_VIEW_DOCUMENT_TO_SIGN: "contractor/documents/view";
+    readonly CONTRACTOR_SIGN_DOCUMENT: "contractor/documents/sign";
     readonly CONTRACTOR_DOCUMENTS_DONE: "contractor/documents/done";
 };
 /**
@@ -434,7 +435,7 @@ export declare const timeOffEvents: {
  * a few cross-cutting keys: `ERROR`, `CANCEL`, and `BREADCRUMB_NAVIGATE`.
  *
  * @public
- * @group Events
+ * @group Event names
  *
  * @example
  * ```tsx
@@ -570,6 +571,7 @@ export declare const componentEvents: {
     readonly CONTRACTOR_INVITE_CONTRACTOR: "contractor/invite/selfOnboarding";
     readonly CONTRACTOR_ONBOARDING_CONTINUE: "contractor/onboarding/continue";
     readonly CONTRACTOR_VIEW_DOCUMENT_TO_SIGN: "contractor/documents/view";
+    readonly CONTRACTOR_SIGN_DOCUMENT: "contractor/documents/sign";
     readonly CONTRACTOR_DOCUMENTS_DONE: "contractor/documents/done";
     readonly PAY_SCHEDULE_CREATE: "paySchedule/create";
     readonly PAY_SCHEDULE_CREATED: "paySchedule/created";
@@ -741,7 +743,7 @@ export declare const componentEvents: {
  * the specific event keys you care about.
  *
  * @public
- * @group Events
+ * @group Utility types
  *
  * @example
  * ```tsx
@@ -862,8 +864,20 @@ export declare const HOURS_PER_PAY_PERIOD_ANNUALLY = 2080;
  * @public
  */
 export declare const I9_FORM_NAME = "US_I-9";
-/** @internal */
+/**
+ * Two-letter US state abbreviations (including `'DC'`), in the order presented
+ * in state selection controls.
+ *
+ * @public
+ */
 export declare const STATES_ABBR: readonly ["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "DC", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"];
+/**
+ * A two-letter US state abbreviation (including `'DC'`). Derived from
+ * {@link STATES_ABBR}.
+ *
+ * @public
+ */
+export type StateAbbreviation = (typeof STATES_ABBR)[number];
 /** @internal */
 export declare const SIGNATORY_TITLES: {
     readonly OWNER: "owner";

package/dist/shared/constants.js CHANGED Viewed

@@ -1,5 +1,5 @@
-import { OnboardingStatus as E } from "@gusto/embedded-api-v-2025-11-15/models/operations/putv1employeesemployeeidonboardingstatus";
-import { ContractorOnboardingStatus1 as e } from "@gusto/embedded-api-v-2025-11-15/models/components/contractor";
+import { OnboardingStatus as E } from "@gusto/embedded-api-v-2026-02-01/models/operations/putv1employeesemployeeidonboardingstatus";
+import { ContractorOnboardingStatus1 as e } from "@gusto/embedded-api-v-2026-02-01/models/components/contractor";
 const A = {
   EMPLOYEE_CREATE: "employee/create",
   EMPLOYEE_CREATED: "employee/created",
@@ -172,6 +172,7 @@ const A = {
   CONTRACTOR_INVITE_CONTRACTOR: "contractor/invite/selfOnboarding",
   CONTRACTOR_ONBOARDING_CONTINUE: "contractor/onboarding/continue",
   CONTRACTOR_VIEW_DOCUMENT_TO_SIGN: "contractor/documents/view",
+  CONTRACTOR_SIGN_DOCUMENT: "contractor/documents/sign",
   CONTRACTOR_DOCUMENTS_DONE: "contractor/documents/done"
 }, n = {
   CONTRACTOR_PAYMENT_CREATE: "contractor/payments/create",