@gusto/embedded-react-sdk 0.55.6 → 0.55.7

package/dist/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/fields.js

@@ -0,0 +1,136 @@
+import { jsx as y } from "react/jsx-runtime";
+import { TextInputField as h } from "../../../../Common/Fields/TextInputField/TextInputField.js";
+import { useFieldErrorMessage as N } from "../../../../../partner-hook-utils/form/useFieldErrorMessage.js";
+import { PayrollCategory as g } from "../../../payrollTypes.js";
+import { COMPENSATION_NAME_OVERTIME as R, COMPENSATION_NAME_DOUBLE_OVERTIME as C } from "../../../../../shared/constants.js";
+import { RadioGroupHookField as I } from "../../../../../partner-hook-utils/form/fields/RadioGroupHookField.js";
+function W(e) {
+  return !Array.isArray(e);
+}
+function d(e, o) {
+  return function(m) {
+    const l = N(
+      e,
+      o
+    );
+    return /* @__PURE__ */ y(h, { ...m, name: e, type: "number", min: 0, errorMessage: l });
+  };
+}
+function _() {
+  return function(o) {
+    return /* @__PURE__ */ y(I, { ...o, name: "paymentMethod" });
+  };
+}
+function k(e) {
+  return function(r) {
+    return /* @__PURE__ */ y(h, { ...r, name: e });
+  };
+}
+function q(e) {
+  return {
+    Description: k("reimbursementDraft.description"),
+    Amount: d("reimbursementDraft.amount", e)
+  };
+}
+function x(e, o) {
+  return e == null ? null : parseFloat(e) - (parseFloat(o ?? "") || 0);
+}
+function E(e, o, r, m, l, s) {
+  const f = e.filter(
+    (t) => !!t.jobUuid && !!t.name
+  ), u = (t, i, a) => ({
+    key: a ? `${t.jobUuid}:${t.name}:${i}` : `${t.jobUuid}:${t.name}`,
+    jobUuid: t.jobUuid,
+    name: t.name,
+    ...a ? { workweekStart: i } : {},
+    Field: d(
+      `${r}.${t.jobUuid}.${t.name}.${i}`,
+      s
+    )
+  });
+  if (o.length > 1 && m && l) {
+    const t = {};
+    for (const i of o)
+      t[i.startDate] = f.map((a) => u(a, i.startDate, !0));
+    return t;
+  }
+  const c = o[0]?.startDate ?? "";
+  return f.map((t) => u(t, c, !1));
+}
+function z({
+  employeeCompensation: e,
+  fixedCompensations: o,
+  workweeks: r,
+  payrollCategory: m,
+  hasDirectDepositSetup: l,
+  overtimeEarningNames: s,
+  isOvertimeEligible: f,
+  withOvertime: u,
+  jobTitlesByUuid: c,
+  timeOffAccrualByName: t,
+  errorMessages: i
+}) {
+  const a = e?.hourlyCompensations ?? [], F = o.filter(
+    (n) => n.name != null && s.has(n.name)
+  ), U = o.filter(
+    (n) => n.name == null || !s.has(n.name)
+  ), b = [];
+  for (const n of [...a, ...F])
+    n.jobUuid && !b.includes(n.jobUuid) && b.push(n.jobUuid);
+  const O = (n) => n === R || n === C, B = b.map((n) => {
+    const j = a.filter(
+      (p) => p.jobUuid === n
+    ), M = u ? j : j.filter((p) => !O(p.name));
+    return {
+      jobUuid: n,
+      title: c.get(n),
+      hours: E(
+        M,
+        r,
+        "hours",
+        f,
+        u,
+        i
+      )
+    };
+  }), D = E(
+    F,
+    r,
+    "additionalEarnings",
+    f,
+    u,
+    i
+  ), P = U.filter(
+    (n) => !!n.jobUuid && !!n.name
+  ).map((n) => ({
+    key: `${n.jobUuid}:${n.name}`,
+    id: n.name,
+    Field: d(`other.${n.jobUuid}.${n.name}`, i)
+  })), $ = (e?.paidTimeOff ?? []).filter((n) => n.name), T = $.map((n) => ({
+    key: `timeOff:${n.name}`,
+    name: n.name,
+    Field: d(`timeOff.${n.name}`, i),
+    // Seeded from the initial entered hours; the hook recomputes it live.
+    remaining: x(t.get(n.name), n.hours)
+  })), A = m === g.Dismissal ? $.map((n) => ({
+    key: `finalPayout:${n.name}`,
+    name: n.name,
+    Field: d(`finalPayout.${n.name}`, i),
+    remaining: null
+  })) : void 0;
+  return {
+    jobs: B,
+    additionalEarnings: D,
+    otherEarnings: P,
+    timeOff: T,
+    finalPayout: A,
+    paymentMethod: l ? _() : void 0
+  };
+}
+export {
+  x as computeTimeOffRemaining,
+  z as createPayrollEditEmployeeFields,
+  q as createReimbursementDraftFields,
+  W as isSplitByWorkweek
+};
+//# sourceMappingURL=fields.js.map

package/dist/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sources":["../../../../../../src/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/fields.tsx"],"sourcesContent":["import type { ComponentType } from 'react'\nimport type { PayrollEmployeeCompensationsType } from '@gusto/embedded-api/models/components/payrollemployeecompensationstype'\nimport type { PayrollUpdatePaymentMethod } from '@gusto/embedded-api/models/components/payrollupdate'\nimport type { NormalizedWorkweek } from './payrollEditEmployeeHelpers'\nimport type { PayrollEditEmployeeErrorCode } from './payrollEditEmployeeSchema'\nimport { TextInputField } from '@/components/Common/Fields/TextInputField/TextInputField'\nimport { useFieldErrorMessage } from '@/partner-hook-utils/form/useFieldErrorMessage'\nimport { RadioGroupHookField } from '@/partner-hook-utils/form/fields'\nimport type { RadioGroupHookFieldProps } from '@/partner-hook-utils/form/fields/RadioGroupHookField'\nimport type { HookFieldProps, ValidationMessages } from '@/partner-hook-utils/types'\nimport type { TextInputProps } from '@/components/Common/UI/TextInput/TextInputTypes'\nimport { PayrollCategory } from '@/components/Payroll/payrollTypes'\nimport { COMPENSATION_NAME_DOUBLE_OVERTIME, COMPENSATION_NAME_OVERTIME } from '@/shared/constants'\n\n/**\n * Display copy for each validation error code a bound field can surface, so the\n * consumer supplies error text once (keyed by code) rather than reconstructing\n * form paths or hardcoding which rule each field can fail. Partial: a missing\n * code falls back to the raw error code.\n *\n * @public\n */\nexport type PayrollEditEmployeeErrorMessages = Partial<Record<PayrollEditEmployeeErrorCode, string>>\n\n/**\n * Presentation props accepted by a bound numeric field in the payroll editor.\n *\n * @remarks\n * The hook binds the react-hook-form `name`, forces `type=\"number\"`, and\n * resolves the field's own validation message internally; the UI supplies copy\n * and layout props (label, adornments, `shouldVisuallyHideLabel`, required\n * state, `description`).\n *\n * @public\n */\nexport type PayrollEditEmployeeFieldProps = Omit<\n  TextInputProps,\n  'name' | 'value' | 'onChange' | 'isInvalid' | 'type' | 'min' | 'errorMessage'\n>\n\n/**\n * A numeric field component pre-bound by the hook to a specific form path.\n *\n * @public\n */\nexport type PayrollEditEmployeeFieldComponent = ComponentType<PayrollEditEmployeeFieldProps>\n\n/**\n * Presentation props accepted by the bound payment-method field.\n *\n * @remarks\n * The hook binds the `name` and publishes the option values on\n * `fieldsMetadata.paymentMethod`; the UI passes `getOptionLabel` to translate\n * each {@link PayrollUpdatePaymentMethod} value, rather than passing `options`.\n *\n * @public\n */\nexport type PayrollEditEmployeePaymentMethodFieldProps = HookFieldProps<\n  RadioGroupHookFieldProps<never, PayrollUpdatePaymentMethod>\n>\n\n/**\n * The payment-method radio field component pre-bound by the hook.\n *\n * @public\n */\nexport type PayrollEditEmployeePaymentMethodField =\n  ComponentType<PayrollEditEmployeePaymentMethodFieldProps>\n\n/**\n * One hours input within the hours section.\n *\n * @remarks\n * `key` is an opaque, stable React key. `jobUuid`, `name`, and (when the pay\n * period is multi-workweek) `workweekStart` are reach-in handles the UI uses to\n * group and label entries. When the section is a flat array, `workweekStart` is\n * omitted (single-workweek degenerate case); when it is a `Record` keyed by\n * workweek start, each entry carries its `workweekStart`.\n *\n * @public\n */\nexport interface HourEntry {\n  /** Opaque, stable React key. */\n  key: string\n  /** The job this hours line belongs to. */\n  jobUuid: string\n  /** The compensation name (e.g. the API hours-compensation name). */\n  name: string\n  /** The workweek start date (`YYYY-MM-DD`) when the section is workweek-keyed. */\n  workweekStart?: string\n  /** Field component pre-bound to this entry's form path. */\n  Field: PayrollEditEmployeeFieldComponent\n}\n\n/**\n * One earning input, used by the additional-earnings section.\n *\n * @remarks\n * Same shape as {@link HourEntry}. Whether an earning feeds the overtime\n * (regular rate of pay) calculation is decided by the hook, which sorts it into\n * the workweek-breakdown additional-earnings section or the flat other\n * section. The UI just renders whichever section an entry appears in.\n *\n * @public\n */\nexport type EarningEntry = HourEntry\n\n/**\n * One time-off or final-payout input.\n *\n * @remarks\n * Time off is never workweek-breakdown, so this section is always a flat array.\n *\n * @public\n */\nexport interface TimeOffEntry {\n  /** Opaque, stable React key. */\n  key: string\n  /** The time-off policy compensation name. */\n  name: string\n  /** Field component pre-bound to this entry's form path. */\n  Field: PayrollEditEmployeeFieldComponent\n  /**\n   * The policy's remaining balance after the entered hours are subtracted,\n   * recomputed live as the user edits. `null` when the policy has no tracked\n   * accrual balance (e.g. final-payout rows). Feed it into the field's own\n   * `description` to render it as the input's help text.\n   */\n  remaining: number | null\n}\n\n/**\n * One entry in the flat `other` section.\n *\n * @remarks\n * Intentionally opaque: `other` collects earnings that are not overtime-affecting\n * and whose input type the partner does not need to reason about. Render each\n * entry's `Field` keyed by `key`; use `id` as a reach-in handle for labeling.\n *\n * @public\n */\nexport interface OtherEntry {\n  /** Opaque, stable React key. */\n  key: string\n  /** Reach-in handle identifying the underlying earning (its compensation name). */\n  id: string\n  /** Field component pre-bound to this entry's form path. */\n  Field: PayrollEditEmployeeFieldComponent\n}\n\n/**\n * A single job's hours section.\n *\n * @remarks\n * An employee can hold multiple jobs, each with its own hourly lines. `hours` is\n * either a flat `Entry[]` (single-workweek, or an overtime-ineligible employee)\n * OR a `Record<workweekStart, Entry[]>` (multi-workweek and overtime-eligible).\n * The value type is the signal — array is flat, object is split by workweek; use\n * {@link isSplitByWorkweek} to discriminate. `title` is the job's display title\n * (entity data, not copy) for rendering a per-job heading. Earnings are not\n * job-scoped: they live in the employee-level `additionalEarnings` and\n * `otherEarnings` sections on {@link PayrollEditEmployeeFields}.\n *\n * @public\n */\nexport interface JobFields {\n  /** The job identifier. */\n  jobUuid: string\n  /** The job's display title, when available, for a per-job heading. */\n  title?: string\n  /**\n   * Hours inputs for this job. Excludes Overtime/Double-overtime rows while\n   * `data.withOvertime` is `false`.\n   */\n  hours: HourEntry[] | Record<string, HourEntry[]>\n}\n\n/**\n * Presentation props accepted by a bound reimbursement description (text) field.\n *\n * @remarks\n * The hook binds the react-hook-form `name` internally; the UI supplies copy and\n * layout props (label, placeholder, `shouldVisuallyHideLabel`).\n *\n * @public\n */\nexport type ReimbursementDescriptionFieldProps = Omit<\n  TextInputProps,\n  'name' | 'value' | 'onChange' | 'isInvalid' | 'type'\n>\n\n/**\n * The draft \"add reimbursement\" field group exposed on\n * `form.Fields.reimbursementDraft`.\n *\n * @remarks\n * A single in-progress row the UI reveals when the user starts adding a\n * reimbursement. `Description` and `Amount` bind to `reimbursementDraft.description`\n * / `reimbursementDraft.amount`. The UI shows them while `form.reimbursementDraft.isAdding`\n * is `true`, then calls `actions.saveReimbursement` (commits to the list) or\n * `actions.cancelReimbursement` (discards). Committed rows are rendered from\n * `data.reimbursements`, not from bound fields.\n *\n * @public\n */\nexport interface ReimbursementDraftFields {\n  /** Description field pre-bound to the draft's form path. */\n  Description: ComponentType<ReimbursementDescriptionFieldProps>\n  /** Amount field pre-bound to the draft's form path. */\n  Amount: PayrollEditEmployeeFieldComponent\n}\n\n/**\n * A committed reimbursement row for display in the consumer's table.\n *\n * @remarks\n * Exposed on `data.reimbursements`, seeded from the employee's existing\n * reimbursements and appended to as the user saves drafts. Display-only: the UI\n * renders `description`, `amount`, and the recurring/one-time `type`, plus a\n * remove control wired to `actions.removeReimbursement(index)`. `index` is the\n * row's position in the underlying form array (the removal handle); `uuid` is\n * present for rows that already exist server-side.\n *\n * @public\n */\nexport interface ReimbursementRow {\n  /** Opaque, stable React key. */\n  key: string\n  /** The row's index in the reimbursements form array; pass to `removeReimbursement`. */\n  index: number\n  /** The reimbursement's server UUID, when it already exists. */\n  uuid?: string\n  /** The reimbursement description (may be blank; the UI supplies a fallback). */\n  description: string\n  /** The reimbursement amount as a decimal string. */\n  amount: string\n  /** Whether this reimbursement recurs. Recurring rows are managed outside payroll. */\n  recurring: boolean\n}\n\n/**\n * The render-ready field collections exposed on `form.Fields`.\n *\n * @remarks\n * Hours are grouped under `jobs`, one entry per job, so multi-job employees\n * render correctly. All earnings and the remaining sections are employee-scoped\n * and stay top-level: `additionalEarnings` (overtime-affecting) and\n * `otherEarnings` (non-overtime) each render as a single section spanning every\n * job, alongside time off, final payout, payment method, and reimbursements.\n *\n * @public\n */\nexport interface PayrollEditEmployeeFields {\n  /** Per-job hours sections; one entry per job. */\n  jobs: JobFields[]\n  /**\n   * Overtime-affecting earnings across all jobs, as a single employee-level\n   * section. Flat `Entry[]` when unsplit, or `Record<workweekStart, Entry[]>`\n   * when split by workweek; use {@link isSplitByWorkweek} to discriminate.\n   */\n  additionalEarnings: EarningEntry[] | Record<string, EarningEntry[]>\n  /** Non-overtime earnings (e.g. tips), always flat; opaque render entries. */\n  otherEarnings: OtherEntry[]\n  /** Time-off inputs (never workweek-breakdown). */\n  timeOff: TimeOffEntry[]\n  /** Final-payout inputs, present only for dismissal payrolls. */\n  finalPayout?: TimeOffEntry[]\n  /** Payment-method selector, present only when the employee has direct deposit set up. */\n  paymentMethod?: PayrollEditEmployeePaymentMethodField\n  /**\n   * The draft \"add reimbursement\" field group, present only for itemized\n   * (non-off-cycle) payrolls. Render while `form.reimbursementDraft.isAdding` is\n   * `true`; committed rows come from `data.reimbursements`.\n   */\n  reimbursementDraft?: ReimbursementDraftFields\n}\n\n/**\n * Discriminates a workweek-breakdown section: `false` for the flat\n * (single-workweek) `Entry[]` form, `true` for the workweek-keyed\n * `Record<workweekStart, Entry[]>` form.\n *\n * @typeParam TEntry - The section's entry type.\n * @param section - A `form.Fields` section that may be flat or workweek-keyed.\n * @returns `true` when the section is keyed by workweek start date.\n * @public\n */\nexport function isSplitByWorkweek<TEntry>(\n  section: TEntry[] | Record<string, TEntry[]>,\n): section is Record<string, TEntry[]> {\n  return !Array.isArray(section)\n}\n\n// ── Bound field factories ──────────────────────────────────────────────\n\nfunction createNumberField(\n  name: string,\n  errorMessages?: PayrollEditEmployeeErrorMessages,\n): PayrollEditEmployeeFieldComponent {\n  return function BoundNumberField(props: PayrollEditEmployeeFieldProps) {\n    // The field resolves its own validation copy from its bound path, so the\n    // consumer supplies error copy once (keyed by code) and never reconstructs\n    // form paths or guesses which rule a field can fail. name, type, min, and\n    // errorMessage are applied after the spread so callers can't override the\n    // binding or the non-negative numeric contract via custom props.\n    const errorMessage = useFieldErrorMessage(\n      name,\n      errorMessages as ValidationMessages<PayrollEditEmployeeErrorCode> | undefined,\n    )\n    return (\n      <TextInputField {...props} name={name} type=\"number\" min={0} errorMessage={errorMessage} />\n    )\n  }\n}\n\nfunction createPaymentMethodField(): PayrollEditEmployeePaymentMethodField {\n  return function BoundPaymentMethodField(props: PayrollEditEmployeePaymentMethodFieldProps) {\n    return (\n      <RadioGroupHookField<never, PayrollUpdatePaymentMethod> {...props} name=\"paymentMethod\" />\n    )\n  }\n}\n\nfunction createTextField(name: string): ComponentType<ReimbursementDescriptionFieldProps> {\n  return function BoundTextField(props: ReimbursementDescriptionFieldProps) {\n    return <TextInputField {...props} name={name} />\n  }\n}\n\n/**\n * Builds the draft \"add reimbursement\" field group, binding its Description and\n * Amount fields to the `reimbursementDraft` form path.\n *\n * @param errorMessages - Copy for each validation error code, baked into the amount field so it self-resolves.\n * @returns The pre-bound draft field group for `form.Fields.reimbursementDraft`.\n * @internal\n */\nexport function createReimbursementDraftFields(\n  errorMessages?: PayrollEditEmployeeErrorMessages,\n): ReimbursementDraftFields {\n  return {\n    Description: createTextField('reimbursementDraft.description'),\n    Amount: createNumberField('reimbursementDraft.amount', errorMessages),\n  }\n}\n\n// ── Builders ───────────────────────────────────────────────────────────\n\n/** @internal */\nexport interface CreatePayrollEditEmployeeFieldsOptions {\n  employeeCompensation: PayrollEmployeeCompensationsType | undefined\n  /**\n   * Fixed compensations to render, already merged with blank placeholders for\n   * every company earning type (see `resolveEditableFixedCompensations`).\n   */\n  fixedCompensations: NonNullable<PayrollEmployeeCompensationsType['fixedCompensations']>\n  workweeks: NormalizedWorkweek[]\n  payrollCategory: PayrollCategory\n  hasDirectDepositSetup: boolean\n  /** Names of earning types included in the regular-rate-of-pay overtime calculation. */\n  overtimeEarningNames: Set<string>\n  /** Whether the employee is overtime-eligible (nonexempt family). Gates per-workweek splitting. */\n  isOvertimeEligible: boolean\n  /**\n   * Gates per-workweek splitting\n   * alongside `isOvertimeEligible`, and whether Overtime/Double-overtime rows\n   * are included in `hours`.\n   */\n  withOvertime: boolean\n  /** Job title lookup by job UUID, for per-job section headings. */\n  jobTitlesByUuid: Map<string, string>\n  /** Accrual balance by time-off policy name, for the remaining-balance display. */\n  timeOffAccrualByName: Map<string, string>\n  /** Copy for each validation error code, baked into every bound field so it self-resolves. */\n  errorMessages?: PayrollEditEmployeeErrorMessages\n}\n\n/**\n * A time-off policy's remaining balance: its accrual balance minus the entered\n * hours. `null` when the policy has no tracked accrual balance (final-payout\n * rows). Shared by the field builder (seeding the initial value) and the hook\n * (recomputing it live as the user edits).\n *\n * @param accrualBalance - The policy's accrual balance, or `undefined` when untracked.\n * @param enteredHours - The currently entered hours for the policy.\n * @returns The remaining balance, or `null` when untracked.\n * @internal\n */\nexport function computeTimeOffRemaining(\n  accrualBalance: string | undefined,\n  enteredHours: string | null | undefined,\n): number | null {\n  if (accrualBalance == null) return null\n  return parseFloat(accrualBalance) - (parseFloat(enteredHours ?? '') || 0)\n}\n\nfunction buildBreakdownSection(\n  compensations: Array<{ jobUuid?: string; name?: string }>,\n  workweeks: NormalizedWorkweek[],\n  pathPrefix: 'hours' | 'additionalEarnings',\n  isOvertimeEligible: boolean,\n  withOvertime: boolean,\n  errorMessages: PayrollEditEmployeeErrorMessages | undefined,\n): HourEntry[] | Record<string, HourEntry[]> {\n  const rows = compensations.filter(\n    (compensation): compensation is { jobUuid: string; name: string } =>\n      Boolean(compensation.jobUuid) && Boolean(compensation.name),\n  )\n\n  const toEntry = (\n    row: { jobUuid: string; name: string },\n    weekStart: string,\n    includeWorkweek: boolean,\n  ): HourEntry => ({\n    key: includeWorkweek ? `${row.jobUuid}:${row.name}:${weekStart}` : `${row.jobUuid}:${row.name}`,\n    jobUuid: row.jobUuid,\n    name: row.name,\n    ...(includeWorkweek ? { workweekStart: weekStart } : {}),\n    Field: createNumberField(\n      `${pathPrefix}.${row.jobUuid}.${row.name}.${weekStart}`,\n      errorMessages,\n    ),\n  })\n\n  // Split into per-workweek columns only for overtime-eligible employees while\n  // `withOvertime` is on; workweek breakdowns exist solely to compute overtime\n  // premiums, so an ineligible employee renders flat even on a multi-workweek\n  // payroll, and an eligible one stays flat until `withOvertime` is set.\n  if (workweeks.length > 1 && isOvertimeEligible && withOvertime) {\n    const byWeek: Record<string, HourEntry[]> = {}\n    for (const workweek of workweeks) {\n      byWeek[workweek.startDate] = rows.map(row => toEntry(row, workweek.startDate, true))\n    }\n    return byWeek\n  }\n\n  const weekStart = workweeks[0]?.startDate ?? ''\n  return rows.map(row => toEntry(row, weekStart, false))\n}\n\n/**\n * Builds the render-ready {@link PayrollEditEmployeeFields} from the prepared\n * compensation.\n *\n * @remarks\n * Hours and overtime-affecting earnings are grouped per job into `jobs` (a job\n * appears if it has hourly lines or overtime-affecting earnings). Fixed\n * compensations are split by whether their earning type is included in the\n * regular-rate-of-pay overtime calculation (`overtimeEarningNames`): included\n * earnings become each job's additional earnings, the rest become the flat,\n * employee-level `other` section. Time off comes from the paid-time-off list,\n * final payout is added only for dismissal payrolls, and the payment-method\n * selector appears only when direct deposit is set up.\n *\n * @param options - The prepared compensation, normalized workweeks, payroll category, direct-deposit flag, overtime earning names, eligibility, the `withOvertime` flag, job titles, time-off accrual balances and entered values, and error copy.\n * @returns The populated field collections.\n * @internal\n */\nexport function createPayrollEditEmployeeFields({\n  employeeCompensation,\n  fixedCompensations,\n  workweeks,\n  payrollCategory,\n  hasDirectDepositSetup,\n  overtimeEarningNames,\n  isOvertimeEligible,\n  withOvertime,\n  jobTitlesByUuid,\n  timeOffAccrualByName,\n  errorMessages,\n}: CreatePayrollEditEmployeeFieldsOptions): PayrollEditEmployeeFields {\n  const hourlyCompensations = employeeCompensation?.hourlyCompensations ?? []\n  const overtimeAffecting = fixedCompensations.filter(\n    compensation => compensation.name != null && overtimeEarningNames.has(compensation.name),\n  )\n  const nonOvertime = fixedCompensations.filter(\n    compensation => compensation.name == null || !overtimeEarningNames.has(compensation.name),\n  )\n\n  // A job appears if it has hourly lines or overtime-affecting earnings, in first\n  // appearance order across those two sources.\n  const jobUuids: string[] = []\n  for (const compensation of [...hourlyCompensations, ...overtimeAffecting]) {\n    if (compensation.jobUuid && !jobUuids.includes(compensation.jobUuid)) {\n      jobUuids.push(compensation.jobUuid)\n    }\n  }\n\n  const isOvertimeName = (name: string | null | undefined) =>\n    name === COMPENSATION_NAME_OVERTIME || name === COMPENSATION_NAME_DOUBLE_OVERTIME\n\n  const jobs: JobFields[] = jobUuids.map(jobUuid => {\n    const jobHourlyCompensations = hourlyCompensations.filter(\n      compensation => compensation.jobUuid === jobUuid,\n    )\n    // Overtime/Double-overtime rows stay out of `hours` entirely while\n    // `withOvertime` is off — their underlying form values are untouched\n    // (still whatever the prepared compensation carried), so hiding the row\n    // can't lose or corrupt data. Driven by the single, employee-level flag —\n    // no per-job hidden state.\n    const visibleHourlyCompensations = withOvertime\n      ? jobHourlyCompensations\n      : jobHourlyCompensations.filter(compensation => !isOvertimeName(compensation.name))\n\n    return {\n      jobUuid,\n      title: jobTitlesByUuid.get(jobUuid),\n      hours: buildBreakdownSection(\n        visibleHourlyCompensations,\n        workweeks,\n        'hours',\n        isOvertimeEligible,\n        withOvertime,\n        errorMessages,\n      ),\n    }\n  })\n\n  // Overtime-affecting earnings render as one employee-level section spanning\n  // every job. Each entry keeps its per-job form path\n  // (`additionalEarnings.<jobUuid>.<name>`), so the flat section still binds and\n  // submits per job.\n  const additionalEarnings = buildBreakdownSection(\n    overtimeAffecting,\n    workweeks,\n    'additionalEarnings',\n    isOvertimeEligible,\n    withOvertime,\n    errorMessages,\n  )\n\n  const otherEarnings: OtherEntry[] = nonOvertime\n    .filter(\n      (compensation): compensation is { jobUuid: string; name: string } =>\n        Boolean(compensation.jobUuid) && Boolean(compensation.name),\n    )\n    .map(compensation => ({\n      key: `${compensation.jobUuid}:${compensation.name}`,\n      id: compensation.name,\n      Field: createNumberField(`other.${compensation.jobUuid}.${compensation.name}`, errorMessages),\n    }))\n\n  const timeOffRows = (employeeCompensation?.paidTimeOff ?? []).filter(entry => entry.name)\n  const timeOff: TimeOffEntry[] = timeOffRows.map(entry => ({\n    key: `timeOff:${entry.name!}`,\n    name: entry.name!,\n    Field: createNumberField(`timeOff.${entry.name!}`, errorMessages),\n    // Seeded from the initial entered hours; the hook recomputes it live.\n    remaining: computeTimeOffRemaining(timeOffAccrualByName.get(entry.name!), entry.hours),\n  }))\n\n  // Final-payout rows never show a remaining balance.\n  const finalPayout =\n    payrollCategory === PayrollCategory.Dismissal\n      ? timeOffRows.map(entry => ({\n          key: `finalPayout:${entry.name!}`,\n          name: entry.name!,\n          Field: createNumberField(`finalPayout.${entry.name!}`, errorMessages),\n          remaining: null,\n        }))\n      : undefined\n\n  return {\n    jobs,\n    additionalEarnings,\n    otherEarnings,\n    timeOff,\n    finalPayout,\n    paymentMethod: hasDirectDepositSetup ? createPaymentMethodField() : undefined,\n  }\n}\n"],"names":["isSplitByWorkweek","section","createNumberField","name","errorMessages","props","errorMessage","useFieldErrorMessage","jsx","TextInputField","createPaymentMethodField","RadioGroupHookField","createTextField","createReimbursementDraftFields","computeTimeOffRemaining","accrualBalance","enteredHours","buildBreakdownSection","compensations","workweeks","pathPrefix","isOvertimeEligible","withOvertime","rows","compensation","toEntry","row","weekStart","includeWorkweek","byWeek","workweek","createPayrollEditEmployeeFields","employeeCompensation","fixedCompensations","payrollCategory","hasDirectDepositSetup","overtimeEarningNames","jobTitlesByUuid","timeOffAccrualByName","hourlyCompensations","overtimeAffecting","nonOvertime","jobUuids","isOvertimeName","COMPENSATION_NAME_OVERTIME","COMPENSATION_NAME_DOUBLE_OVERTIME","jobs","jobUuid","jobHourlyCompensations","visibleHourlyCompensations","additionalEarnings","otherEarnings","timeOffRows","entry","timeOff","finalPayout","PayrollCategory"],"mappings":"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"}

package/dist/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeHelpers.js

@@ -0,0 +1,210 @@
+import { PayrollUpdatePaymentMethod as p } from "@gusto/embedded-api/models/components/payrollupdate";
+import { RFCDate as S } from "@gusto/embedded-api/types/rfcdate";
+import { PayrollCategory as x, isOffCyclePayroll as R } from "../../../payrollTypes.js";
+import { cleanupReimbursements as _ } from "../../../helpers.js";
+import { SDKInternalError as F } from "../../../../../types/sdkError.js";
+import { COMPENSATION_NAME_OVERTIME as W, COMPENSATION_NAME_DOUBLE_OVERTIME as H, FlsaStatus as L, EXCLUDED_ADDITIONAL_EARNINGS as I } from "../../../../../shared/constants.js";
+function Y(t, n) {
+  const e = (t ?? []).flatMap(
+    (o) => o.startDate && o.endDate ? [{ startDate: o.startDate.toString(), endDate: o.endDate.toString() }] : []
+  );
+  if (e.length > 0)
+    return e;
+  if (n?.startDate && n.endDate)
+    return [{ startDate: n.startDate, endDate: n.endDate }];
+  throw new F("Prepared payroll has no workweeks or pay period to derive from");
+}
+function Z(t) {
+  const n = /* @__PURE__ */ new Set();
+  for (const e of [
+    ...t?.default ?? [],
+    ...t?.custom ?? []
+  ])
+    e.name && e.includedInOvertimePay && n.add(e.name);
+  return n;
+}
+function J(t, n, e, o) {
+  const l = [...t ?? []];
+  if (o !== L.OWNER && e)
+    for (const i of n ?? []) {
+      const a = i.name;
+      if (!a || I.includes(a)) continue;
+      l.some((D) => D.name?.toLowerCase() === a.toLowerCase()) || l.push({ name: a, jobUuid: e });
+    }
+  return l.filter((i) => i.name && !I.includes(i.name)).sort((i, a) => (i.name ?? "").localeCompare(a.name ?? ""));
+}
+function w(t) {
+  return (t ?? []).some(
+    (n) => (n.name === W || n.name === H) && parseFloat(n.hours ?? "0") > 0
+  );
+}
+function A(t, n) {
+  return !t || t.length === 0 ? !1 : n.every(
+    (e) => t.some(
+      (o) => o.startDate?.toString() === e.startDate && o.endDate?.toString() === e.endDate
+    )
+  );
+}
+function k(t, n) {
+  return (t ?? []).some(
+    (e) => A(e.breakdowns, n)
+  );
+}
+function b(t) {
+  if (t == null || t === "") return "";
+  const n = parseFloat(t);
+  return Number.isNaN(n) ? "" : n.toString();
+}
+function N(t) {
+  const n = b(t);
+  return n === "0" ? "" : n;
+}
+function j(t, n, e, o) {
+  const l = t[0]?.startDate ?? "";
+  if (!o)
+    return { [l]: N(n) };
+  const i = {};
+  return A(e, t) ? t.forEach((a) => {
+    const u = e?.find(
+      (D) => D.startDate?.toString() === a.startDate
+    );
+    i[a.startDate] = b(u?.hours ?? u?.amount);
+  }) : t.forEach((a, u) => {
+    i[a.startDate] = u === 0 ? N(n) : "";
+  }), i;
+}
+function tt(t, n, e, o, l, i, a = t?.fixedCompensations ?? []) {
+  const u = n.length > 1 && l && i, D = {};
+  for (const r of t?.hourlyCompensations ?? []) {
+    if (!r.jobUuid || !r.name) continue;
+    const h = D[r.jobUuid] ??= {};
+    h[r.name] = j(
+      n,
+      r.hours,
+      r.breakdowns,
+      u
+    );
+  }
+  const E = {}, g = {};
+  for (const r of a)
+    if (!(!r.jobUuid || !r.name))
+      if (o.has(r.name)) {
+        const h = E[r.jobUuid] ??= {};
+        h[r.name] = j(
+          n,
+          r.amount,
+          r.breakdowns,
+          u
+        );
+      } else {
+        const h = g[r.jobUuid] ??= {};
+        h[r.name] = b(r.amount);
+      }
+  const O = {}, M = {};
+  for (const r of t?.paidTimeOff ?? [])
+    r.name && (O[r.name] = b(r.hours), M[r.name] = b(r.finalPayoutUnusedHoursInput));
+  const y = (t?.reimbursements ?? []).map((r) => ({
+    uuid: r.uuid ?? null,
+    description: r.description ?? "",
+    amount: r.amount,
+    recurring: r.recurring ?? !1
+  }));
+  return {
+    hours: D,
+    additionalEarnings: E,
+    other: g,
+    timeOff: O,
+    finalPayout: M,
+    reimbursements: y,
+    reimbursementDraft: { description: "", amount: "" },
+    paymentMethod: $(t?.paymentMethod, e)
+  };
+}
+function $(t, n) {
+  return t === p.Check ? p.Check : t === p.DirectDeposit && n ? p.DirectDeposit : n ? p.DirectDeposit : p.Check;
+}
+function P(t, n) {
+  const e = /* @__PURE__ */ new Map();
+  for (const o of t ?? [])
+    !o.jobUuid || !o.name || e.set(`${o.jobUuid}|${o.name}`, n(o) ?? "");
+  return e;
+}
+const V = 2, z = 6;
+function U(t, n, e) {
+  const o = 10 ** e, l = n.reduce((i, a) => {
+    const u = parseFloat(t[a.startDate] ?? "0") || 0;
+    return i + Math.round(u * o);
+  }, 0);
+  return String(l / o);
+}
+function nt(t, n, e, o, l, i) {
+  const a = e.length > 1 && l && i, u = (s) => s != null && s !== "", D = P(
+    n?.hourlyCompensations,
+    (s) => s.hours
+  ), E = P(
+    n?.fixedCompensations,
+    (s) => s.amount
+  ), g = (s) => e.every((m) => u(s[m.startDate])), O = (s, m, f, c) => {
+    const d = f[e[0]?.startDate ?? ""];
+    return u(d) ? d : c.get(`${s}|${m}`) ?? "0";
+  }, M = Object.entries(t.hours).flatMap(
+    ([s, m]) => Object.entries(m).flatMap(([f, c]) => a ? g(c) ? [
+      {
+        jobUuid: s,
+        name: f,
+        hours: U(c, e, z),
+        breakdowns: e.map((d) => ({
+          startDate: new S(d.startDate),
+          endDate: new S(d.endDate),
+          hours: c[d.startDate]
+        }))
+      }
+    ] : [] : [{ jobUuid: s, name: f, hours: O(s, f, c, D) }])
+  ), y = Object.entries(t.additionalEarnings).flatMap(
+    ([s, m]) => Object.entries(m).flatMap(([f, c]) => a ? g(c) ? [
+      {
+        jobUuid: s,
+        name: f,
+        amount: U(c, e, V),
+        breakdowns: e.map((d) => ({
+          startDate: new S(d.startDate),
+          endDate: new S(d.endDate),
+          amount: c[d.startDate]
+        }))
+      }
+    ] : [] : [
+      { jobUuid: s, name: f, amount: O(s, f, c, E) }
+    ])
+  ), r = Object.entries(t.other).flatMap(
+    ([s, m]) => Object.entries(m).map(([f, c]) => ({
+      jobUuid: s,
+      name: f,
+      amount: u(c) ? c : E.get(`${s}|${f}`) ?? "0"
+    }))
+  ), h = [...y, ...r], C = o === x.Dismissal, T = Object.entries(t.timeOff).map(([s, m]) => ({
+    name: s,
+    hours: m || "0",
+    ...C && t.finalPayout[s] != null ? { finalPayoutUnusedHoursInput: t.finalPayout[s] || "0" } : {}
+  })), v = !R(o);
+  return {
+    employeeUuid: n?.employeeUuid,
+    version: n?.version,
+    excluded: n?.excluded,
+    memo: n?.memo || void 0,
+    ...t.paymentMethod ? { paymentMethod: t.paymentMethod } : {},
+    hourlyCompensations: M,
+    fixedCompensations: h,
+    paidTimeOff: T,
+    ...v ? { reimbursements: _(t.reimbursements) } : {}
+  };
+}
+export {
+  nt as buildPayrollUpdateEmployeeCompensation,
+  Z as collectOvertimeEarningNames,
+  tt as derivePayrollEditEmployeeDefaults,
+  k as hasBreakdownsMatchingWorkweeks,
+  w as hasExistingOvertimeHours,
+  Y as normalizeWorkweeks,
+  J as resolveEditableFixedCompensations
+};
+//# sourceMappingURL=payrollEditEmployeeHelpers.js.map

package/dist/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payrollEditEmployeeHelpers.js","sources":["../../../../../../src/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeHelpers.ts"],"sourcesContent":["import type { PayrollEmployeeCompensationsType } from '@gusto/embedded-api/models/components/payrollemployeecompensationstype'\nimport type { EarningTypeList } from '@gusto/embedded-api/models/components/earningtypelist'\nimport {\n  PayrollUpdatePaymentMethod,\n  type PayrollUpdateEmployeeCompensations,\n} from '@gusto/embedded-api/models/components/payrollupdate'\nimport { RFCDate } from '@gusto/embedded-api/types/rfcdate'\nimport type {\n  PayrollEditEmployeeFormData,\n  PayrollEditEmployeeFormOutputs,\n} from './payrollEditEmployeeSchema'\nimport { PayrollCategory, isOffCyclePayroll } from '@/components/Payroll/payrollTypes'\nimport { cleanupReimbursements } from '@/components/Payroll/helpers'\nimport { SDKInternalError } from '@/types/sdkError'\nimport {\n  COMPENSATION_NAME_DOUBLE_OVERTIME,\n  COMPENSATION_NAME_OVERTIME,\n  EXCLUDED_ADDITIONAL_EARNINGS,\n  FlsaStatus,\n} from '@/shared/constants'\n\n/** One fixed-compensation line off the prepared compensation. */\ntype FixedCompensationEntry = NonNullable<\n  PayrollEmployeeCompensationsType['fixedCompensations']\n>[number]\n\n/**\n * Normalized form of a workweek: the API exposes\n * `{ startDate?: RFCDate; endDate?: RFCDate }`, but the hook keys week-maps by\n * `YYYY-MM-DD` strings and builds breakdowns from them, so both boundaries are\n * required strings here. Surfaced on the hook's `data.workweeks` so the UI can\n * label each per-workweek column without re-parsing the raw API workweeks.\n *\n * @internal\n */\nexport interface NormalizedWorkweek {\n  startDate: string\n  endDate: string\n}\n\n/**\n * Normalizes the prepared payroll's top-level `workweeks` into\n * {@link NormalizedWorkweek} boundary strings, falling back to a single\n * pay-period-spanning workweek when the API returns no workweek boundaries.\n *\n * @param workweeks - The prepared payroll's top-level `workweeks` (RFCDate boundaries), possibly `null`.\n * @param payPeriod - The prepared payroll's `payPeriod`, used as the single-workweek fallback.\n * @returns One entry per workweek; a single entry spanning the pay period when none are supplied.\n * @throws SDKInternalError when neither workweeks nor a pay period are present (a malformed prepared payroll).\n * @internal\n */\nexport function normalizeWorkweeks(\n  workweeks: Array<{ startDate?: RFCDate; endDate?: RFCDate }> | null | undefined,\n  payPeriod: { startDate?: string; endDate?: string } | undefined,\n): NormalizedWorkweek[] {\n  const normalized = (workweeks ?? []).flatMap(week =>\n    week.startDate && week.endDate\n      ? [{ startDate: week.startDate.toString(), endDate: week.endDate.toString() }]\n      : [],\n  )\n\n  if (normalized.length > 0) {\n    return normalized\n  }\n\n  if (payPeriod?.startDate && payPeriod.endDate) {\n    return [{ startDate: payPeriod.startDate, endDate: payPeriod.endDate }]\n  }\n\n  // A prepared payroll always carries a pay period, so reaching here means the\n  // response was malformed. Fail loud rather than build an empty, mis-keyed form\n  // that could submit an employee's pay against a blank workweek.\n  throw new SDKInternalError('Prepared payroll has no workweeks or pay period to derive from')\n}\n\n/**\n * Collects the names of earning types included in the regular-rate-of-pay\n * overtime calculation. These earnings render in the workweek-breakdown\n * additional-earnings section; all others fall into the flat `other` section.\n *\n * @param earningTypeList - The company's default and custom earning types.\n * @returns A set of earning-type names with `includedInOvertimePay` set.\n * @internal\n */\nexport function collectOvertimeEarningNames(\n  earningTypeList: EarningTypeList | undefined,\n): Set<string> {\n  const names = new Set<string>()\n  for (const earningType of [\n    ...(earningTypeList?.default ?? []),\n    ...(earningTypeList?.custom ?? []),\n  ]) {\n    if (earningType.name && earningType.includedInOvertimePay) {\n      names.add(earningType.name)\n    }\n  }\n  return names\n}\n\n/**\n * Merges the employee's existing fixed compensations with a blank placeholder for\n * every payroll fixed-compensation type they don't yet have, mirroring the stable editor\n * (`getAdditionalEarningsCompensations`). This is what lets the editor surface an\n * empty input for Bonus, Commission, etc. even when the prepared payroll carries\n * no fixed compensations. Placeholders attach to the primary job and carry no\n * amount (blank), so an untouched earning submits as zero without altering pay.\n *\n * @remarks\n * Owners (FLSA status `Owner`) never receive placeholders. Earning types that are\n * handled elsewhere or never shown as additional earnings\n * ({@link EXCLUDED_ADDITIONAL_EARNINGS}) and inactive types are skipped. The\n * result is sorted alphabetically by name. The regular-rate-of-pay split between\n * additional earnings and `other` happens downstream via `overtimeEarningNames`;\n * this helper only decides which earning lines exist.\n *\n * @param existingFixedCompensations - The prepared compensation's fixed compensations.\n * @param fixedCompensationTypes - The prepared payroll's `fixedCompensationTypes` (the same source the stable editor uses).\n * @param primaryJobUuid - The employee's primary job UUID; placeholders attach here.\n * @param flsaStatus - The employee's FLSA status; owners get no placeholders.\n * @returns The merged, filtered, alphabetically sorted fixed-compensation lines.\n * @internal\n */\nexport function resolveEditableFixedCompensations(\n  existingFixedCompensations: FixedCompensationEntry[] | undefined,\n  fixedCompensationTypes: Array<{ name?: string | null }> | undefined,\n  primaryJobUuid: string | undefined,\n  flsaStatus: string | undefined,\n): FixedCompensationEntry[] {\n  const merged: FixedCompensationEntry[] = [...(existingFixedCompensations ?? [])]\n\n  if (flsaStatus !== FlsaStatus.OWNER && primaryJobUuid) {\n    for (const compensationType of fixedCompensationTypes ?? []) {\n      const name = compensationType.name\n      if (!name) continue\n      if (EXCLUDED_ADDITIONAL_EARNINGS.includes(name)) continue\n      const exists = merged.some(entry => entry.name?.toLowerCase() === name.toLowerCase())\n      if (!exists) merged.push({ name, jobUuid: primaryJobUuid })\n    }\n  }\n\n  return merged\n    .filter(entry => entry.name && !EXCLUDED_ADDITIONAL_EARNINGS.includes(entry.name))\n    .sort((a, b) => (a.name ?? '').localeCompare(b.name ?? ''))\n}\n\n/**\n * Whether the employee's prepared compensation already carries non-zero\n * Overtime or Double-overtime hours.\n *\n * @remarks\n * Used to default the single `withOvertime` flag: an employee who already\n * has real overtime hours starts with the workweek split shown rather than\n * requiring an extra click to see data that's already there.\n *\n * @param hourlyCompensations - The prepared compensation's hourly lines.\n * @returns `true` when any Overtime or Double-overtime line has hours greater than zero.\n * @internal\n */\nexport function hasExistingOvertimeHours(\n  hourlyCompensations: PayrollEmployeeCompensationsType['hourlyCompensations'] | undefined,\n): boolean {\n  return (hourlyCompensations ?? []).some(\n    compensation =>\n      (compensation.name === COMPENSATION_NAME_OVERTIME ||\n        compensation.name === COMPENSATION_NAME_DOUBLE_OVERTIME) &&\n      parseFloat(compensation.hours ?? '0') > 0,\n  )\n}\n\n/**\n * Whether a line's `breakdowns` exactly cover every workweek in `workweeks`\n * (each workweek has a breakdown entry matching both its start and end date).\n */\nfunction lineBreakdownsMatchWorkweeks(\n  breakdowns: Array<{ startDate?: RFCDate; endDate?: RFCDate }> | undefined,\n  workweeks: NormalizedWorkweek[],\n): boolean {\n  if (!breakdowns || breakdowns.length === 0) return false\n  return workweeks.every(workweek =>\n    breakdowns.some(\n      breakdown =>\n        breakdown.startDate?.toString() === workweek.startDate &&\n        breakdown.endDate?.toString() === workweek.endDate,\n    ),\n  )\n}\n\n/**\n * Whether any of the employee's hourly-compensation lines already carries a\n * real, per-workweek `breakdowns` array that exactly tiles the current pay\n * period's workweeks.\n *\n * @remarks\n * Used alongside {@link hasExistingOvertimeHours} to default the single\n * `withOvertime` flag: an employee whose hours are already broken down by\n * workweek (e.g. a previous edit entered real per-week values) starts with the\n * workweek split shown, seeded from those breakdowns rather than from a blank\n * or first-cell-only guess. See {@link buildWeekMap}, which applies the same\n * per-line check to decide each line's population mode.\n *\n * @param hourlyCompensations - The prepared compensation's hourly lines.\n * @param workweeks - Normalized workweeks for the pay period.\n * @returns `true` when at least one hourly line's breakdowns cover every workweek.\n * @internal\n */\nexport function hasBreakdownsMatchingWorkweeks(\n  hourlyCompensations: PayrollEmployeeCompensationsType['hourlyCompensations'] | undefined,\n  workweeks: NormalizedWorkweek[],\n): boolean {\n  return (hourlyCompensations ?? []).some(compensation =>\n    lineBreakdownsMatchWorkweeks(compensation.breakdowns, workweeks),\n  )\n}\n\n/**\n * Trims an API decimal string (e.g. `\"40.000\"`, `\"500.00\"`) to a clean editable\n * value (`\"40\"`, `\"500\"`), preserving real fractional parts (`\"40.5\"`). A blank\n * or non-numeric value returns `''` (meaning \"not provided\").\n */\nfunction formatAmountInput(value: string | null | undefined): string {\n  if (value == null || value === '') return ''\n  const parsed = parseFloat(value)\n  return Number.isNaN(parsed) ? '' : parsed.toString()\n}\n\n/**\n * Seeds a cell from a line's total: same as {@link formatAmountInput} except a\n * zero total yields `''` rather than `\"0\"`. A line whose total is zero (e.g. an\n * Overtime line with no overtime) should render as a blank cell the user can\n * fill in, not a pre-filled `0` — and a pre-filled `0` would also count as a\n * filled cell, tripping the per-row \"fill every workweek\" check for a line the\n * user never actually touched. Only used for total-seeded cells, never for real\n * per-week breakdown values (a genuine `0` breakdown must survive to keep a\n * matched split's tiling intact).\n */\nfunction formatSeededTotal(value: string | null | undefined): string {\n  const formatted = formatAmountInput(value)\n  return formatted === '0' ? '' : formatted\n}\n\n/**\n * Builds one job+name line's week map in one of three shapes, gated by\n * `isSplit` (`workweeks.length > 1 && isOvertimeEligible && withOvertime`):\n *\n * - Collapsed (`isSplit` false): a single key — the first workweek's start —\n *   holding the total. No key is emitted for any other workweek, which is what\n *   keeps a collapsed row's per-row validation a no-op (see\n *   {@link createPayrollEditEmployeeSchema}).\n * - Split, breakdowns match ({@link hasBreakdownsMatchingWorkweeks} true for\n *   this line): one key per workweek, each seeded from its real breakdown value.\n * - Split, no matching breakdowns: one key per workweek, with only the first\n *   seeded (from the total) and the rest left blank — never auto-distributed,\n *   so the user must fill them in (enforced by the schema's per-row check).\n */\nfunction buildWeekMap(\n  workweeks: NormalizedWorkweek[],\n  total: string | undefined,\n  breakdowns:\n    Array<{ startDate?: RFCDate; endDate?: RFCDate; hours?: string; amount?: string }> | undefined,\n  isSplit: boolean,\n): Record<string, string> {\n  const firstWorkweekStart = workweeks[0]?.startDate ?? ''\n\n  if (!isSplit) {\n    return { [firstWorkweekStart]: formatSeededTotal(total) }\n  }\n\n  const weekMap: Record<string, string> = {}\n  if (lineBreakdownsMatchWorkweeks(breakdowns, workweeks)) {\n    workweeks.forEach(workweek => {\n      const breakdown = breakdowns?.find(\n        entry => entry.startDate?.toString() === workweek.startDate,\n      )\n      weekMap[workweek.startDate] = formatAmountInput(breakdown?.hours ?? breakdown?.amount)\n    })\n  } else {\n    workweeks.forEach((workweek, index) => {\n      weekMap[workweek.startDate] = index === 0 ? formatSeededTotal(total) : ''\n    })\n  }\n  return weekMap\n}\n\n/**\n * Derives the form's default values from the employee's prepared compensation.\n *\n * @remarks\n * Hourly and additional earnings are expanded into per-workweek maps via\n * {@link buildWeekMap}: collapsed to the total when not split, seeded from real\n * breakdowns or first-cell-only otherwise. Time off, final payout,\n * reimbursements, and payment method are read straight off the compensation.\n *\n * @param employeeCompensation - The employee's prepared compensation, if loaded.\n * @param workweeks - Normalized workweeks for the pay period.\n * @param withOvertime - The single, form-wide overtime-mode flag (see {@link hasExistingOvertimeHours}, {@link hasBreakdownsMatchingWorkweeks}, `actions.addOvertime`). Gates splitting alongside `isOvertimeEligible`.\n * @returns Default {@link PayrollEditEmployeeFormData} for `useForm`.\n * @internal\n */\nexport function derivePayrollEditEmployeeDefaults(\n  employeeCompensation: PayrollEmployeeCompensationsType | undefined,\n  workweeks: NormalizedWorkweek[],\n  hasDirectDepositSetup: boolean,\n  overtimeEarningNames: Set<string>,\n  isOvertimeEligible: boolean,\n  withOvertime: boolean,\n  fixedCompensations: FixedCompensationEntry[] = employeeCompensation?.fixedCompensations ?? [],\n): PayrollEditEmployeeFormData {\n  // Only overtime-eligible employees split hours/earnings by workweek, and only\n  // while the single `withOvertime` flag is on; everyone else renders (and\n  // seeds) flat, even on a multi-workweek payroll.\n  const isSplit = workweeks.length > 1 && isOvertimeEligible && withOvertime\n\n  const hours: PayrollEditEmployeeFormData['hours'] = {}\n  for (const compensation of employeeCompensation?.hourlyCompensations ?? []) {\n    if (!compensation.jobUuid || !compensation.name) continue\n    const jobHours = (hours[compensation.jobUuid] ??= {})\n    jobHours[compensation.name] = buildWeekMap(\n      workweeks,\n      compensation.hours,\n      compensation.breakdowns,\n      isSplit,\n    )\n  }\n\n  // Earnings whose earning type is included in the regular-rate-of-pay overtime\n  // calculation stay workweek-breakdown; the rest are flat and land in `other`.\n  // The hook owns this bucketing so the UI just renders each section.\n  const additionalEarnings: PayrollEditEmployeeFormData['additionalEarnings'] = {}\n  const other: PayrollEditEmployeeFormData['other'] = {}\n  for (const compensation of fixedCompensations) {\n    if (!compensation.jobUuid || !compensation.name) continue\n    if (overtimeEarningNames.has(compensation.name)) {\n      const jobEarnings = (additionalEarnings[compensation.jobUuid] ??= {})\n      jobEarnings[compensation.name] = buildWeekMap(\n        workweeks,\n        compensation.amount,\n        compensation.breakdowns,\n        isSplit,\n      )\n    } else {\n      const jobOther = (other[compensation.jobUuid] ??= {})\n      jobOther[compensation.name] = formatAmountInput(compensation.amount)\n    }\n  }\n\n  const timeOff: PayrollEditEmployeeFormData['timeOff'] = {}\n  const finalPayout: PayrollEditEmployeeFormData['finalPayout'] = {}\n  for (const entry of employeeCompensation?.paidTimeOff ?? []) {\n    if (!entry.name) continue\n    timeOff[entry.name] = formatAmountInput(entry.hours)\n    finalPayout[entry.name] = formatAmountInput(entry.finalPayoutUnusedHoursInput)\n  }\n\n  const reimbursements: PayrollEditEmployeeFormData['reimbursements'] = (\n    employeeCompensation?.reimbursements ?? []\n  ).map(reimbursement => ({\n    uuid: reimbursement.uuid ?? null,\n    description: reimbursement.description ?? '',\n    amount: reimbursement.amount,\n    recurring: reimbursement.recurring ?? false,\n  }))\n\n  return {\n    hours,\n    additionalEarnings,\n    other,\n    timeOff,\n    finalPayout,\n    reimbursements,\n    reimbursementDraft: { description: '', amount: '' },\n    paymentMethod: resolvePaymentMethod(employeeCompensation?.paymentMethod, hasDirectDepositSetup),\n  }\n}\n\n/**\n * Resolves the default payment method, mirroring the stable component (#2683):\n * an employee with no direct deposit set up defaults to (and is forced to)\n * `Check`, even when the prepared payroll carried `Direct Deposit` or nothing.\n * `Historical` is treated as unset. The result is always `Direct Deposit` or\n * `Check` — never `Historical` — since those are the only values the update\n * endpoint accepts.\n */\nfunction resolvePaymentMethod(\n  paymentMethod: string | null | undefined,\n  hasDirectDepositSetup: boolean,\n): PayrollUpdatePaymentMethod {\n  if (paymentMethod === PayrollUpdatePaymentMethod.Check) return PayrollUpdatePaymentMethod.Check\n  if (paymentMethod === PayrollUpdatePaymentMethod.DirectDeposit && hasDirectDepositSetup) {\n    return PayrollUpdatePaymentMethod.DirectDeposit\n  }\n  return hasDirectDepositSetup\n    ? PayrollUpdatePaymentMethod.DirectDeposit\n    : PayrollUpdatePaymentMethod.Check\n}\n\nfunction originalTotals<T extends { jobUuid?: string; name?: string }>(\n  compensations: T[] | undefined,\n  selectTotal: (compensation: T) => string | null | undefined,\n): Map<string, string> {\n  const totals = new Map<string, string>()\n  for (const compensation of compensations ?? []) {\n    if (!compensation.jobUuid || !compensation.name) continue\n    totals.set(`${compensation.jobUuid}|${compensation.name}`, selectTotal(compensation) ?? '')\n  }\n  return totals\n}\n\n// Precision of the per-workweek values being summed: dollar amounts carry cents,\n// hours up to six places.\nconst AMOUNT_DECIMALS = 2\nconst HOURS_DECIMALS = 6\n\n/**\n * Sums per-workweek input values in integer minor units, then scales back.\n *\n * @remarks\n * Each value is already bounded to `decimals` places, so scaling it to an\n * integer (cents for amounts, millionths for hours) and summing those integers\n * is exact. Float-accumulating the decimals directly and rounding at the end\n * would instead leak binary error into the wire value (e.g. `0.1 + 0.2` →\n * `\"0.30000000000000004\"`), which the payroll API should never receive.\n */\nfunction sumWeekValues(\n  weekMap: Record<string, string>,\n  workweeks: NormalizedWorkweek[],\n  decimals: number,\n): string {\n  const factor = 10 ** decimals\n  const totalMinorUnits = workweeks.reduce((total, workweek) => {\n    const value = parseFloat(weekMap[workweek.startDate] ?? '0') || 0\n    return total + Math.round(value * factor)\n  }, 0)\n  return String(totalMinorUnits / factor)\n}\n\n/**\n * Builds the `PayrollUpdate` employee-compensation payload from form values.\n *\n * @remarks\n * When the pay period spans a single workweek (or the employee isn't split by\n * workweek), totals are sent without `breakdowns`. When split, each hourly and\n * additional-earning line is decided independently — per line, not per job\n * (the API models breakdowns on each compensation line, not as a per-job\n * all-or-nothing unit):\n *\n * - A fully-filled line (every workweek cell has a value) sends `breakdowns`\n *   tiling every workweek exactly, with the total equal to the sum of the\n *   per-week values.\n * - An entirely blank line sends nothing for it — no `breakdowns`, no\n *   fabricated `0`, no fabricated total — leaving it as the flat, untouched\n *   value it already was.\n * - A partial line (some but not all cells filled) can never reach this\n *   function: {@link createPayrollEditEmployeeSchema}'s per-row check blocks\n *   submit until every cell in a touched row is filled.\n *\n * @param formData - Current parsed form values.\n * @param employeeCompensation - The prepared compensation, for identifying metadata (`version`, `employeeUuid`).\n * @param workweeks - Normalized workweeks for the pay period.\n * @param payrollCategory - The payroll category, gating itemized vs. off-cycle reimbursements.\n * @param isOvertimeEligible - Whether the employee is overtime-eligible (nonexempt family).\n * @param withOvertime - The single, form-wide overtime-mode flag. Gates splitting alongside `isOvertimeEligible` and `workweeks.length > 1`; when `false`, every line submits its flat (collapsed) value regardless of eligibility.\n * @returns The employee-compensation entry for the `PayrollUpdate` request body.\n * @internal\n */\nexport function buildPayrollUpdateEmployeeCompensation(\n  formData: PayrollEditEmployeeFormOutputs,\n  employeeCompensation: PayrollEmployeeCompensationsType | undefined,\n  workweeks: NormalizedWorkweek[],\n  payrollCategory: PayrollCategory,\n  isOvertimeEligible: boolean,\n  withOvertime: boolean,\n): PayrollUpdateEmployeeCompensations {\n  // Breakdowns are emitted only when the line is actually split by workweek:\n  // multiple workweeks, an overtime-eligible employee, and `withOvertime` on.\n  // This must match the field builder's gate so what renders and what submits\n  // never drift.\n  const isSplit = workweeks.length > 1 && isOvertimeEligible && withOvertime\n  const hasValue = (value: string | undefined) => value != null && value !== ''\n  const originalHours = originalTotals(\n    employeeCompensation?.hourlyCompensations,\n    comp => comp.hours,\n  )\n  const originalAmounts = originalTotals(\n    employeeCompensation?.fixedCompensations,\n    comp => comp.amount,\n  )\n  const isRowFilled = (weekMap: Record<string, string>) =>\n    workweeks.every(workweek => hasValue(weekMap[workweek.startDate]))\n  const collapsedValue = (\n    jobUuid: string,\n    name: string,\n    weekMap: Record<string, string>,\n    originals: Map<string, string>,\n  ) => {\n    const single = weekMap[workweeks[0]?.startDate ?? '']\n    return hasValue(single) ? single! : (originals.get(`${jobUuid}|${name}`) ?? '0')\n  }\n\n  const hourlyCompensations = Object.entries(formData.hours).flatMap(([jobUuid, names]) =>\n    Object.entries(names).flatMap(([name, weekMap]) => {\n      if (!isSplit) {\n        return [{ jobUuid, name, hours: collapsedValue(jobUuid, name, weekMap, originalHours) }]\n      }\n      if (!isRowFilled(weekMap)) return []\n      return [\n        {\n          jobUuid,\n          name,\n          hours: sumWeekValues(weekMap, workweeks, HOURS_DECIMALS),\n          breakdowns: workweeks.map(workweek => ({\n            startDate: new RFCDate(workweek.startDate),\n            endDate: new RFCDate(workweek.endDate),\n            hours: weekMap[workweek.startDate]!,\n          })),\n        },\n      ]\n    }),\n  )\n\n  const breakdownEarnings = Object.entries(formData.additionalEarnings).flatMap(\n    ([jobUuid, names]) =>\n      Object.entries(names).flatMap(([name, weekMap]) => {\n        if (!isSplit) {\n          return [\n            { jobUuid, name, amount: collapsedValue(jobUuid, name, weekMap, originalAmounts) },\n          ]\n        }\n        if (!isRowFilled(weekMap)) return []\n        return [\n          {\n            jobUuid,\n            name,\n            amount: sumWeekValues(weekMap, workweeks, AMOUNT_DECIMALS),\n            breakdowns: workweeks.map(workweek => ({\n              startDate: new RFCDate(workweek.startDate),\n              endDate: new RFCDate(workweek.endDate),\n              amount: weekMap[workweek.startDate]!,\n            })),\n          },\n        ]\n      }),\n  )\n\n  // Non-overtime earnings never carry breakdowns; they are sent as flat totals.\n  const flatEarnings = Object.entries(formData.other).flatMap(([jobUuid, names]) =>\n    Object.entries(names).map(([name, amount]) => ({\n      jobUuid,\n      name,\n      amount: hasValue(amount) ? amount : (originalAmounts.get(`${jobUuid}|${name}`) ?? '0'),\n    })),\n  )\n\n  const fixedCompensations = [...breakdownEarnings, ...flatEarnings]\n\n  const isDismissal = payrollCategory === PayrollCategory.Dismissal\n  const paidTimeOff = Object.entries(formData.timeOff).map(([name, value]) => ({\n    name,\n    hours: value || '0',\n    ...(isDismissal && formData.finalPayout[name] != null\n      ? { finalPayoutUnusedHoursInput: formData.finalPayout[name] || '0' }\n      : {}),\n  }))\n\n  const usesItemizedReimbursements = !isOffCyclePayroll(payrollCategory)\n\n  return {\n    employeeUuid: employeeCompensation?.employeeUuid,\n    version: employeeCompensation?.version as string | undefined,\n    excluded: employeeCompensation?.excluded,\n    memo: employeeCompensation?.memo || undefined,\n    ...(formData.paymentMethod ? { paymentMethod: formData.paymentMethod } : {}),\n    hourlyCompensations,\n    fixedCompensations,\n    paidTimeOff,\n    ...(usesItemizedReimbursements\n      ? { reimbursements: cleanupReimbursements(formData.reimbursements) }\n      : {}),\n  }\n}\n"],"names":["normalizeWorkweeks","workweeks","payPeriod","normalized","week","SDKInternalError","collectOvertimeEarningNames","earningTypeList","names","earningType","resolveEditableFixedCompensations","existingFixedCompensations","fixedCompensationTypes","primaryJobUuid","flsaStatus","merged","FlsaStatus","compensationType","name","EXCLUDED_ADDITIONAL_EARNINGS","entry","a","b","hasExistingOvertimeHours","hourlyCompensations","compensation","COMPENSATION_NAME_OVERTIME","COMPENSATION_NAME_DOUBLE_OVERTIME","lineBreakdownsMatchWorkweeks","breakdowns","breakdown","workweek","hasBreakdownsMatchingWorkweeks","formatAmountInput","value","parsed","formatSeededTotal","formatted","buildWeekMap","total","isSplit","firstWorkweekStart","weekMap","index","derivePayrollEditEmployeeDefaults","employeeCompensation","hasDirectDepositSetup","overtimeEarningNames","isOvertimeEligible","withOvertime","fixedCompensations","hours","jobHours","additionalEarnings","other","jobEarnings","jobOther","timeOff","finalPayout","reimbursements","reimbursement","resolvePaymentMethod","paymentMethod","PayrollUpdatePaymentMethod","originalTotals","compensations","selectTotal","totals","AMOUNT_DECIMALS","HOURS_DECIMALS","sumWeekValues","decimals","factor","totalMinorUnits","buildPayrollUpdateEmployeeCompensation","formData","payrollCategory","hasValue","originalHours","comp","originalAmounts","isRowFilled","collapsedValue","jobUuid","originals","single","RFCDate","breakdownEarnings","flatEarnings","amount","isDismissal","PayrollCategory","paidTimeOff","usesItemizedReimbursements","isOffCyclePayroll","cleanupReimbursements"],"mappings":"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"}

package/dist/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeSchema.js

@@ -0,0 +1,63 @@
+import { z as e } from "zod";
+import { PayrollUpdatePaymentMethod as i } from "@gusto/embedded-api/models/components/payrollupdate";
+const f = [
+  i.DirectDeposit,
+  i.Check
+], R = f.map((r) => ({ value: r, label: r })), a = {
+  NEGATIVE_AMOUNT: "NEGATIVE_AMOUNT",
+  REIMBURSEMENT_AMOUNT: "REIMBURSEMENT_AMOUNT",
+  REQUIRED_WORKWEEK: "REQUIRED_WORKWEEK"
+}, p = /^\d+(\.\d+)?$/, t = e.string().refine((r) => r === "" || p.test(r), {
+  message: a.NEGATIVE_AMOUNT
+}), M = e.object({
+  uuid: e.string().nullable().optional(),
+  description: e.string(),
+  amount: e.string(),
+  recurring: e.boolean().optional()
+}), A = e.object({
+  description: e.string(),
+  amount: e.string().refine((r) => parseFloat(r) > 0, {
+    message: a.REIMBURSEMENT_AMOUNT
+  })
+});
+function c(r, o, E) {
+  for (const [d, m] of Object.entries(o))
+    for (const [u, g] of Object.entries(m)) {
+      const n = Object.entries(g);
+      if (!(n.length <= 1 || !n.some(([, s]) => s !== "")))
+        for (const [s, l] of n)
+          l === "" && r.addIssue({
+            code: e.ZodIssueCode.custom,
+            message: a.REQUIRED_WORKWEEK,
+            path: [E, d, u, s]
+          });
+    }
+}
+function b() {
+  return e.object({
+    hours: e.record(e.string(), e.record(e.string(), e.record(e.string(), t))),
+    additionalEarnings: e.record(
+      e.string(),
+      e.record(e.string(), e.record(e.string(), t))
+    ),
+    other: e.record(e.string(), e.record(e.string(), t)),
+    timeOff: e.record(e.string(), t),
+    finalPayout: e.record(e.string(), t),
+    reimbursements: e.array(M),
+    // Binding shape only — the draft is validated against `reimbursementDraftSchema`
+    // at save time, not by the main resolver, so a half-filled draft never blocks
+    // the payroll submit.
+    reimbursementDraft: e.object({ description: e.string(), amount: e.string() }),
+    paymentMethod: e.enum(i).optional()
+  }).superRefine((r, o) => {
+    c(o, r.hours, "hours"), c(o, r.additionalEarnings, "additionalEarnings");
+  });
+}
+export {
+  R as PAYMENT_METHOD_OPTIONS,
+  f as PAYMENT_METHOD_VALUES,
+  a as PayrollEditEmployeeErrorCodes,
+  b as createPayrollEditEmployeeSchema,
+  A as reimbursementDraftSchema
+};
+//# sourceMappingURL=payrollEditEmployeeSchema.js.map

package/dist/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"payrollEditEmployeeSchema.js","sources":["../../../../../../src/components/Payroll/PayrollEditEmployee/shared/usePayrollEditEmployeeForm/payrollEditEmployeeSchema.ts"],"sourcesContent":["import { z } from 'zod'\nimport { PayrollUpdatePaymentMethod } from '@gusto/embedded-api/models/components/payrollupdate'\n\n/**\n * Payment-method option values, in display order. The hook publishes these on\n * `fieldsMetadata.paymentMethod` via `withOptions`; the UI supplies the\n * translated labels through `getOptionLabel`.\n *\n * @internal\n */\nexport const PAYMENT_METHOD_VALUES = [\n  PayrollUpdatePaymentMethod.DirectDeposit,\n  PayrollUpdatePaymentMethod.Check,\n] as const\n\n/** @internal */\nexport const PAYMENT_METHOD_OPTIONS = PAYMENT_METHOD_VALUES.map(value => ({ value, label: value }))\n\n/**\n * Validation error codes produced by the payroll edit-employee schema.\n *\n * @public\n */\nexport const PayrollEditEmployeeErrorCodes = {\n  NEGATIVE_AMOUNT: 'NEGATIVE_AMOUNT',\n  REIMBURSEMENT_AMOUNT: 'REIMBURSEMENT_AMOUNT',\n  REQUIRED_WORKWEEK: 'REQUIRED_WORKWEEK',\n} as const\n\n/**\n * Union of validation error codes emitted by the payroll edit-employee schema.\n *\n * @public\n */\nexport type PayrollEditEmployeeErrorCode =\n  (typeof PayrollEditEmployeeErrorCodes)[keyof typeof PayrollEditEmployeeErrorCodes]\n\n// A plain, non-negative decimal: one or more digits with an optional fractional\n// part. Deliberately strict — `parseFloat` would accept \"5ea\" (→ 5), \"Infinity\",\n// and \"1e3\", any of which would silently corrupt the amount downstream.\nconst NON_NEGATIVE = /^\\d+(\\.\\d+)?$/\n\n// Hours and amounts are entered as strings. Blank is allowed (it means \"not\n// provided\" — see the submit rule), but any provided value must be a valid,\n// non-negative number.\nconst nonNegativeAmount = z.string().refine(value => value === '' || NON_NEGATIVE.test(value), {\n  message: PayrollEditEmployeeErrorCodes.NEGATIVE_AMOUNT,\n})\n\n// Committed reimbursement rows are presentational passthrough: they hold data\n// that was already validated when its draft was saved (or came from the server),\n// so the amount is a plain string here. All reimbursement validation lives in\n// `reimbursementDraftSchema` below, mirroring the legacy editor.\nconst reimbursementSchema = z.object({\n  uuid: z.string().nullable().optional(),\n  description: z.string(),\n  amount: z.string(),\n  recurring: z.boolean().optional(),\n})\n\n/**\n * The single reimbursement validation schema: the \"add reimbursement\" draft row.\n * Amount must be a number greater than zero, matching the legacy editor's\n * inline validation. The hook validates the draft against this before committing\n * it to the presentational `reimbursements` list.\n *\n * @internal\n */\nexport const reimbursementDraftSchema = z.object({\n  description: z.string(),\n  amount: z.string().refine(value => parseFloat(value) > 0, {\n    message: PayrollEditEmployeeErrorCodes.REIMBURSEMENT_AMOUNT,\n  }),\n})\n\n// A \"row\" is one job+name line's week map (`{ [workweekStart]: amount }`). A\n// collapsed (non-split) row always has exactly one key, so `entries.length <= 1`\n// makes this a no-op for collapsed rows — only a split row (multiple workweek\n// keys) can be \"partial.\" See the module-level remarks on {@link createPayrollEditEmployeeSchema}.\nfunction addRequiredWorkweekIssues(\n  ctx: z.RefinementCtx,\n  section: Record<string, Record<string, Record<string, string>>>,\n  sectionKey: 'hours' | 'additionalEarnings',\n): void {\n  for (const [jobUuid, names] of Object.entries(section)) {\n    for (const [name, weekMap] of Object.entries(names)) {\n      const entries = Object.entries(weekMap)\n      if (entries.length <= 1) continue\n      const hasAnyValue = entries.some(([, value]) => value !== '')\n      if (!hasAnyValue) continue\n      for (const [workweekStart, value] of entries) {\n        if (value === '') {\n          ctx.addIssue({\n            code: z.ZodIssueCode.custom,\n            message: PayrollEditEmployeeErrorCodes.REQUIRED_WORKWEEK,\n            path: [sectionKey, jobUuid, name, workweekStart],\n          })\n        }\n      }\n    }\n  }\n}\n\n/**\n * Builds the Zod schema for the payroll edit-employee form.\n *\n * @remarks\n * Overtime-affecting values are keyed by workweek internally: hours and\n * additional earnings are job-then-name-then-workweekStart records, so the\n * single-workweek (or not-yet-split) case is just the degenerate one-key form\n * of the multi-workweek shape. Non-overtime earnings (other) are flat\n * job-then-name-to-amount records with no per-workweek breakdown, since they do\n * not feed the blended rate. Time off and final payout are keyed by\n * compensation name. This keeps one schema and one submit path.\n *\n * A `superRefine` enforces per-row completeness on `hours` and\n * `additionalEarnings`: once any workweek cell in a job+name row is filled, every\n * other cell in that row must be filled too, surfaced per empty cell as\n * {@link PayrollEditEmployeeErrorCodes.REQUIRED_WORKWEEK}. A row with nothing\n * filled is left alone (still submittable as untouched). This needs no\n * workweek/split context passed in — it's purely structural on whatever keys a\n * row happens to have, which is why a collapsed row (always exactly one key)\n * can never trigger it.\n *\n * @returns The Zod schema validating {@link PayrollEditEmployeeFormData}.\n * @internal\n */\nexport function createPayrollEditEmployeeSchema() {\n  return z\n    .object({\n      hours: z.record(z.string(), z.record(z.string(), z.record(z.string(), nonNegativeAmount))),\n      additionalEarnings: z.record(\n        z.string(),\n        z.record(z.string(), z.record(z.string(), nonNegativeAmount)),\n      ),\n      other: z.record(z.string(), z.record(z.string(), nonNegativeAmount)),\n      timeOff: z.record(z.string(), nonNegativeAmount),\n      finalPayout: z.record(z.string(), nonNegativeAmount),\n      reimbursements: z.array(reimbursementSchema),\n      // Binding shape only — the draft is validated against `reimbursementDraftSchema`\n      // at save time, not by the main resolver, so a half-filled draft never blocks\n      // the payroll submit.\n      reimbursementDraft: z.object({ description: z.string(), amount: z.string() }),\n      paymentMethod: z.enum(PayrollUpdatePaymentMethod).optional(),\n    })\n    .superRefine((data, ctx) => {\n      addRequiredWorkweekIssues(ctx, data.hours, 'hours')\n      addRequiredWorkweekIssues(ctx, data.additionalEarnings, 'additionalEarnings')\n    })\n}\n\n/**\n * Shape of the values managed by the payroll edit-employee form.\n *\n * @public\n */\nexport type PayrollEditEmployeeFormData = z.infer<\n  ReturnType<typeof createPayrollEditEmployeeSchema>\n>\n\n/**\n * Validated values produced by the payroll edit-employee form on submit.\n *\n * @internal\n */\nexport type PayrollEditEmployeeFormOutputs = PayrollEditEmployeeFormData\n\n/**\n * A single reimbursement row in {@link PayrollEditEmployeeFormData}.\n *\n * @public\n */\nexport type ReimbursementFormEntry = PayrollEditEmployeeFormData['reimbursements'][number]\n"],"names":["PAYMENT_METHOD_VALUES","PayrollUpdatePaymentMethod","PAYMENT_METHOD_OPTIONS","value","PayrollEditEmployeeErrorCodes","NON_NEGATIVE","nonNegativeAmount","z","reimbursementSchema","reimbursementDraftSchema","addRequiredWorkweekIssues","ctx","section","sectionKey","jobUuid","names","name","weekMap","entries","workweekStart","createPayrollEditEmployeeSchema","data"],"mappings":";;AAUO,MAAMA,IAAwB;AAAA,EACnCC,EAA2B;AAAA,EAC3BA,EAA2B;AAC7B,GAGaC,IAAyBF,EAAsB,IAAI,CAAAG,OAAU,EAAE,OAAAA,GAAO,OAAOA,IAAQ,GAOrFC,IAAgC;AAAA,EAC3C,iBAAiB;AAAA,EACjB,sBAAsB;AAAA,EACtB,mBAAmB;AACrB,GAaMC,IAAe,iBAKfC,IAAoBC,EAAE,OAAA,EAAS,OAAO,CAAAJ,MAASA,MAAU,MAAME,EAAa,KAAKF,CAAK,GAAG;AAAA,EAC7F,SAASC,EAA8B;AACzC,CAAC,GAMKI,IAAsBD,EAAE,OAAO;AAAA,EACnC,MAAMA,EAAE,OAAA,EAAS,SAAA,EAAW,SAAA;AAAA,EAC5B,aAAaA,EAAE,OAAA;AAAA,EACf,QAAQA,EAAE,OAAA;AAAA,EACV,WAAWA,EAAE,QAAA,EAAU,SAAA;AACzB,CAAC,GAUYE,IAA2BF,EAAE,OAAO;AAAA,EAC/C,aAAaA,EAAE,OAAA;AAAA,EACf,QAAQA,EAAE,OAAA,EAAS,OAAO,CAAAJ,MAAS,WAAWA,CAAK,IAAI,GAAG;AAAA,IACxD,SAASC,EAA8B;AAAA,EAAA,CACxC;AACH,CAAC;AAMD,SAASM,EACPC,GACAC,GACAC,GACM;AACN,aAAW,CAACC,GAASC,CAAK,KAAK,OAAO,QAAQH,CAAO;AACnD,eAAW,CAACI,GAAMC,CAAO,KAAK,OAAO,QAAQF,CAAK,GAAG;AACnD,YAAMG,IAAU,OAAO,QAAQD,CAAO;AAGtC,UAFI,EAAAC,EAAQ,UAAU,KAElB,CADgBA,EAAQ,KAAK,CAAC,CAAA,EAAGf,CAAK,MAAMA,MAAU,EAAE;AAE5D,mBAAW,CAACgB,GAAehB,CAAK,KAAKe;AACnC,UAAIf,MAAU,MACZQ,EAAI,SAAS;AAAA,YACX,MAAMJ,EAAE,aAAa;AAAA,YACrB,SAASH,EAA8B;AAAA,YACvC,MAAM,CAACS,GAAYC,GAASE,GAAMG,CAAa;AAAA,UAAA,CAChD;AAAA,IAGP;AAEJ;AA0BO,SAASC,IAAkC;AAChD,SAAOb,EACJ,OAAO;AAAA,IACN,OAAOA,EAAE,OAAOA,EAAE,OAAA,GAAUA,EAAE,OAAOA,EAAE,OAAA,GAAUA,EAAE,OAAOA,EAAE,UAAUD,CAAiB,CAAC,CAAC;AAAA,IACzF,oBAAoBC,EAAE;AAAA,MACpBA,EAAE,OAAA;AAAA,MACFA,EAAE,OAAOA,EAAE,OAAA,GAAUA,EAAE,OAAOA,EAAE,OAAA,GAAUD,CAAiB,CAAC;AAAA,IAAA;AAAA,IAE9D,OAAOC,EAAE,OAAOA,EAAE,OAAA,GAAUA,EAAE,OAAOA,EAAE,OAAA,GAAUD,CAAiB,CAAC;AAAA,IACnE,SAASC,EAAE,OAAOA,EAAE,OAAA,GAAUD,CAAiB;AAAA,IAC/C,aAAaC,EAAE,OAAOA,EAAE,OAAA,GAAUD,CAAiB;AAAA,IACnD,gBAAgBC,EAAE,MAAMC,CAAmB;AAAA;AAAA;AAAA;AAAA,IAI3C,oBAAoBD,EAAE,OAAO,EAAE,aAAaA,EAAE,OAAA,GAAU,QAAQA,EAAE,OAAA,EAAO,CAAG;AAAA,IAC5E,eAAeA,EAAE,KAAKN,CAA0B,EAAE,SAAA;AAAA,EAAS,CAC5D,EACA,YAAY,CAACoB,GAAMV,MAAQ;AAC1B,IAAAD,EAA0BC,GAAKU,EAAK,OAAO,OAAO,GAClDX,EAA0BC,GAAKU,EAAK,oBAAoB,oBAAoB;AAAA,EAC9E,CAAC;AACL;"}