@nightkatana/kronosys-app 1.0.0-beta.2 → 1.0.0-beta.21

package/lib/globalPausePreview.ts

@@ -0,0 +1,292 @@
+import { sessionWallClockMinutes, type LooseSession } from "@/lib/reportingAggregate";
+import { taskTitleForDisplay } from "@/lib/taskParsing";
+
+function asRecord(v: unknown): Record<string, unknown> | undefined {
+  return v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : undefined;
+}
+
+function getActiveTasksArray(sess: Record<string, unknown>): Record<string, unknown>[] {
+  return Array.isArray(sess.activeTasks) ? ([...sess.activeTasks] as Record<string, unknown>[]) : [];
+}
+
+function getTasksArray(sess: Record<string, unknown>): Record<string, unknown>[] {
+  return Array.isArray(sess.tasks) ? ([...sess.tasks] as Record<string, unknown>[]) : [];
+}
+
+/** Aligné sur `SUBTASK_TIMER_STARTED_AT` / `MAIN_TIMER_SEGMENT_STARTED_AT` côté serveur. */
+const SUBTASK_TIMER_STARTED_AT = "subtaskTimerStartedAt";
+const MAIN_TIMER_SEGMENT_STARTED_AT = "mainTimerSegmentStartedAt";
+
+/** Même ordre que `forEachTaskRecordInSession` côté serveur (`server/actionTaskSession.ts`). */
+export function forEachTaskRecordInSessionShape(
+  sess: Record<string, unknown>,
+  fn: (task: Record<string, unknown>, taskId: string) => void,
+): void {
+  const seen = new Set<string>();
+  for (const t of getActiveTasksArray(sess)) {
+    const id = String(t.id ?? "");
+    if (!id || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    fn(t, id);
+  }
+  const at = asRecord(sess.activeTask);
+  if (at) {
+    const id = String(at.id ?? "");
+    if (id && !seen.has(id)) {
+      seen.add(id);
+      fn(at, id);
+    }
+  }
+  for (const t of getTasksArray(sess)) {
+    const id = String(t.id ?? "");
+    if (!id || seen.has(id)) {
+      continue;
+    }
+    seen.add(id);
+    fn(t, id);
+  }
+}
+
+function ensureSubtasksList(task: Record<string, unknown>): unknown[] {
+  return Array.isArray(task.subtasks) ? task.subtasks : [];
+}
+
+/** Somme des `durationMs` persistées sur les sous-tâches (entiers non négatifs). */
+function sumSubtasksDurationMsStored(task: Record<string, unknown>): number {
+  let sum = 0;
+  for (const st of ensureSubtasksList(task)) {
+    const row = asRecord(st);
+    if (!row) {
+      continue;
+    }
+    const d = row.durationMs;
+    const v = typeof d === "number" && Number.isFinite(d) ? d : 0;
+    sum += Math.max(0, Math.floor(v));
+  }
+  return sum;
+}
+
+function subtasksInflightMs(task: Record<string, unknown>, nowMs: number): number {
+  const activeSub = String(task.activeSubtaskTimerId ?? "").trim();
+  if (!activeSub) {
+    return 0;
+  }
+  const raw = task[SUBTASK_TIMER_STARTED_AT];
+  const startedMs =
+    typeof raw === "string" && raw.trim() !== ""
+      ? Date.parse(raw.trim())
+      : typeof raw === "number" && Number.isFinite(raw)
+        ? Number(raw)
+        : Number.NaN;
+  if (!Number.isFinite(startedMs)) {
+    return 0;
+  }
+  return Math.max(0, Math.floor(nowMs - startedMs));
+}
+
+/**
+ * Durée minuteur « totale » côté tâche (persistée + segment courant parent ou sous-tâche active),
+ * alignée sur les règles serveur : pas de double segment parent + sous-tâche.
+ */
+function taskInclusiveTimerMs(task: Record<string, unknown>, nowMs: number): number {
+  const stored =
+    typeof task.durationMs === "number" && Number.isFinite(task.durationMs)
+      ? Math.max(0, Math.floor(Number(task.durationMs)))
+      : 0;
+  if (String(task.activeSubtaskTimerId ?? "").trim() !== "") {
+    return stored + subtasksInflightMs(task, nowMs);
+  }
+  const rawMain = task[MAIN_TIMER_SEGMENT_STARTED_AT];
+  if (typeof rawMain === "string" && rawMain.trim() !== "") {
+    const startedMs = Date.parse(rawMain.trim());
+    if (Number.isFinite(startedMs)) {
+      return stored + Math.max(0, Math.floor(nowMs - startedMs));
+    }
+  }
+  return stored;
+}
+
+/** Total temps sous-tâches (persisté + segment actif éventuel). */
+function subtasksTimerMsDisplay(task: Record<string, unknown>, nowMs: number): number {
+  return sumSubtasksDurationMsStored(task) + subtasksInflightMs(task, nowMs);
+}
+
+function subtaskTitleFor(task: Record<string, unknown>, subId: string): string | undefined {
+  const list = task.subtasks;
+  if (!Array.isArray(list)) {
+    return undefined;
+  }
+  const row = list.find((s) => asRecord(s) && String(asRecord(s)!.id ?? "") === subId);
+  const t = row && asRecord(row)?.title;
+  return typeof t === "string" && t.trim() !== "" ? t.trim() : undefined;
+}
+
+function optionalNonNegativeMinutesFromLive(raw: unknown): number | null {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    return null;
+  }
+  return Math.max(0, raw);
+}
+
+function looseSessionWallStub(sess: Record<string, unknown>): LooseSession {
+  return {
+    sessionId: typeof sess.sessionId === "string" ? sess.sessionId.trim() || "?" : "?",
+    savedAt:
+      typeof sess.savedAt === "string" && sess.savedAt.trim() !== "" ? sess.savedAt.trim() : undefined,
+    startAt:
+      typeof sess.startAt === "string" && sess.startAt.trim() !== ""
+        ? sess.startAt.trim()
+        : typeof sess.createdAt === "string" && sess.createdAt.trim() !== ""
+          ? sess.createdAt.trim()
+          : undefined,
+    endAt:
+      typeof sess.endAt === "string" && sess.endAt.trim() !== "" ? sess.endAt.trim() : undefined,
+    sessionDurationMinutes:
+      typeof sess.sessionDurationMinutes === "number" && Number.isFinite(sess.sessionDurationMinutes)
+        ? sess.sessionDurationMinutes
+        : undefined,
+  };
+}
+
+export type GlobalPausePreviewRow = {
+  taskId: string;
+  taskTitle: string;
+  pauseMainTimer: boolean;
+  /** Minuteur de sous-tâche actif : sera arrêté et consolidé. */
+  activeSubtaskLabel?: string;
+};
+
+export type GlobalPauseActivationPreview = {
+  sessionName: string;
+  sessionWallWillPause: boolean;
+  sessionWallAlreadyPaused: boolean;
+  rows: GlobalPausePreviewRow[];
+  /** ISO début session (priorité `startAt`, sinon `savedAt`, `createdAt`). */
+  sessionStartIso: string;
+  /** ISO fin ; vide si session encore ouverte côté client. */
+  sessionEndIso: string;
+  /** Durée murale (minutes), voir {@link sessionWallClockMinutes}. */
+  sessionWallMinutes: number;
+  taskCount: number;
+  subtaskCount: number;
+  /**
+   * Temps minuteur sur la partie « tâche » hors attribution sous-tâche (persisté + segments en cours),
+   * en millisecondes.
+   */
+  taskMainTimerMsExclusive: number;
+  /** Somme des temps minuteur sous-tâches (persisté + segment actif éventuel), en millisecondes. */
+  subtasksTimerMsTotal: number;
+  /** Total minuteurs tâches (somme inclusive sur les tâches), identique à exclusif + sous-tâches. */
+  taskTimersTotalMs: number;
+  /** Minutes de codage IDE sur la session (`codingMinutesSession`), ou null si non suivies. */
+  sessionCodingMinutes: number | null;
+  /** Minutes actives IDE sur la session (`activeMinutes`), ou null si non suivies. */
+  sessionActiveMinutes: number | null;
+};
+
+export type GlobalPauseActivationPreviewOpts = {
+  /** Point de référence pour les segments en cours (tests). */
+  nowMs?: number;
+};
+
+/**
+ * Indique qu’activer la pause globale n’aurait aucun effet : horloge murale déjà figée
+ * et aucun minuteur de tâche ou de sous-tâche à traiter (même critères que la liste d’effets).
+ */
+export function isGlobalPauseActivationNoOp(preview: GlobalPauseActivationPreview): boolean {
+  return !preview.sessionWallWillPause && preview.rows.length === 0;
+}
+
+/**
+ * Aperçu de ce que fera `toggleGlobalPauseContext` lorsqu’il active la pause globale
+ * (pas lors de la reprise).
+ */
+export function buildGlobalPauseActivationPreview(
+  live: Record<string, unknown> | null | undefined,
+  opts?: GlobalPauseActivationPreviewOpts,
+): GlobalPauseActivationPreview | null {
+  if (!live) {
+    return null;
+  }
+  const nowMs = typeof opts?.nowMs === "number" && Number.isFinite(opts.nowMs) ? opts.nowMs : Date.now();
+
+  const rawName = typeof live.sessionName === "string" ? live.sessionName.trim() : "";
+  const sid = typeof live.sessionId === "string" ? live.sessionId.trim() : "";
+  const sessionName = rawName || (sid ? sid.slice(0, 8) : "—");
+
+  const sessionWallAlreadyPaused = live.isPaused === true;
+  const sessionWallWillPause = !sessionWallAlreadyPaused;
+
+  const rows: GlobalPausePreviewRow[] = [];
+  let taskCount = 0;
+  let subtaskCount = 0;
+  let taskMainTimerMsExclusive = 0;
+  let subtasksTimerMsTotal = 0;
+
+  forEachTaskRecordInSessionShape(live, (task) => {
+    taskCount += 1;
+    for (const st of ensureSubtasksList(task)) {
+      if (asRecord(st)) {
+        subtaskCount += 1;
+      }
+    }
+    const subTotal = subtasksTimerMsDisplay(task, nowMs);
+    const inclusive = taskInclusiveTimerMs(task, nowMs);
+    subtasksTimerMsTotal += subTotal;
+    taskMainTimerMsExclusive += Math.max(0, inclusive - subTotal);
+
+    if (task.isDone === true) {
+      return;
+    }
+    const nameRaw = typeof task.name === "string" ? task.name : "";
+    const taskTitle = taskTitleForDisplay(nameRaw).trim() || String(task.id ?? "").slice(0, 8);
+    const activeSubtaskId =
+      typeof task.activeSubtaskTimerId === "string" ? task.activeSubtaskTimerId.trim() : "";
+    const hasSub = activeSubtaskId.length > 0;
+    const pauseMainTimer = task.manualTaskTimerPaused !== true;
+    const activeSubtaskLabel = hasSub
+      ? subtaskTitleFor(task, activeSubtaskId) ?? activeSubtaskId.slice(0, 8)
+      : undefined;
+
+    if (!pauseMainTimer && !hasSub) {
+      return;
+    }
+    rows.push({
+      taskId: String(task.id ?? ""),
+      taskTitle,
+      pauseMainTimer,
+      ...(hasSub ? { activeSubtaskLabel } : {}),
+    });
+  });
+
+  const startCand =
+    (typeof live.startAt === "string" && live.startAt.trim()) ||
+    (typeof live.savedAt === "string" && live.savedAt.trim()) ||
+    (typeof live.createdAt === "string" && live.createdAt.trim()) ||
+    "";
+  const endCand = typeof live.endAt === "string" && live.endAt.trim() !== "" ? live.endAt.trim() : "";
+
+  const wallLoose = looseSessionWallStub(live);
+  const sessionCodingMinutes = optionalNonNegativeMinutesFromLive(live.codingMinutesSession);
+  const sessionActiveMinutes = optionalNonNegativeMinutesFromLive(live.activeMinutes);
+  const taskTimersTotalMs = taskMainTimerMsExclusive + subtasksTimerMsTotal;
+
+  return {
+    sessionName,
+    sessionWallWillPause,
+    sessionWallAlreadyPaused,
+    rows,
+    sessionStartIso: startCand.trim(),
+    sessionEndIso: endCand.trim(),
+    sessionWallMinutes: sessionWallClockMinutes(wallLoose),
+    taskCount,
+    subtaskCount,
+    taskMainTimerMsExclusive,
+    subtasksTimerMsTotal,
+    taskTimersTotalMs,
+    sessionCodingMinutes,
+    sessionActiveMinutes,
+  };
+}