@gusto/embedded-react-sdk 0.55.5 → 0.55.6

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

@@ -1,198 +1,219 @@
-import { jsx as C, jsxs as Pe, Fragment as Ue } from "react/jsx-runtime";
-import { useState as f, useRef as D, useMemo as q, useEffect as O } from "react";
-import { usePayrollsGetSuspense as ge } from "@gusto/embedded-api/react-query/payrollsGet";
-import { payrollsCalculate as he } from "@gusto/embedded-api/funcs/payrollsCalculate";
+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 { PayrollProcessingRequestStatus as E } from "@gusto/embedded-api/models/components/payrollprocessingrequest";
 import { useTranslation as Se } from "react-i18next";
 import { usePayrollsUpdateMutation as we } from "@gusto/embedded-api/react-query/payrollsUpdate";
-import { usePayrollsCalculateGrossUpMutation as Re } from "@gusto/embedded-api/react-query/payrollsCalculateGrossUp";
-import { usePayrollsGetBlockersSuspense as Ae } from "@gusto/embedded-api/react-query/payrollsGetBlockers";
+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 Oe } from "./PayrollConfigurationPresentation.js";
-import { usePayrollConfigurationData as Ee } from "./usePayrollConfigurationData.js";
-import { isGrossUpEligible as Te, getGrossUpTargetCompensationName as xe } from "./grossUpHelpers.js";
-import { BaseComponent as be } from "../../Base/Base.js";
-import { componentEvents as l } from "../../../shared/constants.js";
-import { useComponentDictionary as ke, useI18n as Ge } from "../../../i18n/I18n.js";
-import { useBase as Ne } from "../../Base/useBase.js";
-import { useDateFormatter as Ye } from "../../../hooks/useDateFormatter.js";
-import { SDKInternalError as W } from "../../../types/sdkError.js";
-import { GrossUpModal as Me } from "../GrossUpModal/GrossUpModal.js";
-const v = (o) => o?.status === E.Calculating, Be = (o, n) => n != null && (o?.status === E.CalculateSuccess || o == null);
-function ut(o) {
-  return /* @__PURE__ */ C(be, { ...o, children: /* @__PURE__ */ C(Fe, { ...o, children: o.children }) });
+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 { 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 }) });
 }
-const Fe = ({
-  onEvent: o,
+const je = ({
+  onEvent: t,
   companyId: n,
-  payrollId: i,
-  dictionary: K,
-  alerts: H,
-  withReimbursements: T = !0
+  payrollId: l,
+  dictionary: W,
+  alerts: q,
+  withReimbursements: D = !0
 }) => {
-  ke("Payroll.PayrollConfiguration", K), Ge("Payroll.PayrollConfiguration");
-  const { t: c } = Se("Payroll.PayrollConfiguration"), { baseSubmitHandler: P } = Ne(), m = Ye(), [u, d] = f(!1), [x, b] = f(!1), g = D(null), p = D(!1), V = Le(), { data: a } = ge(
-    {
+  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 = _(
+    () => ({
       companyId: n,
-      payrollId: i,
+      payrollId: l,
       include: ["taxes", "benefits", "deductions", "payroll_status_meta"]
-    },
-    { refetchInterval: u ? 5e3 : !1 }
-  ), I = q(
-    () => a.payrollShow?.employeeCompensations?.filter((e) => e.excluded).map((e) => e.employeeUuid).filter(Boolean) ?? [],
-    [a.payrollShow?.employeeCompensations]
+    }),
+    [n, l]
+  ), { data: s, refetch: V } = he(H), J = _(
+    () => s.payrollShow?.employeeCompensations?.filter((e) => e.excluded).map((e) => e.employeeUuid).filter(Boolean) ?? [],
+    [s.payrollShow?.employeeCompensations]
   );
-  v(a.payrollShow?.processingRequest) && (p.current = !0);
-  const k = x || u || p.current, {
-    employeeDetails: J,
-    employeeCompensations: G,
-    paySchedule: z,
-    payPeriod: Q,
-    payrollCategory: h,
-    pagination: X,
-    isLoading: Z,
+  v(s.payrollShow?.processingRequest) && (u.current = !0);
+  const { data: z } = Re({
+    companyUuid: n
+  }), b = (z.payrollBlockers ?? []).map((e) => ({
+    key: e.key,
+    message: e.message
+  })), [Q, U] = P(b), { start: h, isPolling: f } = ke({
+    refetch: V,
+    onCalculated: (e) => {
+      t(i.RUN_PAYROLL_CALCULATED, {
+        payrollId: l,
+        alert: {
+          type: "success",
+          title: c("alerts.progressSaved"),
+          alertKey: "progressSaved"
+        },
+        payPeriod: e?.payPeriod
+      }), U([]);
+    },
+    onProcessingFailed: (e) => {
+      t(i.RUN_PAYROLL_PROCESSING_FAILED), e?.calculatedAt == null && (u.current = !1);
+    }
+  }), x = E || f || u.current, {
+    employeeDetails: X,
+    employeeCompensations: k,
+    paySchedule: Z,
+    payPeriod: $,
+    payrollCategory: g,
+    pagination: I,
+    isLoading: ee,
     isAlreadyProcessed: L,
     refetch: S
-  } = Ee({
+  } = Oe({
     companyId: n,
-    payrollId: i,
+    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: u || x || p.current,
-    excludedEmployeeUuids: I
-  }), w = q(
+    disablePrepare: f || E || u.current,
+    excludedEmployeeUuids: J
+  }), w = _(
     () => ({
       type: "error",
       title: c("alerts.alreadyProcessed"),
       alertKey: "alreadyProcessed"
     }),
     [c]
-  ), R = D(!1);
-  O(() => {
+  ), A = B(!1);
+  j(() => {
     if (!L) {
-      R.current = !1;
+      A.current = !1;
       return;
     }
-    R.current || (R.current = !0, o(l.RUN_PAYROLL_ALREADY_PROCESSED, {
-      payrollId: i,
+    A.current || (A.current = !0, t(i.RUN_PAYROLL_ALREADY_PROCESSED, {
+      payrollId: l,
       alert: w,
-      payPeriod: a.payrollShow?.payPeriod
+      payPeriod: s.payrollShow?.payPeriod
     }));
   }, [
     L,
-    o,
-    i,
+    t,
+    l,
     w,
-    a.payrollShow?.payPeriod
+    s.payrollShow?.payPeriod
   ]);
-  const { mutateAsync: N, isPending: $ } = we(), { mutateAsync: ee } = Re(), [y, Y] = f(null), [te, A] = f(!1), M = Te(h), U = xe(h), oe = (e) => {
-    Y(e), A(!0), o(l.RUN_PAYROLL_GROSS_UP_SELECTED, { employeeUuid: e });
-  }, ae = async (e) => {
-    if (!y) return null;
-    let t = null;
-    return await P(null, async () => {
-      t = (await ee({
+  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) => {
+    if (!m) return null;
+    let o = null;
+    return await y(null, async () => {
+      o = (await te({
         request: {
-          payrollUuid: i,
+          payrollUuid: l,
           payrollGrossUpRequest: {
-            employeeUuid: y,
+            employeeUuid: m,
             netPay: e.toString()
           }
         }
-      })).payrollGrossUpResponse?.grossUp ?? null, t && o(l.RUN_PAYROLL_GROSS_UP_CALCULATED, {
-        grossUp: t,
+      })).payrollGrossUpResponse?.grossUp ?? null, o && t(i.RUN_PAYROLL_GROSS_UP_CALCULATED, {
+        grossUp: o,
         netPay: e,
-        employeeUuid: y
+        employeeUuid: m
       });
-    }), t;
-  }, se = async (e) => {
-    if (!y || !U)
-      throw new W(
+    }), o;
+  }, le = async (e) => {
+    if (!m || !C)
+      throw new F(
         "Unable to apply gross-up: missing employee or target compensation."
       );
-    const t = G.find((s) => s.employeeUuid === y);
-    if (!t)
-      throw new W("Unable to apply gross-up: employee compensation not found.");
-    const r = t.fixedCompensations ?? [], de = r.some(
-      (s) => s.name?.toLowerCase() === U.toLowerCase()
-    ), j = r.map((s) => ({
-      name: s.name,
-      jobUuid: s.jobUuid,
-      amount: s.name?.toLowerCase() === U.toLowerCase() ? e : "0"
+    const o = k.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) => ({
+      name: a.name,
+      jobUuid: a.jobUuid,
+      amount: a.name?.toLowerCase() === C.toLowerCase() ? e : "0"
     }));
     if (!de) {
-      const s = t.hourlyCompensations?.[0]?.jobUuid ?? r[0]?.jobUuid ?? "";
-      j.push({
-        name: U,
-        jobUuid: s,
+      const a = o.hourlyCompensations?.[0]?.jobUuid ?? r[0]?.jobUuid ?? "";
+      M.push({
+        name: C,
+        jobUuid: a,
         amount: e
       });
     }
-    const ye = (t.hourlyCompensations ?? []).map((s) => ({
-      name: s.name,
-      jobUuid: s.jobUuid,
+    const ye = (o.hourlyCompensations ?? []).map((a) => ({
+      name: a.name,
+      jobUuid: a.jobUuid,
       hours: "0"
-    })), fe = (t.paidTimeOff ?? []).map((s) => ({
-      name: s.name,
+    })), fe = (o.paidTimeOff ?? []).map((a) => ({
+      name: a.name,
       hours: "0"
-    })), Ce = F({
-      ...t,
-      fixedCompensations: j,
+    })), Ce = Y({
+      ...o,
+      fixedCompensations: M,
       hourlyCompensations: ye,
       paidTimeOff: fe
     });
-    await P({}, async () => {
-      const s = await N({
+    await y({}, async () => {
+      const a = await T({
         request: {
           companyId: n,
-          payrollId: i,
+          payrollId: l,
           payrollUpdate: {
             employeeCompensations: [{ ...Ce, excluded: !1 }]
           }
         }
       });
-      o(l.RUN_PAYROLL_EMPLOYEE_SAVED, {
-        payrollPrepared: s.payrollPrepared
+      t(i.RUN_PAYROLL_EMPLOYEE_SAVED, {
+        payrollPrepared: a.payrollPrepared
       }), await S();
-    }), Y(null), A(!1);
-  }, re = async (e) => {
+    }), G(null), R(!1);
+  }, ie = async (e) => {
     try {
-      await se(e);
+      await le(e);
     } catch {
     }
-  }, { data: le } = Ae({
-    companyUuid: n
-  }), B = (le.payrollBlockers ?? []).map((e) => ({
-    key: e.key,
-    message: e.message
-  })), [ie, _] = f(B), ne = async () => {
-    _([]), p.current = !0, g.current = a.payrollShow?.calculatedAt?.getTime() ?? null, await P({}, async () => {
+  }, ne = async () => {
+    U([]), u.current = !0, await y({}, async () => {
       const e = await _e(async () => {
-        b(!0);
+        O(!0);
         try {
-          const t = await he(V, {
+          const o = await ge(K, {
             companyId: n,
-            payrollId: i
+            payrollId: l
+          });
+          if (!o.ok)
+            throw o.error;
+          h({
+            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
           });
-          if (!t.ok)
-            throw t.error;
-          d(!0);
+        } catch (o) {
+          throw u.current = !1, o;
         } finally {
-          b(!1);
+          O(!1);
         }
       });
-      !e.success && e.blockers.length > 0 && _(e.blockers);
+      !e.success && e.blockers.length > 0 && U(e.blockers);
     });
-  }, ue = (e) => {
-    o(l.RUN_PAYROLL_EMPLOYEE_EDIT, {
+  }, ce = (e) => {
+    t(i.RUN_PAYROLL_EMPLOYEE_EDIT, {
       employeeId: e.uuid,
       firstName: e.firstName,
       lastName: e.lastName
     });
-  }, F = (e) => {
-    const { paymentMethod: t } = e;
+  }, Y = (e) => {
+    const { paymentMethod: o } = e;
     return {
       employeeUuid: e.employeeUuid,
       version: e.version,
@@ -201,133 +222,117 @@ const Fe = ({
       hourlyCompensations: e.hourlyCompensations,
       paidTimeOff: e.paidTimeOff,
       deductions: e.deductions,
-      ...t && t !== "Historical" ? { paymentMethod: t } : {},
+      ...o && o !== "Historical" ? { paymentMethod: o } : {},
       memo: e.memo || void 0
     };
-  }, ce = async (e) => {
-    o(l.RUN_PAYROLL_EMPLOYEE_SKIP, {
+  }, ue = async (e) => {
+    t(i.RUN_PAYROLL_EMPLOYEE_SKIP, {
       employeeId: e.employeeUuid
-    }), await P({}, async () => {
-      const t = F(e), r = await N({
+    }), await y({}, async () => {
+      const o = Y(e), r = await T({
         request: {
           companyId: n,
-          payrollId: i,
+          payrollId: l,
           payrollUpdate: {
             employeeCompensations: [
-              { ...t, excluded: !t.excluded }
+              { ...o, excluded: !o.excluded }
             ]
           }
         }
       });
-      o(l.RUN_PAYROLL_EMPLOYEE_SAVED, {
+      t(i.RUN_PAYROLL_EMPLOYEE_SAVED, {
         payrollPrepared: r.payrollPrepared
       }), await S();
     });
   }, pe = () => {
-    o(l.RUN_PAYROLL_BLOCKERS_VIEW_ALL);
+    t(i.RUN_PAYROLL_BLOCKERS_VIEW_ALL);
   };
-  O(() => {
-    v(a.payrollShow?.processingRequest) && !u && (g.current = a.payrollShow?.calculatedAt?.getTime() ?? null, d(!0));
-    const e = a.payrollShow?.calculatedAt, t = e?.getTime() !== g.current;
-    u && t && Be(a.payrollShow?.processingRequest, e) && (o(l.RUN_PAYROLL_CALCULATED, {
-      payrollId: i,
-      alert: {
-        type: "success",
-        title: c("alerts.progressSaved"),
-        alertKey: "progressSaved"
-      },
-      payPeriod: a.payrollShow?.payPeriod
-    }), _([]), d(!1)), u && a.payrollShow?.processingRequest?.status === E.ProcessingFailed && (o(l.RUN_PAYROLL_PROCESSING_FAILED), d(!1), p.current = !1);
+  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
+    });
   }, [
-    a.payrollShow?.processingRequest?.status,
-    a.payrollShow?.calculatedAt,
-    u,
-    o,
-    c,
-    i
-  ]), O(() => {
-    if (!u) return;
-    const e = 180 * 1e3, t = setTimeout(() => {
-      o(l.RUN_PAYROLL_PROCESSING_FAILED), d(!1), p.current = !1;
-    }, e);
-    return () => {
-      clearTimeout(t);
-    };
-  }, [u, o]);
+    s.payrollShow?.processingRequest,
+    s.payrollShow?.calculatedAt,
+    f,
+    h
+  ]);
   const me = (() => {
-    const e = a.payrollShow?.payrollStatusMeta;
+    const e = s.payrollShow?.payrollStatusMeta;
     if (e?.payrollLate && e.initialCheckDate && e.expectedDebitTime && e.expectedCheckDate)
       return {
         label: c("alerts.payrollLate", {
-          initialCheckDate: m.formatShortWithWeekday(e.initialCheckDate)
+          initialCheckDate: p.formatShortWithWeekday(e.initialCheckDate)
         }),
         content: c("alerts.payrollLateText", {
-          ...m.formatWithTime(e.expectedDebitTime),
-          newCheckDate: m.formatShortWithWeekday(e.expectedCheckDate)
+          ...p.formatWithTime(e.expectedDebitTime),
+          newCheckDate: p.formatShortWithWeekday(e.expectedCheckDate)
         }),
         variant: "warning"
       };
-    const { payrollShow: r } = a;
+    const { payrollShow: r } = s;
     if (r?.checkDate && r.payrollDeadline)
       return {
         label: c("alerts.directDepositDeadline", {
-          payDate: m.formatShortWithWeekday(r.checkDate),
-          ...m.formatWithTime(r.payrollDeadline)
+          payDate: p.formatShortWithWeekday(r.checkDate),
+          ...p.formatWithTime(r.payrollDeadline)
         }),
         content: c("alerts.directDepositDeadlineText"),
         variant: "info"
       };
   })();
-  return L ? /* @__PURE__ */ C(
+  return L ? /* @__PURE__ */ d(
     De,
     {
       companyId: n,
-      payrollId: i,
-      onEvent: (t, r) => {
-        t === l.RUN_PAYROLL_CANCELLED && S(), o(t, r);
+      payrollId: l,
+      onEvent: (o, r) => {
+        o === i.RUN_PAYROLL_CANCELLED && S(), t(o, r);
       },
-      withReimbursements: T,
+      withReimbursements: D,
       alerts: [w]
     }
   ) : /* @__PURE__ */ Pe(Ue, { children: [
-    /* @__PURE__ */ C(
-      Oe,
+    /* @__PURE__ */ d(
+      Ee,
       {
         onCalculatePayroll: ne,
-        isCalculateDisabled: B.length > 0,
-        onEdit: ue,
-        onToggleExclude: ce,
+        isCalculateDisabled: b.length > 0,
+        onEdit: ce,
+        onToggleExclude: ue,
         onViewBlockers: pe,
-        employeeCompensations: G,
-        employeeDetails: J,
-        payPeriod: Q,
-        paySchedule: z,
-        payrollCategory: h,
-        alerts: H,
+        employeeCompensations: k,
+        employeeDetails: X,
+        payPeriod: $,
+        paySchedule: Z,
+        payrollCategory: g,
+        alerts: q,
         payrollAlert: me,
-        isPending: k || Z || $,
-        isCalculating: k,
-        payrollBlockers: ie,
-        pagination: X,
-        withReimbursements: T,
-        grossUpEnabled: M,
-        onGrossUpSelect: oe
+        isPending: x || ee || oe,
+        isCalculating: x,
+        payrollBlockers: Q,
+        pagination: I,
+        withReimbursements: D,
+        grossUpEnabled: N,
+        onGrossUpSelect: re
       }
     ),
-    M && /* @__PURE__ */ C(
-      Me,
+    N && /* @__PURE__ */ d(
+      Be,
       {
-        isOpen: te,
-        onCalculateGrossUp: ae,
-        onApply: re,
+        isOpen: ae,
+        onCalculateGrossUp: se,
+        onApply: ie,
         onCancel: () => {
-          A(!1);
+          R(!1);
         }
       }
     )
   ] });
 };
 export {
-  ut as PayrollConfiguration
+  co as PayrollConfiguration
 };
 //# sourceMappingURL=PayrollConfiguration.js.map