@nightkatana/kronosys-app 1.0.0-beta.0

package/lib/reportingTagWeekBreakdown.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  buildTagWeekDisplayBlocks,
+  groupTagDayRowsForDisplay,
+} from "./reportingTagWeekBreakdown";
+import type { TagWeekCalendarRow } from "./reportingWeekLayout";
+import type { ReportingTagTimeDayRow } from "./reportingAggregate";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeWeekRow(tagKey: string, slots: number[] = [0, 0, 0, 0, 0, 0, 0]): TagWeekCalendarRow {
+  return {
+    tagKey,
+    displayTag: tagKey,
+    weekStart: "2026-04-20",
+    slots,
+    total: slots.reduce((s, v) => s + v, 0),
+  };
+}
+
+function makeDayRow(tagKey: string, day: string, minutes: number): ReportingTagTimeDayRow {
+  return { tagKey, displayTag: tagKey, day, minutes };
+}
+
+// ---------------------------------------------------------------------------
+// buildTagWeekDisplayBlocks
+// ---------------------------------------------------------------------------
+describe("buildTagWeekDisplayBlocks", () => {
+  it("retourne un tableau vide pour une entrée vide", () => {
+    expect(buildTagWeekDisplayBlocks([])).toEqual([]);
+  });
+
+  it("étiquette globale → leaf", () => {
+    const rows = [makeWeekRow("dev")];
+    const blocks = buildTagWeekDisplayBlocks(rows);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].kind).toBe("leaf");
+  });
+
+  it("étiquette fallback (default) placée en dernier", () => {
+    const rows = [makeWeekRow("default"), makeWeekRow("design")];
+    const blocks = buildTagWeekDisplayBlocks(rows);
+    expect(blocks[blocks.length - 1].kind).toBe("leaf");
+    if (blocks[blocks.length - 1].kind === "leaf") {
+      expect(blocks[blocks.length - 1].row.tagKey).toBe("default");
+    }
+  });
+
+  it("étiquette unique projet#code → leaf (pas de rollup)", () => {
+    const rows = [makeWeekRow("acme#frontend")];
+    const blocks = buildTagWeekDisplayBlocks(rows);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].kind).toBe("leaf");
+  });
+
+  it("deux étiquettes projet#code du même projet → rollup", () => {
+    const rows = [makeWeekRow("acme#frontend", [30, 0, 0, 0, 0, 0, 0]), makeWeekRow("acme#backend", [0, 60, 0, 0, 0, 0, 0])];
+    const blocks = buildTagWeekDisplayBlocks(rows);
+    expect(blocks).toHaveLength(1);
+    expect(blocks[0].kind).toBe("rollup");
+    if (blocks[0].kind === "rollup") {
+      expect(blocks[0].children).toHaveLength(2);
+      expect(blocks[0].parentTotal).toBe(90);
+      expect(blocks[0].parentSlots[0]).toBe(30);
+      expect(blocks[0].parentSlots[1]).toBe(60);
+    }
+  });
+
+  it("deux projets différents → deux rollups distincts", () => {
+    const rows = [
+      makeWeekRow("acme#a"),
+      makeWeekRow("acme#b"),
+      makeWeekRow("beta#x"),
+      makeWeekRow("beta#y"),
+    ];
+    const blocks = buildTagWeekDisplayBlocks(rows);
+    const rollups = blocks.filter((b) => b.kind === "rollup");
+    expect(rollups).toHaveLength(2);
+  });
+
+  it("les globales sont triées alphabétiquement avant les rollups projet", () => {
+    const rows = [makeWeekRow("zzz"), makeWeekRow("aaa"), makeWeekRow("proj#x"), makeWeekRow("proj#y")];
+    const blocks = buildTagWeekDisplayBlocks(rows);
+    expect(blocks[0].kind).toBe("leaf");
+    if (blocks[0].kind === "leaf") expect(blocks[0].row.tagKey).toBe("aaa");
+    expect(blocks[1].kind).toBe("leaf");
+    if (blocks[1].kind === "leaf") expect(blocks[1].row.tagKey).toBe("zzz");
+    expect(blocks[2].kind).toBe("rollup");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// groupTagDayRowsForDisplay
+// ---------------------------------------------------------------------------
+describe("groupTagDayRowsForDisplay", () => {
+  it("retourne un tableau vide pour entrée vide", () => {
+    expect(groupTagDayRowsForDisplay([])).toEqual([]);
+  });
+
+  it("regroupe les lignes par jour et trie les jours", () => {
+    const rows = [
+      makeDayRow("dev", "2026-04-22", 30),
+      makeDayRow("design", "2026-04-21", 60),
+      makeDayRow("dev", "2026-04-21", 15),
+    ];
+    const groups = groupTagDayRowsForDisplay(rows);
+    expect(groups).toHaveLength(2);
+    expect(groups[0].day).toBe("2026-04-21");
+    expect(groups[1].day).toBe("2026-04-22");
+  });
+
+  it("chaque groupe contient les bons blocs", () => {
+    const rows = [
+      makeDayRow("dev", "2026-04-21", 30),
+      makeDayRow("design", "2026-04-21", 45),
+    ];
+    const groups = groupTagDayRowsForDisplay(rows);
+    expect(groups[0].blocks).toHaveLength(2);
+  });
+
+  it("projet#code unique dans un groupe → leaf", () => {
+    const rows = [makeDayRow("acme#frontend", "2026-04-21", 60)];
+    const groups = groupTagDayRowsForDisplay(rows);
+    expect(groups[0].blocks[0].kind).toBe("leaf");
+  });
+
+  it("deux proj#code mêmes projet dans un groupe → rollup", () => {
+    const rows = [
+      makeDayRow("acme#frontend", "2026-04-21", 30),
+      makeDayRow("acme#backend", "2026-04-21", 90),
+    ];
+    const groups = groupTagDayRowsForDisplay(rows);
+    const rollup = groups[0].blocks.find((b) => b.kind === "rollup");
+    expect(rollup).toBeDefined();
+    if (rollup?.kind === "rollup") {
+      expect(rollup.parentMinutes).toBe(120);
+    }
+  });
+});

package/lib/reportingTagWeekBreakdown.ts

@@ -0,0 +1,181 @@
+import type { ReportingTagTimeDayRow } from "@/lib/reportingAggregate";
+import type { TagWeekCalendarRow } from "@/lib/reportingWeekLayout";
+import {
+  formatProjectDisplay,
+  isFallbackTaskTagKey,
+  normalizeProjectKey,
+  normalizeTagKey,
+  parseProjectScopedTag,
+} from "@/lib/taskParsing";
+
+export type TagWeekDisplayLeaf = { kind: "leaf"; row: TagWeekCalendarRow };
+
+export type TagWeekDisplayRollup = {
+  kind: "rollup";
+  projectKeyLower: string;
+  displayProject: string;
+  weekStart: string;
+  parentSlots: number[];
+  parentTotal: number;
+  children: TagWeekCalendarRow[];
+};
+
+export type TagWeekDisplayBlock = TagWeekDisplayLeaf | TagWeekDisplayRollup;
+
+function sumSlots(rows: readonly TagWeekCalendarRow[]): number[] {
+  const acc = [0, 0, 0, 0, 0, 0, 0];
+  for (const r of rows) {
+    for (let i = 0; i < 7; i++) {
+      acc[i] += r.slots[i] ?? 0;
+    }
+  }
+  return acc;
+}
+
+/**
+ * Prépare les lignes du calendrier hebdo par étiquette : étiquettes globales et sans étiquette telles quelles ;
+ * les étiquettes `projet#suffixe` (plusieurs pour le même projet) deviennent un bloc repliable avec total par projet.
+ */
+export function buildTagWeekDisplayBlocks(rows: readonly TagWeekCalendarRow[]): TagWeekDisplayBlock[] {
+  const scopedBuckets = new Map<string, TagWeekCalendarRow[]>();
+  const globals: TagWeekCalendarRow[] = [];
+  let untagged: TagWeekCalendarRow | null = null;
+
+  for (const row of rows) {
+    if (isFallbackTaskTagKey(row.tagKey)) {
+      untagged = row;
+      continue;
+    }
+    const scoped = parseProjectScopedTag(row.tagKey);
+    if (!scoped) {
+      globals.push(row);
+      continue;
+    }
+    const pk = normalizeProjectKey(scoped.projectKey).toLowerCase();
+    const list = scopedBuckets.get(pk) ?? [];
+    list.push(row);
+    scopedBuckets.set(pk, list);
+  }
+
+  globals.sort((a, b) => normalizeTagKey(a.tagKey).localeCompare(normalizeTagKey(b.tagKey)));
+
+  const blocks: TagWeekDisplayBlock[] = [];
+  for (const r of globals) {
+    blocks.push({ kind: "leaf", row: r });
+  }
+
+  const projKeys = [...scopedBuckets.keys()].sort((a, b) => a.localeCompare(b));
+  for (const pk of projKeys) {
+    const children = [...scopedBuckets.get(pk)!].sort((a, b) =>
+      normalizeTagKey(a.tagKey).localeCompare(normalizeTagKey(b.tagKey))
+    );
+    if (children.length === 1) {
+      blocks.push({ kind: "leaf", row: children[0] });
+      continue;
+    }
+    const first = parseProjectScopedTag(children[0].tagKey);
+    const displayProject = first ? formatProjectDisplay(first.projectKey) : pk;
+    const weekStart = children[0].weekStart;
+    blocks.push({
+      kind: "rollup",
+      projectKeyLower: pk,
+      displayProject,
+      weekStart,
+      parentSlots: sumSlots(children),
+      parentTotal: children.reduce((s, c) => s + c.total, 0),
+      children,
+    });
+  }
+
+  if (untagged) {
+    blocks.push({ kind: "leaf", row: untagged });
+  }
+
+  return blocks;
+}
+
+export type TagDayDisplayLeaf = { kind: "leaf"; row: ReportingTagTimeDayRow };
+
+export type TagDayDisplayRollup = {
+  kind: "rollup";
+  projectKeyLower: string;
+  displayProject: string;
+  day: string;
+  parentMinutes: number;
+  children: ReportingTagTimeDayRow[];
+};
+
+export type TagDayDisplayBlock = TagDayDisplayLeaf | TagDayDisplayRollup;
+
+function buildTagDaySegmentBlocks(segment: readonly ReportingTagTimeDayRow[]): TagDayDisplayBlock[] {
+  const scopedBuckets = new Map<string, ReportingTagTimeDayRow[]>();
+  const globals: ReportingTagTimeDayRow[] = [];
+  let untagged: ReportingTagTimeDayRow | null = null;
+
+  for (const row of segment) {
+    if (isFallbackTaskTagKey(row.tagKey)) {
+      untagged = row;
+      continue;
+    }
+    const scoped = parseProjectScopedTag(row.tagKey);
+    if (!scoped) {
+      globals.push(row);
+      continue;
+    }
+    const pk = normalizeProjectKey(scoped.projectKey).toLowerCase();
+    const list = scopedBuckets.get(pk) ?? [];
+    list.push(row);
+    scopedBuckets.set(pk, list);
+  }
+
+  globals.sort((a, b) => normalizeTagKey(a.tagKey).localeCompare(normalizeTagKey(b.tagKey)));
+
+  const blocks: TagDayDisplayBlock[] = [];
+  for (const r of globals) {
+    blocks.push({ kind: "leaf", row: r });
+  }
+
+  const projKeys = [...scopedBuckets.keys()].sort((a, b) => a.localeCompare(b));
+  for (const pk of projKeys) {
+    const children = [...scopedBuckets.get(pk)!].sort((a, b) =>
+      normalizeTagKey(a.tagKey).localeCompare(normalizeTagKey(b.tagKey))
+    );
+    if (children.length === 1) {
+      blocks.push({ kind: "leaf", row: children[0] });
+      continue;
+    }
+    const first = parseProjectScopedTag(children[0].tagKey);
+    const displayProject = first ? formatProjectDisplay(first.projectKey) : pk;
+    const day = children[0].day;
+    const parentMinutes = children.reduce((s, c) => s + c.minutes, 0);
+    blocks.push({
+      kind: "rollup",
+      projectKeyLower: pk,
+      displayProject,
+      day,
+      parentMinutes,
+      children,
+    });
+  }
+
+  if (untagged) {
+    blocks.push({ kind: "leaf", row: untagged });
+  }
+
+  return blocks;
+}
+
+/** Regroupe les lignes « par jour » par date, avec blocs repliables par projet pour les `projet#code`. */
+export function groupTagDayRowsForDisplay(
+  rows: readonly ReportingTagTimeDayRow[]
+): Array<{ day: string; blocks: TagDayDisplayBlock[] }> {
+  const byDay = new Map<string, ReportingTagTimeDayRow[]>();
+  for (const r of rows) {
+    const list = byDay.get(r.day) ?? [];
+    list.push(r);
+    byDay.set(r.day, list);
+  }
+  return [...byDay.keys()]
+    .sort()
+    .map((day) => ({ day, blocks: buildTagDaySegmentBlocks(byDay.get(day) ?? []) }));
+}

package/lib/reportingWeekLayout.test.ts

@@ -0,0 +1,239 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  addDaysYmd,
+  buildKeyedWeekCalendarRows,
+  buildProjectWeekCalendarRows,
+  buildTagWeekCalendarRows,
+  formatWeekRangeLabel,
+  localCalendarDaysBetween,
+  localWeekStartKeyFromDayKey,
+  weekdayColumnLabels,
+  weekdayDateColumnHeaders,
+} from "./reportingWeekLayout";
+
+// ---------------------------------------------------------------------------
+// addDaysYmd
+// ---------------------------------------------------------------------------
+describe("addDaysYmd", () => {
+  it("ajoute des jours positifs", () => {
+    expect(addDaysYmd("2026-04-29", 1)).toBe("2026-04-30");
+    expect(addDaysYmd("2026-04-29", 7)).toBe("2026-05-06");
+  });
+
+  it("soustrait des jours (delta négatif)", () => {
+    expect(addDaysYmd("2026-05-01", -1)).toBe("2026-04-30");
+  });
+
+  it("traverse les fins de mois et d'année", () => {
+    expect(addDaysYmd("2026-12-31", 1)).toBe("2027-01-01");
+    expect(addDaysYmd("2026-02-28", 1)).toBe("2026-03-01");
+  });
+
+  it("delta = 0 retourne la même date", () => {
+    expect(addDaysYmd("2026-04-15", 0)).toBe("2026-04-15");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// localCalendarDaysBetween
+// ---------------------------------------------------------------------------
+describe("localCalendarDaysBetween", () => {
+  it("même jour → 0", () => {
+    expect(localCalendarDaysBetween("2026-04-29", "2026-04-29")).toBe(0);
+  });
+
+  it("différence positive", () => {
+    expect(localCalendarDaysBetween("2026-04-20", "2026-04-27")).toBe(7);
+  });
+
+  it("différence négative (fin < début)", () => {
+    expect(localCalendarDaysBetween("2026-04-27", "2026-04-20")).toBe(-7);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// localWeekStartKeyFromDayKey
+// ---------------------------------------------------------------------------
+describe("localWeekStartKeyFromDayKey", () => {
+  it("retourne null pour chaîne vide", () => {
+    expect(localWeekStartKeyFromDayKey("", "monday")).toBeNull();
+  });
+
+  it("retourne null pour 'undated'", () => {
+    expect(localWeekStartKeyFromDayKey("undated", "monday")).toBeNull();
+  });
+
+  it("retourne null pour format invalide", () => {
+    expect(localWeekStartKeyFromDayKey("2026-04", "monday")).toBeNull();
+  });
+
+  it("lundi de la semaine contenant mercredi 2026-04-29 (weekStartsOn=monday)", () => {
+    // 2026-04-29 est un mercredi → lundi = 2026-04-27
+    expect(localWeekStartKeyFromDayKey("2026-04-29", "monday")).toBe("2026-04-27");
+  });
+
+  it("dimanche de la semaine contenant mercredi 2026-04-29 (weekStartsOn=sunday)", () => {
+    // semaine commence dimanche → 2026-04-26
+    expect(localWeekStartKeyFromDayKey("2026-04-29", "sunday")).toBe("2026-04-26");
+  });
+
+  it("samedi de la semaine (weekStartsOn=saturday)", () => {
+    // semaine commence samedi → 2026-04-25
+    expect(localWeekStartKeyFromDayKey("2026-04-29", "saturday")).toBe("2026-04-25");
+  });
+
+  it("le premier jour de la semaine pointe sur lui-même", () => {
+    // 2026-04-27 est un lundi
+    expect(localWeekStartKeyFromDayKey("2026-04-27", "monday")).toBe("2026-04-27");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// weekdayColumnLabels
+// ---------------------------------------------------------------------------
+describe("weekdayColumnLabels", () => {
+  it("retourne 7 libellés", () => {
+    expect(weekdayColumnLabels("monday", "en-CA")).toHaveLength(7);
+    expect(weekdayColumnLabels("sunday", "fr-CA")).toHaveLength(7);
+  });
+
+  it("les libellés sont non vides", () => {
+    const labels = weekdayColumnLabels("monday", "en-CA");
+    for (const l of labels) {
+      expect(l.trim().length).toBeGreaterThan(0);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// weekdayDateColumnHeaders
+// ---------------------------------------------------------------------------
+describe("weekdayDateColumnHeaders", () => {
+  it("retourne 7 en-têtes depuis le weekStartKey", () => {
+    const headers = weekdayDateColumnHeaders("2026-04-27", "en-CA");
+    expect(headers).toHaveLength(7);
+  });
+
+  it("le premier dateKey correspond au weekStartKey", () => {
+    const headers = weekdayDateColumnHeaders("2026-04-27", "en-CA");
+    expect(headers[0].dateKey).toBe("2026-04-27");
+  });
+
+  it("le dernier dateKey est weekStart + 6 jours", () => {
+    const headers = weekdayDateColumnHeaders("2026-04-27", "en-CA");
+    expect(headers[6].dateKey).toBe("2026-05-03");
+  });
+
+  it("chaque en-tête a weekdayShort et calendarDateShort non vides", () => {
+    const headers = weekdayDateColumnHeaders("2026-04-27", "fr-CA");
+    for (const h of headers) {
+      expect(h.weekdayShort.trim().length).toBeGreaterThan(0);
+      expect(h.calendarDateShort.trim().length).toBeGreaterThan(0);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// formatWeekRangeLabel
+// ---------------------------------------------------------------------------
+describe("formatWeekRangeLabel", () => {
+  it("retourne une chaîne non vide", () => {
+    const label = formatWeekRangeLabel("2026-04-27", "fr-CA");
+    expect(label.trim().length).toBeGreaterThan(0);
+  });
+
+  it("inclut l'année dans le label", () => {
+    const label = formatWeekRangeLabel("2026-04-27", "en-CA");
+    expect(label).toContain("2026");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildKeyedWeekCalendarRows
+// ---------------------------------------------------------------------------
+describe("buildKeyedWeekCalendarRows", () => {
+  it("retourne un tableau vide pour une entrée vide", () => {
+    expect(buildKeyedWeekCalendarRows([], "monday")).toEqual([]);
+  });
+
+  it("ignore les lignes 'undated'", () => {
+    const rows = [{ day: "undated", rowKey: "dev", displayLabel: "Dev", minutes: 60 }];
+    expect(buildKeyedWeekCalendarRows(rows, "monday")).toEqual([]);
+  });
+
+  it("ignore les lignes avec minutes <= 0", () => {
+    const rows = [{ day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 0 }];
+    expect(buildKeyedWeekCalendarRows(rows, "monday")).toEqual([]);
+  });
+
+  it("agrège correctement deux entrées dans la même semaine pour la même clé", () => {
+    const rows = [
+      { day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 30 },
+      { day: "2026-04-28", rowKey: "dev", displayLabel: "Dev", minutes: 45 },
+    ];
+    const result = buildKeyedWeekCalendarRows(rows, "monday");
+    expect(result).toHaveLength(1);
+    expect(result[0].total).toBe(75);
+    expect(result[0].slots[0]).toBe(30); // lundi (idx 0)
+    expect(result[0].slots[1]).toBe(45); // mardi (idx 1)
+  });
+
+  it("deux clés différentes → deux lignes", () => {
+    const rows = [
+      { day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 30 },
+      { day: "2026-04-27", rowKey: "design", displayLabel: "Design", minutes: 20 },
+    ];
+    const result = buildKeyedWeekCalendarRows(rows, "monday");
+    expect(result).toHaveLength(2);
+  });
+
+  it("deux semaines différentes → deux lignes pour la même clé", () => {
+    const rows = [
+      { day: "2026-04-27", rowKey: "dev", displayLabel: "Dev", minutes: 30 },
+      { day: "2026-05-04", rowKey: "dev", displayLabel: "Dev", minutes: 60 },
+    ];
+    const result = buildKeyedWeekCalendarRows(rows, "monday");
+    expect(result).toHaveLength(2);
+  });
+
+  it("la clé vide est triée en dernier (empty key last)", () => {
+    const rows = [
+      { day: "2026-04-27", rowKey: "", displayLabel: "", minutes: 10 },
+      { day: "2026-04-27", rowKey: "zzz", displayLabel: "Zzz", minutes: 10 },
+      { day: "2026-04-27", rowKey: "aaa", displayLabel: "Aaa", minutes: 10 },
+    ];
+    const result = buildKeyedWeekCalendarRows(rows, "monday");
+    expect(result[result.length - 1].rowKey).toBe("");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildTagWeekCalendarRows (wrapper)
+// ---------------------------------------------------------------------------
+describe("buildTagWeekCalendarRows", () => {
+  it("mappe correctement tagKey et displayTag", () => {
+    const rows = [
+      { day: "2026-04-27", tagKey: "dev", displayTag: "Développement", minutes: 60 },
+    ];
+    const result = buildTagWeekCalendarRows(rows, "monday");
+    expect(result[0].tagKey).toBe("dev");
+    expect(result[0].displayTag).toBe("Développement");
+    expect(result[0].total).toBe(60);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildProjectWeekCalendarRows (wrapper)
+// ---------------------------------------------------------------------------
+describe("buildProjectWeekCalendarRows", () => {
+  it("mappe correctement projectKey et displayProject", () => {
+    const rows = [
+      { day: "2026-04-27", projectKey: "acme", displayProject: "Acme Corp", minutes: 90 },
+    ];
+    const result = buildProjectWeekCalendarRows(rows, "monday");
+    expect(result[0].projectKey).toBe("acme");
+    expect(result[0].displayProject).toBe("Acme Corp");
+    expect(result[0].total).toBe(90);
+  });
+});