ppt-template-reuse 0.4.0-rc.2

package/src/core/renderer.mjs

@@ -0,0 +1,402 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { pathToFileURL } from "node:url";
+
+import pixelmatch from "pixelmatch";
+import { PNG } from "pngjs";
+
+import { exists } from "./io.mjs";
+import { extractSource } from "./source-extractor.mjs";
+
+function executableCandidates() {
+  const candidates = [
+    "soffice",
+    "libreoffice",
+    "/Applications/LibreOffice.app/Contents/MacOS/soffice",
+  ];
+  for (const root of [
+    process.env.ProgramFiles,
+    process.env["ProgramFiles(x86)"],
+  ].filter(Boolean)) {
+    candidates.push(path.join(root, "LibreOffice", "program", "soffice.exe"));
+  }
+  return candidates;
+}
+
+function canRun(command) {
+  const result = spawnSync(command, ["--version"], {
+    encoding: "utf8",
+    timeout: 10000,
+  });
+  return result.status === 0
+    ? String(result.stdout || result.stderr || "").trim()
+    : null;
+}
+
+export async function locateLibreOffice(explicit) {
+  for (const candidate of [explicit, ...executableCandidates()].filter(Boolean)) {
+    if (path.isAbsolute(candidate) && !(await exists(candidate))) continue;
+    const version = canRun(candidate);
+    if (version) return { command: candidate, version };
+  }
+  return null;
+}
+
+async function loadCanvasRuntime() {
+  const canvas = await import("@napi-rs/canvas").catch(() => null);
+  if (!canvas) {
+    const error = new Error(
+      "The optional @napi-rs/canvas runtime is required for PDF page rendering",
+    );
+    error.code = "CANVAS_RUNTIME_REQUIRED";
+    throw error;
+  }
+  for (const key of ["DOMMatrix", "ImageData", "Path2D"]) {
+    if (canvas[key] && !globalThis[key]) globalThis[key] = canvas[key];
+  }
+  return canvas;
+}
+
+function sha256(bytes) {
+  return crypto.createHash("sha256").update(bytes).digest("hex");
+}
+
+export async function renderPdfPages({
+  pdfPath,
+  outputDir,
+  dpi = 144,
+  prefix = "slide",
+}) {
+  const canvasRuntime = await loadCanvasRuntime();
+  const pdfjs = await import("pdfjs-dist/legacy/build/pdf.mjs");
+  const data = new Uint8Array(await fs.readFile(pdfPath));
+  const document = await pdfjs.getDocument({
+    data,
+    disableFontFace: false,
+    isEvalSupported: false,
+    useSystemFonts: true,
+    verbosity: 0,
+  }).promise;
+  await fs.mkdir(outputDir, { recursive: true });
+  const pages = [];
+  for (let pageNumber = 1; pageNumber <= document.numPages; pageNumber += 1) {
+    const page = await document.getPage(pageNumber);
+    const viewport = page.getViewport({ scale: dpi / 72 });
+    const canvas = canvasRuntime.createCanvas(
+      Math.ceil(viewport.width),
+      Math.ceil(viewport.height),
+    );
+    const context = canvas.getContext("2d");
+    await page.render({ canvasContext: context, viewport }).promise;
+    const bytes = canvas.toBuffer("image/png");
+    const output = path.join(
+      outputDir,
+      `${prefix}-${String(pageNumber).padStart(2, "0")}.png`,
+    );
+    await fs.writeFile(output, bytes);
+    pages.push({
+      page: pageNumber,
+      path: output,
+      width: canvas.width,
+      height: canvas.height,
+      sha256: sha256(bytes),
+    });
+  }
+  return pages;
+}
+
+export async function createMontage({ pages, outputPath, columns = 4 }) {
+  if (!pages.length) throw new Error("Cannot create a montage without pages");
+  const canvasRuntime = await loadCanvasRuntime();
+  const images = await Promise.all(
+    pages.map((page) => canvasRuntime.loadImage(page.path)),
+  );
+  const thumbWidth = 360;
+  const ratio = images[0].height / images[0].width;
+  const thumbHeight = Math.round(thumbWidth * ratio);
+  const gap = 16;
+  const rows = Math.ceil(images.length / columns);
+  const canvas = canvasRuntime.createCanvas(
+    columns * thumbWidth + (columns + 1) * gap,
+    rows * thumbHeight + (rows + 1) * gap,
+  );
+  const context = canvas.getContext("2d");
+  context.fillStyle = "#e5e7eb";
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  images.forEach((image, index) => {
+    const column = index % columns;
+    const row = Math.floor(index / columns);
+    const x = gap + column * (thumbWidth + gap);
+    const y = gap + row * (thumbHeight + gap);
+    context.drawImage(image, x, y, thumbWidth, thumbHeight);
+  });
+  const bytes = canvas.toBuffer("image/png");
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, bytes);
+  return { path: outputPath, sha256: sha256(bytes) };
+}
+
+export async function renderPptx({
+  pptxPath,
+  workspace,
+  libreOffice,
+  dpi = 144,
+}) {
+  const located = await locateLibreOffice(libreOffice);
+  if (!located) {
+    const error = new Error(
+      "LibreOffice is required before a final PPTX can be visually validated",
+    );
+    error.code = "RENDERER_REQUIRED";
+    throw error;
+  }
+  const root = path.resolve(workspace);
+  const pdfDir = path.join(root, "pdf");
+  const pageDir = path.join(root, "pages");
+  const profileDir = path.join(root, "libreoffice-profile");
+  await fs.mkdir(pdfDir, { recursive: true });
+  await fs.mkdir(profileDir, { recursive: true });
+  const result = spawnSync(
+    located.command,
+    [
+      "--headless",
+      `-env:UserInstallation=${pathToFileURL(profileDir).href}`,
+      "--convert-to",
+      "pdf",
+      "--outdir",
+      pdfDir,
+      path.resolve(pptxPath),
+    ],
+    {
+      encoding: "utf8",
+      maxBuffer: 64 * 1024 * 1024,
+      timeout: 180000,
+    },
+  );
+  if (result.status !== 0) {
+    throw new Error(
+      String(result.stderr || result.stdout || "LibreOffice conversion failed"),
+    );
+  }
+  const pdfPath = path.join(
+    pdfDir,
+    `${path.basename(pptxPath, path.extname(pptxPath))}.pdf`,
+  );
+  if (!(await exists(pdfPath))) {
+    throw new Error(`LibreOffice did not create ${pdfPath}`);
+  }
+  const pages = await renderPdfPages({ pdfPath, outputDir: pageDir, dpi });
+  const montage = await createMontage({
+    pages,
+    outputPath: path.join(root, "contact-sheet.png"),
+  });
+  return {
+    renderer: located,
+    pdfPath,
+    pages,
+    montage,
+  };
+}
+
+export async function comparePng({
+  expectedPath,
+  actualPath,
+  diffPath,
+  threshold = 0.1,
+}) {
+  const expected = PNG.sync.read(await fs.readFile(expectedPath));
+  const actual = PNG.sync.read(await fs.readFile(actualPath));
+  if (expected.width !== actual.width || expected.height !== actual.height) {
+    return {
+      passed: false,
+      reason: "dimension-mismatch",
+      expected: { width: expected.width, height: expected.height },
+      actual: { width: actual.width, height: actual.height },
+    };
+  }
+  const diff = new PNG({ width: expected.width, height: expected.height });
+  const changedPixels = pixelmatch(
+    expected.data,
+    actual.data,
+    diff.data,
+    expected.width,
+    expected.height,
+    { threshold },
+  );
+  if (diffPath) await fs.writeFile(diffPath, PNG.sync.write(diff));
+  const ratio = changedPixels / (expected.width * expected.height);
+  return {
+    passed: ratio <= 0.002,
+    changedPixels,
+    changedPixelRatio: ratio,
+    diffPath,
+  };
+}
+
+export async function compareProtectedPng({
+  expectedPath,
+  actualPath,
+  editableBoxes = [],
+  canvas,
+  diffPath,
+  threshold = 0.1,
+  maxChangedPixelRatio = 0.002,
+}) {
+  const expected = PNG.sync.read(await fs.readFile(expectedPath));
+  const actual = PNG.sync.read(await fs.readFile(actualPath));
+  if (expected.width !== actual.width || expected.height !== actual.height) {
+    return {
+      passed: false,
+      reason: "dimension-mismatch",
+      expected: { width: expected.width, height: expected.height },
+      actual: { width: actual.width, height: actual.height },
+    };
+  }
+  const compared = PNG.sync.read(PNG.sync.write(actual));
+  const editable = new Uint8Array(expected.width * expected.height);
+  const scaleX = expected.width / Number(canvas?.width || 960);
+  const scaleY = expected.height / Number(canvas?.height || 540);
+  for (const box of editableBoxes) {
+    const padding = 3;
+    const x0 = Math.max(0, Math.floor(Number(box.x || 0) * scaleX) - padding);
+    const y0 = Math.max(0, Math.floor(Number(box.y || 0) * scaleY) - padding);
+    const x1 = Math.min(
+      expected.width,
+      Math.ceil((Number(box.x || 0) + Number(box.width || 0)) * scaleX) +
+        padding,
+    );
+    const y1 = Math.min(
+      expected.height,
+      Math.ceil((Number(box.y || 0) + Number(box.height || 0)) * scaleY) +
+        padding,
+    );
+    for (let y = y0; y < y1; y += 1) {
+      for (let x = x0; x < x1; x += 1) {
+        const pixel = y * expected.width + x;
+        editable[pixel] = 1;
+        const offset = pixel * 4;
+        compared.data[offset] = expected.data[offset];
+        compared.data[offset + 1] = expected.data[offset + 1];
+        compared.data[offset + 2] = expected.data[offset + 2];
+        compared.data[offset + 3] = expected.data[offset + 3];
+      }
+    }
+  }
+  const diff = new PNG({ width: expected.width, height: expected.height });
+  const rawChanged = pixelmatch(
+    expected.data,
+    compared.data,
+    diff.data,
+    expected.width,
+    expected.height,
+    { threshold },
+  );
+  const protectedPixels =
+    expected.width * expected.height -
+    editable.reduce((sum, value) => sum + value, 0);
+  const ratio = rawChanged / Math.max(1, protectedPixels);
+  if (diffPath) {
+    await fs.mkdir(path.dirname(diffPath), { recursive: true });
+    await fs.writeFile(diffPath, PNG.sync.write(diff));
+  }
+  return {
+    passed: ratio <= maxChangedPixelRatio,
+    changedPixels: rawChanged,
+    protectedPixels,
+    changedPixelRatio: ratio,
+    editableBoxCount: editableBoxes.length,
+    diffPath,
+  };
+}
+
+function comparableText(value) {
+  return String(value || "")
+    .normalize("NFKC")
+    .replace(/[^\p{L}\p{N}]+/gu, "");
+}
+
+function ngrams(value, size = 2) {
+  const characters = [...comparableText(value)];
+  const result = new Set();
+  for (let index = 0; index <= characters.length - size; index += 1) {
+    result.add(characters.slice(index, index + size).join(""));
+  }
+  return result;
+}
+
+function unitsByPage(extraction) {
+  const result = new Map();
+  for (const unit of extraction.units || []) {
+    const page = Number(
+      unit.sourcePage || unit.page || unit.metadata?.page || 0,
+    );
+    if (!page) continue;
+    result.set(
+      page,
+      [result.get(page), unit.text].filter(Boolean).join("\n"),
+    );
+  }
+  return result;
+}
+
+export async function compareRenderedTextFidelity({
+  pptxPath,
+  pdfPath,
+  minimumBigramRecall = 0.72,
+}) {
+  const [pptx, pdf] = await Promise.all([
+    extractSource(pptxPath),
+    extractSource(pdfPath),
+  ]);
+  const expectedByPage = unitsByPage(pptx);
+  const actualByPage = unitsByPage(pdf);
+  const pages = [];
+  for (const [page, expectedText] of expectedByPage) {
+    const expected = comparableText(expectedText);
+    if ([...expected].length < 10) continue;
+    const actual = comparableText(actualByPage.get(page) || "");
+    const expectedNgrams = ngrams(expected);
+    const actualNgrams = ngrams(actual);
+    const matched = [...expectedNgrams].filter((item) =>
+      actualNgrams.has(item),
+    ).length;
+    const bigramRecall =
+      expectedNgrams.size > 0 ? matched / expectedNgrams.size : 1;
+    pages.push({
+      page,
+      expectedCharacters: [...expected].length,
+      renderedCharacters: [...actual].length,
+      expectedBigramCount: expectedNgrams.size,
+      matchedBigramCount: matched,
+      bigramRecall,
+      passed: bigramRecall + Number.EPSILON >= minimumBigramRecall,
+    });
+  }
+  const failures = pages.filter((page) => !page.passed);
+  return {
+    passed: failures.length === 0,
+    minimumBigramRecall,
+    pages,
+    failures,
+    requiresManualOfficeReview: failures.length > 0,
+  };
+}
+
+export async function rendererDoctor(options = {}) {
+  const libreOffice = await locateLibreOffice(options.libreOffice);
+  const canvas = await import("@napi-rs/canvas")
+    .then(() => true)
+    .catch(() => false);
+  return {
+    platform: process.platform,
+    architecture: process.arch,
+    node: process.version,
+    libreOffice,
+    canvas,
+    finalRenderingAvailable: Boolean(libreOffice && canvas),
+    temporaryDirectory: os.tmpdir(),
+  };
+}