@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/entries/page.js

@@ -0,0 +1,981 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { extensionPoints } from "@open-mercato/core/modules/staff/extension-points";
+import * as React from "react";
+import { usePathname, useRouter, useSearchParams } from "next/navigation";
+import { Copy, Lock, Plus } from "lucide-react";
+import { Page, PageBody } from "@open-mercato/ui/backend/Page";
+import { DataTable } from "@open-mercato/ui/backend/DataTable";
+import { RowActions } from "@open-mercato/ui/backend/RowActions";
+import { Button } from "@open-mercato/ui/primitives/button";
+import { Checkbox } from "@open-mercato/ui/primitives/checkbox";
+import { StatusBadge } from "@open-mercato/ui/primitives/status-badge";
+import {
+  EntryFilterChips,
+  EntryFilterPresets,
+  matchActivePreset
+} from "../../../../lib/time-tracking-ui/EntryFilterBar.js";
+import {
+  apiCall,
+  apiCallOrThrow,
+  readApiResultOrThrow,
+  withScopedApiRequestHeaders
+} from "@open-mercato/ui/backend/utils/apiCall";
+import { deleteCrud, updateCrud } from "@open-mercato/ui/backend/utils/crud";
+import { buildOptimisticLockHeader } from "@open-mercato/ui/backend/utils/optimisticLock";
+import { surfaceRecordConflict } from "@open-mercato/ui/backend/conflicts";
+import { useGuardedMutation } from "@open-mercato/ui/backend/injection/useGuardedMutation";
+import { useBackendChrome } from "@open-mercato/ui/backend/BackendChromeProvider";
+import { useConfirmDialog } from "@open-mercato/ui/backend/confirm-dialog";
+import { flash } from "@open-mercato/ui/backend/FlashMessages";
+import { useOperationStore } from "@open-mercato/ui/backend/operations/store";
+import { formatCurrency } from "@open-mercato/ui/utils/format";
+import { deserializeOperationMetadata } from "@open-mercato/shared/lib/commands/operationMetadata";
+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 { TimeEntryDialog } from "../../../../lib/time-tracking-ui/TimeEntryDialog.js";
+import { TimeEntryDurationCell } from "../../../../lib/time-tracking-ui/TimeEntryDurationCell.js";
+import { TimeEntriesSummaryFooter } from "../../../../lib/time-tracking-ui/TimeEntriesSummaryFooter.js";
+import {
+  collectDirectoryIds,
+  currentWeekRange,
+  formatEntryClockRange,
+  formatEntryDay,
+  isEntryLockedError,
+  readCopyDayTargetConflict,
+  summarizeTimeEntries,
+  toTimeEntryListRow
+} from "../../../../lib/time-tracking-ui/timeEntryListData.js";
+import {
+  readRowItems,
+  shiftIsoDate,
+  todayIsoDate,
+  toProjectOption,
+  toTaskOption
+} from "../../../../lib/time-tracking-ui/timeEntryDialogState.js";
+import { formatDuration } from "../../../../lib/time-tracking/duration.js";
+const logger = createLogger("staff").child({ component: "time-tracking/entries" });
+const PAGE_SIZE = 50;
+const DIRECTORY_PAGE_SIZE = 100;
+const ENTRIES_API_PATH = "staff/timesheets/time-entries";
+const ENTRIES_API = `/api/${ENTRIES_API_PATH}`;
+const RATES_FEATURE = "staff.timesheets.rates.view";
+const MANAGE_OWN_FEATURE = "staff.timesheets.manage_own";
+const MANAGE_ALL_FEATURE = "staff.timesheets.manage_all";
+const DEEP_LINK_PARAMS = ["taskId", "ids"];
+const REPORTS_PATH = "/backend/staff/time-tracking/reports";
+const MUTATION_CONTEXT_ID = "staff.time_tracking.entriesList";
+const RESOURCE_KIND = "staff.timesheets.time_entry";
+function readUndoToken(response) {
+  const header = response?.headers?.get?.("x-om-operation") ?? null;
+  return deserializeOperationMetadata(header)?.undoToken ?? null;
+}
+async function loadDirectory(taskIds, projectIds) {
+  const taskTitles = /* @__PURE__ */ new Map();
+  const projectLabels = /* @__PURE__ */ new Map();
+  const requests = [];
+  if (taskIds.length > 0) {
+    const params = new URLSearchParams({ page: "1", pageSize: String(DIRECTORY_PAGE_SIZE), ids: taskIds.join(",") });
+    requests.push(
+      readApiResultOrThrow(`/api/staff/timesheets/tasks?${params.toString()}`, void 0, {
+        allowNullResult: true
+      }).then((payload) => {
+        for (const row of readRowItems(payload)) {
+          const option = toTaskOption(row);
+          if (option) taskTitles.set(option.id, option.title);
+        }
+      })
+    );
+  }
+  if (projectIds.length > 0) {
+    const params = new URLSearchParams({
+      page: "1",
+      pageSize: String(DIRECTORY_PAGE_SIZE),
+      ids: projectIds.join(",")
+    });
+    requests.push(
+      readApiResultOrThrow(
+        `/api/staff/timesheets/time-projects?${params.toString()}`,
+        void 0,
+        { allowNullResult: true }
+      ).then((payload) => {
+        for (const row of readRowItems(payload)) {
+          const option = toProjectOption(row);
+          if (!option) continue;
+          projectLabels.set(option.id, option.customerName ? `${option.customerName} \u2014 ${option.name}` : option.name);
+        }
+      })
+    );
+  }
+  await Promise.all(requests);
+  return { taskTitles, projectLabels };
+}
+function TimeTrackingEntriesPage() {
+  const t = useT();
+  const router = useRouter();
+  const pathname = usePathname();
+  const searchParams = useSearchParams();
+  const scopeVersion = useOrganizationScopeVersion();
+  const { payload } = useBackendChrome();
+  const canSeeMoney = hasFeature(payload?.grantedFeatures, RATES_FEATURE);
+  const canManage = hasFeature(payload?.grantedFeatures, MANAGE_OWN_FEATURE);
+  const canManageAll = hasFeature(payload?.grantedFeatures, MANAGE_ALL_FEATURE);
+  const { confirm, ConfirmDialogElement } = useConfirmDialog();
+  const deepLinkTaskId = searchParams?.get("taskId")?.trim() ?? "";
+  const deepLinkEntryIds = searchParams?.get("ids")?.trim() ?? "";
+  const defaultRange = React.useMemo(() => currentWeekRange(), []);
+  const [filterValues, setFilterValues] = React.useState(() => {
+    if (deepLinkTaskId) return { taskId: deepLinkTaskId };
+    if (deepLinkEntryIds) return { ids: deepLinkEntryIds };
+    return { period: { from: defaultRange.from, to: defaultRange.to } };
+  });
+  const [selfStaffMemberId, setSelfStaffMemberId] = React.useState(null);
+  const [projectOptions, setProjectOptions] = React.useState([]);
+  const [customerOptions, setCustomerOptions] = React.useState([]);
+  const [tagOptions, setTagOptions] = React.useState([]);
+  const [peopleOptions, setPeopleOptions] = React.useState([]);
+  const personSeededRef = React.useRef(Boolean(deepLinkTaskId || deepLinkEntryIds));
+  const [page, setPage] = React.useState(1);
+  const [sorting, setSorting] = React.useState([{ id: "date", desc: true }]);
+  const [rows, setRows] = React.useState([]);
+  const [total, setTotal] = React.useState(0);
+  const [totalIsCapped, setTotalIsCapped] = React.useState(false);
+  const [totalPages, setTotalPages] = React.useState(1);
+  const [isLoading, setIsLoading] = React.useState(true);
+  const [isRefreshing, setIsRefreshing] = React.useState(false);
+  const [reloadToken, setReloadToken] = React.useState(0);
+  const [selectedIds, setSelectedIds] = React.useState([]);
+  const [savingEntryId, setSavingEntryId] = React.useState(null);
+  const [dialogOpen, setDialogOpen] = React.useState(false);
+  const [dialogEntryId, setDialogEntryId] = React.useState(null);
+  const hasLoadedOnceRef = React.useRef(false);
+  const labels = React.useMemo(
+    () => ({
+      title: t("staff.time_tracking.entries.title", "Time entries"),
+      add: t("staff.time_tracking.entries.actions.add", "Add entry"),
+      copyDay: t("staff.time_tracking.entries.actions.copyDay", "Copy yesterday"),
+      duplicate: t("staff.time_tracking.entries.actions.duplicate", "Duplicate"),
+      delete: t("staff.time_tracking.entries.actions.delete", "Delete"),
+      showReport: t("staff.time_tracking.entries.actions.showReport", "Show the report"),
+      refresh: t("staff.time_tracking.entries.actions.refresh", "Refresh"),
+      columns: {
+        date: t("staff.time_tracking.entries.columns.date", "Date"),
+        task: t("staff.time_tracking.entries.columns.task", "Task / description"),
+        project: t("staff.time_tracking.entries.columns.project", "Project"),
+        clock: t("staff.time_tracking.entries.columns.clock", "Hours"),
+        duration: t("staff.time_tracking.entries.columns.duration", "Time"),
+        cost: t("staff.time_tracking.entries.columns.cost", "Cost")
+      },
+      selectAll: t("staff.time_tracking.entries.table.selectAll", "Select all entries"),
+      selectRow: t("staff.time_tracking.entries.table.selectRow", "Select entry"),
+      durationAria: t("staff.time_tracking.entries.table.durationAria", "Entry duration"),
+      noTask: t("staff.time_tracking.entries.table.noTask", "No task"),
+      empty: t("staff.time_tracking.entries.empty", "No time entries in this period."),
+      badges: {
+        locked: t("staff.time_tracking.entries.badges.locked", "locked"),
+        nonBillable: t("staff.time_tracking.entries.badges.nonBillable", "non-billable")
+      },
+      filters: {
+        period: t("staff.time_tracking.entries.filters.period", "Period"),
+        project: t("staff.time_tracking.entries.filters.project", "Project"),
+        customer: t("staff.time_tracking.entries.filters.customer", "Customer"),
+        person: t("staff.time_tracking.entries.filters.person", "Person"),
+        tag: t("staff.time_tracking.entries.filters.tag", "Tag"),
+        billable: t("staff.time_tracking.entries.filters.billable", "Billable"),
+        billableYes: t("staff.time_tracking.entries.filters.billableYes", "Billable only"),
+        billableNo: t("staff.time_tracking.entries.filters.billableNo", "Non-billable only"),
+        locked: t("staff.time_tracking.entries.filters.locked", "Report status"),
+        lockedYes: t("staff.time_tracking.entries.filters.lockedYes", "Locked in a report"),
+        lockedNo: t("staff.time_tracking.entries.filters.lockedNo", "Not yet reported"),
+        text: t("staff.time_tracking.entries.filters.text", "Description contains"),
+        task: t("staff.time_tracking.entries.filters.task", "Task"),
+        entry: t("staff.time_tracking.entries.filters.entry", "Entry"),
+        entrySelection: t("staff.time_tracking.entries.filters.entrySelection", "{count} entries"),
+        clearAll: t("staff.time_tracking.entries.filters.clearAll", "Clear all"),
+        remove: t("staff.time_tracking.entries.filters.remove", "Remove filter {name}")
+      },
+      presets: {
+        mineWeek: t("staff.time_tracking.entries.presets.mineWeek", "Mine, this week"),
+        unbilled: t("staff.time_tracking.entries.presets.unbilled", "Unbilled"),
+        nonBillable: t("staff.time_tracking.entries.presets.nonBillable", "Non-billable"),
+        thisMonth: t("staff.time_tracking.entries.presets.thisMonth", "This month")
+      },
+      errors: {
+        load: t("staff.time_tracking.entries.errors.load", "Could not load the time entries."),
+        save: t("staff.time_tracking.entries.errors.save", "Could not save the time entry."),
+        delete: t("staff.time_tracking.entries.errors.delete", "Could not delete the time entry."),
+        duplicate: t("staff.time_tracking.entries.errors.duplicate", "Could not duplicate the time entry."),
+        copyDay: t("staff.time_tracking.entries.errors.copyDay", "Could not copy the day."),
+        locked: t(
+          "staff.time_tracking.entries.errors.entryLocked",
+          "This time entry is locked in a closed report and cannot be changed. Unlock the report first."
+        )
+      }
+    }),
+    [t]
+  );
+  const handleRefresh = React.useCallback(() => {
+    setReloadToken((token) => token + 1);
+  }, []);
+  const reportFailure = React.useCallback(
+    (error, fallbackMessage, logTag) => {
+      if (surfaceRecordConflict(error, t)) return;
+      if (isEntryLockedError(error)) {
+        flash(labels.errors.locked, "error");
+        return;
+      }
+      logger.error(logTag, { err: error });
+      flash(error instanceof Error && error.message ? error.message : fallbackMessage, "error");
+    },
+    [labels.errors.locked, t]
+  );
+  const period = filterValues.period ?? {};
+  const projectFilter = typeof filterValues.projectId === "string" ? filterValues.projectId : "";
+  React.useEffect(() => {
+    let cancelled = false;
+    void (async () => {
+      const safeCall = async (url) => {
+        try {
+          return await Promise.resolve(apiCall(url)) ?? null;
+        } catch {
+          return null;
+        }
+      };
+      const [selfRes, projectsRes, tagsRes, peopleRes] = await Promise.all([
+        safeCall("/api/staff/team-members/self"),
+        safeCall("/api/staff/timesheets/time-projects?page=1&pageSize=100"),
+        safeCall("/api/staff/timesheets/tags?page=1&pageSize=100"),
+        safeCall("/api/staff/team-members?page=1&pageSize=100")
+      ]);
+      if (cancelled) return;
+      const selfId = selfRes?.ok ? selfRes.result?.member?.id ?? null : null;
+      if (selfId) {
+        setSelfStaffMemberId(selfId);
+        if (!personSeededRef.current) {
+          personSeededRef.current = true;
+          setFilterValues((prev) => ({ ...prev, staffMemberId: selfId }));
+        }
+      }
+      const projects = projectsRes?.ok && Array.isArray(projectsRes.result?.items) ? projectsRes.result.items : [];
+      const customers = /* @__PURE__ */ new Map();
+      setProjectOptions(
+        projects.map((row) => {
+          const id = typeof row.id === "string" ? row.id : null;
+          if (!id) return null;
+          const name = typeof row.name === "string" ? row.name : id;
+          const code = typeof row.code === "string" ? row.code : null;
+          const customerId = typeof row.customer_id === "string" ? row.customer_id : null;
+          const snapshot = row.customer_snapshot;
+          if (customerId && typeof snapshot?.name === "string") customers.set(customerId, snapshot.name);
+          return { value: id, label: code ? `${code} \xB7 ${name}` : name };
+        }).filter((option) => option !== null)
+      );
+      setCustomerOptions([...customers].map(([value, label]) => ({ value, label })));
+      const tags = tagsRes?.ok && Array.isArray(tagsRes.result?.items) ? tagsRes.result.items : [];
+      setTagOptions(
+        tags.map((row) => {
+          const id = typeof row.id === "string" ? row.id : null;
+          const label = typeof row.label === "string" ? row.label : null;
+          return id && label ? { value: id, label } : null;
+        }).filter((option) => option !== null)
+      );
+      const people = peopleRes?.ok && Array.isArray(peopleRes.result?.items) ? peopleRes.result.items : [];
+      setPeopleOptions(
+        people.map((row) => {
+          const id = typeof row.id === "string" ? row.id : null;
+          const label = typeof row.display_name === "string" ? row.display_name : typeof row.displayName === "string" ? row.displayName : null;
+          return id && label ? { value: id, label } : null;
+        }).filter((option) => option !== null)
+      );
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [scopeVersion]);
+  const presets = React.useMemo(
+    () => [
+      {
+        id: "mine-week",
+        label: labels.presets.mineWeek,
+        build: ({ staffMemberId }) => ({
+          period: { from: defaultRange.from, to: defaultRange.to },
+          ...staffMemberId ? { staffMemberId } : {}
+        })
+      },
+      {
+        id: "unbilled",
+        label: labels.presets.unbilled,
+        build: () => ({ locked: "false", billable: "true" })
+      },
+      { id: "non-billable", label: labels.presets.nonBillable, build: () => ({ billable: "false" }) },
+      {
+        id: "this-month",
+        label: labels.presets.thisMonth,
+        build: ({ today }) => {
+          const start = `${today.slice(0, 7)}-01`;
+          return { period: { from: start, to: today } };
+        }
+      }
+    ],
+    [defaultRange.from, defaultRange.to, labels.presets]
+  );
+  const presetContext = React.useMemo(
+    () => ({ staffMemberId: selfStaffMemberId, today: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10) }),
+    [selfStaffMemberId]
+  );
+  const activePresetId = React.useMemo(
+    () => matchActivePreset(filterValues, presets, presetContext),
+    [filterValues, presetContext, presets]
+  );
+  const applyPreset = React.useCallback(
+    (preset) => {
+      setFilterValues((current) => ({ ...current, ...preset.build(presetContext) }));
+      setPage(1);
+    },
+    [presetContext]
+  );
+  const dropDeepLinkParams = React.useCallback(
+    (ids) => {
+      if (!searchParams) return;
+      const next = new URLSearchParams(searchParams.toString());
+      let changed = false;
+      for (const id of ids) {
+        if (!next.has(id)) continue;
+        next.delete(id);
+        changed = true;
+      }
+      if (!changed) return;
+      const query = next.toString();
+      router.replace(query ? `${pathname}?${query}` : pathname);
+    },
+    [pathname, router, searchParams]
+  );
+  const removeChip = React.useCallback(
+    (id) => {
+      setFilterValues((current) => {
+        const next = { ...current };
+        delete next[id];
+        return next;
+      });
+      setPage(1);
+      dropDeepLinkParams([id]);
+    },
+    [dropDeepLinkParams]
+  );
+  const clearAllFilters = React.useCallback(() => {
+    setFilterValues({});
+    setPage(1);
+    dropDeepLinkParams(DEEP_LINK_PARAMS);
+  }, [dropDeepLinkParams]);
+  const loadEntries = React.useCallback(async () => {
+    if (hasLoadedOnceRef.current) setIsRefreshing(true);
+    else setIsLoading(true);
+    try {
+      const params = new URLSearchParams({ page: String(page), pageSize: String(PAGE_SIZE) });
+      const sort = sorting[0];
+      params.set("sortField", sort?.id ?? "date");
+      params.set("sortDir", sort?.desc === false ? "asc" : "desc");
+      if (period.from) params.set("from", period.from);
+      if (period.to) params.set("to", period.to);
+      if (projectFilter) params.set("projectId", projectFilter);
+      const readFilter = (key) => typeof filterValues[key] === "string" ? filterValues[key] : "";
+      const person = readFilter("staffMemberId");
+      if (person) params.set("staffMemberId", person);
+      const billable = readFilter("billable");
+      if (billable) params.set("billable", billable);
+      const lockedFilter = readFilter("locked");
+      if (lockedFilter) params.set("locked", lockedFilter);
+      const customer = readFilter("customerId");
+      if (customer) params.set("customerId", customer);
+      const tag = readFilter("tagIds");
+      if (tag) params.set("tagIds", tag);
+      const text = readFilter("q");
+      if (text.trim()) params.set("q", text.trim());
+      const taskFilter = readFilter("taskId");
+      if (taskFilter) params.set("taskId", taskFilter);
+      const entryIdsFilter = readFilter("ids");
+      if (entryIdsFilter) params.set("ids", entryIdsFilter);
+      const listPayload = await readApiResultOrThrow(
+        `${ENTRIES_API}?${params.toString()}`,
+        void 0,
+        { errorMessage: labels.errors.load, fallback: { items: [], total: 0, totalPages: 1 } }
+      );
+      const items = Array.isArray(listPayload.items) ? listPayload.items : [];
+      const bare = items.map((item) => toTimeEntryListRow(item)).filter((row) => row !== null);
+      const { taskIds, projectIds } = collectDirectoryIds(bare);
+      let directory = { taskTitles: /* @__PURE__ */ new Map(), projectLabels: /* @__PURE__ */ new Map() };
+      try {
+        directory = await loadDirectory(taskIds, projectIds);
+      } catch (error) {
+        logger.warn("staff.time_tracking.entries directory load failed", { err: error });
+      }
+      setRows(
+        items.map((item) => toTimeEntryListRow(item, directory)).filter((row) => row !== null)
+      );
+      setTotal(typeof listPayload.total === "number" ? listPayload.total : items.length);
+      setTotalIsCapped(listPayload.totalIsCapped === true);
+      setTotalPages(
+        typeof listPayload.totalPages === "number" ? listPayload.totalPages : Math.max(1, Math.ceil(items.length / PAGE_SIZE))
+      );
+    } catch (error) {
+      logger.error("staff.time_tracking.entries list failed", { err: error });
+      flash(labels.errors.load, "error");
+    } finally {
+      setIsLoading(false);
+      setIsRefreshing(false);
+      hasLoadedOnceRef.current = true;
+    }
+  }, [labels.errors.load, page, period.from, period.to, projectFilter, sorting, filterValues]);
+  React.useEffect(() => {
+    void loadEntries();
+  }, [loadEntries, scopeVersion, reloadToken]);
+  React.useEffect(() => {
+    setSelectedIds([]);
+  }, [page, period.from, period.to, projectFilter, scopeVersion]);
+  const undoneTokens = useOperationStore((state) => state.undone.map((entry) => entry.undoToken).join("|"));
+  const pendingUndoTokensRef = React.useRef(/* @__PURE__ */ new Set());
+  React.useEffect(() => {
+    if (pendingUndoTokensRef.current.size === 0) return;
+    const undone = new Set(undoneTokens.split("|").filter(Boolean));
+    let restored = false;
+    for (const token of Array.from(pendingUndoTokensRef.current)) {
+      if (!undone.has(token)) continue;
+      pendingUndoTokensRef.current.delete(token);
+      restored = true;
+    }
+    if (restored) handleRefresh();
+  }, [handleRefresh, undoneTokens]);
+  const { runMutation, retryLastMutation } = useGuardedMutation({
+    contextId: MUTATION_CONTEXT_ID,
+    blockedMessage: labels.errors.save
+  });
+  const mutationContext = React.useCallback(
+    (resourceId) => ({
+      formId: MUTATION_CONTEXT_ID,
+      resourceKind: RESOURCE_KIND,
+      resourceId,
+      retryLastMutation
+    }),
+    [retryLastMutation]
+  );
+  const handleDurationCommit = React.useCallback(
+    async (entry, durationMinutes) => {
+      setSavingEntryId(entry.id);
+      try {
+        await runMutation({
+          operation: () => withScopedApiRequestHeaders(
+            buildOptimisticLockHeader(entry.updatedAt),
+            () => updateCrud(
+              ENTRIES_API_PATH,
+              { id: entry.id, durationMinutes },
+              { errorMessage: labels.errors.save }
+            )
+          ),
+          context: mutationContext(entry.id),
+          mutationPayload: { id: entry.id, durationMinutes }
+        });
+        handleRefresh();
+      } catch (error) {
+        reportFailure(error, labels.errors.save, "staff.time_tracking.entries inline duration save failed");
+        handleRefresh();
+      } finally {
+        setSavingEntryId(null);
+      }
+    },
+    [handleRefresh, labels.errors.save, mutationContext, reportFailure, runMutation]
+  );
+  const handleDelete = React.useCallback(
+    async (entry) => {
+      const previousRows = rows;
+      setRows((current) => current.filter((row) => row.id !== entry.id));
+      setTotal((current) => Math.max(0, current - 1));
+      setSelectedIds((current) => current.filter((id) => id !== entry.id));
+      try {
+        const call = await runMutation({
+          operation: () => withScopedApiRequestHeaders(
+            buildOptimisticLockHeader(entry.updatedAt),
+            () => deleteCrud(ENTRIES_API_PATH, entry.id, { errorMessage: labels.errors.delete })
+          ),
+          context: mutationContext(entry.id),
+          mutationPayload: { id: entry.id }
+        });
+        const undoToken = readUndoToken(call.response);
+        if (undoToken) pendingUndoTokensRef.current.add(undoToken);
+        flash(
+          t("staff.time_tracking.entries.messages.deleted", "Deleted \u201C{name}\u201D ({duration}). Use Undo to restore it.", {
+            name: entry.taskTitle ?? entry.description ?? labels.noTask,
+            duration: formatDuration(entry.durationMinutes, "clock")
+          }),
+          "success"
+        );
+      } catch (error) {
+        setRows(previousRows);
+        setTotal((current) => current + 1);
+        reportFailure(error, labels.errors.delete, "staff.time_tracking.entries delete failed");
+      }
+    },
+    [labels.errors.delete, labels.noTask, mutationContext, reportFailure, rows, runMutation, t]
+  );
+  const handleDuplicate = React.useCallback(
+    async (entry) => {
+      try {
+        await runMutation({
+          operation: () => apiCallOrThrow(
+            `${ENTRIES_API}/${encodeURIComponent(entry.id)}/duplicate`,
+            {
+              method: "POST",
+              headers: { "content-type": "application/json" },
+              body: JSON.stringify({ tagIds: entry.tagIds })
+            },
+            { errorMessage: labels.errors.duplicate }
+          ),
+          context: mutationContext(entry.id),
+          mutationPayload: { id: entry.id }
+        });
+        flash(t("staff.time_tracking.entries.messages.duplicated", "Entry duplicated."), "success");
+        handleRefresh();
+      } catch (error) {
+        reportFailure(error, labels.errors.duplicate, "staff.time_tracking.entries duplicate failed");
+      }
+    },
+    [handleRefresh, labels.errors.duplicate, mutationContext, reportFailure, runMutation, t]
+  );
+  const runCopyDay = React.useCallback(
+    async (fromDate, toDate, allowDuplicates) => runMutation({
+      operation: () => apiCallOrThrow(
+        `${ENTRIES_API}/copy-day`,
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({ fromDate, toDate, allowDuplicates })
+        },
+        { errorMessage: labels.errors.copyDay }
+      ),
+      context: mutationContext(toDate),
+      mutationPayload: { fromDate, toDate, allowDuplicates }
+    }),
+    [labels.errors.copyDay, mutationContext, runMutation]
+  );
+  const handleCopyDay = React.useCallback(async () => {
+    const toDate = todayIsoDate();
+    const fromDate = shiftIsoDate(toDate, -1);
+    const announce = (result) => {
+      const copied = typeof result?.copied === "number" ? result.copied : 0;
+      const skipped = Array.isArray(result?.skipped) ? result.skipped.length : 0;
+      if (copied === 0) {
+        flash(t("staff.time_tracking.entries.copyDay.nothing", "Yesterday has no entries to copy."), "info");
+      } else {
+        flash(
+          t("staff.time_tracking.entries.copyDay.success", "{count} entries copied as drafts \u2014 review them.", {
+            count: copied
+          }),
+          "success"
+        );
+        setFilterValues((current) => ({ ...current, period: { from: toDate, to: toDate } }));
+        setPage(1);
+      }
+      if (skipped > 0) {
+        flash(
+          t("staff.time_tracking.entries.copyDay.skipped", "{count} entries were skipped because they are locked.", {
+            count: skipped
+          }),
+          "warning"
+        );
+      }
+      handleRefresh();
+    };
+    try {
+      const call = await runCopyDay(fromDate, toDate, false);
+      announce(call.result);
+    } catch (error) {
+      const conflict = readCopyDayTargetConflict(error);
+      if (!conflict) {
+        reportFailure(error, labels.errors.copyDay, "staff.time_tracking.entries copy-day failed");
+        return;
+      }
+      const confirmed = await confirm({
+        title: labels.copyDay,
+        text: t(
+          "staff.time_tracking.entries.copyDay.conflict",
+          "Today already has {count} entries. Add yesterday\u2019s copies on top of them?",
+          { count: conflict.existingEntryCount }
+        ),
+        confirmText: t("staff.time_tracking.entries.copyDay.confirmDuplicates", "Add copies anyway")
+      });
+      if (!confirmed) return;
+      try {
+        const retry = await runCopyDay(fromDate, toDate, true);
+        announce(retry.result);
+      } catch (retryError) {
+        reportFailure(retryError, labels.errors.copyDay, "staff.time_tracking.entries copy-day retry failed");
+      }
+    }
+  }, [confirm, handleRefresh, labels.copyDay, labels.errors.copyDay, reportFailure, runCopyDay, t]);
+  const openCreate = React.useCallback(() => {
+    setDialogEntryId(null);
+    setDialogOpen(true);
+  }, []);
+  const openEdit = React.useCallback((entryId) => {
+    setDialogEntryId(entryId);
+    setDialogOpen(true);
+  }, []);
+  const selectableRows = React.useMemo(() => rows.filter((row) => !row.isLocked), [rows]);
+  const allSelected = selectableRows.length > 0 && selectedIds.length === selectableRows.length;
+  const someSelected = selectedIds.length > 0 && !allSelected;
+  const toggleRowSelection = React.useCallback((id, checked) => {
+    setSelectedIds((current) => checked ? Array.from(/* @__PURE__ */ new Set([...current, id])) : current.filter((value) => value !== id));
+  }, []);
+  const toggleAllSelection = React.useCallback(
+    (checked) => {
+      setSelectedIds(checked ? selectableRows.map((row) => row.id) : []);
+    },
+    [selectableRows]
+  );
+  const filters = React.useMemo(
+    () => [
+      { id: "period", label: labels.filters.period, type: "dateRange" },
+      { id: "projectId", label: labels.filters.project, type: "select", options: projectOptions },
+      { id: "customerId", label: labels.filters.customer, type: "select", options: customerOptions },
+      // Only offered when the caller can actually see somebody else's time; for
+      // everyone else the route already scopes to their own entries and the
+      // control would be a lever attached to nothing.
+      ...canManageAll && peopleOptions.length > 1 ? [{ id: "staffMemberId", label: labels.filters.person, type: "select", options: peopleOptions }] : [],
+      { id: "tagIds", label: labels.filters.tag, type: "select", options: tagOptions },
+      {
+        id: "billable",
+        label: labels.filters.billable,
+        type: "select",
+        options: [
+          { value: "true", label: labels.filters.billableYes },
+          { value: "false", label: labels.filters.billableNo }
+        ]
+      },
+      {
+        id: "locked",
+        label: labels.filters.locked,
+        type: "select",
+        options: [
+          { value: "true", label: labels.filters.lockedYes },
+          { value: "false", label: labels.filters.lockedNo }
+        ]
+      },
+      { id: "q", label: labels.filters.text, type: "text" }
+    ],
+    [labels.filters, canManageAll, projectOptions, customerOptions, peopleOptions, tagOptions]
+  );
+  const unlistedFilters = React.useMemo(
+    () => [
+      { id: "staffMemberId", label: labels.filters.person, type: "select", options: peopleOptions },
+      { id: "taskId", label: labels.filters.task, type: "text" },
+      { id: "ids", label: labels.filters.entry, type: "text" }
+    ],
+    [labels.filters, peopleOptions]
+  );
+  const appliedChips = React.useMemo(() => {
+    const defOf = (id) => filters.find((filter) => filter.id === id) ?? unlistedFilters.find((filter) => filter.id === id);
+    const label = (id) => defOf(id)?.label ?? id;
+    const optionLabel = (id, value) => defOf(id)?.options?.find((option) => option.value === value)?.label ?? value;
+    const chips = [];
+    for (const [id, raw] of Object.entries(filterValues)) {
+      if (raw === void 0 || raw === null || raw === "") continue;
+      if (id === "period") {
+        const range = raw;
+        if (!range?.from && !range?.to) continue;
+        chips.push({ id, label: label(id), value: `${range.from ?? "\u2026"} \u2192 ${range.to ?? "\u2026"}` });
+        continue;
+      }
+      if (typeof raw !== "string") continue;
+      if (id === "taskId") {
+        const first = raw.split(",")[0] ?? raw;
+        const match = rows.find((row) => row.taskId === first);
+        chips.push({ id, label: label(id), value: match?.taskTitle ?? first });
+        continue;
+      }
+      if (id === "ids") {
+        const list = raw.split(",").map((value) => value.trim()).filter(Boolean);
+        if (list.length === 0) continue;
+        const single = list.length === 1 ? rows.find((row) => row.id === list[0]) : void 0;
+        chips.push({
+          id,
+          label: label(id),
+          value: single ? single.taskTitle ?? single.description ?? labels.noTask : labels.filters.entrySelection.replace("{count}", String(list.length))
+        });
+        continue;
+      }
+      chips.push({ id, label: label(id), value: optionLabel(id, raw) });
+    }
+    return chips;
+  }, [filterValues, filters, labels.filters.entrySelection, labels.noTask, rows, unlistedFilters]);
+  const columns = React.useMemo(() => {
+    const rightHeader = (label) => () => /* @__PURE__ */ jsx("span", { className: "block text-right", children: label });
+    const defs = [];
+    if (canManage) {
+      defs.push({
+        id: "select",
+        accessorKey: "id",
+        header: () => /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            checked: allSelected ? true : someSelected ? "indeterminate" : false,
+            onCheckedChange: (checked) => toggleAllSelection(Boolean(checked)),
+            "aria-label": labels.selectAll
+          }
+        ),
+        enableSorting: false,
+        meta: { priority: 1 },
+        cell: ({ row }) => row.original.isLocked ? null : /* @__PURE__ */ jsx(
+          Checkbox,
+          {
+            checked: selectedIds.includes(row.original.id),
+            onCheckedChange: (checked) => toggleRowSelection(row.original.id, Boolean(checked)),
+            onClick: (event) => event.stopPropagation(),
+            "aria-label": labels.selectRow
+          }
+        )
+      });
+    }
+    defs.push({
+      accessorKey: "date",
+      header: labels.columns.date,
+      meta: { priority: 1 },
+      cell: ({ row }) => /* @__PURE__ */ jsx("span", { className: "whitespace-nowrap text-sm text-muted-foreground", children: formatEntryDay(row.original.date) })
+    });
+    defs.push({
+      id: "task",
+      accessorKey: "taskTitle",
+      header: labels.columns.task,
+      enableSorting: false,
+      // `taskTitle` matches none of DataTable's wide-column keys, so it fell to the
+      // 150px default and truncated to "Consulting / Worksh…" while the nowrap
+      // numeric columns kept their slack. This is the row's primary content.
+      meta: { priority: 1, maxWidth: "520px" },
+      cell: ({ row }) => {
+        const entry = row.original;
+        const rateOverrideLabel = canSeeMoney && entry.rateOverrideAmount !== null ? formatCurrency(entry.rateOverrideAmount, entry.currencyCode) ?? String(entry.rateOverrideAmount) : null;
+        return /* @__PURE__ */ jsxs("div", { className: "flex min-w-0 flex-col gap-0.5", children: [
+          /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap items-center gap-1.5", children: [
+            /* @__PURE__ */ jsx("span", { className: "truncate text-sm font-medium text-foreground", children: entry.taskTitle ?? labels.noTask }),
+            !entry.isBillable ? /* @__PURE__ */ jsx(StatusBadge, { variant: "neutral", children: labels.badges.nonBillable }) : null,
+            rateOverrideLabel ? /* @__PURE__ */ jsx("span", { "data-testid": "entry-rate-override", children: /* @__PURE__ */ jsx(StatusBadge, { variant: "info", children: t("staff.time_tracking.entries.badges.rateOverride", "{amount}/h", { amount: rateOverrideLabel }) }) }) : null,
+            entry.isLocked ? /* @__PURE__ */ jsx("span", { "data-testid": "entry-locked-badge", children: /* @__PURE__ */ jsxs(StatusBadge, { variant: "neutral", children: [
+              /* @__PURE__ */ jsx(Lock, { className: "h-3 w-3", "aria-hidden": "true" }),
+              labels.badges.locked
+            ] }) }) : null
+          ] }),
+          entry.description ? /* @__PURE__ */ jsx("span", { className: "truncate text-xs text-muted-foreground", children: entry.description }) : null
+        ] });
+      }
+    });
+    defs.push({
+      id: "project",
+      accessorKey: "projectLabel",
+      header: labels.columns.project,
+      enableSorting: false,
+      meta: { priority: 2, maxWidth: "240px" },
+      cell: ({ row }) => row.original.projectLabel ? /* @__PURE__ */ jsx("span", { className: "truncate text-sm text-muted-foreground", children: row.original.projectLabel }) : /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground/70", children: "\u2014" })
+    });
+    defs.push({
+      id: "clock",
+      accessorKey: "startText",
+      header: labels.columns.clock,
+      enableSorting: false,
+      meta: { priority: 3, maxWidth: "160px" },
+      cell: ({ row }) => {
+        const range = formatEntryClockRange(row.original);
+        return range ? /* @__PURE__ */ jsx("span", { className: "whitespace-nowrap font-mono text-sm tabular-nums text-muted-foreground", children: range }) : /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground/70", children: "\u2014" });
+      }
+    });
+    defs.push({
+      id: "durationMinutes",
+      accessorKey: "durationMinutes",
+      header: rightHeader(labels.columns.duration),
+      meta: { priority: 1, maxWidth: "120px" },
+      cell: ({ row }) => /* @__PURE__ */ jsx(
+        TimeEntryDurationCell,
+        {
+          value: row.original.durationMinutes,
+          readOnly: row.original.isLocked || !canManage,
+          saving: savingEntryId === row.original.id,
+          ariaLabel: labels.durationAria,
+          lockedTitle: row.original.isLocked ? labels.errors.locked : void 0,
+          onCommit: (minutes) => handleDurationCommit(row.original, minutes)
+        }
+      )
+    });
+    if (canSeeMoney) {
+      defs.push({
+        id: "cost",
+        accessorKey: "cost",
+        header: rightHeader(labels.columns.cost),
+        enableSorting: false,
+        meta: { priority: 4, maxWidth: "140px" },
+        cell: ({ row }) => {
+          const formatted = row.original.cost === null ? null : formatCurrency(row.original.cost, row.original.currencyCode);
+          return formatted ? /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: "block text-right font-mono text-sm tabular-nums text-foreground",
+              "data-testid": "entry-cost",
+              children: formatted
+            }
+          ) : /* @__PURE__ */ jsx("span", { className: "block text-right text-xs text-muted-foreground/70", "data-testid": "entry-cost-empty", children: "\u2014" });
+        }
+      });
+    }
+    return defs;
+  }, [
+    allSelected,
+    canManage,
+    canSeeMoney,
+    handleDurationCommit,
+    labels,
+    savingEntryId,
+    selectedIds,
+    someSelected,
+    t,
+    toggleAllSelection,
+    toggleRowSelection
+  ]);
+  const summary = React.useMemo(() => summarizeTimeEntries(rows), [rows]);
+  return /* @__PURE__ */ jsxs(Page, { children: [
+    /* @__PURE__ */ jsxs(PageBody, { children: [
+      /* @__PURE__ */ jsx(
+        DataTable,
+        {
+          extensionTableId: extensionPoints.hosts.timeEntriesTable.tableId,
+          title: labels.title,
+          titleHeadingLevel: 1,
+          data: rows,
+          columns,
+          isLoading,
+          filters,
+          filterValues,
+          onFiltersApply: (values) => {
+            setFilterValues(values);
+            setPage(1);
+            dropDeepLinkParams(DEEP_LINK_PARAMS.filter((id) => !values[id]));
+          },
+          onFiltersClear: clearAllFilters,
+          activeFilterChips: /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+            /* @__PURE__ */ jsx(
+              EntryFilterPresets,
+              {
+                presets,
+                activePresetId,
+                onApplyPreset: applyPreset
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              EntryFilterChips,
+              {
+                chips: appliedChips,
+                onRemove: removeChip,
+                onClearAll: clearAllFilters,
+                clearAllLabel: labels.filters.clearAll,
+                removeLabel: (name) => labels.filters.remove.replace("{name}", name)
+              }
+            )
+          ] }),
+          filterAwareEmptyState: {
+            active: appliedChips.length > 0,
+            entityNamePlural: labels.title,
+            canRemoveLast: appliedChips.length > 0,
+            onClearAll: clearAllFilters,
+            onRemoveLast: () => {
+              const last = appliedChips[appliedChips.length - 1];
+              if (last) removeChip(last.id);
+            }
+          },
+          emptyState: /* @__PURE__ */ jsx("div", { className: "py-12 text-center text-sm text-muted-foreground", children: labels.empty }),
+          actions: canManage ? /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2", children: [
+            /* @__PURE__ */ jsxs(Button, { size: "sm", variant: "outline", onClick: () => void handleCopyDay(), children: [
+              /* @__PURE__ */ jsx(Copy, { className: "h-4 w-4", "aria-hidden": "true" }),
+              labels.copyDay
+            ] }),
+            /* @__PURE__ */ jsxs(Button, { size: "sm", onClick: openCreate, children: [
+              /* @__PURE__ */ jsx(Plus, { className: "h-4 w-4", "aria-hidden": "true" }),
+              labels.add
+            ] })
+          ] }) : void 0,
+          refreshButton: {
+            label: labels.refresh,
+            onRefresh: handleRefresh,
+            isRefreshing: isLoading || isRefreshing
+          },
+          sortable: true,
+          manualSorting: true,
+          sorting,
+          onSortingChange: setSorting,
+          pagination: {
+            page,
+            pageSize: PAGE_SIZE,
+            total,
+            totalIsCapped,
+            totalPages,
+            onPageChange: setPage
+          },
+          stickyActionsColumn: true,
+          rowActions: (row) => row.isLocked ? /* @__PURE__ */ jsx(
+            RowActions,
+            {
+              items: [
+                {
+                  id: "show-report",
+                  label: labels.showReport,
+                  href: row.lockedReportId ? `${REPORTS_PATH}?id=${encodeURIComponent(row.lockedReportId)}` : REPORTS_PATH
+                }
+              ]
+            }
+          ) : canManage ? /* @__PURE__ */ jsx(
+            RowActions,
+            {
+              items: [
+                {
+                  id: "duplicate",
+                  label: labels.duplicate,
+                  onSelect: () => {
+                    void handleDuplicate(row);
+                  }
+                },
+                {
+                  id: "delete",
+                  label: labels.delete,
+                  destructive: true,
+                  onSelect: () => {
+                    void handleDelete(row);
+                  }
+                }
+              ]
+            }
+          ) : null,
+          onRowClick: (row) => {
+            if (row.isLocked) return;
+            openEdit(row.id);
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx(TimeEntriesSummaryFooter, { summary, totalCount: total, canSeeMoney }),
+      !canManage ? /* @__PURE__ */ jsx("p", { className: "mt-2 text-xs text-muted-foreground", children: t("staff.time_tracking.entries.readOnlyNotice", "You can view these entries but not change them.") }) : null
+    ] }),
+    /* @__PURE__ */ jsx(
+      TimeEntryDialog,
+      {
+        open: dialogOpen,
+        onOpenChange: setDialogOpen,
+        entryId: dialogEntryId,
+        onSaved: ({ keptOpen }) => {
+          handleRefresh();
+          if (!keptOpen) setDialogOpen(false);
+        },
+        onShowEntry: (entryId) => openEdit(entryId)
+      }
+    ),
+    ConfirmDialogElement
+  ] });
+}
+export {
+  TimeTrackingEntriesPage as default
+};
+//# sourceMappingURL=page.js.map