@u1f992/pdfdiff 0.2.0 → 0.2.2

package/dist/cli.js

@@ -2,6 +2,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import util$2 from 'node:util';
+import { Worker as Worker$1 } from 'node:worker_threads';
 import require$$0, { promises, existsSync } from 'fs';
 import require$$0$1 from 'util';
 import require$$1 from 'stream';
@@ -39407,6 +39408,82 @@ globalThis.$libmupdf_device = {
 	},
 };
 
+/*
+ * 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;
+    return g.__PDFDIFF_PROFILE__ === true;
+})();
+const _counters = Object.create(null);
+const _NOOP_SPAN = Object.freeze({ stop() { } });
+const _noop = () => { };
+const _emptyDump = () => Object.freeze({});
+const _realPerf = {
+    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 = {
+    enabled: false,
+    span: () => _NOOP_SPAN,
+    incr: _noop,
+    setMax: _noop,
+    merge: _noop,
+    dump: _emptyDump,
+    reset: _noop,
+};
+const perf = _enabled ? _realPerf : _noopPerf;
+
 /*
  * Copyright (C) 2025  Koutaro Mukai
  *
@@ -39520,6 +39597,8 @@ async function* withIndex(iter, start = 0) {
     }
 }
 
+const VERSION = "0.2.2";
+
 /*
  * Copyright (C) 2025  Koutaro Mukai
  *
@@ -39563,24 +39642,42 @@ function asSharedBytes(bytes) {
 }
 class WorkerHandle {
     worker;
+    loaded;
     pendingResolve = null;
     pendingReject = null;
     constructor(url) {
         this.worker = new Worker(url, { type: "module" });
-        this.worker.addEventListener("message", (e) => {
-            const resolve = this.pendingResolve;
-            this.pendingResolve = null;
-            this.pendingReject = null;
-            resolve?.(e.data);
-        });
-        this.worker.addEventListener("error", (e) => {
-            const reject = this.pendingReject;
-            this.pendingResolve = null;
-            this.pendingReject = null;
-            reject?.(e.error ?? new Error(e.message));
+        this.loaded = new Promise((resolveLoaded, rejectLoaded) => {
+            const onMessage = (e) => {
+                const data = e.data;
+                if (data.type === "loaded") {
+                    resolveLoaded();
+                    return;
+                }
+                const resolve = this.pendingResolve;
+                const reject = this.pendingReject;
+                this.pendingResolve = null;
+                this.pendingReject = null;
+                if (data.type === "error") {
+                    reject?.(new Error(`worker: ${data.message}`));
+                }
+                else {
+                    resolve?.(data);
+                }
+            };
+            this.worker.addEventListener("message", onMessage);
+            this.worker.addEventListener("error", (e) => {
+                const err = e.error ?? new Error(e.message);
+                rejectLoaded(err);
+                const reject = this.pendingReject;
+                this.pendingResolve = null;
+                this.pendingReject = null;
+                reject?.(err);
+            });
         });
     }
-    init(msg) {
+    async init(msg) {
+        await this.loaded;
         return new Promise((resolve, reject) => {
             this.pendingResolve = resolve;
             this.pendingReject = reject;
@@ -39600,10 +39697,12 @@ class WorkerHandle {
     }
 }
 function workerUrl() {
-    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) {
-    return {
+    const sP = perf.span("main.pageResultToResult_ms");
+    const r = {
         a: Jimp.fromBitmap({
             width: msg.a.width,
             height: msg.a.height,
@@ -39623,6 +39722,11 @@ function pageResultToResult(msg) {
         deletion: msg.deletion,
         modification: msg.modification,
     };
+    sP.stop();
+    perf.incr("main.resultsReceived");
+    if (msg.perf)
+        perf.merge(msg.perf);
+    return r;
 }
 async function* visualizeDifferences(a, b, options) {
     const merged = {
@@ -39688,6 +39792,7 @@ async function* visualizeDifferences(a, b, options) {
                 }
                 else {
                     buffered.set(idx, result);
+                    perf.setMax("main.bufferedPeak", buffered.size);
                 }
             }
             catch (e) {
@@ -39710,11 +39815,15 @@ async function* visualizeDifferences(a, b, options) {
                 r = buf;
             }
             else {
+                const sWait = perf.span("main.yieldWaitMain_ms");
                 r = await new Promise((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);
     }
@@ -39740,6 +39849,83 @@ async function* visualizeDifferences(a, b, options) {
  * 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.
+ */
+function sliceBackingBuffer(src) {
+    return src.buffer.slice(src.byteOffset, src.byteOffset + src.byteLength);
+}
+
+/*
+ * 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/>.
+ */
+class PngWriterPool {
+    workers = [];
+    idle = [];
+    waiting = [];
+    constructor(size, scriptUrl) {
+        for (let i = 0; i < size; i++) {
+            const w = new Worker$1(scriptUrl);
+            this.workers.push(w);
+            this.idle.push(w);
+        }
+    }
+    acquire() {
+        const w = this.idle.pop();
+        if (w)
+            return Promise.resolve(w);
+        return new Promise((resolve) => this.waiting.push(resolve));
+    }
+    release(w) {
+        const next = this.waiting.shift();
+        if (next)
+            next(w);
+        else
+            this.idle.push(w);
+    }
+    async submit(job) {
+        const w = await this.acquire();
+        return new Promise((resolve, reject) => {
+            const onMessage = (msg) => {
+                w.off("message", onMessage);
+                w.off("error", onError);
+                this.release(w);
+                if (msg.ok)
+                    resolve();
+                else
+                    reject(new Error(msg.error));
+            };
+            const onError = (err) => {
+                w.off("message", onMessage);
+                w.off("error", onError);
+                this.release(w);
+                reject(err);
+            };
+            w.on("message", onMessage);
+            w.once("error", onError);
+            w.postMessage(job, [job.data]);
+        });
+    }
+    async terminate() {
+        await Promise.all(this.workers.map((w) => w.terminate()));
+    }
+}
+const _wallSpan = perf.span("cli.wallTotal_ms");
 const { positionals, values: { dpi: dpi_, alpha: alpha_, mask: mask_, align: align_, "addition-color": additionColorHex, "deletion-color": deletionColorHex, "modification-color": modificationColorHex, workers: workers_, version, help, }, } = util$2.parseArgs({
     allowPositionals: true,
     options: {
@@ -39784,15 +39970,7 @@ NOTES:
     process.exit(0);
 }
 if (version) {
-    try {
-        const versionStr = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), {
-            encoding: "utf-8",
-        })).version;
-        console.log(versionStr);
-    }
-    catch {
-        console.log("unknown");
-    }
+    console.log(VERSION);
     process.exit(0);
 }
 if (positionals.length !== 3) {
@@ -39834,6 +40012,9 @@ if (Number.isNaN(workers) || workers < 1) {
     throw new Error("Invalid workers value");
 }
 fs.mkdirSync(outDir, { recursive: true });
+const writerPool = new PngWriterPool(workers, new URL("./cli-png-worker.js", import.meta.url));
+const pendingWrites = [];
+const _loopSpan = perf.span("cli.loopWall_ms");
 for await (const [i, { a, b, diff, addition, deletion, modification },] of withIndex(visualizeDifferences(pdfA, pdfB, {
     dpi,
     alpha,
@@ -39849,8 +40030,41 @@ for await (const [i, { a, b, diff, addition, deletion, modification },] of withI
     console.log(`Page ${i}, Addition: ${addition.length}, Deletion: ${deletion.length}, Modification: ${modification.length}`);
     const dir = path.join(outDir, i.toString(10));
     fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(dir, "a.png"), new Uint8Array(await a.getBuffer("image/png")));
-    fs.writeFileSync(path.join(dir, "b.png"), new Uint8Array(await b.getBuffer("image/png")));
-    fs.writeFileSync(path.join(dir, "diff.png"), new Uint8Array(await diff.getBuffer("image/png")));
+    const sSubmit = perf.span("cli.poolSubmit_ms");
+    const aBuf = sliceBackingBuffer(a.bitmap.data);
+    const bBuf = sliceBackingBuffer(b.bitmap.data);
+    const dBuf = sliceBackingBuffer(diff.bitmap.data);
+    pendingWrites.push(writerPool.submit({
+        width: a.width,
+        height: a.height,
+        data: aBuf,
+        path: path.join(dir, "a.png"),
+    }), writerPool.submit({
+        width: b.width,
+        height: b.height,
+        data: bBuf,
+        path: path.join(dir, "b.png"),
+    }), writerPool.submit({
+        width: diff.width,
+        height: diff.height,
+        data: dBuf,
+        path: path.join(dir, "diff.png"),
+    }));
+    sSubmit.stop();
+}
+const sDrain = perf.span("cli.poolDrain_ms");
+await Promise.all(pendingWrites);
+sDrain.stop();
+await writerPool.terminate();
+_loopSpan.stop();
+_wallSpan.stop();
+if (perf.enabled) {
+    const counters = perf.dump();
+    process.stderr.write("\n=== PERF ===\n");
+    const keys = Object.keys(counters).sort();
+    const out = {};
+    for (const k of keys)
+        out[k] = Math.round(counters[k] * 1000) / 1000;
+    process.stderr.write(JSON.stringify(out, null, 2) + "\n");
 }
 //# sourceMappingURL=cli.js.map