[4/5] Use one row contract across rendering and columns

src/renderer/column-layout.ts

@@ -2,11 +2,11 @@ import { defaults } from "../columns/defaults";
 import type { Column } from "../columns/types";
 import type { TaskId } from "../task-model";
 import { prepareColumns, type ResolvedColumn } from "./prepare-columns";
-import type { TaskRowModel } from "./row-model";
+import type { CellInfo } from "../columns/types";
 
 export interface ResolvedColumnPosition {
   readonly index: number;
-  readonly rows: ReadonlyArray<TaskRowModel>;
+  readonly rows: ReadonlyArray<CellInfo>;
   readonly entries: ReadonlyArray<ResolvedColumn | undefined>;
   readonly flexGrow?: number;
   readonly flexShrink?: number;
@@ -17,7 +17,7 @@ export interface ResolvedColumnPosition {
 const DEFAULT_COLUMNS = defaults();
 
 const getColumnsForRow = (
-  row: TaskRowModel,
+  row: CellInfo,
   columns: ReadonlyMap<TaskId, ReadonlyArray<Column>>,
 ): ReadonlyArray<Column> => columns.get(row.task.id) ?? DEFAULT_COLUMNS;
 
@@ -29,7 +29,7 @@ const maxDefined = (values: ReadonlyArray<number | undefined>): number | undefin
   );
 
 export const resolveColumns = (
-  rows: ReadonlyArray<TaskRowModel>,
+  rows: ReadonlyArray<CellInfo>,
   columns: ReadonlyMap<TaskId, ReadonlyArray<Column>>,
 ): ReadonlyArray<ResolvedColumnPosition> => {
   const columnsByRow = rows.map((row) => getColumnsForRow(row, columns));

src/renderer/hooks/use-progress-render-view.ts

@@ -3,10 +3,8 @@ import type { ProgressStoreService } from "../../services/store/store";
 import type { ProgressState } from "../../services/store/types";
 import { prepareRows, type RenderSnapshot } from "../prepare-rows";
 
-interface ProgressRenderView {
-  readonly storeSnapshot: ProgressState;
-  readonly renderSnapshot: RenderSnapshot;
-  readonly hasRunningTasks: boolean;
+interface ProgressRenderView extends RenderSnapshot {
+  readonly columns: ProgressState["columns"];
 }
 
 const useRenderSnapshot = (storeSnapshot: ProgressState): RenderSnapshot => {
@@ -33,8 +31,8 @@ export const useProgressRenderView = (store: ProgressStoreService): ProgressRend
   const renderSnapshot = useRenderSnapshot(storeSnapshot);
 
   return {
-    storeSnapshot,
-    renderSnapshot,
+    rows: renderSnapshot.rows,
+    columns: storeSnapshot.columns,
     hasRunningTasks: renderSnapshot.hasRunningTasks,
   };
 };

src/renderer/prepare-rows.ts

@@ -1,6 +1,11 @@
 import type { ProgressState } from "../services/store/types";
 import { textWidth } from "./shared/text-width";
-import type { OrderedTask, TaskRowModel } from "./row-model";
+import type { CellInfo } from "../columns/types";
+
+interface OrderedTask {
+  readonly snapshot: CellInfo["task"];
+  readonly depth: number;
+}
 
 const orderedVisibleTasks = (store: ProgressState): ReadonlyArray<OrderedTask> =>
   store.renderOrder.flatMap((row) => {
@@ -18,7 +23,7 @@ const orderedVisibleTasks = (store: ProgressState): ReadonlyArray<OrderedTask> =
   });
 
 export interface RenderSnapshot {
-  readonly rows: ReadonlyArray<TaskRowModel>;
+  readonly rows: ReadonlyArray<CellInfo>;
   readonly hasRunningTasks: boolean;
 }
 
@@ -28,7 +33,7 @@ const treeAncestorPrefix = (ancestorHasNextSibling: ReadonlyArray<boolean>): str
     .map((hasNextSibling) => (hasNextSibling ? "│  " : "   "))
     .join("");
 
-const renderTreePrefix = (tree: TaskRowModel["tree"]): string => {
+const renderTreePrefix = (tree: CellInfo["tree"]): string => {
   if (tree.depth <= 0) {
     return "";
   }
@@ -50,16 +55,16 @@ const arraysEqual = (left: ReadonlyArray<boolean>, right: ReadonlyArray<boolean>
   return true;
 };
 
-const sameTreePrefixInputs = (left: TaskRowModel["tree"], right: TaskRowModel["tree"]): boolean =>
+const sameTreePrefixInputs = (left: CellInfo["tree"], right: CellInfo["tree"]): boolean =>
   left.depth === right.depth &&
   left.hasNextSibling === right.hasNextSibling &&
   arraysEqual(left.ancestorHasNextSibling, right.ancestorHasNextSibling);
 
 const deriveRow = (
   task: OrderedTask["snapshot"],
   treePrefix: string,
-  previousRow: TaskRowModel | undefined,
-): TaskRowModel["derived"] => {
+  previousRow: CellInfo | undefined,
+): CellInfo["derived"] => {
   // Tree prefixes are built from fixed box-drawing glyphs we treat as single-cell.
   const treePrefixWidth = treePrefix.length;
   const descriptionWidth =
@@ -79,8 +84,8 @@ const deriveRow = (
 
 const buildTaskRows = (
   ordered: ReadonlyArray<OrderedTask>,
-  previousRows: ReadonlyArray<TaskRowModel>,
-): ReadonlyArray<TaskRowModel> => {
+  previousRows: ReadonlyArray<CellInfo>,
+): ReadonlyArray<CellInfo> => {
   const hasNextSiblingByIndex: Array<boolean> = Array.from({ length: ordered.length }, () => false);
   const seenByDepth: Array<boolean> = [];
   for (let i = ordered.length - 1; i >= 0; i--) {

src/renderer/progress-table.tsx

@@ -5,10 +5,10 @@ import { useRef } from "react";
 import type { ColumnAlign, Column } from "../columns/types";
 import type { TaskId } from "../task-model";
 import { resolveColumns, type ResolvedColumnPosition } from "./column-layout";
-import type { TaskRowModel } from "./row-model";
+import type { CellInfo } from "../columns/types";
 
 interface ProgressTableProps {
-  readonly rows: ReadonlyArray<TaskRowModel>;
+  readonly rows: ReadonlyArray<CellInfo>;
   readonly columns: ReadonlyMap<TaskId, ReadonlyArray<Column>>;
 }
 

src/renderer/renderer.tsx

@@ -14,12 +14,12 @@ interface RendererService {
 const MAX_FPS = 24;
 
 const ProgressRoot = ({ store }: { readonly store: ProgressStoreService }) => {
-  const { renderSnapshot, hasRunningTasks, storeSnapshot } = useProgressRenderView(store);
+  const { rows, columns, hasRunningTasks } = useProgressRenderView(store);
 
   return (
     <SpinnerProvider active={hasRunningTasks}>
       <NowProvider active={hasRunningTasks}>
-        <ProgressTable rows={renderSnapshot.rows} columns={storeSnapshot.columns} />
+        <ProgressTable rows={rows} columns={columns} />
       </NowProvider>
     </SpinnerProvider>
   );

tests/columns/description.test.tsx

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 import * as Progress from "../../src";
 import { makeTaskSnapshot, makeRows, renderRows } from "../helpers/renderer";
-import type { TaskRowModel } from "../../src/renderer/row-model";
+import type { CellInfo } from "../../src/columns/types";
 
 const makeTask = (
   id: number,
@@ -18,7 +18,7 @@ const makeTask = (
     completedAt: status === "running" ? null : 1_000,
   });
 
-const renderDescriptionColumn = (rows: ReadonlyArray<TaskRowModel>, spinnerTick = 0): string =>
+const renderDescriptionColumn = (rows: ReadonlyArray<CellInfo>, spinnerTick = 0): string =>
   renderRows(rows, {
     now: 0,
     spinnerTick,

tests/helpers/renderer.tsx

@@ -7,7 +7,7 @@ import { NowProvider } from "../../src/renderer/context/now-context";
 import { SpinnerProvider } from "../../src/renderer/context/spinner-context";
 import { ProgressTable } from "../../src/renderer/progress-table";
 import { prepareRows } from "../../src/renderer/prepare-rows";
-import type { TaskRowModel } from "../../src/renderer/row-model";
+import type { CellInfo } from "../../src/columns/types";
 
 export const makeTaskSnapshot = (overrides: Partial<TaskSnapshot> = {}): TaskSnapshot => ({
   id: TaskId(1),
@@ -31,17 +31,17 @@ export const makeTaskSnapshot = (overrides: Partial<TaskSnapshot> = {}): TaskSna
 export const makeRows = (
   tasks: ReadonlyArray<TaskSnapshot>,
   renderOrder: ProgressState["renderOrder"] = tasks.map(({ id }) => ({ id, depth: 0 })),
-): ReadonlyArray<TaskRowModel> =>
+): ReadonlyArray<CellInfo> =>
   prepareRows({
     tasks: new Map(tasks.map((task) => [task.id, task])),
     renderOrder,
     columns: new Map(),
   }).rows;
 
-export const makeRow = (task: TaskSnapshot): TaskRowModel => makeRows([task])[0]!;
+export const makeRow = (task: TaskSnapshot): CellInfo => makeRows([task])[0]!;
 
 export const renderRows = (
-  rows: ReadonlyArray<TaskRowModel>,
+  rows: ReadonlyArray<CellInfo>,
   {
     columns = new Map(),
     now = 1_000,

tests/renderer/column-layout.test.tsx

@@ -2,7 +2,7 @@ import { describe, expect, test } from "bun:test";
 import * as Progress from "../../src";
 import { makeTaskSnapshot, makeRow as deriveRow, renderRows } from "../helpers/renderer";
 import { resolveColumns } from "../../src/renderer/column-layout";
-import type { TaskRowModel } from "../../src/renderer/row-model";
+import type { CellInfo } from "../../src/columns/types";
 
 const makeTask = <M,>(
   id: number,
@@ -13,7 +13,7 @@ const makeTask = <M,>(
   makeTaskSnapshot({ id: Progress.TaskId(id), description, metadata, ...overrides });
 
 const renderWithColumns = (
-  rows: ReadonlyArray<TaskRowModel>,
+  rows: ReadonlyArray<CellInfo>,
   columns: Progress.ProgressState["columns"],
   now = 1_000,
 ): string => renderRows(rows, { columns, now });