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

package/lib/taskTemplateDraft.ts

@@ -0,0 +1,135 @@
+import {
+  formatProjectDisplay,
+  formatTagDisplay,
+  normalizeProjectKey,
+  normalizeTagKey,
+  taskTitleForDisplay,
+} from "@/lib/taskParsing";
+
+/** Entrée `taskTemplates` du payload (après validation légère). */
+export type ParsedTaskTemplateRow = {
+  id: string;
+  name: string;
+  tags: string[];
+  project: string | null;
+  /** Projet personnel (`!`) — distinct des projets `@`. */
+  personalProject?: boolean;
+  updatedAt?: string;
+};
+
+export function formatTaskTemplateDraftLine(tpl: {
+  name: string;
+  tags?: string[];
+  project?: string | null;
+  personalProject?: boolean;
+}): string {
+  const title = taskTitleForDisplay(tpl.name).trim();
+  const tags = (tpl.tags ?? [])
+    .map((tag) => `#${normalizeTagKey(tag)}`)
+    .filter(Boolean);
+  const project =
+    typeof tpl.project === "string" && tpl.project.trim()
+      ? formatProjectDisplay(tpl.project, {
+          personal: tpl.personalProject === true,
+        })
+      : "";
+  return [title, ...tags, project].filter(Boolean).join(" ").trim();
+}
+
+/**
+ * Libellé lisible pour datalist / aide : préfixe localisé + titre · métadonnées.
+ */
+export function formatTaskTemplateDatalistLabel(
+  tpl: {
+    name: string;
+    tags?: string[];
+    project?: string | null;
+    personalProject?: boolean;
+  },
+  prefix: string,
+): string {
+  const title = taskTitleForDisplay(tpl.name).trim() || "—";
+  const metaParts: string[] = [];
+  for (const tag of tpl.tags ?? []) {
+    const k = normalizeTagKey(tag);
+    if (k) {
+      metaParts.push(formatTagDisplay(k));
+    }
+  }
+  if (typeof tpl.project === "string" && tpl.project.trim()) {
+    metaParts.push(
+      formatProjectDisplay(tpl.project, {
+        personal: tpl.personalProject === true,
+      }),
+    );
+  }
+  const suffix = metaParts.length > 0 ? ` · ${metaParts.join(" · ")}` : "";
+  return `${prefix} ${title}${suffix}`.trim();
+}
+
+export function parseTaskTemplatesFromPayload(
+  raw: unknown,
+): ParsedTaskTemplateRow[] {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  const out: ParsedTaskTemplateRow[] = [];
+  for (const row of raw) {
+    if (!row || typeof row !== "object" || Array.isArray(row)) {
+      continue;
+    }
+    const rec = row as Record<string, unknown>;
+    const id = typeof rec.id === "string" ? rec.id.trim() : "";
+    const name = typeof rec.name === "string" ? rec.name.trim() : "";
+    if (!id || !name) {
+      continue;
+    }
+    const tags = Array.isArray(rec.tags)
+      ? rec.tags
+          .map((t) => (typeof t === "string" ? normalizeTagKey(t) : ""))
+          .filter((t) => t.length > 0)
+      : [];
+    const project =
+      typeof rec.project === "string"
+        ? normalizeProjectKey(rec.project)
+        : null;
+    const personalProject = rec.personalProject === true;
+    const updatedAt =
+      typeof rec.updatedAt === "string" ? rec.updatedAt : undefined;
+    out.push({ id, name, tags, project, personalProject, updatedAt });
+  }
+  return out;
+}
+
+function dedupeAndSortTagKeys(tags: string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const t of tags) {
+    const key = normalizeTagKey(t).trim().toLowerCase();
+    if (!key || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(key);
+  }
+  out.sort();
+  return out;
+}
+
+/** Signature stable pour comparer une tâche avec un template (insensible à la casse / ordre des tags). */
+export function buildTaskTemplateSignature(input: {
+  name: string;
+  tags?: string[];
+  project?: string | null;
+  /** Même clé projet `@` / `!` doit produire des signatures distinctes. */
+  personalProject?: boolean;
+}): string {
+  const name = taskTitleForDisplay(input.name).trim().toLowerCase();
+  const project =
+    typeof input.project === "string" && input.project.trim()
+      ? normalizeProjectKey(input.project).toLowerCase()
+      : "";
+  const scope = input.personalProject === true ? "p" : "w";
+  const tags = dedupeAndSortTagKeys(input.tags ?? []);
+  return `${name}|${scope}|${project}|${tags.join(",")}`;
+}

package/lib/taskTimelineGantt.ts

@@ -0,0 +1,265 @@
+import type { Lang } from "@/lib/dashboardCopy";
+import { formatIsoInstantShort } from "@/lib/formatIsoShort";
+import { formatDuration } from "@/lib/taskParsing";
+
+export type TaskTimelineGanttRow = {
+  id: string;
+  name: string;
+  project: string | null;
+  /** Temps personnel (`!projet`) vs productif (`@`). */
+  personalProject?: boolean;
+  startMs: number;
+  /** Absent lorsque la tâche est encore au minuteur (fin = « maintenant » dans la modale). */
+  endMs?: number;
+  /** Durée suivie par le minuteur (ms), tel que stocké côté tâche ; absent si inconnu. */
+  timerDurationMs: number | null;
+  startLabel: string;
+  endLabel: string;
+  durationLabel: string | null;
+};
+
+type TaskLike = {
+  id?: string;
+  name?: string;
+  startTime?: string;
+  endTime?: string;
+  durationMs?: number;
+  project?: string | null;
+  personalProject?: boolean;
+  taskTimerLaps?: Array<{
+    startTime?: string;
+    endTime?: string;
+    durationMs?: number;
+  }>;
+  taskCurrentLapStartedAt?: string | number | null;
+};
+
+/**
+ * Même fusion que le panneau Tâches : `tasks` + pile active (sans doublon id).
+ */
+export function mergeSessionTasksForTimeline(
+  sess: {
+    tasks?: unknown;
+    activeTasks?: unknown;
+    activeTask?: unknown;
+  } | null | undefined,
+): TaskLike[] {
+  if (!sess) {
+    return [];
+  }
+  const map = new Map<string, TaskLike>();
+  const base = Array.isArray(sess.tasks) ? sess.tasks : [];
+  for (const raw of base) {
+    const t = raw as TaskLike;
+    if (t?.id) {
+      map.set(String(t.id), t);
+    }
+  }
+  const stack: TaskLike[] =
+    Array.isArray(sess.activeTasks) && sess.activeTasks.length > 0
+      ? [...(sess.activeTasks as TaskLike[])]
+      : sess.activeTask
+        ? [sess.activeTask as TaskLike]
+        : [];
+  for (const t of stack) {
+    if (t?.id) {
+      map.set(String(t.id), t);
+    }
+  }
+  return [...map.values()];
+}
+
+export function buildTaskTimelineGanttRows(
+  mergedTasks: TaskLike[],
+  opts: {
+    isInspecting: boolean;
+    lang: Lang;
+    displayTimeZone: string;
+    use24HourClock: boolean;
+  },
+): TaskTimelineGanttRow[] {
+  const out: TaskTimelineGanttRow[] = [];
+  const { isInspecting, lang, displayTimeZone, use24HourClock } = opts;
+  for (const task of mergedTasks) {
+    const taskId = String(task.id ?? "").trim();
+    if (!taskId) {
+      continue;
+    }
+    const taskName = typeof task.name === "string" ? task.name : "";
+    const taskProject = task.project ?? null;
+    const personalProject = task.personalProject === true;
+    const laps = Array.isArray(task.taskTimerLaps) ? task.taskTimerLaps : [];
+    let lapRowCount = 0;
+    for (let i = 0; i < laps.length; i++) {
+      const lap = laps[i];
+      const startMs =
+        typeof lap?.startTime === "string" ? Date.parse(lap.startTime) : Number.NaN;
+      const endMsRaw =
+        typeof lap?.endTime === "string" ? Date.parse(lap.endTime) : Number.NaN;
+      if (!Number.isFinite(startMs) || !Number.isFinite(endMsRaw) || endMsRaw < startMs) {
+        continue;
+      }
+      const timerDurationMs =
+        typeof lap?.durationMs === "number" && Number.isFinite(lap.durationMs)
+          ? Math.max(0, Math.floor(lap.durationMs))
+          : Math.max(0, Math.floor(endMsRaw - startMs));
+      if (timerDurationMs <= 0) {
+        continue;
+      }
+      const startLabel =
+        formatIsoInstantShort(
+          new Date(startMs).toISOString(),
+          lang,
+          displayTimeZone,
+          use24HourClock,
+        ) ?? "—";
+      const endLabel =
+        formatIsoInstantShort(
+          new Date(endMsRaw).toISOString(),
+          lang,
+          displayTimeZone,
+          use24HourClock,
+        ) ?? "—";
+      lapRowCount += 1;
+      out.push({
+        id: `${taskId}::lap::${i + 1}`,
+        name: taskName,
+        project: taskProject,
+        personalProject,
+        startMs,
+        endMs: endMsRaw,
+        timerDurationMs,
+        startLabel,
+        endLabel,
+        durationLabel: formatDuration(timerDurationMs / 60000),
+      });
+    }
+    const runningLapStartRaw = task.taskCurrentLapStartedAt;
+    const runningLapStartMs =
+      typeof runningLapStartRaw === "string"
+        ? Date.parse(runningLapStartRaw)
+        : typeof runningLapStartRaw === "number" && Number.isFinite(runningLapStartRaw)
+          ? runningLapStartRaw
+          : Number.NaN;
+    let hasLapRows = lapRowCount > 0;
+    if (!isInspecting && Number.isFinite(runningLapStartMs)) {
+      const nowMs = Date.now();
+      if (nowMs >= runningLapStartMs) {
+        const timerDurationMs = Math.max(0, Math.floor(nowMs - runningLapStartMs));
+        const startLabel =
+          formatIsoInstantShort(
+            new Date(runningLapStartMs).toISOString(),
+            lang,
+            displayTimeZone,
+            use24HourClock,
+          ) ?? "—";
+        out.push({
+          id: `${taskId}::lap::running`,
+          name: taskName,
+          project: taskProject,
+          personalProject,
+          startMs: runningLapStartMs,
+          endMs: undefined,
+          timerDurationMs,
+          startLabel,
+          endLabel: lang === "fr" ? "en cours" : "running",
+          durationLabel: timerDurationMs > 0 ? formatDuration(timerDurationMs / 60000) : null,
+        });
+        hasLapRows = true;
+      }
+    }
+    if (hasLapRows) {
+      continue;
+    }
+    let startMs =
+      typeof task.startTime === "string"
+        ? Date.parse(task.startTime)
+        : Number.NaN;
+    const endMsRaw =
+      typeof task.endTime === "string"
+        ? Date.parse(task.endTime)
+        : Number.NaN;
+    if (!Number.isFinite(startMs) && !Number.isFinite(endMsRaw)) {
+      continue;
+    }
+    if (!Number.isFinite(startMs) && Number.isFinite(endMsRaw)) {
+      const dur =
+        typeof task.durationMs === "number" &&
+        Number.isFinite(task.durationMs)
+          ? task.durationMs
+          : 60_000;
+      startMs = endMsRaw - dur;
+    }
+    if (!Number.isFinite(startMs)) {
+      continue;
+    }
+    const hasEnd = Number.isFinite(endMsRaw);
+    const endMs = hasEnd ? endMsRaw : undefined;
+
+    const startLabel =
+      formatIsoInstantShort(
+        new Date(startMs).toISOString(),
+        lang,
+        displayTimeZone,
+        use24HourClock,
+      ) ?? "—";
+    const endLabel = hasEnd
+      ? formatIsoInstantShort(
+          new Date(endMsRaw).toISOString(),
+          lang,
+          displayTimeZone,
+          use24HourClock,
+        ) ?? "—"
+      : isInspecting
+        ? "—"
+        : lang === "fr"
+          ? "en cours"
+          : "running";
+    const durationMin =
+      typeof task.durationMs === "number" && Number.isFinite(task.durationMs)
+        ? task.durationMs / 60000
+        : Number.NaN;
+    const timerDurationMs =
+      typeof task.durationMs === "number" && Number.isFinite(task.durationMs)
+        ? task.durationMs
+        : null;
+    out.push({
+      id: taskId,
+      name: taskName,
+      project: taskProject,
+      personalProject,
+      startMs,
+      endMs,
+      timerDurationMs,
+      startLabel,
+      endLabel,
+      durationLabel:
+        Number.isFinite(durationMin) && durationMin > 0
+          ? formatDuration(durationMin)
+          : null,
+    });
+  }
+  out.sort(
+    (a, b) => a.startMs - b.startMs || String(a.id).localeCompare(b.id),
+  );
+  return out;
+}
+
+export function parseSessionBoundsMs(session: {
+  startAt?: string | null;
+  endAt?: string | null;
+} | null | undefined): {
+  sessionStartMs: number | null;
+  sessionEndMs: number | null;
+} {
+  const rawStart =
+    typeof session?.startAt === "string" ? session.startAt.trim() : "";
+  const rawEnd =
+    typeof session?.endAt === "string" ? session.endAt.trim() : "";
+  const sessionStartMs = rawStart ? Date.parse(rawStart) : Number.NaN;
+  const sessionEndMs = rawEnd ? Date.parse(rawEnd) : Number.NaN;
+  return {
+    sessionStartMs: Number.isFinite(sessionStartMs) ? sessionStartMs : null,
+    sessionEndMs: Number.isFinite(sessionEndMs) ? sessionEndMs : null,
+  };
+}

package/lib/temporalDisplayPlanned.ts

@@ -0,0 +1,71 @@
+/**
+ * Détermine si une tâche doit s’afficher comme « planifiée » (fenêtre temporelle encore dans le futur),
+ * plutôt que comme en cours ou terminée.
+ */
+
+function parseIsoMs(raw: string | undefined | null): number {
+  if (typeof raw !== "string") {
+    return Number.NaN;
+  }
+  const t = raw.trim();
+  if (!t) {
+    return Number.NaN;
+  }
+  const ms = Date.parse(t);
+  return Number.isFinite(ms) ? ms : Number.NaN;
+}
+
+export type TaskTemporalPlannedInput = {
+  isDone?: boolean;
+  startTime?: string;
+  endTime?: string;
+};
+
+/**
+ * - Tâche non terminée : `startTime` strictement postérieur à `nowMs`.
+ * - Tâche terminée : affichage « planifié » seulement si **tout** le créneau est encore dans le futur —
+ *   `startTime` et `endTime` parseables et strictement postérieurs à `nowMs`. Sinon (début déjà passé,
+ *   fin encore future : ex. fin programmée sur une tâche déjà terminée), la carte suit la section **terminées**,
+ *   pas **Planifiées**, pour ne pas bloquer visuellement entre deux mondes jusqu’à l’heure de fin.
+ * - Si `startTime` est absent ou non parseable mais `endTime` est future : on conserve le comportement
+ *   hérité (planifié tant que la fin est future) pour les entrées rétro sans début fiable.
+ */
+export function isTaskDisplayPlanned(
+  task: TaskTemporalPlannedInput,
+  nowMs: number = Date.now(),
+): boolean {
+  if (task.isDone === true) {
+    const endMs = parseIsoMs(task.endTime);
+    if (!Number.isFinite(endMs) || endMs <= nowMs) {
+      return false;
+    }
+    const startMs = parseIsoMs(task.startTime);
+    if (Number.isFinite(startMs)) {
+      return startMs > nowMs;
+    }
+    return true;
+  }
+  const startMs = parseIsoMs(task.startTime);
+  return Number.isFinite(startMs) && startMs > nowMs;
+}
+
+export type SessionTemporalPlannedInput = {
+  startAt?: string | null;
+  endAt?: string | null;
+};
+
+/** Session ouverte dont l’horodatage officiel de début est encore dans le futur. */
+export function isOpenSessionDisplayPlanned(
+  session: SessionTemporalPlannedInput | null | undefined,
+  nowMs: number = Date.now(),
+): boolean {
+  const endRaw =
+    typeof session?.endAt === "string" ? session.endAt.trim() : "";
+  if (endRaw) {
+    return false;
+  }
+  const startMs = parseIsoMs(
+    typeof session?.startAt === "string" ? session.startAt : null,
+  );
+  return Number.isFinite(startMs) && startMs > nowMs;
+}