@u1f992/pdfdiff 0.0.1 → 0.2.0

package/src/index.ts

@@ -0,0 +1,275 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as jimp from "jimp";
+import * as mupdf from "mupdf";
+import Worker from "web-worker";
+
+import { type Pallet } from "./diff.ts";
+import { isValidAlignStrategy, type AlignStrategy } from "./image.ts";
+import { withIndex } from "./iterable.ts";
+import { parseHex, formatHex } from "./rgba-color.ts";
+import type { JimpInstance } from "./jimp.ts";
+import type {
+  InitMessage,
+  PageMessage,
+  PageResultMessage,
+  ReadyMessage,
+} from "./worker.ts";
+
+export { withIndex, isValidAlignStrategy, parseHex, formatHex };
+
+type Options = {
+  dpi: number;
+  alpha: boolean;
+  mask: Uint8Array | undefined;
+  align: AlignStrategy;
+  pallet: Pallet;
+  workers: number;
+};
+
+type Result = {
+  a: JimpInstance;
+  b: JimpInstance;
+  diff: JimpInstance;
+  addition: [number, number][];
+  deletion: [number, number][];
+  modification: [number, number][];
+};
+
+export const defaultOptions: Options = {
+  dpi: 150,
+  alpha: true,
+  mask: undefined,
+  align: "resize",
+  pallet: {
+    addition: [0x4c, 0xae, 0x4f, 0xff],
+    deletion: [0xff, 0x57, 0x24, 0xff],
+    modification: [0xff, 0xc1, 0x05, 0xff],
+  },
+  workers: 1,
+};
+
+function asSharedBytes(bytes: Uint8Array): Uint8Array {
+  const isNode =
+    typeof globalThis.process !== "undefined" &&
+    !!globalThis.process.versions?.node;
+  const coiOk =
+    (globalThis as { crossOriginIsolated?: boolean }).crossOriginIsolated ===
+    true;
+  if (typeof SharedArrayBuffer !== "undefined" && (isNode || coiOk)) {
+    const sab = new SharedArrayBuffer(bytes.byteLength);
+    const view = new Uint8Array(sab);
+    view.set(bytes);
+    return view;
+  }
+  return new Uint8Array(bytes);
+}
+
+class WorkerHandle {
+  worker: InstanceType<typeof Worker>;
+  private pendingResolve:
+    | ((data: ReadyMessage | PageResultMessage) => void)
+    | null = null;
+  private pendingReject: ((reason: unknown) => void) | null = null;
+
+  constructor(url: URL) {
+    this.worker = new Worker(url, { type: "module" });
+    this.worker.addEventListener(
+      "message",
+      (e: MessageEvent<ReadyMessage | PageResultMessage>) => {
+        const resolve = this.pendingResolve;
+        this.pendingResolve = null;
+        this.pendingReject = null;
+        resolve?.(e.data);
+      },
+    );
+    this.worker.addEventListener("error", (e: ErrorEvent) => {
+      const reject = this.pendingReject;
+      this.pendingResolve = null;
+      this.pendingReject = null;
+      reject?.(e.error ?? new Error(e.message));
+    });
+  }
+
+  init(msg: InitMessage): Promise<ReadyMessage> {
+    return new Promise<ReadyMessage>((resolve, reject) => {
+      this.pendingResolve = resolve as (
+        data: ReadyMessage | PageResultMessage,
+      ) => void;
+      this.pendingReject = reject;
+      this.worker.postMessage(msg);
+    });
+  }
+
+  processPage(index: number): Promise<PageResultMessage> {
+    return new Promise<PageResultMessage>((resolve, reject) => {
+      this.pendingResolve = resolve as (
+        data: ReadyMessage | PageResultMessage,
+      ) => void;
+      this.pendingReject = reject;
+      const msg: PageMessage = { type: "page", index };
+      this.worker.postMessage(msg);
+    });
+  }
+
+  terminate() {
+    this.worker.terminate();
+  }
+}
+
+function workerUrl(): URL {
+  return new URL(
+    import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js",
+    import.meta.url,
+  );
+}
+
+function pageResultToResult(msg: PageResultMessage): Result {
+  return {
+    a: jimp.Jimp.fromBitmap({
+      width: msg.a.width,
+      height: msg.a.height,
+      data: new Uint8Array(msg.a.data),
+    }) as JimpInstance,
+    b: jimp.Jimp.fromBitmap({
+      width: msg.b.width,
+      height: msg.b.height,
+      data: new Uint8Array(msg.b.data),
+    }) as JimpInstance,
+    diff: jimp.Jimp.fromBitmap({
+      width: msg.diff.width,
+      height: msg.diff.height,
+      data: new Uint8Array(msg.diff.data),
+    }) as JimpInstance,
+    addition: msg.addition,
+    deletion: msg.deletion,
+    modification: msg.modification,
+  };
+}
+
+export async function* visualizeDifferences(
+  a: Uint8Array,
+  b: Uint8Array,
+  options: Partial<Omit<Options, "pallet"> & { pallet: Partial<Pallet> }>,
+) {
+  const merged = {
+    dpi: options?.dpi ?? defaultOptions.dpi,
+    alpha: options?.alpha ?? defaultOptions.alpha,
+    mask: options?.mask ?? defaultOptions.mask,
+    align: options?.align ?? defaultOptions.align,
+    pallet: {
+      addition: options?.pallet?.addition ?? defaultOptions.pallet.addition,
+      deletion: options?.pallet?.deletion ?? defaultOptions.pallet.deletion,
+      modification:
+        options?.pallet?.modification ?? defaultOptions.pallet.modification,
+    },
+    workers: options?.workers ?? defaultOptions.workers,
+  };
+
+  const probe = mupdf.PDFDocument.openDocument(a, "application/pdf");
+  const probeB = mupdf.PDFDocument.openDocument(b, "application/pdf");
+  const probeMask =
+    typeof merged.mask !== "undefined"
+      ? mupdf.PDFDocument.openDocument(merged.mask, "application/pdf")
+      : new mupdf.PDFDocument();
+  const maxPages = Math.max(
+    probe.countPages(),
+    probeB.countPages(),
+    probeMask.countPages(),
+  );
+  probe.destroy();
+  probeB.destroy();
+  probeMask.destroy();
+
+  if (maxPages === 0) return;
+
+  const aBytes = asSharedBytes(a);
+  const bBytes = asSharedBytes(b);
+  const maskBytes =
+    typeof merged.mask !== "undefined" ? asSharedBytes(merged.mask) : null;
+
+  const initMsg: InitMessage = {
+    type: "init",
+    aBytes,
+    bBytes,
+    maskBytes,
+    dpi: merged.dpi,
+    alpha: merged.alpha,
+    pallet: merged.pallet,
+    align: merged.align,
+  };
+
+  const N = Math.max(1, Math.min(merged.workers, maxPages));
+  const url = workerUrl();
+  const worker0 = new WorkerHandle(url);
+  await worker0.init(initMsg);
+
+  const buffered = new Map<number, Result>();
+  let nextToAssign = 0;
+
+  const workers: WorkerHandle[] = [worker0];
+  for (let i = 1; i < N; i++) {
+    const w = new WorkerHandle(url);
+    await w.init(initMsg);
+    workers.push(w);
+  }
+
+  const resolvers = new Map<number, (r: Result) => void>();
+  let workerError: unknown = null;
+
+  const loops = workers.map(async (w) => {
+    while (nextToAssign < maxPages && workerError === null) {
+      const idx = nextToAssign++;
+      try {
+        const msg = await w.processPage(idx);
+        const result = pageResultToResult(msg);
+        const resolve = resolvers.get(idx);
+        if (resolve) {
+          resolvers.delete(idx);
+          resolve(result);
+        } else {
+          buffered.set(idx, result);
+        }
+      } catch (e) {
+        workerError = e;
+        for (const [, resolve] of resolvers) resolve(null as never);
+        resolvers.clear();
+        return;
+      }
+    }
+  });
+
+  try {
+    for (let i = 0; i < maxPages; i++) {
+      if (workerError !== null) throw workerError;
+      let r: Result;
+      const buf = buffered.get(i);
+      if (buf !== undefined) {
+        buffered.delete(i);
+        r = buf;
+      } else {
+        r = await new Promise<Result>((resolve) => resolvers.set(i, resolve));
+        if (workerError !== null) throw workerError;
+      }
+      yield r;
+    }
+    await Promise.all(loops);
+  } finally {
+    for (const w of workers) w.terminate();
+  }
+}

package/src/iterable.test.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import assert from "assert";
+import test from "node:test";
+
+import { withIndex } from "./iterable.ts";
+
+test("withIndex", async () => {
+  assert.deepStrictEqual(
+    // @ts-ignore
+    await Array.fromAsync(
+      withIndex(
+        (async function* () {
+          yield "a";
+          yield "b";
+        })(),
+        0,
+      ),
+    ),
+    [
+      [0, "a"],
+      [1, "b"],
+    ],
+  );
+});

package/src/iterable.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+export async function* withIndex<T>(iter: AsyncIterable<T>, start = 0) {
+  let index = start;
+  for await (const item of iter) {
+    yield [index, item] as [number, T];
+    index++;
+  }
+}

package/src/jimp.ts

@@ -0,0 +1,15 @@
+import * as jimp from "jimp";
+
+export type JimpInstance = Pick<
+  jimp.JimpInstance,
+  | "width"
+  | "height"
+  | "bitmap"
+  | "getPixelColor"
+  | "setPixelColor"
+  | "resize"
+  | "composite"
+> & {
+  getBuffer: (mime: "image/png") => ReturnType<jimp.JimpInstance["getBuffer"]>;
+  getBase64: (mime: "image/png") => ReturnType<jimp.JimpInstance["getBase64"]>;
+};

package/src/pdf.ts

@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import * as jimp from "jimp";
+import * as mupdf from "mupdf";
+
+import type { JimpInstance } from "./jimp.ts";
+
+export function* loadPages(pdf: mupdf.Document) {
+  for (let i = 0; i < pdf.countPages(); i++) {
+    yield pdf.loadPage(i);
+  }
+}
+
+function pixmapToRGBA(pixmap: mupdf.Pixmap): Uint8Array {
+  const width = pixmap.getWidth();
+  const height = pixmap.getHeight();
+  const stride = pixmap.getStride();
+  const hasAlpha = pixmap.getAlpha() !== 0;
+  const samples = pixmap.getPixels();
+
+  if (hasAlpha && stride === width * 4) {
+    return new Uint8Array(samples);
+  }
+
+  const out = new Uint8Array(width * height * 4);
+  const srcBpp = pixmap.getNumberOfComponents() + (hasAlpha ? 1 : 0);
+  for (let y = 0; y < height; y++) {
+    const srcRow = y * stride;
+    const dstRow = y * width * 4;
+    for (let x = 0; x < width; x++) {
+      const s = srcRow + x * srcBpp;
+      const d = dstRow + x * 4;
+      out[d] = samples[s]!;
+      out[d + 1] = samples[s + 1]!;
+      out[d + 2] = samples[s + 2]!;
+      out[d + 3] = hasAlpha ? samples[s + 3]! : 255;
+    }
+  }
+  return out;
+}
+
+export async function pageToImage(
+  page: mupdf.Page,
+  dpi: number,
+  alpha: boolean,
+) {
+  const zoom = dpi / 72;
+  const pixmap = page.toPixmap(
+    [zoom, 0, 0, zoom, 0, 0],
+    mupdf.ColorSpace.DeviceRGB,
+    alpha,
+  );
+  const width = pixmap.getWidth();
+  const height = pixmap.getHeight();
+  const data = pixmapToRGBA(pixmap);
+  pixmap.destroy();
+  page.destroy();
+  return jimp.Jimp.fromBitmap({ width, height, data }) as JimpInstance;
+}

package/src/rgba-color.test.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+import assert from "assert";
+import test from "node:test";
+
+import { parseHex, formatHex } from "./rgba-color.ts";
+
+test("parseHex", async (ctx) => {
+  await ctx.test("#rgb", () => {
+    assert.deepStrictEqual(parseHex("#fed"), [0xff, 0xee, 0xdd, 0xff]);
+  });
+  await ctx.test("#rrggbb", () => {
+    assert.deepStrictEqual(parseHex("#fffefd"), [0xff, 0xfe, 0xfd, 0xff]);
+  });
+  await ctx.test("#rgba", () => {
+    assert.deepStrictEqual(parseHex("#fedc"), [0xff, 0xee, 0xdd, 0xcc]);
+  });
+  await ctx.test("#rrggbbaa", () => {
+    assert.deepStrictEqual(parseHex("#fffefdfc"), [0xff, 0xfe, 0xfd, 0xfc]);
+  });
+  await ctx.test("invalid", () => {
+    assert.deepStrictEqual(parseHex("foobar"), null);
+  });
+});
+
+test("formatHex", () => {
+  assert.deepStrictEqual(formatHex([0xff, 0xfe, 0xfd, 0xfc]), "#fffefdfc");
+});

package/src/rgba-color.ts

@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2025  Koutaro Mukai
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+export type RGBAColor = [number, number, number, number];
+
+export const parseHex = (hex: string) => {
+  if (/^#([0-9a-fA-F]{3})$/.test(hex)) {
+    return [
+      parseInt(hex[1]! + hex[1]!, 16),
+      parseInt(hex[2]! + hex[2]!, 16),
+      parseInt(hex[3]! + hex[3]!, 16),
+      255,
+    ] as RGBAColor;
+  }
+  if (/^#([0-9a-fA-F]{4})$/.test(hex)) {
+    return [
+      parseInt(hex[1]! + hex[1]!, 16),
+      parseInt(hex[2]! + hex[2]!, 16),
+      parseInt(hex[3]! + hex[3]!, 16),
+      parseInt(hex[4]! + hex[4]!, 16),
+    ] as RGBAColor;
+  }
+  if (/^#([0-9a-fA-F]{6})$/.test(hex)) {
+    return [
+      parseInt(hex.slice(1, 3), 16),
+      parseInt(hex.slice(3, 5), 16),
+      parseInt(hex.slice(5, 7), 16),
+      255,
+    ] as RGBAColor;
+  }
+  if (/^#([0-9a-fA-F]{8})$/.test(hex)) {
+    return [
+      parseInt(hex.slice(1, 3), 16),
+      parseInt(hex.slice(3, 5), 16),
+      parseInt(hex.slice(5, 7), 16),
+      parseInt(hex.slice(7, 9), 16),
+    ] as RGBAColor;
+  }
+  return null;
+};
+
+export const formatHex = ([r, g, b, a]: RGBAColor) =>
+  "#" +
+  [r, g, b, a]
+    .map((v) => {
+      const hex = v.toString(16);
+      return hex.length === 1 ? "0" + hex : hex;
+    })
+    .join("");

package/src/style.css

@@ -0,0 +1,19 @@
+.summary-content {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 20px;
+}
+
+.checkerboard-bg {
+  background-image: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAAAAABWESUoAAAAHUlEQVQ4y2P4gQYeoAGGUQUjSgG6ALqGUQUjSgEAdjWwLh+tpFgAAAAASUVORK5CYII=");
+}
+
+.diff-table {
+  border: 1px solid black;
+  border-collapse: collapse;
+}
+
+.diff-table th,
+.diff-table td {
+  border: 1px solid black;
+}