website

import { html as renderDiffHtml, parse as parseDiff } from "diff2html";
import { readCache, writeCache } from "../_helpers/dataCache.js";
import { discoverLocalRepos, getCommitDiff, getHeadSha } from "../_helpers/gitRepos.js";
import { mapPool } from "../_helpers/pool.js";

const CONCURRENCY = 8;

// Some repos have vendored/generated/binary-as-text blobs committed at some
// point in their history (a minified bundle, a compiled binary git doesn't
// detect as binary, ...) — `git show -p` dumps the whole file as a diff on
// every commit that touches it, and diff2html's per-line markup multiplies
// that further. Left unguarded, that's easily 100s of MB of HTML per repo,
// held for every commit at once across every repo — well past Node's default
// heap. Cap it the way GitHub's own diff viewer does: skip rendering past a
// size threshold rather than trying to syntax-highlight a multi-MB blob.
const MAX_DIFF_SIZE = 300 * 1024;
const DIFF_TOO_LARGE_HTML = '<p class="diff-too-large">This diff is too large to display.</p>';

const toDiffHtml = (diffText) => {
  const idx = diffText.indexOf("diff --git");
  const patch = idx >= 0 ? diffText.slice(idx) : "";
  if (!patch.trim()) return "";
  if (patch.length > MAX_DIFF_SIZE) return DIFF_TOO_LARGE_HTML;
  try {
    const json = parseDiff(patch);
    return renderDiffHtml(json, { drawFileList: true, matching: "lines" });
  } catch {
    return "";
  }
};

export default async () => {
  const repos = discoverLocalRepos();
  const pages = [];
  for (const repo of repos) {
    // Unlike repoFiles.js, none of this reads the working tree — `git
    // show` only ever sees committed history — so it's safe to cache on
    // HEAD sha alone, with no working-tree-clean requirement. That
    // matters because this repo (website) is usually dirty while it's
    // being actively worked on, and its commit history is the most
    // expensive part of the build.
    const sha = getHeadSha(repo.dir);
    const cacheKey = `commits-${repo.id}`;

    let entries = sha ? readCache(cacheKey, sha) : null;
    if (!entries) {
      entries = await mapPool(repo.commits, CONCURRENCY, async (commit) => {
        const diffText = await getCommitDiff(repo.dir, commit.hash);
        return { commit, diffHtml: toDiffHtml(diffText) };
      });
      if (sha) writeCache(cacheKey, sha, entries);
    }

    // Only `id`/`data`/`version` ever get read off `item.repo` in
    // commit.njk — not the full `repo` object's `files`/`tree`/`commits`/
    // `readme`. Eleventy's paginator deep-clones each page's data slice for
    // isolation, so embedding the whole repo (every commit's metadata,
    // every file, the tree, the README) here means that whole structure
    // gets cloned once per commit page — the actual multiplier behind the
    // OOM, not just the diff HTML size.
    const slimRepo = { id: repo.id, data: repo.data, version: repo.version };
    for (const entry of entries) pages.push({ repoId: repo.id, repo: slimRepo, ...entry });
  }
  return pages;
};