npm - @u1f992/pdfdiff - Versions diffs - 0.2.0 → 0.2.2 - Mend

@u1f992/pdfdiff 0.2.0 → 0.2.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (45) hide show

package/.github/workflows/gh-pages.yml +6 -1
package/dist/browser.js +1219 -19
package/dist/browser.js.map +1 -1
package/dist/cli-png-worker.d.ts +13 -0
package/dist/cli-png-worker.d.ts.map +1 -0
package/dist/cli-png-worker.js +303 -0
package/dist/cli-png-worker.js.map +1 -0
package/dist/cli.js +240 -26
package/dist/cli.js.map +1 -1
package/dist/diff.d.ts +2 -1
package/dist/diff.d.ts.map +1 -1
package/dist/image.d.ts.map +1 -1
package/dist/index.d.ts +2 -1
package/dist/index.d.ts.map +1 -1
package/dist/index.html +6 -1
package/dist/index.js +123 -15
package/dist/index.js.map +1 -1
package/dist/pdf.d.ts.map +1 -1
package/dist/perf.d.ts +16 -0
package/dist/perf.d.ts.map +1 -0
package/dist/squoosh_png_bg.wasm +0 -0
package/dist/style.css +12 -0
package/dist/transferable.d.ts +7 -0
package/dist/transferable.d.ts.map +1 -0
package/dist/version.d.ts +2 -0
package/dist/version.d.ts.map +1 -0
package/dist/worker.d.ts +9 -0
package/dist/worker.d.ts.map +1 -1
package/dist/worker.js +274 -88
package/dist/worker.js.map +1 -1
package/package.json +5 -2
package/rollup.config.js +20 -0
package/scripts/version.ts +35 -0
package/src/browser.ts +119 -5
package/src/cli-png-worker.ts +59 -0
package/src/cli.ts +106 -21
package/src/diff.ts +99 -34
package/src/image.ts +3 -0
package/src/index.html +6 -1
package/src/index.ts +53 -27
package/src/pdf.ts +9 -1
package/src/perf.ts +94 -0
package/src/style.css +12 -0
package/src/transferable.ts +30 -0
package/src/worker.ts +77 -54

package/src/index.html CHANGED Viewed

@@ -9,7 +9,7 @@
     <script type="module" src="./browser.js"></script>
   </head>
   <body>
-    <h1>pdfdiff</h1>
+    <h1>pdfdiff <small id="version"></small></h1>
     <div class="form-container">
       <form id="pdf-diff-form">
         <div>
@@ -64,6 +64,11 @@
           <input type="color" id="modification-color" value="#ffc105" />
         </div>
         <button type="submit">Submit</button>
+        <label>
+          <input type="checkbox" id="hide-no-diff" />
+          Hide pages with no diff
+        </label>
+        <button type="button" id="download-zip" disabled>Download zip</button>
       </form>
     </div>
     <div class="error" id="error-message"></div>

package/src/index.ts CHANGED Viewed

@@ -22,16 +22,20 @@ import Worker from "web-worker";
 import { type Pallet } from "./diff.ts";
 import { isValidAlignStrategy, type AlignStrategy } from "./image.ts";
 import { withIndex } from "./iterable.ts";
+import { perf } from "./perf.ts";
 import { parseHex, formatHex } from "./rgba-color.ts";
+import { VERSION } from "./version.ts";
 import type { JimpInstance } from "./jimp.ts";
 import type {
+  ErrorMessage,
   InitMessage,
+  LoadedMessage,
   PageMessage,
   PageResultMessage,
   ReadyMessage,
 } from "./worker.ts";
-export { withIndex, isValidAlignStrategy, parseHex, formatHex };
+export { withIndex, isValidAlignStrategy, parseHex, formatHex, perf };
 type Options = {
   dpi: number;
@@ -80,37 +84,53 @@ function asSharedBytes(bytes: Uint8Array): Uint8Array {
   return new Uint8Array(bytes);
 }
+type WorkerResponse =
+  | LoadedMessage
+  | ReadyMessage
+  | PageResultMessage
+  | ErrorMessage;
 class WorkerHandle {
   worker: InstanceType<typeof Worker>;
-  private pendingResolve:
-    | ((data: ReadyMessage | PageResultMessage) => void)
-    | null = null;
+  private loaded: Promise<void>;
+  private pendingResolve: ((data: WorkerResponse) => 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>) => {
+    this.loaded = new Promise<void>((resolveLoaded, rejectLoaded) => {
+      const onMessage = (e: MessageEvent<WorkerResponse>) => {
+        const data = e.data;
+        if (data.type === "loaded") {
+          resolveLoaded();
+          return;
+        }
         const resolve = this.pendingResolve;
+        const reject = this.pendingReject;
         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));
+        if (data.type === "error") {
+          reject?.(new Error(`worker: ${data.message}`));
+        } else {
+          resolve?.(data);
+        }
+      };
+      this.worker.addEventListener("message", onMessage);
+      this.worker.addEventListener("error", (e: ErrorEvent) => {
+        const err = e.error ?? new Error(e.message);
+        rejectLoaded(err);
+        const reject = this.pendingReject;
+        this.pendingResolve = null;
+        this.pendingReject = null;
+        reject?.(err);
+      });
     });
   }
-  init(msg: InitMessage): Promise<ReadyMessage> {
+  async init(msg: InitMessage): Promise<ReadyMessage> {
+    await this.loaded;
     return new Promise<ReadyMessage>((resolve, reject) => {
-      this.pendingResolve = resolve as (
-        data: ReadyMessage | PageResultMessage,
-      ) => void;
+      this.pendingResolve = resolve as (data: WorkerResponse) => void;
       this.pendingReject = reject;
       this.worker.postMessage(msg);
     });
@@ -118,9 +138,7 @@ class WorkerHandle {
   processPage(index: number): Promise<PageResultMessage> {
     return new Promise<PageResultMessage>((resolve, reject) => {
-      this.pendingResolve = resolve as (
-        data: ReadyMessage | PageResultMessage,
-      ) => void;
+      this.pendingResolve = resolve as (data: WorkerResponse) => void;
       this.pendingReject = reject;
       const msg: PageMessage = { type: "page", index };
       this.worker.postMessage(msg);
@@ -133,14 +151,13 @@ class WorkerHandle {
 }
 function workerUrl(): URL {
-  return new URL(
-    import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js",
-    import.meta.url,
-  );
+  const file = import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.js";
+  return new URL(`${file}?v=${encodeURIComponent(VERSION)}`, import.meta.url);
 }
 function pageResultToResult(msg: PageResultMessage): Result {
-  return {
+  const sP = perf.span("main.pageResultToResult_ms");
+  const r = {
     a: jimp.Jimp.fromBitmap({
       width: msg.a.width,
       height: msg.a.height,
@@ -160,6 +177,10 @@ function pageResultToResult(msg: PageResultMessage): Result {
     deletion: msg.deletion,
     modification: msg.modification,
   };
+  sP.stop();
+  perf.incr("main.resultsReceived");
+  if (msg.perf) perf.merge(msg.perf);
+  return r;
 }
 export async function* visualizeDifferences(
@@ -244,6 +265,7 @@ export async function* visualizeDifferences(
           resolve(result);
         } else {
           buffered.set(idx, result);
+          perf.setMax("main.bufferedPeak", buffered.size);
         }
       } catch (e) {
         workerError = e;
@@ -263,10 +285,14 @@ export async function* visualizeDifferences(
         buffered.delete(i);
         r = buf;
       } else {
+        const sWait = perf.span("main.yieldWaitMain_ms");
         r = await new Promise<Result>((resolve) => resolvers.set(i, resolve));
+        sWait.stop();
         if (workerError !== null) throw workerError;
       }
+      const sYield = perf.span("main.consumerTime_ms");
       yield r;
+      sYield.stop();
     }
     await Promise.all(loops);
   } finally {

package/src/pdf.ts CHANGED Viewed

@@ -19,6 +19,7 @@ import * as jimp from "jimp";
 import * as mupdf from "mupdf";
 import type { JimpInstance } from "./jimp.ts";
+import { perf } from "./perf.ts";
 export function* loadPages(pdf: mupdf.Document) {
   for (let i = 0; i < pdf.countPages(); i++) {
@@ -60,6 +61,7 @@ export async function pageToImage(
   alpha: boolean,
 ) {
   const zoom = dpi / 72;
+  const sToPixmap = perf.span("pdf.toPixmap_ms");
   const pixmap = page.toPixmap(
     [zoom, 0, 0, zoom, 0, 0],
     mupdf.ColorSpace.DeviceRGB,
@@ -67,8 +69,14 @@ export async function pageToImage(
   );
   const width = pixmap.getWidth();
   const height = pixmap.getHeight();
+  sToPixmap.stop();
+  const sRgba = perf.span("pdf.pixmapToRGBA_ms");
   const data = pixmapToRGBA(pixmap);
   pixmap.destroy();
   page.destroy();
-  return jimp.Jimp.fromBitmap({ width, height, data }) as JimpInstance;
+  sRgba.stop();
+  const sFromBitmap = perf.span("pdf.fromBitmap_ms");
+  const result = jimp.Jimp.fromBitmap({ width, height, data }) as JimpInstance;
+  sFromBitmap.stop();
+  return result;
 }

package/src/perf.ts ADDED Viewed

@@ -0,0 +1,94 @@
+/*
+ * 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/>.
+ */
+const _enabled = (() => {
+  try {
+    if (
+      typeof process !== "undefined" &&
+      process.env &&
+      process.env.PDFDIFF_PROFILE === "1"
+    ) {
+      return true;
+    }
+  } catch {
+    // process not available (e.g. in some browser worker environments)
+  }
+  const g = globalThis as { __PDFDIFF_PROFILE__?: boolean };
+  return g.__PDFDIFF_PROFILE__ === true;
+})();
+export type Counters = Readonly<Record<string, number>>;
+export type Span = { stop(): void };
+type Perf = {
+  readonly enabled: boolean;
+  span(key: string): Span;
+  incr(key: string, delta?: number): void;
+  setMax(key: string, value: number): void;
+  merge(other: Counters): void;
+  dump(): Counters;
+  reset(): void;
+};
+const _counters: Record<string, number> = Object.create(null);
+const _NOOP_SPAN: Span = Object.freeze({ stop() {} });
+const _noop = () => {};
+const _emptyDump = (): Counters => Object.freeze({});
+const _realPerf: Perf = {
+  enabled: true,
+  span(key) {
+    const t0 = performance.now();
+    return {
+      stop() {
+        _counters[key] = (_counters[key] ?? 0) + (performance.now() - t0);
+      },
+    };
+  },
+  incr(key, delta = 1) {
+    _counters[key] = (_counters[key] ?? 0) + delta;
+  },
+  setMax(key, value) {
+    const cur = _counters[key];
+    if (cur === undefined || value > cur) _counters[key] = value;
+  },
+  merge(other) {
+    for (const k of Object.keys(other)) {
+      _counters[k] = (_counters[k] ?? 0) + other[k]!;
+    }
+  },
+  dump() {
+    return { ..._counters };
+  },
+  reset() {
+    for (const k of Object.keys(_counters)) delete _counters[k];
+  },
+};
+const _noopPerf: Perf = {
+  enabled: false,
+  span: () => _NOOP_SPAN,
+  incr: _noop,
+  setMax: _noop,
+  merge: _noop,
+  dump: _emptyDump,
+  reset: _noop,
+};
+export const perf: Perf = _enabled ? _realPerf : _noopPerf;

package/src/style.css CHANGED Viewed

@@ -11,9 +11,21 @@
 .diff-table {
   border: 1px solid black;
   border-collapse: collapse;
+  width: 100%;
+  table-layout: fixed;
 }
 .diff-table th,
 .diff-table td {
   border: 1px solid black;
 }
+.diff-table img {
+  display: block;
+  max-width: 100%;
+  height: auto;
+}
+body.hide-no-diff .diff-details.no-diff {
+  display: none;
+}

package/src/transferable.ts ADDED Viewed

@@ -0,0 +1,30 @@
+/*
+ * 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/>.
+ */
+/**
+ * Slice a typed-array view into a standalone backing buffer of the same kind
+ * (ArrayBuffer in, ArrayBuffer out; SharedArrayBuffer in, SharedArrayBuffer
+ * out). The buffer kind is preserved through the generic parameter.
+ */
+export function sliceBackingBuffer<TArrayBuffer extends ArrayBufferLike>(
+  src: Uint8Array<TArrayBuffer> | Uint8ClampedArray<TArrayBuffer>,
+): TArrayBuffer {
+  return src.buffer.slice(
+    src.byteOffset,
+    src.byteOffset + src.byteLength,
+  ) as TArrayBuffer;
+}

package/src/worker.ts CHANGED Viewed

@@ -25,6 +25,8 @@ import {
 } from "./image.ts";
 import type { JimpInstance } from "./jimp.ts";
 import { pageToImage } from "./pdf.ts";
+import { perf, type Counters } from "./perf.ts";
+import { sliceBackingBuffer } from "./transferable.ts";
 export type InitMessage = {
   type: "init";
@@ -42,6 +44,10 @@ export type PageMessage = {
   index: number;
 };
+export type LoadedMessage = {
+  type: "loaded";
+};
 export type ReadyMessage = {
   type: "ready";
 };
@@ -55,6 +61,12 @@ export type PageResultMessage = {
   addition: [number, number][];
   deletion: [number, number][];
   modification: [number, number][];
+  perf?: Counters | undefined;
+};
+export type ErrorMessage = {
+  type: "error";
+  message: string;
 };
 let pdfA: mupdf.Document;
@@ -67,19 +79,8 @@ let opts: {
   align: AlignStrategy;
 };
-function toTransferable(
-  src: Buffer | Uint8Array | Uint8ClampedArray | number[],
-): ArrayBuffer {
-  const view =
-    src instanceof Uint8Array || src instanceof Uint8ClampedArray
-      ? src
-      : Uint8Array.from(src as ArrayLike<number>);
-  const out = new ArrayBuffer(view.byteLength);
-  new Uint8Array(out).set(view);
-  return out;
-}
 async function processPage(index: number): Promise<PageResultMessage> {
+  const sLoad = perf.span("worker.pageToImageAll_ms");
   const [pageA, pageB, pageMask] = (await Promise.all([
     index < pdfA.countPages()
       ? pageToImage(pdfA.loadPage(index), opts.dpi, opts.alpha)
@@ -89,71 +90,93 @@ async function processPage(index: number): Promise<PageResultMessage> {
       : createEmptyImage(1, 1),
     index < pdfMask.countPages()
       ? pageToImage(pdfMask.loadPage(index), opts.dpi, opts.alpha)
-      : createEmptyImage(1, 1),
-  ])) as [JimpInstance, JimpInstance, JimpInstance];
+      : Promise.resolve(null),
+  ])) as [JimpInstance, JimpInstance, JimpInstance | null];
+  sLoad.stop();
+  const sDiff = perf.span("worker.drawDifference_ms");
   const {
     diff: diffLayer,
     addition,
     deletion,
     modification,
+    hasDiff,
   } = drawDifference(pageA, pageB, pageMask, opts.pallet, opts.align);
-  const diff = composeLayers(pageA.width, pageA.height, [
+  sDiff.stop();
+  const sCompose = perf.span("worker.composeLayers_ms");
+  const layers: [JimpInstance, number][] = [
     [pageA, 0.2],
     [pageB, 0.2],
-    [diffLayer, 1],
-  ]);
+  ];
+  if (hasDiff) layers.push([diffLayer, 1]);
+  const diff = composeLayers(pageA.width, pageA.height, layers);
+  sCompose.stop();
+  const sXfer = perf.span("worker.toTransferable_ms");
+  const aBuf = sliceBackingBuffer(pageA.bitmap.data);
+  const bBuf = sliceBackingBuffer(pageB.bitmap.data);
+  const dBuf = sliceBackingBuffer(diff.bitmap.data);
+  sXfer.stop();
+  perf.incr("worker.pages");
+  let pagePerf: Counters | undefined;
+  if (perf.enabled) {
+    pagePerf = perf.dump();
+    perf.reset();
+  }
   return {
     type: "pageResult",
     index,
-    a: {
-      width: pageA.width,
-      height: pageA.height,
-      data: toTransferable(pageA.bitmap.data),
-    },
-    b: {
-      width: pageB.width,
-      height: pageB.height,
-      data: toTransferable(pageB.bitmap.data),
-    },
-    diff: {
-      width: diff.width,
-      height: diff.height,
-      data: toTransferable(diff.bitmap.data),
-    },
+    a: { width: pageA.width, height: pageA.height, data: aBuf },
+    b: { width: pageB.width, height: pageB.height, data: bBuf },
+    diff: { width: diff.width, height: diff.height, data: dBuf },
     addition,
     deletion,
     modification,
+    perf: pagePerf,
   };
 }
 self.addEventListener(
   "message",
   async (e: MessageEvent<InitMessage | PageMessage>) => {
-    const msg = e.data;
-    if (msg.type === "init") {
-      pdfA = mupdf.PDFDocument.openDocument(msg.aBytes, "application/pdf");
-      pdfB = mupdf.PDFDocument.openDocument(msg.bBytes, "application/pdf");
-      pdfMask = msg.maskBytes
-        ? mupdf.PDFDocument.openDocument(msg.maskBytes, "application/pdf")
-        : new mupdf.PDFDocument();
-      opts = {
-        dpi: msg.dpi,
-        alpha: msg.alpha,
-        pallet: msg.pallet,
-        align: msg.align,
+    try {
+      const msg = e.data;
+      if (msg.type === "init") {
+        pdfA = mupdf.PDFDocument.openDocument(msg.aBytes, "application/pdf");
+        pdfB = mupdf.PDFDocument.openDocument(msg.bBytes, "application/pdf");
+        pdfMask = msg.maskBytes
+          ? mupdf.PDFDocument.openDocument(msg.maskBytes, "application/pdf")
+          : new mupdf.PDFDocument();
+        opts = {
+          dpi: msg.dpi,
+          alpha: msg.alpha,
+          pallet: msg.pallet,
+          align: msg.align,
+        };
+        if (pdfA.countPages() > 0) pdfA.loadPage(0).destroy();
+        const ready: ReadyMessage = { type: "ready" };
+        self.postMessage(ready);
+      } else if (msg.type === "page") {
+        const result = await processPage(msg.index);
+        self.postMessage(result, [
+          result.a.data,
+          result.b.data,
+          result.diff.data,
+        ]);
+      }
+    } catch (err) {
+      const errorMsg: ErrorMessage = {
+        type: "error",
+        message:
+          err instanceof Error ? `${err.message}\n${err.stack}` : String(err),
       };
-      if (pdfA.countPages() > 0) pdfA.loadPage(0).destroy();
-      const ready: ReadyMessage = { type: "ready" };
-      self.postMessage(ready);
-    } else if (msg.type === "page") {
-      const result = await processPage(msg.index);
-      self.postMessage(result, [
-        result.a.data,
-        result.b.data,
-        result.diff.data,
-      ]);
+      self.postMessage(errorMsg);
     }
   },
 );
+const loaded: LoadedMessage = { type: "loaded" };
+self.postMessage(loaded);