@pablocm90/visual-review 0.0.0-stage → 0.1.1

package/dist/read-range.js

@@ -0,0 +1,158 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdtemp, readFile, realpath, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, join, relative } from 'node:path';
+import { promisify } from 'node:util';
+import { CONFIG_FILE, checkConfig, configuredNodes, parseConfig } from './config.js';
+import { stackOfIn } from './graph.js';
+import { fetchAxumLinker } from './linkers/fetch-axum.js';
+import { onPath } from './on-path.js';
+import { rustReader } from './readers/rust.js';
+import { typeScriptReader } from './readers/typescript.js';
+import { testChanges, withMovedTests } from './test-statements.js';
+const run = promisify(execFile);
+const git = async (repo, ...args) => (await run('git', ['-C', repo, ...args])).stdout.trim();
+const readers = [rustReader, typeScriptReader];
+const linkers = [fetchAxumLinker];
+const missingToolOf = ({ tool }) => tool === undefined || onPath(tool) ? undefined : tool;
+const readSide = async ({ repo, revision, directory, config, }) => {
+    await git(repo, 'worktree', 'add', '--detach', directory, revision);
+    const { opened } = readers.reduce((sofar, reader) => {
+        const checkout = reader.open({
+            directory,
+            repoName: basename(repo),
+            config,
+            taken: sofar.taken,
+        });
+        return {
+            taken: new Set([...sofar.taken, ...checkout.stacks.values()]),
+            opened: [...sofar.opened, { reader, checkout }],
+        };
+    }, { taken: new Set(), opened: [] });
+    const kept = (stack) => config.stacks[stack] !== false;
+    const skipped = opened.flatMap(({ reader, checkout }) => {
+        const tool = missingToolOf(reader);
+        const stacks = [...checkout.stacks.values()].filter(kept);
+        return tool === undefined || stacks.length === 0 ? [] : [{ reader: reader.name, tool, stacks }];
+    });
+    const graphs = (await Promise.all(opened
+        .filter(({ reader }) => !skipped.some(({ reader: name }) => name === reader.name))
+        .map(({ checkout }) => Promise.all([...checkout.stacks]
+        .filter(([, stack]) => kept(stack))
+        .map(([root]) => checkout.graph(root)))))).flat();
+    const stacks = opened.flatMap(({ reader, checkout }) => [...checkout.stacks].map(([root, stack]) => ({ stack, reader, root })));
+    const nodes = configuredNodes(config, graphs.flatMap(graph => graph.nodes));
+    const roots = stacks.filter(({ stack }) => kept(stack));
+    const stackOf = stackOfIn(nodes);
+    const linkedBy = (reader, only) => roots
+        .filter(drawn => drawn.reader.name === reader && (only?.includes(drawn.stack) ?? true))
+        .map(({ stack }) => ({ stack, nodes: nodes.filter(({ id }) => stackOf(id) === stack) }));
+    const links = await Promise.all(linkers.flatMap(linker => {
+        const settings = config.linkers[linker.name] ?? {};
+        if (settings === false)
+            return [];
+        return [
+            linker.link({
+                directory,
+                from: linkedBy(linker.from, settings.from),
+                to: linkedBy(linker.to, settings.to),
+            }),
+        ];
+    }));
+    const ids = new Set(nodes.map(({ id }) => id));
+    const edges = [...graphs.flatMap(graph => graph.edges), ...links.flatMap(({ edges }) => edges)];
+    return {
+        graph: { nodes, edges: edges.filter(edge => ids.has(edge.from) && ids.has(edge.to)) },
+        danglingCalls: links.flatMap(({ dangling }) => dangling),
+        roots,
+        stacks,
+        skipped,
+    };
+};
+const skippedAcross = (skips) => skips.reduce((merged, skip) => {
+    const known = merged.find(({ reader }) => reader === skip.reader);
+    return known === undefined
+        ? [...merged, skip]
+        : merged.map(each => each === known
+            ? { ...each, stacks: [...new Set([...each.stacks, ...skip.stacks])] }
+            : each);
+}, []);
+const textIn = async (directory, path) => existsSync(join(directory, path)) ? readFile(join(directory, path), 'utf8') : undefined;
+const testFileAt = async ({ scratch, change: { from, to }, reader, }) => {
+    const before = await textIn(join(scratch, 'before'), from);
+    const after = await textIn(join(scratch, 'after'), to);
+    const renamedFrom = from === to ? undefined : from;
+    try {
+        return {
+            path: to,
+            renamedFrom,
+            statements: testChanges({ read: reader.readTests, before, after }),
+        };
+    }
+    catch (error) {
+        return { path: to, renamedFrom, unreadable: String(error) };
+    }
+};
+const isUnder = (path, root) => !relative(root, path).startsWith('..');
+const testsIn = async ({ scratch, changes, roots, }) => {
+    const files = await Promise.all(changes.flatMap(change => {
+        const reader = roots.find(({ reader, root }) => reader.isTestFile(change.to) && isUnder(change.to, root))?.reader;
+        return reader === undefined ? [] : [testFileAt({ scratch, change, reader })];
+    }));
+    return files.filter(file => !('statements' in file) || file.statements.length > 0);
+};
+const configAt = async (repo, revision) => {
+    if ((await git(repo, 'ls-tree', '--name-only', revision, '--', CONFIG_FILE)) !== '')
+        return parseConfig(await git(repo, 'show', `${revision}:${CONFIG_FILE}`));
+    return parseConfig((await textIn(repo, CONFIG_FILE)) ?? '{}');
+};
+const resolve = (repo, revision) => git(repo, 'rev-parse', '--verify', '--quiet', `${revision}^{commit}`).catch(() => {
+    throw new Error(`Unknown revision: ${revision}`);
+});
+export const readRange = async ({ repo, from, to }) => {
+    const [fromCommit, toCommit] = await Promise.all([resolve(repo, from), resolve(repo, to)]);
+    const base = await git(repo, 'merge-base', fromCommit, toCommit);
+    const config = await configAt(repo, toCommit);
+    const scratch = await realpath(await mkdtemp(join(tmpdir(), 'visual-review-')));
+    try {
+        const before = await readSide({
+            repo,
+            revision: base,
+            directory: join(scratch, 'before'),
+            config,
+        });
+        const after = await readSide({
+            repo,
+            revision: toCommit,
+            directory: join(scratch, 'after'),
+            config,
+        });
+        checkConfig(config, [...before.stacks, ...after.stacks], linkers);
+        const changes = (await git(repo, 'diff', '--find-renames', '--name-status', base, toCommit))
+            .split('\n')
+            .filter(line => line !== '')
+            .map(line => line.split('\t').slice(1));
+        return {
+            before: before.graph,
+            after: after.graph,
+            danglingCalls: after.danglingCalls,
+            skipped: skippedAcross([...before.skipped, ...after.skipped]),
+            changedPaths: changes.flat(),
+            renames: changes.flatMap(([from = '', to]) => (to === undefined ? [] : [{ from, to }])),
+            tests: withMovedTests(await testsIn({
+                scratch,
+                changes: changes.map(([from = '', to = from]) => ({ from, to })),
+                roots: [...before.roots, ...after.roots],
+            })),
+            patches: await Promise.all(changes.map(async (paths) => ({
+                path: paths.at(-1) ?? '',
+                patch: await git(repo, 'diff', '--find-renames', base, toCommit, '--', ...paths),
+            }))),
+        };
+    }
+    finally {
+        await rm(scratch, { recursive: true });
+        await git(repo, 'worktree', 'prune');
+    }
+};

package/dist/reader.d.ts

@@ -0,0 +1,30 @@
+import type { Config, ReaderName } from './config.ts';
+import type { Graph } from './graph.ts';
+import type { ReadTest } from './test-statements.ts';
+export type Checkout = {
+    readonly directory: string;
+    readonly repoName: string;
+    readonly config: Config;
+    readonly taken: ReadonlySet<string>;
+};
+export type OpenedCheckout = {
+    readonly stacks: ReadonlyMap<string, string>;
+    readonly graph: (root: string) => Promise<Graph>;
+};
+/**
+ * Reads one stack of a checkout. `open` looks at a checkout once, given the reviewed repo's folder
+ * name for a stack with no name of its own, the review's config and the ids readers before it took: `stacks` maps each directory,
+ * relative to the checkout, where a stack is found (none when it isn't) to the id the stack is
+ * drawn under, and `graph` reads one of those roots into nodes and edges. The reader also owns its
+ * test files, saying which paths they are and how their tests read. `tool` names the command its
+ * `graph` runs, if any: when it isn't on `PATH`, none of the reader's stacks is read, and the
+ * review lists them as skipped.
+ */
+export interface Reader {
+    readonly name: ReaderName;
+    readonly tool?: string;
+    readonly stackFields: ReadonlyArray<string>;
+    readonly open: (checkout: Checkout) => OpenedCheckout;
+    readonly isTestFile: (path: string) => boolean;
+    readonly readTests: (text: string) => ReadonlyArray<ReadTest>;
+}

package/dist/reader.js

@@ -0,0 +1 @@
+export {};

package/dist/readers/rust.d.ts

@@ -0,0 +1,2 @@
+import type { Reader } from '../reader.ts';
+export declare const rustReader: Reader;

package/dist/readers/rust.js

@@ -0,0 +1,66 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { promisify } from 'node:util';
+import { addedStacks } from '../config.js';
+import { crateGraph, crateRoots } from '../crate-graph.js';
+import { crateModules } from '../crate-modules.js';
+import { readRustTests } from '../rust-tests.js';
+import { sourcesIn } from '../sources-in.js';
+const run = promisify(execFile);
+const reviewersToolchain = (outside) => run('rustup', ['show', 'active-toolchain'], { cwd: outside }).then(({ stdout }) => ({ ...process.env, RUSTUP_TOOLCHAIN: stdout.split(' ')[0] }), () => process.env);
+const graphAt = async (checkout, root) => {
+    const directory = join(checkout, root);
+    const { stdout } = await run('cargo', [
+        'metadata',
+        '--no-deps',
+        '--format-version',
+        '1',
+        '--manifest-path',
+        join(directory, 'Cargo.toml'),
+    ], { cwd: directory, env: await reviewersToolchain(dirname(checkout)) });
+    const crates = crateGraph(stdout);
+    const modules = await Promise.all(crateRoots(stdout).map(async ({ crate, directory: crateDirectory, roots }) => {
+        const files = await sourcesIn(directory, join(crateDirectory, '**/*.rs'));
+        const sources = Object.fromEntries(files.map(({ file, text }) => [file, text]));
+        return crateModules({ crate, roots, sources });
+    }));
+    return {
+        nodes: [...crates.nodes, ...modules.flatMap(graph => graph.nodes)],
+        edges: [...crates.edges, ...modules.flatMap(graph => graph.edges)],
+    };
+};
+const rebased = (graph, { stack, root }) => {
+    const id = (old) => `${stack}${old.slice('rust'.length)}`;
+    return {
+        nodes: graph.nodes.map(node => ({
+            ...node,
+            id: id(node.id),
+            label: node.parent === undefined ? stack : node.label,
+            ...(node.parent === undefined ? {} : { parent: id(node.parent) }),
+            path: node.kind === 'stack' ? '' : join(root, node.path),
+        })),
+        edges: graph.edges.map(edge => ({ ...edge, from: id(edge.from), to: id(edge.to) })),
+    };
+};
+const isWorkspace = (directory) => existsSync(join(directory, 'Cargo.toml'));
+export const rustReader = {
+    name: 'rust',
+    tool: 'cargo',
+    stackFields: [],
+    open: ({ directory, config, taken }) => {
+        const detected = new Map(isWorkspace(directory) ? [['.', 'rust']] : []);
+        const stacks = new Map([
+            ...detected,
+            ...addedStacks({ config, reader: 'rust', detected, taken })
+                .filter(({ root }) => isWorkspace(join(directory, root)))
+                .map(({ root, stack }) => [root, stack]),
+        ]);
+        return {
+            stacks,
+            graph: async (root) => rebased(await graphAt(directory, root), { stack: stacks.get(root) ?? 'rust', root }),
+        };
+    },
+    isTestFile: path => path.endsWith('.rs'),
+    readTests: readRustTests,
+};

package/dist/readers/typescript.d.ts

@@ -0,0 +1,2 @@
+import type { Reader } from '../reader.ts';
+export declare const typeScriptReader: Reader;

package/dist/readers/typescript.js

@@ -0,0 +1,124 @@
+import { existsSync, globSync, readFileSync, statSync } from 'node:fs';
+import { basename, dirname, join, relative } from 'node:path';
+import { cruise } from 'dependency-cruiser';
+import { parse } from 'jsonc-parser';
+import { z } from 'zod';
+import { addedStacks, folderOf, stackSettings } from '../config.js';
+import { readTypeScriptTests } from '../test-statements.js';
+import { webGraph } from '../web-graph.js';
+const TEST_FILE = /\.(test|spec)\.[cm]?[jt]sx?$/;
+const SOURCES = '**/*.{ts,tsx,js,jsx,mjs,cjs}';
+const TsconfigSchema = z.object({
+    compilerOptions: z.object({ rootDir: z.string().optional() }).optional(),
+    include: z.array(z.string()).optional(),
+});
+const tsconfigIn = (directory) => {
+    const tsconfig = join(directory, 'tsconfig.json');
+    return existsSync(tsconfig)
+        ? (TsconfigSchema.safeParse(parse(readFileSync(tsconfig, 'utf8'))).data ?? {})
+        : {};
+};
+const isDirectory = (path) => existsSync(path) && statSync(path).isDirectory();
+const includedFolders = (directory, include) => [
+    ...new Set(include
+        .map(entry => folderOf(entry.replace(/[*?{[].*$/, '')))
+        .filter(folder => folder !== '.' && isDirectory(join(directory, folder)))),
+];
+const sourceRootOf = (directory) => {
+    const { compilerOptions, include = [] } = tsconfigIn(directory);
+    const [folder, ...others] = includedFolders(directory, include);
+    const rootDir = compilerOptions?.rootDir;
+    if (rootDir !== undefined)
+        return folderOf(rootDir);
+    return folder !== undefined && others.length === 0 ? folder : 'src';
+};
+const PackageSchema = z.object({ name: z.string().optional() });
+const packageNameIn = (directory) => {
+    const manifest = join(directory, 'package.json');
+    return existsSync(manifest)
+        ? PackageSchema.safeParse(parse(readFileSync(manifest, 'utf8'))).data?.name
+        : undefined;
+};
+const stackAt = ({ checkout: { directory, repoName }, root }) => root === '.' ? (packageNameIn(directory) ?? repoName) : root;
+const sourceRootIn = ({ checkout: { directory, config }, root, stack }) => {
+    const { sourceRoot } = stackSettings(config, stack);
+    return sourceRoot === undefined ? sourceRootOf(join(directory, root)) : folderOf(sourceRoot);
+};
+const hasSources = ({ checkout, root }) => globSync(SOURCES, {
+    cwd: join(checkout.directory, root, sourceRootIn({ checkout, root, stack: stackAt({ checkout, root }) })),
+}).length > 0;
+const holdsOthers = ({ checkout, root, roots }) => {
+    const folder = join(root, sourceRootOf(join(checkout, root)));
+    return roots.some(other => other !== root && !relative(folder, other).startsWith('..'));
+};
+const rootsIn = (checkout) => {
+    const roots = globSync('**/package.json', {
+        cwd: checkout.directory,
+        exclude: path => basename(path) === 'node_modules',
+    })
+        .map(dirname)
+        .filter(root => hasSources({ checkout, root }))
+        .toSorted();
+    return roots.filter(root => !holdsOthers({ checkout: checkout.directory, root, roots }));
+};
+const stacksIn = (checkout, roots) => roots.reduce((sofar, root) => {
+    const stack = stackAt({ checkout, root });
+    const free = (n) => sofar.used.has(`${stack}~${n}`) ? free(n + 1) : `${stack}~${n}`;
+    const id = sofar.used.has(stack) ? free(2) : stack;
+    return { used: new Set([...sofar.used, id]), stacks: new Map([...sofar.stacks, [root, id]]) };
+}, { used: checkout.taken, stacks: new Map() }).stacks;
+const packagesIn = (directory, stacks) => new Map([...stacks].flatMap(([root, stack]) => {
+    const name = packageNameIn(join(directory, root));
+    return name === undefined ? [] : [[name, stack]];
+}));
+const graphAt = async ({ directory, root, stack, sourceRoot, boxes, packages }) => {
+    const { output } = await cruise([sourceRoot], {
+        baseDir: join(directory, root),
+        outputType: 'json',
+    });
+    return webGraph({
+        stack,
+        directory: root,
+        sourceRoot,
+        boxes,
+        cruiseJson: String(output),
+        packages,
+    });
+};
+export const typeScriptReader = {
+    name: 'typescript',
+    stackFields: ['boxes', 'sourceRoot'],
+    open: checkout => {
+        const { directory, config } = checkout;
+        const detected = rootsIn(checkout);
+        const detectedStacks = stacksIn(checkout, detected);
+        const added = addedStacks({
+            config,
+            reader: 'typescript',
+            detected: detectedStacks,
+            taken: checkout.taken,
+        }).filter(({ root, stack }) => isDirectory(join(directory, root, sourceRootIn({ checkout, root, stack }))));
+        const stacks = new Map([
+            ...detectedStacks,
+            ...added.map(({ root, stack }) => [root, stack]),
+        ]);
+        const packages = packagesIn(directory, stacks);
+        return {
+            stacks,
+            graph: root => {
+                const stack = stacks.get(root) ?? root;
+                const { boxes = [] } = stackSettings(config, stack);
+                return graphAt({
+                    directory,
+                    root,
+                    stack,
+                    sourceRoot: sourceRootIn({ checkout, root, stack }),
+                    boxes,
+                    packages,
+                });
+            },
+        };
+    },
+    isTestFile: path => TEST_FILE.test(path),
+    readTests: readTypeScriptTests,
+};

package/dist/rust-syntax.d.ts

@@ -0,0 +1,10 @@
+import { type Node } from 'web-tree-sitter';
+export declare const parseRust: (text: string) => Node | undefined;
+type Item = {
+    readonly node: Node;
+    readonly attributes: ReadonlyArray<Node>;
+};
+export declare const itemsIn: (list: Node) => ReadonlyArray<Item>;
+export declare const attributeOf: (item: Node) => Node | undefined;
+export declare const isCfgTest: (item: Node) => boolean;
+export {};

package/dist/rust-syntax.js

@@ -0,0 +1,11 @@
+import { createRequire } from 'node:module';
+import { Language, Parser } from 'web-tree-sitter';
+await Parser.init();
+const parser = new Parser();
+parser.setLanguage(await Language.load(createRequire(import.meta.url).resolve('tree-sitter-rust/tree-sitter-rust.wasm')));
+export const parseRust = (text) => parser.parse(text)?.rootNode;
+export const itemsIn = (list) => list.namedChildren.reduce(({ items, attributes }, child) => child.type === 'attribute_item'
+    ? { items, attributes: [...attributes, child] }
+    : { items: [...items, { node: child, attributes }], attributes: [] }, { items: [], attributes: [] }).items;
+export const attributeOf = (item) => item.namedChildren[0];
+export const isCfgTest = (item) => attributeOf(item)?.text === 'cfg(test)';

package/dist/rust-tests.d.ts

@@ -0,0 +1,2 @@
+import type { ReadTest } from './test-statements.ts';
+export declare const readRustTests: (text: string) => ReadonlyArray<ReadTest>;

package/dist/rust-tests.js

@@ -0,0 +1,24 @@
+import { attributeOf, isCfgTest, itemsIn, parseRust } from './rust-syntax.js';
+const pathOf = (item) => attributeOf(item)?.namedChildren[0]?.text;
+const isTestAttribute = (item) => pathOf(item)?.split('::').at(-1) === 'test';
+const isIgnore = (item) => pathOf(item) === 'ignore';
+const spaced = (name) => (name ?? '').replaceAll('_', ' ');
+export const readRustTests = (text) => {
+    const statementsIn = (list) => itemsIn(list).flatMap(({ node, attributes }) => {
+        const name = spaced(node.childForFieldName('name')?.text);
+        if (attributes.some(isTestAttribute)) {
+            const source = [...attributes, node].map(part => part.text).join('\n');
+            const label = attributes.some(isIgnore) ? 'skip' : undefined;
+            return [{ kind: 'test', name, label, source }];
+        }
+        const body = node.childForFieldName('body');
+        if (body === null)
+            return [];
+        const children = statementsIn(body);
+        if (attributes.some(isCfgTest))
+            return children;
+        return children.length === 0 ? [] : [{ kind: 'heading', name, children }];
+    });
+    const root = parseRust(text);
+    return root === undefined ? [] : statementsIn(root);
+};

package/dist/skipped.d.ts

@@ -0,0 +1,7 @@
+import type { ReaderName } from './config.ts';
+export type Skipped = {
+    readonly reader: ReaderName;
+    readonly tool: string;
+    readonly stacks: ReadonlyArray<string>;
+};
+export declare const notReadLine: ({ tool, stacks }: Skipped) => string;

package/dist/skipped.js

@@ -0,0 +1 @@
+export const notReadLine = ({ tool, stacks }) => `${stacks.join(', ')} not read: ${tool} not found on PATH`;

package/dist/sources-in.d.ts

@@ -0,0 +1,5 @@
+export type SourceFile = {
+    readonly file: string;
+    readonly text: string;
+};
+export declare const sourcesIn: (directory: string, pattern: string) => Promise<ReadonlyArray<SourceFile>>;

package/dist/sources-in.js

@@ -0,0 +1,7 @@
+import { globSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export const sourcesIn = (directory, pattern) => Promise.all(globSync(pattern, { cwd: directory }).map(async (file) => ({
+    file,
+    text: await readFile(join(directory, file), 'utf8'),
+})));

package/dist/test-statements.d.ts

@@ -0,0 +1,46 @@
+export type TestChange = 'added' | 'removed' | 'edited' | 'unchanged';
+export type TestLabel = 'skip' | 'only' | 'todo';
+export type TestStatement = {
+    readonly kind: 'test';
+    readonly name: string;
+    readonly change: TestChange;
+    readonly label?: TestLabel | undefined;
+    readonly movedTo?: string;
+    readonly movedFrom?: string;
+} | {
+    readonly kind: 'heading';
+    readonly name: string;
+    readonly label?: TestLabel | undefined;
+    readonly children: ReadonlyArray<TestStatement>;
+};
+export type TestFile = {
+    readonly path: string;
+    readonly renamedFrom?: string | undefined;
+} & ({
+    readonly statements: ReadonlyArray<TestStatement>;
+} | {
+    readonly unreadable: string;
+});
+export type ReadTest = {
+    readonly kind: 'test';
+    readonly name: string;
+    readonly label?: TestLabel | undefined;
+    readonly source: string;
+} | {
+    readonly kind: 'heading';
+    readonly name: string;
+    readonly label?: TestLabel | undefined;
+    readonly children: ReadonlyArray<ReadTest>;
+};
+export declare const readTypeScriptTests: (text: string) => ReadonlyArray<ReadTest>;
+type TestChangesOptions = {
+    readonly read: (text: string) => ReadonlyArray<ReadTest>;
+    readonly before?: string | undefined;
+    readonly after?: string | undefined;
+};
+export declare const testChanges: ({ read, before, after, }: TestChangesOptions) => ReadonlyArray<TestStatement>;
+export type MarkedTest = Extract<TestStatement, {
+    kind: 'test';
+}>;
+export declare const withMovedTests: (files: ReadonlyArray<TestFile>) => ReadonlyArray<TestFile>;
+export {};

package/dist/test-statements.js

@@ -0,0 +1,121 @@
+import { parse } from '@babel/parser';
+const TEST_CALLS = new Set(['test', 'it']);
+const HEADING_CALLS = new Set(['describe', 'test.describe']);
+const LABELS = new Map([
+    ['skip', 'skip'],
+    ['only', 'only'],
+    ['todo', 'todo'],
+]);
+const TABLES = new Set(['each', 'for']);
+const calleeParts = (callee) => {
+    if (callee.type === 'Identifier')
+        return [callee.name];
+    if (callee.type === 'CallExpression')
+        return calleeParts(callee.callee);
+    if (callee.type === 'TaggedTemplateExpression')
+        return calleeParts(callee.tag);
+    if (callee.type !== 'MemberExpression' || callee.property.type !== 'Identifier')
+        return [];
+    return [...calleeParts(callee.object), callee.property.name];
+};
+export const readTypeScriptTests = (text) => {
+    const statementsIn = (body) => body.flatMap(statement => {
+        if (statement.type !== 'ExpressionStatement')
+            return [];
+        const call = statement.expression;
+        if (call.type !== 'CallExpression')
+            return [];
+        const parts = calleeParts(call.callee);
+        const callee = parts.filter(part => !LABELS.has(part) && !TABLES.has(part)).join('.');
+        const label = parts.map(part => LABELS.get(part)).find(Boolean);
+        const [name, callback] = call.arguments;
+        if (name === undefined)
+            return [];
+        const isTable = call.callee.type !== 'MemberExpression' && call.callee.type !== 'Identifier';
+        const shown = name.type === 'StringLiteral' && !isTable
+            ? name.value
+            : text.slice(name.start ?? undefined, name.end ?? undefined);
+        if (TEST_CALLS.has(callee)) {
+            const source = text.slice(statement.start ?? undefined, statement.end ?? undefined);
+            return [{ kind: 'test', name: shown, label, source }];
+        }
+        if (!HEADING_CALLS.has(callee))
+            return [];
+        if (callback?.type !== 'ArrowFunctionExpression' || callback.body.type !== 'BlockStatement') {
+            return [];
+        }
+        return [{ kind: 'heading', name: shown, label, children: statementsIn(callback.body.body) }];
+    });
+    return statementsIn(parse(text, { sourceType: 'module', plugins: ['typescript', 'jsx'] }).program.body);
+};
+const allMarked = (tests, change) => tests.map(test => test.kind === 'test'
+    ? { kind: 'test', name: test.name, change, label: test.label }
+    : {
+        kind: 'heading',
+        name: test.name,
+        label: test.label,
+        children: allMarked(test.children, change),
+    });
+const sameTest = (one, other) => one.kind === other.kind && one.name === other.name;
+const comparedPair = (old, test) => {
+    if (old?.kind === 'heading' && test.kind === 'heading') {
+        return [
+            {
+                kind: 'heading',
+                name: test.name,
+                label: test.label,
+                children: compared(old.children, test.children),
+            },
+        ];
+    }
+    if (old?.kind !== 'test' || test.kind !== 'test')
+        return allMarked([test], 'added');
+    return [
+        {
+            kind: 'test',
+            name: test.name,
+            change: old.source === test.source ? 'unchanged' : 'edited',
+            label: test.label,
+        },
+    ];
+};
+const compared = (before, after) => {
+    const kept = (test) => after.some(candidate => sameTest(candidate, test));
+    const removedAfter = (anchor) => allMarked(before.filter((test, index) => !kept(test) && before.slice(0, index).findLast(kept) === anchor), 'removed');
+    return [
+        ...removedAfter(undefined),
+        ...after.flatMap(test => {
+            const old = before.find(candidate => sameTest(candidate, test));
+            return [...comparedPair(old, test), ...(old === undefined ? [] : removedAfter(old))];
+        }),
+    ];
+};
+const anyChanged = (statements) => statements.some(statement => statement.kind === 'test' ? statement.change !== 'unchanged' : anyChanged(statement.children));
+export const testChanges = ({ read, before, after, }) => {
+    const readTests = (text) => (text === undefined ? [] : read(text));
+    const statements = compared(readTests(before), readTests(after));
+    return anyChanged(statements) ? statements : [];
+};
+const testsUnder = (statements) => statements.flatMap(statement => statement.kind === 'test' ? [statement] : testsUnder(statement.children));
+export const withMovedTests = (files) => {
+    const pathsWhere = (name, change) => files.flatMap(file => 'statements' in file
+        ? testsUnder(file.statements)
+            .filter(test => test.name === name && test.change === change)
+            .map(() => file.path)
+        : []);
+    const otherEnd = (test) => {
+        const [from, ...moreFrom] = pathsWhere(test.name, 'removed');
+        const [to, ...moreTo] = pathsWhere(test.name, 'added');
+        if (from === undefined || to === undefined || from === to)
+            return {};
+        if (moreFrom.length > 0 || moreTo.length > 0)
+            return {};
+        if (test.change === 'removed')
+            return { movedTo: to };
+        return test.change === 'added' ? { movedFrom: from } : {};
+    };
+    const marked = (statement) => statement.kind === 'test'
+        ? { ...statement, ...otherEnd(statement) }
+        : { ...statement, children: statement.children.map(marked) };
+    return files.map(file => 'statements' in file ? { ...file, statements: file.statements.map(marked) } : file);
+};

package/dist/viewer/review-data.d.ts

@@ -0,0 +1,18 @@
+import type { GraphDiff } from '../diff-graphs.ts';
+import type { DanglingCall } from '../linker.ts';
+import type { ReviewNotes } from '../notes.ts';
+import type { PullRequest } from '../pull-request.ts';
+import type { FilePatch } from '../read-range.ts';
+import type { Skipped } from '../skipped.ts';
+import type { TestFile } from '../test-statements.ts';
+export type ReviewData = {
+    readonly range: string;
+    readonly pullRequest?: PullRequest;
+    readonly diff: GraphDiff;
+    readonly dangling?: ReadonlyArray<DanglingCall>;
+    readonly patches?: ReadonlyArray<FilePatch>;
+    readonly undrawn?: ReadonlyArray<FilePatch>;
+    readonly tests?: ReadonlyArray<TestFile>;
+    readonly notes?: ReviewNotes;
+    readonly skipped?: ReadonlyArray<Skipped>;
+};

package/dist/viewer/review-data.js

@@ -0,0 +1 @@
+export {};