@anchrd/intel 0.59.0

package/ui/src/board/board-stripes/board-stripes.ts

@@ -0,0 +1,128 @@
+import type { BoardTask } from "@contract/board.ts";
+
+/** How many steps the family ramp has before it repeats (`styles.css`). */
+export const FAMILY_TONES = 6;
+
+/**
+ * ⚠️ **A guard against a cycle in the parent chain, not a limit on nesting.** The depth itself is
+ * unbounded (D37) and the server refuses a move into a node's own descendant — but this walk runs
+ * on whatever answer arrived, and an answer that somehow carried a loop would hang the render
+ * rather than draw a wrong card. A number this large is never reached by real work.
+ */
+const MAX_WALK = 1_000;
+
+export interface Family {
+  /** 1 for a root task, 2 for its child, and so on — the number of stripes drawn. 0 means none. */
+  level: number;
+  /** Which step of the ramp, 1…`FAMILY_TONES`. Every card of one family shares it. */
+  tone: number;
+  /** The root task of the family, or `null` when this card is not in one. */
+  rootId: string | null;
+}
+
+/**
+ * Which family a card belongs to, and how deep it sits in it.
+ *
+ * ⚠️ **A card alone is in NO family and takes no stripes.** The pattern exists to relate cards to
+ * one another; drawn on a card that relates to nothing it says "family" where there is none, and a
+ * mark that appears on every card carries no information at all. That is a deliberate reading of
+ * "a root task has one stripe": a root WITH children has one, a card by itself has none.
+ *
+ * ⚠️ **An unknown parent is treated as no parent.** Under a filter a subtask can be in the answer
+ * while its parent is not (`board.ts` says so on `parentTaskId`), and a walk that insisted on
+ * finding it would lose the card entirely.
+ */
+export function familyOf(task: BoardTask, tasks: BoardTask[]): Family {
+  return familiesOf(tasks).get(task.id) ?? { level: 0, tone: 0, rootId: null };
+}
+
+/**
+ * Every card's family, in ONE pass over the board.
+ *
+ * ⚠️ **Per board, not per card.** Asking `familyOf` once per card rebuilds the index every time,
+ * which is quadratic — measured at 800 cards it cost 36 ms per render, and `dnd-kit` re-renders on
+ * every pointer move while a card is being dragged. The whole board is one answer; its families are
+ * one derivation.
+ */
+export function familiesOf(tasks: BoardTask[]): Map<string, Family> {
+  const byId = new Map(tasks.map((entry) => [entry.id, entry]));
+  const parents = new Set<string>();
+  for (const entry of tasks) if (entry.parentTaskId !== null) parents.add(entry.parentTaskId);
+
+  const families = new Map<string, Family>();
+  for (const task of tasks) families.set(task.id, walkFamily(task, byId, parents.has(task.id)));
+  return families;
+}
+
+function walkFamily(task: BoardTask, byId: Map<string, BoardTask>, hasChildren: boolean): Family {
+  let level = 1;
+  let root = task;
+  const seen = new Set<string>([task.id]);
+  for (let step = 0; step < MAX_WALK; step += 1) {
+    const parentId = root.parentTaskId;
+    if (parentId === null || seen.has(parentId)) break;
+    const parent = byId.get(parentId);
+    if (parent === undefined) break;
+    seen.add(parentId);
+    root = parent;
+    level += 1;
+  }
+
+  if (level === 1 && !hasChildren) return { level: 0, tone: 0, rootId: null };
+  return { level, tone: toneOf(root.id), rootId: root.id };
+}
+
+/**
+ * ⚠️ **Derived from the root's ID, not from its place in the list.** A position would change every
+ * time somebody drags a card, and with it every stripe on the board — the one thing a reader was
+ * meant to recognise across a whole session.
+ */
+export function toneOf(rootId: string): number {
+  let sum = 0;
+  for (const character of rootId) sum = (sum * 31 + character.charCodeAt(0)) % 1_000_003;
+  return (sum % FAMILY_TONES) + 1;
+}
+
+/**
+ * The cards of ONE column, ordered so a subtask follows its parent.
+ *
+ * ⚠️ **Threaded, not nested.** A subtask that sits in the same column as its parent is drawn
+ * directly below it, and its own children below that — depth first. A subtask whose parent is in
+ * ANOTHER column has no thread to join here and takes its ordinary place by position. The cards
+ * stay the same width with the same left edge; the relation is carried by the stripes, not by an
+ * indent that would eat the width exactly where the title is.
+ */
+export function threaded(cards: BoardTask[]): BoardTask[] {
+  const here = new Set(cards.map((card) => card.id));
+  const byPosition = [...cards].sort((a, b) => a.position - b.position);
+  const children = new Map<string, BoardTask[]>();
+  const roots: BoardTask[] = [];
+
+  for (const card of byPosition) {
+    const parentId = card.parentTaskId;
+    if (parentId === null || !here.has(parentId)) {
+      roots.push(card);
+      continue;
+    }
+    const siblings = children.get(parentId);
+    if (siblings === undefined) children.set(parentId, [card]);
+    else siblings.push(card);
+  }
+
+  const out: BoardTask[] = [];
+  const emitted = new Set<string>();
+  // ⚠️ A REAL guard, and against a real hole: with a loop in the parent chain (a under b, b under a,
+  // or a card under itself) neither card is a root, so the walk below never starts on them. Left at
+  // that, the column silently loses them — work falls off the board with no error anywhere.
+  const walk = (card: BoardTask) => {
+    if (emitted.has(card.id)) return;
+    emitted.add(card.id);
+    out.push(card);
+    for (const child of children.get(card.id) ?? []) walk(child);
+  };
+  for (const root of roots) walk(root);
+  // ⚠️ Whatever the walk did not reach is appended in the board's own order. A card in a loop has
+  // no sensible place in a thread, and the bottom of the column is the honest one — visible.
+  for (const card of byPosition) walk(card);
+  return out;
+}

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

@@ -0,0 +1,53 @@
+import type { BoardTask } from "@contract/board.ts";
+import type { ColumnWithCards } from "@/board/board-data/board-data.types.ts";
+
+/**
+ * One line of the table: the card, plus the two things the card cannot answer about itself.
+ *
+ * `columnTitle` is its status resolved against the board's configuration, and `blocking` is what
+ * `dependsOn` points at — the blocking card's title when it is on this board, its bare id when it
+ * is not. ⚠️ **The id is shown rather than hidden**: a dependency on something outside this board
+ * is exactly the case somebody needs to see, and an empty cell claims there is no dependency.
+ */
+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);
+  }
+  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[],
+    })),
+  );
+  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 roots;
+}