@gusto/embedded-react-sdk 0.55.7 → 0.56.0

package/dist/components/Payroll/PayrollConfiguration/PayrollConfiguration.js

@@ -1,119 +1,132 @@
-import { jsx as d, jsxs as Pe, Fragment as Ue } from "react/jsx-runtime";
-import { useState as P, useRef as B, useMemo as _, useEffect as j } from "react";
-import { usePayrollsGetSuspense as he } from "@gusto/embedded-api/react-query/payrollsGet";
-import { payrollsCalculate as ge } from "@gusto/embedded-api/funcs/payrollsCalculate";
-import { useGustoEmbeddedContext as Le } from "@gusto/embedded-api/react-query/_context";
-import { useTranslation as Se } from "react-i18next";
-import { usePayrollsUpdateMutation as we } from "@gusto/embedded-api/react-query/payrollsUpdate";
-import { usePayrollsCalculateGrossUpMutation as Ae } from "@gusto/embedded-api/react-query/payrollsCalculateGrossUp";
-import { usePayrollsGetBlockersSuspense as Re } from "@gusto/embedded-api/react-query/payrollsGetBlockers";
-import { payrollSubmitHandler as _e } from "../PayrollBlocker/payrollHelpers.js";
-import { PayrollOverview as De } from "../PayrollOverview/PayrollOverview.js";
-import { PayrollConfigurationPresentation as Ee } from "./PayrollConfigurationPresentation.js";
-import { usePayrollConfigurationData as Oe } from "./usePayrollConfigurationData.js";
-import { isGrossUpEligible as be, getGrossUpTargetCompensationName as xe } from "./grossUpHelpers.js";
-import { isCalculatingStatus as v, useCalculationPoll as ke } from "./useCalculationPoll.js";
-import { BaseComponent as Te } from "../../Base/Base.js";
+import { jsx as y, jsxs as we, Fragment as Re } from "react/jsx-runtime";
+import { useState as d, useRef as O, useMemo as b, useEffect as H } from "react";
+import { usePayrollsGetSuspense as Ee } from "@gusto/embedded-api/react-query/payrollsGet";
+import { payrollsCalculate as _e } from "@gusto/embedded-api/funcs/payrollsCalculate";
+import { useGustoEmbeddedContext as De } from "@gusto/embedded-api/react-query/_context";
+import { useTranslation as Oe } from "react-i18next";
+import { usePayrollsUpdateMutation as be } from "@gusto/embedded-api/react-query/payrollsUpdate";
+import { usePayrollsCalculateGrossUpMutation as xe } from "@gusto/embedded-api/react-query/payrollsCalculateGrossUp";
+import { usePayrollsGetBlockersSuspense as Te } from "@gusto/embedded-api/react-query/payrollsGetBlockers";
+import { payrollSubmitHandler as ke } from "../PayrollBlocker/payrollHelpers.js";
+import { PayrollOverview as Ge } from "../PayrollOverview/PayrollOverview.js";
+import { PayrollConfigurationPresentation as Ne } from "./PayrollConfigurationPresentation.js";
+import { usePayrollConfigurationData as Ye } from "./usePayrollConfigurationData.js";
+import { isGrossUpEligible as Fe, getGrossUpTargetCompensationName as Me } from "./grossUpHelpers.js";
+import { isCalculatingStatus as K, useCalculationPoll as Be } from "./useCalculationPoll.js";
+import { BaseComponent as je } from "../../Base/Base.js";
 import { componentEvents as i } from "../../../shared/constants.js";
-import { useComponentDictionary as Ge, useI18n as Ne } from "../../../i18n/I18n.js";
-import { useBase as Ye } from "../../Base/useBase.js";
-import { useDateFormatter as Me } from "../../../hooks/useDateFormatter.js";
-import { SDKInternalError as F } from "../../../types/sdkError.js";
-import { GrossUpModal as Be } from "../GrossUpModal/GrossUpModal.js";
-function co(t) {
-  return /* @__PURE__ */ d(Te, { ...t, children: /* @__PURE__ */ d(je, { ...t, children: t.children }) });
+import { useComponentDictionary as ve, useI18n as We } from "../../../i18n/I18n.js";
+import { useBase as qe } from "../../Base/useBase.js";
+import { useDateFormatter as He } from "../../../hooks/useDateFormatter.js";
+import { SDKInternalError as V } from "../../../types/sdkError.js";
+import { GrossUpModal as Ke } from "../GrossUpModal/GrossUpModal.js";
+function Co(t) {
+  return /* @__PURE__ */ y(je, { ...t, children: /* @__PURE__ */ y(Ve, { ...t, children: t.children }) });
 }
-const je = ({
+const Ve = ({
   onEvent: t,
-  companyId: n,
+  companyId: c,
   payrollId: l,
-  dictionary: W,
-  alerts: q,
-  withReimbursements: D = !0
+  dictionary: $,
+  alerts: J,
+  withReimbursements: x = !0,
+  className: T
 }) => {
-  Ge("Payroll.PayrollConfiguration", W), Ne("Payroll.PayrollConfiguration");
-  const { t: c } = Se("Payroll.PayrollConfiguration"), { baseSubmitHandler: y } = Ye(), p = Me(), [E, O] = P(!1), u = B(!1), K = Le(), H = _(
+  ve("Payroll.PayrollConfiguration", $), We("Payroll.PayrollConfiguration");
+  const { t: n } = Oe("Payroll.PayrollConfiguration"), { baseSubmitHandler: f, setError: P } = qe(), p = He(), [k, G] = d(!1), u = O(!1), h = O(!1), z = De(), Q = b(
     () => ({
-      companyId: n,
+      companyId: c,
       payrollId: l,
       include: ["taxes", "benefits", "deductions", "payroll_status_meta"]
     }),
-    [n, l]
-  ), { data: s, refetch: V } = he(H), J = _(
+    [c, l]
+  ), { data: s, refetch: X } = Ee(Q), Z = b(
     () => s.payrollShow?.employeeCompensations?.filter((e) => e.excluded).map((e) => e.employeeUuid).filter(Boolean) ?? [],
     [s.payrollShow?.employeeCompensations]
   );
-  v(s.payrollShow?.processingRequest) && (u.current = !0);
-  const { data: z } = Re({
-    companyUuid: n
-  }), b = (z.payrollBlockers ?? []).map((e) => ({
+  K(s.payrollShow?.processingRequest) && (u.current = !0);
+  const { data: I } = Te({
+    companyUuid: c
+  }), N = (I.payrollBlockers ?? []).map((e) => ({
     key: e.key,
     message: e.message
-  })), [Q, U] = P(b), { start: h, isPolling: f } = ke({
-    refetch: V,
+  })), [ee, U] = d(N), [oe, L] = d(!1), Y = () => {
+    t(i.RUN_PAYROLL_PROCESSING_FAILED), L(!0), P({
+      category: "internal_error",
+      message: `${n("alerts.processingFailed.label")}. ${n("alerts.processingFailed.message")}`,
+      fieldErrors: []
+    });
+  }, te = (e) => {
+    Y(), e?.calculatedAt == null && (u.current = !1);
+  }, { start: A, isPolling: C } = Be({
+    refetch: X,
     onCalculated: (e) => {
       t(i.RUN_PAYROLL_CALCULATED, {
         payrollId: l,
         alert: {
           type: "success",
-          title: c("alerts.progressSaved"),
+          title: n("alerts.progressSaved"),
           alertKey: "progressSaved"
         },
         payPeriod: e?.payPeriod
       }), U([]);
     },
-    onProcessingFailed: (e) => {
-      t(i.RUN_PAYROLL_PROCESSING_FAILED), e?.calculatedAt == null && (u.current = !1);
+    onProcessingFailed: te,
+    // Unlike a real processing failure, we never confirmed whether the calculation actually
+    // succeeded server-side, so this must not reset hasSeenCalculatingRef — doing so would
+    // re-arm prepare and risk wiping a calculation that may have genuinely completed.
+    onError: () => {
+      h.current = !0, Y();
     }
-  }), x = E || f || u.current, {
-    employeeDetails: X,
-    employeeCompensations: k,
-    paySchedule: Z,
-    payPeriod: $,
-    payrollCategory: g,
-    pagination: I,
-    isLoading: ee,
-    isAlreadyProcessed: L,
-    refetch: S
-  } = Oe({
-    companyId: n,
+  }), F = !oe && (k || C || u.current), {
+    employeeDetails: ae,
+    employeeCompensations: M,
+    paySchedule: re,
+    payPeriod: se,
+    payrollCategory: S,
+    pagination: le,
+    isLoading: ie,
+    isAlreadyProcessed: w,
+    refetch: R
+  } = Ye({
+    companyId: c,
     payrollId: l,
     // Don't prepare while calculating, or once we've seen it calculate. If the payroll was already
     // calculated when we opened (e.g. clicking Edit), we do prepare so it can be edited.
-    disablePrepare: f || E || u.current,
-    excludedEmployeeUuids: J
-  }), w = _(
+    disablePrepare: C || k || u.current,
+    excludedEmployeeUuids: Z
+  }), E = b(
     () => ({
       type: "error",
-      title: c("alerts.alreadyProcessed"),
+      title: n("alerts.alreadyProcessed"),
       alertKey: "alreadyProcessed"
     }),
-    [c]
-  ), A = B(!1);
-  j(() => {
-    if (!L) {
-      A.current = !1;
+    [n]
+  ), _ = O(!1);
+  H(() => {
+    if (!w) {
+      _.current = !1;
       return;
     }
-    A.current || (A.current = !0, t(i.RUN_PAYROLL_ALREADY_PROCESSED, {
+    _.current || (_.current = !0, t(i.RUN_PAYROLL_ALREADY_PROCESSED, {
       payrollId: l,
-      alert: w,
+      alert: E,
       payPeriod: s.payrollShow?.payPeriod
     }));
   }, [
-    L,
+    w,
     t,
     l,
-    w,
+    E,
     s.payrollShow?.payPeriod
   ]);
-  const { mutateAsync: T, isPending: oe } = we(), { mutateAsync: te } = Ae(), [m, G] = P(null), [ae, R] = P(!1), N = be(g), C = xe(g), re = (e) => {
-    G(e), R(!0), t(i.RUN_PAYROLL_GROSS_UP_SELECTED, { employeeUuid: e });
-  }, se = async (e) => {
+  const { mutateAsync: B, isPending: ne } = be(), { mutateAsync: ce } = xe(), [m, j] = d(null), [ue, D] = d(!1), v = Fe(S), g = Me(S), pe = (e) => {
+    j(e), D(!0), t(i.RUN_PAYROLL_GROSS_UP_SELECTED, { employeeUuid: e });
+  }, me = async (e) => {
     if (!m) return null;
     let o = null;
-    return await y(null, async () => {
-      o = (await te({
+    return await f(null, async () => {
+      o = (await ce({
         request: {
           payrollUuid: l,
           payrollGrossUpRequest: {
@@ -127,73 +140,73 @@ const je = ({
         employeeUuid: m
       });
     }), o;
-  }, le = async (e) => {
-    if (!m || !C)
-      throw new F(
+  }, de = async (e) => {
+    if (!m || !g)
+      throw new V(
         "Unable to apply gross-up: missing employee or target compensation."
       );
-    const o = k.find((a) => a.employeeUuid === m);
+    const o = M.find((a) => a.employeeUuid === m);
     if (!o)
-      throw new F("Unable to apply gross-up: employee compensation not found.");
-    const r = o.fixedCompensations ?? [], de = r.some(
-      (a) => a.name?.toLowerCase() === C.toLowerCase()
-    ), M = r.map((a) => ({
+      throw new V("Unable to apply gross-up: employee compensation not found.");
+    const r = o.fixedCompensations ?? [], Ue = r.some(
+      (a) => a.name?.toLowerCase() === g.toLowerCase()
+    ), q = r.map((a) => ({
       name: a.name,
       jobUuid: a.jobUuid,
-      amount: a.name?.toLowerCase() === C.toLowerCase() ? e : "0"
+      amount: a.name?.toLowerCase() === g.toLowerCase() ? e : "0"
     }));
-    if (!de) {
+    if (!Ue) {
       const a = o.hourlyCompensations?.[0]?.jobUuid ?? r[0]?.jobUuid ?? "";
-      M.push({
-        name: C,
+      q.push({
+        name: g,
         jobUuid: a,
         amount: e
       });
     }
-    const ye = (o.hourlyCompensations ?? []).map((a) => ({
+    const Le = (o.hourlyCompensations ?? []).map((a) => ({
       name: a.name,
       jobUuid: a.jobUuid,
       hours: "0"
-    })), fe = (o.paidTimeOff ?? []).map((a) => ({
+    })), Ae = (o.paidTimeOff ?? []).map((a) => ({
       name: a.name,
       hours: "0"
-    })), Ce = Y({
+    })), Se = W({
       ...o,
-      fixedCompensations: M,
-      hourlyCompensations: ye,
-      paidTimeOff: fe
+      fixedCompensations: q,
+      hourlyCompensations: Le,
+      paidTimeOff: Ae
     });
-    await y({}, async () => {
-      const a = await T({
+    await f({}, async () => {
+      const a = await B({
         request: {
-          companyId: n,
+          companyId: c,
           payrollId: l,
           payrollUpdate: {
-            employeeCompensations: [{ ...Ce, excluded: !1 }]
+            employeeCompensations: [{ ...Se, excluded: !1 }]
           }
         }
       });
       t(i.RUN_PAYROLL_EMPLOYEE_SAVED, {
         payrollPrepared: a.payrollPrepared
-      }), await S();
-    }), G(null), R(!1);
-  }, ie = async (e) => {
+      }), await R();
+    }), j(null), D(!1);
+  }, ye = async (e) => {
     try {
-      await le(e);
+      await de(e);
     } catch {
     }
-  }, ne = async () => {
-    U([]), u.current = !0, await y({}, async () => {
-      const e = await _e(async () => {
-        O(!0);
+  }, fe = async () => {
+    U([]), L(!1), P(null), u.current = !0, await f({}, async () => {
+      const e = await ke(async () => {
+        G(!0);
         try {
-          const o = await ge(K, {
-            companyId: n,
+          const o = await _e(z, {
+            companyId: c,
             payrollId: l
           });
           if (!o.ok)
             throw o.error;
-          h({
+          A({
             baselineCalculatedAt: s.payrollShow?.calculatedAt?.getTime() ?? null,
             // We just submitted the payroll, so we haven't yet seen it return with the calculating status
             sawCalculatingThisPoll: !1
@@ -201,18 +214,18 @@ const je = ({
         } catch (o) {
           throw u.current = !1, o;
         } finally {
-          O(!1);
+          G(!1);
         }
       });
       !e.success && e.blockers.length > 0 && U(e.blockers);
     });
-  }, ce = (e) => {
+  }, Pe = (e) => {
     t(i.RUN_PAYROLL_EMPLOYEE_EDIT, {
       employeeId: e.uuid,
       firstName: e.firstName,
       lastName: e.lastName
     });
-  }, Y = (e) => {
+  }, W = (e) => {
     const { paymentMethod: o } = e;
     return {
       employeeUuid: e.employeeUuid,
@@ -225,13 +238,13 @@ const je = ({
       ...o && o !== "Historical" ? { paymentMethod: o } : {},
       memo: e.memo || void 0
     };
-  }, ue = async (e) => {
+  }, Ce = async (e) => {
     t(i.RUN_PAYROLL_EMPLOYEE_SKIP, {
       employeeId: e.employeeUuid
-    }), await y({}, async () => {
-      const o = Y(e), r = await T({
+    }), await f({}, async () => {
+      const o = W(e), r = await B({
         request: {
-          companyId: n,
+          companyId: c,
           payrollId: l,
           payrollUpdate: {
             employeeCompensations: [
@@ -242,31 +255,38 @@ const je = ({
       });
       t(i.RUN_PAYROLL_EMPLOYEE_SAVED, {
         payrollPrepared: r.payrollPrepared
-      }), await S();
+      }), await R();
     });
-  }, pe = () => {
+  }, ge = () => {
     t(i.RUN_PAYROLL_BLOCKERS_VIEW_ALL);
   };
-  j(() => {
-    f || v(s.payrollShow?.processingRequest) && h({
-      baselineCalculatedAt: s.payrollShow?.calculatedAt?.getTime() ?? null,
-      // We have seen the calculating status, which is why we're starting to poll now until it completes or fails.
-      sawCalculatingThisPoll: !0
-    });
+  H(() => {
+    if (!C) {
+      if (!K(s.payrollShow?.processingRequest)) {
+        h.current = !1;
+        return;
+      }
+      h.current || (L(!1), P(null), A({
+        baselineCalculatedAt: s.payrollShow?.calculatedAt?.getTime() ?? null,
+        // We have seen the calculating status, which is why we're starting to poll now until it completes or fails.
+        sawCalculatingThisPoll: !0
+      }));
+    }
   }, [
     s.payrollShow?.processingRequest,
     s.payrollShow?.calculatedAt,
-    f,
-    h
+    C,
+    A,
+    P
   ]);
-  const me = (() => {
+  const he = (() => {
     const e = s.payrollShow?.payrollStatusMeta;
     if (e?.payrollLate && e.initialCheckDate && e.expectedDebitTime && e.expectedCheckDate)
       return {
-        label: c("alerts.payrollLate", {
+        label: n("alerts.payrollLate", {
           initialCheckDate: p.formatShortWithWeekday(e.initialCheckDate)
         }),
-        content: c("alerts.payrollLateText", {
+        content: n("alerts.payrollLateText", {
           ...p.formatWithTime(e.expectedDebitTime),
           newCheckDate: p.formatShortWithWeekday(e.expectedCheckDate)
         }),
@@ -275,64 +295,66 @@ const je = ({
     const { payrollShow: r } = s;
     if (r?.checkDate && r.payrollDeadline)
       return {
-        label: c("alerts.directDepositDeadline", {
+        label: n("alerts.directDepositDeadline", {
           payDate: p.formatShortWithWeekday(r.checkDate),
           ...p.formatWithTime(r.payrollDeadline)
         }),
-        content: c("alerts.directDepositDeadlineText"),
+        content: n("alerts.directDepositDeadlineText"),
         variant: "info"
       };
   })();
-  return L ? /* @__PURE__ */ d(
-    De,
+  return w ? /* @__PURE__ */ y(
+    Ge,
     {
-      companyId: n,
+      className: T,
+      companyId: c,
       payrollId: l,
       onEvent: (o, r) => {
-        o === i.RUN_PAYROLL_CANCELLED && S(), t(o, r);
+        o === i.RUN_PAYROLL_CANCELLED && R(), t(o, r);
       },
-      withReimbursements: D,
-      alerts: [w]
+      withReimbursements: x,
+      alerts: [E]
     }
-  ) : /* @__PURE__ */ Pe(Ue, { children: [
-    /* @__PURE__ */ d(
-      Ee,
+  ) : /* @__PURE__ */ we(Re, { children: [
+    /* @__PURE__ */ y(
+      Ne,
       {
-        onCalculatePayroll: ne,
-        isCalculateDisabled: b.length > 0,
-        onEdit: ce,
-        onToggleExclude: ue,
-        onViewBlockers: pe,
-        employeeCompensations: k,
-        employeeDetails: X,
-        payPeriod: $,
-        paySchedule: Z,
-        payrollCategory: g,
-        alerts: q,
-        payrollAlert: me,
-        isPending: x || ee || oe,
-        isCalculating: x,
-        payrollBlockers: Q,
-        pagination: I,
-        withReimbursements: D,
-        grossUpEnabled: N,
-        onGrossUpSelect: re
+        className: T,
+        onCalculatePayroll: fe,
+        isCalculateDisabled: N.length > 0,
+        onEdit: Pe,
+        onToggleExclude: Ce,
+        onViewBlockers: ge,
+        employeeCompensations: M,
+        employeeDetails: ae,
+        payPeriod: se,
+        paySchedule: re,
+        payrollCategory: S,
+        alerts: J,
+        payrollAlert: he,
+        isPending: F || ie || ne,
+        isCalculating: F,
+        payrollBlockers: ee,
+        pagination: le,
+        withReimbursements: x,
+        grossUpEnabled: v,
+        onGrossUpSelect: pe
       }
     ),
-    N && /* @__PURE__ */ d(
-      Be,
+    v && /* @__PURE__ */ y(
+      Ke,
       {
-        isOpen: ae,
-        onCalculateGrossUp: se,
-        onApply: ie,
+        isOpen: ue,
+        onCalculateGrossUp: me,
+        onApply: ye,
         onCancel: () => {
-          R(!1);
+          D(!1);
         }
       }
     )
   ] });
 };
 export {
-  co as PayrollConfiguration
+  Co as PayrollConfiguration
 };
 //# sourceMappingURL=PayrollConfiguration.js.map