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

@u1f992/pdfdiff 0.2.0 → 0.2.1

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 (21) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@u1f992/pdfdiff",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Visualize and quantify differences between two PDF files.",
   "main": "dist/index.js",
   "bin": {
@@ -9,7 +9,8 @@
   "scripts": {
     "test": "node --test",
     "test:cli": "node src/cli.js test/a.pdf test/b.pdf out --mask test/mask.pdf --dpi 300 && echo \"expected: Page 1, Addition: 7500, Deletion: 7500, Modification: 7500\"",
-    "build": "rollup -c",
+    "build:version": "node scripts/version.ts",
+    "build": "npm run build:version && rollup -c",
     "serve": "npm run build && http-server dist"
   },
   "repository": {

package/scripts/version.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+const version = JSON.parse(readFileSync("package.json", "utf-8")).version;
+let suffix = "";
+try {
+  execSync(`git describe --tags --match "v${version}" --exact-match`, {
+    stdio: "ignore",
+  });
+} catch {
+  try {
+    const hash = execSync("git rev-parse --short HEAD", {
+      encoding: "utf-8",
+    }).trim();
+    suffix = `+${hash}`;
+  } catch {
+    // not in a git repo
+  }
+}
+try {
+  const dirty = execSync("git status --porcelain", {
+    encoding: "utf-8",
+  }).trim();
+  if (dirty) {
+    suffix += ".dirty";
+  }
+} catch {
+  // not in a git repo
+}
+const full = version + suffix;
+writeFileSync("src/version.ts", `export const VERSION = "${full}";\n`, "utf-8");
+console.log(full);

package/src/browser.ts CHANGED Viewed

@@ -1,6 +1,10 @@
 /// <reference lib="dom" />
 import * as pdfdiff from "./index.ts";
+import { VERSION } from "./version.ts";
+const versionEl = document.getElementById("version");
+if (versionEl) versionEl.textContent = "v" + VERSION;
 async function readFileAsUint8Array(file: File): Promise<Uint8Array> {
   return new Promise((resolve, reject) => {

package/src/cli.ts CHANGED Viewed

@@ -29,6 +29,7 @@ import {
   formatHex,
   visualizeDifferences,
 } from "./index.ts";
+import { VERSION } from "./version.ts";
 const {
   positionals,
@@ -89,16 +90,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);
 }

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>

package/src/index.ts CHANGED Viewed

@@ -23,9 +23,12 @@ 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 { VERSION } from "./version.ts";
 import type { JimpInstance } from "./jimp.ts";
 import type {
+  ErrorMessage,
   InitMessage,
+  LoadedMessage,
   PageMessage,
   PageResultMessage,
   ReadyMessage,
@@ -80,37 +83,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 +137,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,10 +150,8 @@ 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 {

package/src/worker.ts CHANGED Viewed

@@ -42,6 +42,10 @@ export type PageMessage = {
   index: number;
 };
+export type LoadedMessage = {
+  type: "loaded";
+};
 export type ReadyMessage = {
   type: "ready";
 };
@@ -57,6 +61,11 @@ export type PageResultMessage = {
   modification: [number, number][];
 };
+export type ErrorMessage = {
+  type: "error";
+  message: string;
+};
 let pdfA: mupdf.Document;
 let pdfB: mupdf.Document;
 let pdfMask: mupdf.Document;
@@ -131,29 +140,41 @@ async function processPage(index: number): Promise<PageResultMessage> {
 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);