@anchrd/intel-ui 0.38.0 → 0.40.0

package/src/board/board-table/board-table.ts

@@ -1,14 +1,6 @@
 import type { BoardTask } from "@anchrd/intel-contract/board";
 import type { ColumnWithCards } from "@/board/board-data/board-data.types.ts";
 
-export type SortKey = "title" | "status" | "assignee" | "due" | "dependsOn";
-export type GroupKey = "none" | "status" | "assignee";
-
-export interface Sort {
-  key: SortKey;
-  direction: "asc" | "desc";
-}
-
 /**
  * One line of the table: the card, plus the two things the card cannot answer about itself.
  *
@@ -21,115 +13,41 @@ export interface Row {
   task: BoardTask;
   columnTitle: string;
   blocking: string | null;
+  /** The subtasks under this one. Empty for a card nothing hangs beneath (#669). */
+  subRows: Row[];
 }
 
+/**
+ * The rows as a TREE: a subtask hangs under its parent (#669).
+ *
+ * ⚠️ **A subtask whose parent is not in the answer is drawn at the top level.** `board_get` returns
+ * what matches the filter, and a subtask can match while its parent does not — hung under a parent
+ * that is not there, the row would be lost from the table entirely. The contract says the same at
+ * `BoardTask.parentTaskId`; this is the reader that has to honour it.
+ *
+ * ⚠️ **The order inside a level is the board's**: columns in their configured order, cards by
+ * position. That is what a table without a sort shows, and it is the order somebody arranged by
+ * hand.
+ */
 export function rowsOf(columns: ColumnWithCards[]): Row[] {
   const titles = new Map<string, string>();
   for (const entry of columns) {
     for (const card of entry.cards) titles.set(card.id, card.title);
   }
-  return columns.flatMap((entry) =>
+  const flat = columns.flatMap((entry) =>
     entry.cards.map((task) => ({
       task,
       columnTitle: entry.column.title,
       blocking: task.dependsOn === null ? null : (titles.get(task.dependsOn) ?? task.dependsOn),
+      subRows: [] as Row[],
     })),
   );
-}
-
-function cellOf(row: Row, key: SortKey): string | null {
-  switch (key) {
-    case "title":
-      return row.task.title;
-    case "status":
-      return row.columnTitle;
-    case "assignee":
-      return row.task.assigneeId;
-    case "due":
-      return row.task.dueDate;
-    case "dependsOn":
-      return row.blocking;
-  }
-}
-
-/**
- * The table in one order.
- *
- * ⚠️ **An empty cell sorts last in BOTH directions, and that is not a preference.** A card without
- * a due date is not the earliest one — it is one whose date nobody knows, and putting it first is a
- * table that answers "what is due next" with the rows that have no answer. Comparing `null` with a
- * string instead is worse than wrong: `null < "2026-08-19"` and `null > "2026-08-19"` are BOTH
- * false, so the comparator claims equality between rows that are not equal, and the order then
- * depends on where the dateless rows happened to sit.
- *
- * ⚠️ **The sort is stable and the incoming order is the tiebreaker.** Rows arrive in the board's
- * own order — configured columns first, cards by position — so two cards with the same due date
- * keep the order the board gives them rather than swapping on every render.
- */
-export function sortRows(rows: Row[], sort: Sort | null): Row[] {
-  if (sort === null) return rows;
-  const factor = sort.direction === "asc" ? 1 : -1;
-  return [...rows].sort((left, right) => {
-    const a = cellOf(left, sort.key);
-    const b = cellOf(right, sort.key);
-    if (a === null && b === null) return 0;
-    if (a === null) return 1;
-    if (b === null) return -1;
-    // An ISO timestamp compares correctly as a string, so one comparison serves every column.
-    return factor * a.localeCompare(b, undefined, { numeric: true, sensitivity: "base" });
-  });
-}
-
-export interface Group {
-  /**
-   * The VALUE the rows were grouped by, not the text to draw.
-   *
-   * ⚠️ The difference matters for the assignee: the value is a Gate principal id, and an id must
-   * never reach the screen (`user-name.ts`, #258). The view resolves it to a name or to the word
-   * for somebody it cannot name; this module has no business deciding that, and returning a
-   * ready-made label would have made the id the obvious thing to put there.
-   *
-   * `null` is the group the key does not answer for — unassigned, mostly.
-   */
-  key: string | null;
-  rows: Row[];
-}
-
-/**
- * The rows in groups, in the order the rows themselves arrive.
- *
- * ⚠️ **Not alphabetically.** Grouped by status, the groups are the board's columns, and their order
- * carries meaning the alphabet destroys: `todo, doing, done` would be drawn `doing, done, todo`.
- * Walking the rows and appending each new group as it first appears keeps the board's order for
- * free — and keeps whatever `sortRows` decided when the grouping key is something else.
- */
-export function groupRows(rows: Row[], key: GroupKey): Group[] {
-  if (key === "none") return [{ key: null, rows }];
-  const groups: Group[] = [];
-  for (const row of rows) {
-    const value = key === "status" ? row.columnTitle : row.task.assigneeId;
-    const existing = groups.find((group) => group.key === value);
-    if (existing === undefined) groups.push({ key: value, rows: [row] });
-    else existing.rows.push(row);
+  const byId = new Map(flat.map((row) => [row.task.id, row]));
+  const roots: Row[] = [];
+  for (const row of flat) {
+    const parent = row.task.parentTaskId === null ? undefined : byId.get(row.task.parentTaskId);
+    if (parent === undefined) roots.push(row);
+    else parent.subRows.push(row);
   }
-  return groups;
-}
-
-/** What the header of a sortable column has to say for a reader who cannot see the arrow. */
-export function ariaSortOf(sort: Sort | null, key: SortKey): "ascending" | "descending" | "none" {
-  if (sort === null || sort.key !== key) return "none";
-  return sort.direction === "asc" ? "ascending" : "descending";
-}
-
-/**
- * What a click on a header means.
- *
- * ⚠️ Three states, not two: ascending, descending, and back to the board's own order. Without the
- * third there is no way back — once a table is sorted it stays sorted, and the order the board was
- * arranged in by hand is unreachable for the rest of the session.
- */
-export function nextSort(sort: Sort | null, key: SortKey): Sort | null {
-  if (sort === null || sort.key !== key) return { key, direction: "asc" };
-  if (sort.direction === "asc") return { key, direction: "desc" };
-  return null;
+  return roots;
 }