@open-mercato/core 0.7.1-develop.7178.1.ab93fbaf4e → 0.7.1-develop.7180.1.9717fbbb43

package/dist/modules/staff/backend/staff/time-tracking/settings/page.js

@@ -0,0 +1,546 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { InjectionSpot } from "@open-mercato/ui/backend/injection/InjectionSpot";
+import { extensionPoints } from "@open-mercato/core/modules/staff/extension-points";
+import * as React from "react";
+import { AlertTriangle, History, Info, Save } from "lucide-react";
+import { Page, PageBody, PageHeader } from "@open-mercato/ui/backend/Page";
+import { Alert, AlertDescription, AlertTitle } from "@open-mercato/ui/primitives/alert";
+import { Button } from "@open-mercato/ui/primitives/button";
+import { Card, CardContent, CardHeader, CardTitle } from "@open-mercato/ui/primitives/card";
+import { Input } from "@open-mercato/ui/primitives/input";
+import { Label } from "@open-mercato/ui/primitives/label";
+import { SegmentedControl, SegmentedControlItem } from "@open-mercato/ui/primitives/segmented-control";
+import { SwitchField } from "@open-mercato/ui/primitives/switch-field";
+import { Spinner } from "@open-mercato/ui/primitives/spinner";
+import { ErrorMessage, LoadingMessage } from "@open-mercato/ui/backend/detail";
+import { apiCall } from "@open-mercato/ui/backend/utils/apiCall";
+import { useGuardedMutation } from "@open-mercato/ui/backend/injection/useGuardedMutation";
+import { useConfirmDialog } from "@open-mercato/ui/backend/confirm-dialog";
+import { useBackendChrome } from "@open-mercato/ui/backend/BackendChromeProvider";
+import { flash } from "@open-mercato/ui/backend/FlashMessages";
+import { hasFeature } from "@open-mercato/shared/security/features";
+import { useT } from "@open-mercato/shared/lib/i18n/context";
+import { useOrganizationScopeVersion } from "@open-mercato/shared/lib/frontend/useOrganizationScope";
+import { createLogger } from "@open-mercato/shared/lib/logger";
+import { formatDuration } from "../../../../lib/time-tracking/duration.js";
+import { contributedTimeTrackingSettingKeys } from "../../../../lib/time-tracking/settingKeys.js";
+import {
+  ROUNDING_UNIT_OPTIONS,
+  buildRoundingExamples,
+  draftRounding,
+  formatSignedMinutes,
+  isSettingsDraftDirty,
+  settingsDraftErrors,
+  toSettingsDraft,
+  toSettingsPayload
+} from "../../../../lib/time-tracking-ui/timeTrackingSettingsForm.js";
+const logger = createLogger("staff").child({ component: "time-tracking/settings" });
+const SETTINGS_API = "/api/staff/timesheets/settings";
+const IMPACT_API = "/api/staff/timesheets/settings/rounding-impact";
+const REAPPLY_API = "/api/staff/timesheets/settings/reapply-rounding";
+const MANAGE_FEATURE = "staff.timesheets.settings.manage";
+const MUTATION_CONTEXT_ID = "staff.time_tracking.settings";
+const RESOURCE_KIND = "staff.timesheets.settings";
+const RESOURCE_ID = "time_tracking";
+const IMPACT_DEBOUNCE_MS = 350;
+const TIME_TRACKING_SETTINGS_MODULE_ID = "staff.time_tracking";
+const EMPTY_CONTRIBUTED_SETTINGS = {};
+function TimeTrackingSettingsPage() {
+  const t = useT();
+  const { payload } = useBackendChrome();
+  const scopeVersion = useOrganizationScopeVersion();
+  const { confirm, ConfirmDialogElement } = useConfirmDialog();
+  const canManage = hasFeature(payload?.grantedFeatures, MANAGE_FEATURE);
+  const [baseline, setBaseline] = React.useState(null);
+  const [draft, setDraft] = React.useState(null);
+  const [isLoading, setIsLoading] = React.useState(true);
+  const [loadError, setLoadError] = React.useState(null);
+  const [isSaving, setIsSaving] = React.useState(false);
+  const [isReapplying, setIsReapplying] = React.useState(false);
+  const [impact, setImpact] = React.useState(null);
+  const [impactState, setImpactState] = React.useState("idle");
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: MUTATION_CONTEXT_ID,
+    blockedMessage: t("staff.time_tracking.settings.saveError", "Failed to save the settings.")
+  });
+  const loadSettings = React.useCallback(async () => {
+    setIsLoading(true);
+    setLoadError(null);
+    try {
+      const call = await apiCall(SETTINGS_API);
+      if (!call.ok || !call.result) {
+        setLoadError(t("staff.time_tracking.settings.loadError", "Failed to load the settings."));
+        return;
+      }
+      const next = toSettingsDraft(call.result);
+      setBaseline(next);
+      setDraft(next);
+    } catch (err) {
+      logger.error("time tracking settings load failed", { err });
+      setLoadError(t("staff.time_tracking.settings.loadError", "Failed to load the settings."));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [t]);
+  React.useEffect(() => {
+    void loadSettings();
+  }, [loadSettings, scopeVersion]);
+  const rounding = draft ? draftRounding(draft) : null;
+  const roundingUnit = rounding?.unitMinutes ?? null;
+  const roundingDirection = rounding?.direction ?? null;
+  React.useEffect(() => {
+    if (roundingUnit === null || roundingDirection === null) return;
+    let cancelled = false;
+    setImpactState("loading");
+    const timer = setTimeout(() => {
+      void (async () => {
+        try {
+          const call = await apiCall(
+            `${IMPACT_API}?unitMinutes=${roundingUnit}&direction=${roundingDirection}`
+          );
+          if (cancelled) return;
+          if (!call.ok || !call.result) {
+            setImpactState("error");
+            return;
+          }
+          setImpact(call.result);
+          setImpactState("idle");
+        } catch (err) {
+          if (cancelled) return;
+          logger.error("rounding impact preview failed", { err });
+          setImpactState("error");
+        }
+      })();
+    }, IMPACT_DEBOUNCE_MS);
+    return () => {
+      cancelled = true;
+      clearTimeout(timer);
+    };
+  }, [roundingUnit, roundingDirection, scopeVersion]);
+  const patchDraft = React.useCallback((patch) => {
+    setDraft((current) => current ? { ...current, ...patch } : current);
+  }, []);
+  const fieldErrors = draft ? settingsDraftErrors(draft) : [];
+  const isDirty = draft && baseline ? isSettingsDraftDirty(draft, baseline) : false;
+  const setContributedSetting = React.useCallback((id, value) => {
+    setDraft(
+      (current) => current ? { ...current, contributed: { ...current.contributed, [id]: value } } : current
+    );
+  }, []);
+  const contributedValues = draft?.contributed ?? EMPTY_CONTRIBUTED_SETTINGS;
+  const settingsInjectionContext = React.useMemo(
+    () => ({
+      moduleId: TIME_TRACKING_SETTINGS_MODULE_ID,
+      canManage,
+      keys: contributedTimeTrackingSettingKeys(),
+      values: contributedValues,
+      setValue: setContributedSetting
+    }),
+    [canManage, contributedValues, setContributedSetting]
+  );
+  const canSave = canManage && isDirty && fieldErrors.length === 0 && !isSaving;
+  const handleSave = React.useCallback(async () => {
+    if (!draft) return;
+    const body = toSettingsPayload(draft);
+    if (!body) return;
+    setIsSaving(true);
+    try {
+      const call = await runMutation({
+        operation: () => apiCall(SETTINGS_API, {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(body)
+        }),
+        context: {
+          formId: MUTATION_CONTEXT_ID,
+          resourceKind: RESOURCE_KIND,
+          resourceId: RESOURCE_ID,
+          retryLastMutation
+        },
+        mutationPayload: body
+      });
+      if (!call.ok || !call.result) {
+        flash(t("staff.time_tracking.settings.saveError", "Failed to save the settings."), "error");
+        return;
+      }
+      const saved = toSettingsDraft(call.result);
+      setBaseline(saved);
+      setDraft(saved);
+      flash(t("staff.time_tracking.settings.saved", "Settings saved."), "success");
+    } catch (err) {
+      logger.error("time tracking settings save failed", { err });
+      flash(t("staff.time_tracking.settings.saveError", "Failed to save the settings."), "error");
+    } finally {
+      setIsSaving(false);
+    }
+  }, [draft, retryLastMutation, runMutation, t]);
+  const handleReapply = React.useCallback(async () => {
+    const candidateCount = impact?.projected.entryCount ?? 0;
+    const confirmed = await confirm({
+      title: t("staff.time_tracking.settings.retro.confirmTitle", "Reapply rounding to existing entries?"),
+      text: t(
+        "staff.time_tracking.settings.retro.confirmText",
+        "Rounded time will be recomputed on existing entries using the saved rule. Entries locked in closed reports are never changed."
+      ),
+      confirmText: t("staff.time_tracking.settings.retro.cta", "Reapply to existing entries")
+    });
+    if (!confirmed) return;
+    setIsReapplying(true);
+    try {
+      const call = await runMutation({
+        operation: () => apiCall(REAPPLY_API, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({})
+        }),
+        context: {
+          formId: MUTATION_CONTEXT_ID,
+          resourceKind: RESOURCE_KIND,
+          resourceId: RESOURCE_ID,
+          retryLastMutation
+        },
+        mutationPayload: { action: "reapply-rounding", candidateCount }
+      });
+      if (!call.ok) {
+        flash(t("staff.time_tracking.settings.retro.error", "Failed to start the recalculation."), "error");
+        return;
+      }
+      if (!call.result?.progressJobId) {
+        flash(t("staff.time_tracking.settings.retro.nothing", "There is nothing to recalculate."), "info");
+        return;
+      }
+      flash(
+        t(
+          "staff.time_tracking.settings.retro.queued",
+          "Recalculating rounded time on {count} entries. Progress is shown in the top bar.",
+          { count: call.result.candidateCount }
+        ),
+        "success"
+      );
+    } catch (err) {
+      logger.error("reapply rounding request failed", { err });
+      flash(t("staff.time_tracking.settings.retro.error", "Failed to start the recalculation."), "error");
+    } finally {
+      setIsReapplying(false);
+    }
+  }, [confirm, impact, retryLastMutation, runMutation, t]);
+  const examples = rounding ? buildRoundingExamples(rounding) : [];
+  const ruleLabel = React.useMemo(() => {
+    if (!rounding) return "";
+    if (rounding.unitMinutes === 0) {
+      return t("staff.time_tracking.settings.impact.rule.none", "no rounding");
+    }
+    return rounding.direction === "up" ? t("staff.time_tracking.settings.impact.rule.up", "{unit} min up", { unit: rounding.unitMinutes }) : t("staff.time_tracking.settings.impact.rule.nearest", "{unit} min to nearest", {
+      unit: rounding.unitMinutes
+    });
+  }, [rounding, t]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsxs(Page, { children: [
+      /* @__PURE__ */ jsx(PageHeader, { title: t("staff.time_tracking.settings.title", "Module settings") }),
+      /* @__PURE__ */ jsx(PageBody, { children: /* @__PURE__ */ jsx(LoadingMessage, { label: t("staff.time_tracking.settings.loading", "Loading settings\u2026") }) })
+    ] });
+  }
+  if (loadError || !draft) {
+    return /* @__PURE__ */ jsxs(Page, { children: [
+      /* @__PURE__ */ jsx(PageHeader, { title: t("staff.time_tracking.settings.title", "Module settings") }),
+      /* @__PURE__ */ jsx(PageBody, { children: /* @__PURE__ */ jsx(
+        ErrorMessage,
+        {
+          label: loadError ?? t("staff.time_tracking.settings.loadError", "Failed to load the settings."),
+          action: /* @__PURE__ */ jsx(Button, { type: "button", variant: "outline", onClick: () => void loadSettings(), children: t("staff.time_tracking.settings.retry", "Try again") })
+        }
+      ) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs(Page, { children: [
+    /* @__PURE__ */ jsx(
+      PageHeader,
+      {
+        title: t("staff.time_tracking.settings.title", "Module settings"),
+        description: t(
+          "staff.time_tracking.settings.subtitle",
+          "Rules shared by all customers and projects"
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxs(PageBody, { children: [
+      /* @__PURE__ */ jsxs("div", { className: "grid gap-6 lg:grid-cols-[minmax(0,2fr)_minmax(0,1fr)]", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-6", children: [
+          /* @__PURE__ */ jsxs(Card, { children: [
+            /* @__PURE__ */ jsxs(CardHeader, { children: [
+              /* @__PURE__ */ jsx(CardTitle, { children: t("staff.time_tracking.settings.rounding.title", "Time rounding") }),
+              /* @__PURE__ */ jsx("p", { className: "text-sm text-muted-foreground", children: t(
+                "staff.time_tracking.settings.rounding.description",
+                "Applies to all projects. The rounded value is the one cost is calculated from."
+              ) })
+            ] }),
+            /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-col gap-4", children: [
+              /* @__PURE__ */ jsxs("div", { className: "grid gap-4 sm:grid-cols-2", children: [
+                /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+                  /* @__PURE__ */ jsx(Label, { children: t("staff.time_tracking.settings.rounding.unit", "Unit") }),
+                  /* @__PURE__ */ jsx(
+                    SegmentedControl,
+                    {
+                      value: String(draft.roundingUnitMinutes),
+                      onValueChange: (value) => {
+                        const parsed = Number(value);
+                        if (!ROUNDING_UNIT_OPTIONS.includes(parsed)) return;
+                        patchDraft({ roundingUnitMinutes: parsed });
+                      },
+                      disabled: !canManage,
+                      "aria-label": t("staff.time_tracking.settings.rounding.unit", "Unit"),
+                      children: ROUNDING_UNIT_OPTIONS.map((unit) => /* @__PURE__ */ jsx(SegmentedControlItem, { value: String(unit), children: unit === 0 ? t("staff.time_tracking.settings.rounding.unit.none", "None") : t("staff.time_tracking.settings.rounding.unit.minutes", "{count} min", {
+                        count: unit
+                      }) }, unit))
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+                  /* @__PURE__ */ jsx(Label, { children: t("staff.time_tracking.settings.rounding.direction", "Direction") }),
+                  /* @__PURE__ */ jsxs(
+                    SegmentedControl,
+                    {
+                      value: draft.roundingDirection,
+                      onValueChange: (value) => {
+                        if (value !== "up" && value !== "nearest") return;
+                        patchDraft({ roundingDirection: value });
+                      },
+                      disabled: !canManage || draft.roundingUnitMinutes === 0,
+                      "aria-label": t("staff.time_tracking.settings.rounding.direction", "Direction"),
+                      children: [
+                        /* @__PURE__ */ jsx(SegmentedControlItem, { value: "up", children: t("staff.time_tracking.settings.rounding.direction.up", "Up") }),
+                        /* @__PURE__ */ jsx(SegmentedControlItem, { value: "nearest", children: t("staff.time_tracking.settings.rounding.direction.nearest", "To nearest") })
+                      ]
+                    }
+                  )
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs(Alert, { status: "information", icon: /* @__PURE__ */ jsx(Info, { "aria-hidden": "true" }), children: [
+                /* @__PURE__ */ jsx(AlertTitle, { children: t("staff.time_tracking.settings.rounding.examples.title", "Examples at the current setting") }),
+                /* @__PURE__ */ jsx(AlertDescription, { children: /* @__PURE__ */ jsx("span", { className: "font-mono text-sm", "data-testid": "rounding-examples", children: examples.map((example) => `${example.rawLabel} \u2192 ${example.roundedLabel}`).join(" \xB7 ") }) })
+              ] }),
+              /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2 rounded-md border border-border p-4", children: [
+                /* @__PURE__ */ jsx("span", { className: "text-sm font-medium", children: t(
+                  "staff.time_tracking.settings.retro.title",
+                  "Apply retroactively to existing entries"
+                ) }),
+                /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: t(
+                  "staff.time_tracking.settings.retro.hint",
+                  "Saving changes new entries only. Recalculating existing ones is a separate, explicit action \u2014 and it never changes entries locked in closed reports."
+                ) }),
+                /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsxs(
+                  Button,
+                  {
+                    type: "button",
+                    variant: "outline",
+                    onClick: () => void handleReapply(),
+                    disabled: !canManage || isReapplying || isDirty,
+                    "data-testid": "reapply-rounding",
+                    children: [
+                      isReapplying ? /* @__PURE__ */ jsx(Spinner, { className: "size-4" }) : /* @__PURE__ */ jsx(History, { className: "size-4", "aria-hidden": "true" }),
+                      t("staff.time_tracking.settings.retro.cta", "Reapply to existing entries")
+                    ]
+                  }
+                ) }),
+                isDirty ? /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: t(
+                  "staff.time_tracking.settings.retro.saveFirst",
+                  "Save the rule first \u2014 the recalculation uses the saved rule, not the one on screen."
+                ) }) : null
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Card, { children: [
+            /* @__PURE__ */ jsx(CardHeader, { children: /* @__PURE__ */ jsx(CardTitle, { children: t("staff.time_tracking.settings.defaults.title", "Entry defaults") }) }),
+            /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-col gap-4", children: [
+              /* @__PURE__ */ jsx(
+                SwitchField,
+                {
+                  label: t("staff.time_tracking.settings.defaults.billable", "New entries are billable"),
+                  description: t(
+                    "staff.time_tracking.settings.defaults.billableHint",
+                    "A project can override this."
+                  ),
+                  checked: draft.defaultsBillable,
+                  onCheckedChange: (value) => patchDraft({ defaultsBillable: value === true }),
+                  disabled: !canManage
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                SwitchField,
+                {
+                  label: t(
+                    "staff.time_tracking.settings.defaults.chainStart",
+                    "Start = end of the previous entry"
+                  ),
+                  description: t(
+                    "staff.time_tracking.settings.defaults.chainStartHint",
+                    "A suggestion when adding another entry on the same day."
+                  ),
+                  checked: draft.defaultsChainStartFromPreviousEnd,
+                  onCheckedChange: (value) => patchDraft({ defaultsChainStartFromPreviousEnd: value === true }),
+                  disabled: !canManage
+                }
+              ),
+              /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+                /* @__PURE__ */ jsx(Label, { htmlFor: "time-tracking-daily-hours", children: t("staff.time_tracking.settings.targets.dailyHours", "Daily hours target") }),
+                /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                  /* @__PURE__ */ jsx(
+                    Input,
+                    {
+                      id: "time-tracking-daily-hours",
+                      className: "max-w-28",
+                      inputMode: "decimal",
+                      value: draft.dailyHoursText,
+                      onChange: (event) => patchDraft({ dailyHoursText: event.target.value }),
+                      disabled: !canManage,
+                      "aria-invalid": fieldErrors.includes("dailyHours")
+                    }
+                  ),
+                  /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground", children: t("staff.time_tracking.settings.targets.hoursUnit", "h") })
+                ] }),
+                /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: t(
+                  "staff.time_tracking.settings.targets.dailyHoursHint",
+                  "Scales the load bars in the timesheet. Leave empty to turn targets off."
+                ) }),
+                fieldErrors.includes("dailyHours") ? /* @__PURE__ */ jsx("span", { className: "text-xs text-status-error-text", children: t(
+                  "staff.time_tracking.settings.targets.dailyHoursError",
+                  "Enter a number of hours between 0 and 24, or leave the field empty."
+                ) }) : null
+              ] })
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Card, { children: [
+            /* @__PURE__ */ jsx(CardHeader, { children: /* @__PURE__ */ jsx(CardTitle, { children: t("staff.time_tracking.settings.warnings.title", "Warnings") }) }),
+            /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-col gap-4", children: [
+              /* @__PURE__ */ jsx(
+                SwitchField,
+                {
+                  label: t("staff.time_tracking.settings.warnings.overlap", "Warn about overlapping entries"),
+                  description: t("staff.time_tracking.settings.warnings.overlapHint", "A warning, not a block."),
+                  checked: draft.warningsOverlap,
+                  onCheckedChange: (value) => patchDraft({ warningsOverlap: value === true }),
+                  disabled: !canManage
+                }
+              ),
+              /* @__PURE__ */ jsx(
+                SwitchField,
+                {
+                  label: t("staff.time_tracking.settings.warnings.runningTimer", "Remind about a running timer"),
+                  description: t(
+                    "staff.time_tracking.settings.warnings.runningTimerHint",
+                    "An unobtrusive reminder when leaving the module and after 8 h of continuous running."
+                  ),
+                  checked: draft.warningsRunningTimer,
+                  onCheckedChange: (value) => patchDraft({ warningsRunningTimer: value === true }),
+                  disabled: !canManage
+                }
+              )
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs(Card, { children: [
+            /* @__PURE__ */ jsx(CardHeader, { children: /* @__PURE__ */ jsx(CardTitle, { children: t("staff.time_tracking.settings.access.title", "Project access") }) }),
+            /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-col gap-2", children: [
+              /* @__PURE__ */ jsx(Label, { htmlFor: "time-tracking-grace-days", children: t(
+                "staff.time_tracking.settings.access.graceDays",
+                "Access grace period after an assignment ends"
+              ) }),
+              /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+                /* @__PURE__ */ jsx(
+                  Input,
+                  {
+                    id: "time-tracking-grace-days",
+                    className: "max-w-28",
+                    inputMode: "numeric",
+                    value: draft.assignmentGraceDaysText,
+                    onChange: (event) => patchDraft({ assignmentGraceDaysText: event.target.value }),
+                    disabled: !canManage,
+                    "aria-invalid": fieldErrors.includes("assignmentGraceDays")
+                  }
+                ),
+                /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground", children: t("staff.time_tracking.settings.access.daysUnit", "days") })
+              ] }),
+              /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: t(
+                "staff.time_tracking.settings.access.graceDaysHint",
+                "A member keeps access to a project for this many days after their assignment end date, so the last week of work can still be logged and corrected. 0 ends access on the end date itself."
+              ) }),
+              fieldErrors.includes("assignmentGraceDays") ? /* @__PURE__ */ jsx("span", { className: "text-xs text-status-error-text", children: t(
+                "staff.time_tracking.settings.access.graceDaysError",
+                "Enter a whole number of days between 0 and 365."
+              ) }) : null
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(
+            InjectionSpot,
+            {
+              spotId: extensionPoints.hosts.timeTrackingSettingsSections.spotId,
+              context: settingsInjectionContext,
+              data: draft
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-6", children: [
+          /* @__PURE__ */ jsxs(Alert, { status: "warning", icon: /* @__PURE__ */ jsx(AlertTriangle, { "aria-hidden": "true" }), children: [
+            /* @__PURE__ */ jsx(AlertTitle, { children: t("staff.time_tracking.settings.impact.title", "Changing rounding affects amounts") }),
+            /* @__PURE__ */ jsx(AlertDescription, { children: impactState === "loading" && !impact ? /* @__PURE__ */ jsx("span", { className: "text-sm", children: t("staff.time_tracking.settings.impact.loading", "Calculating the impact\u2026") }) : impactState === "error" ? /* @__PURE__ */ jsx("span", { className: "text-sm", children: t("staff.time_tracking.settings.impact.error", "The impact preview is unavailable.") }) : impact && impact.projected.entryCount > 0 ? /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-1", "data-testid": "rounding-impact", children: [
+              /* @__PURE__ */ jsx("span", { className: "text-sm", children: t(
+                "staff.time_tracking.settings.impact.body",
+                "With the current {count} entries from the last {days} days, {rule} gives {rounded} ({delta} against raw time). Closed reports stay unchanged.",
+                {
+                  count: impact.projected.entryCount,
+                  days: impact.windowDays,
+                  rule: ruleLabel,
+                  rounded: formatDuration(impact.projected.roundedMinutes, "clock"),
+                  delta: formatSignedMinutes(impact.projected.deltaMinutes)
+                }
+              ) }),
+              impact.lockedEntryCount > 0 ? /* @__PURE__ */ jsx("span", { className: "text-xs", children: t(
+                "staff.time_tracking.settings.impact.locked",
+                "{count} entries in the window are locked in closed reports and are excluded.",
+                { count: impact.lockedEntryCount }
+              ) }) : null
+            ] }) : /* @__PURE__ */ jsx("span", { className: "text-sm", children: t(
+              "staff.time_tracking.settings.impact.empty",
+              "There are no unlocked entries in the last {days} days to project against.",
+              { days: impact?.windowDays ?? 90 }
+            ) }) })
+          ] }),
+          /* @__PURE__ */ jsxs(Card, { children: [
+            /* @__PURE__ */ jsx(CardHeader, { children: /* @__PURE__ */ jsx(CardTitle, { children: t("staff.time_tracking.settings.scope.title", "Settings scope") }) }),
+            /* @__PURE__ */ jsxs(CardContent, { className: "flex flex-col gap-2", children: [
+              /* @__PURE__ */ jsx("span", { className: "text-sm", children: t(
+                "staff.time_tracking.settings.scope.body",
+                "These rules are global \u2014 they cannot be set per customer or per project."
+              ) }),
+              /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: t(
+                "staff.time_tracking.settings.scope.hint",
+                "The rate and currency stay at project level, and a rate override stays at entry level."
+              ) })
+            ] })
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "mt-6 flex items-center justify-end gap-2", children: [
+        /* @__PURE__ */ jsx(
+          Button,
+          {
+            type: "button",
+            variant: "ghost",
+            onClick: () => setDraft(baseline),
+            disabled: !isDirty || isSaving,
+            children: t("staff.time_tracking.settings.actions.cancel", "Cancel")
+          }
+        ),
+        /* @__PURE__ */ jsxs(Button, { type: "button", onClick: () => void handleSave(), disabled: !canSave, "data-testid": "save-settings", children: [
+          isSaving ? /* @__PURE__ */ jsx(Spinner, { className: "size-4" }) : /* @__PURE__ */ jsx(Save, { className: "size-4", "aria-hidden": "true" }),
+          t("staff.time_tracking.settings.actions.save", "Save")
+        ] })
+      ] })
+    ] }),
+    ConfirmDialogElement
+  ] });
+}
+export {
+  TimeTrackingSettingsPage as default
+};
+//# sourceMappingURL=page.js.map