format-png 0.2.0 → 0.3.0

package/dist/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/worker.js

@@ -0,0 +1,137 @@
+// A WorkerPool worker: runs one task at a time with the sync API. It keeps its
+// decoders and encoders between tasks, so a batch keeps the crate's buffer
+// reuse, and the images it prepared until they're finished or freed. See
+// protocol.ts for the messages.
+import { listen, post } from "#port";
+import { PngDecoder, PngEncoder, PngError, compressSegment, finish, init, parseText, prepare, readHeader, rgbaToPngImage, } from "./core.js";
+import { buffersIn } from "./protocol.js";
+/** The most recently used decoders or encoders, one per set of options. */
+class Cache {
+    #entries = new Map();
+    get(key, create) {
+        let entry = this.#entries.get(key);
+        if (entry) {
+            this.#entries.delete(key); // moved to the end: most recently used
+        }
+        else {
+            entry = create();
+            if (this.#entries.size === 4) {
+                const [oldest, value] = this.#entries.entries().next().value;
+                this.#entries.delete(oldest);
+                value.free();
+            }
+        }
+        this.#entries.set(key, entry);
+        return entry;
+    }
+}
+const decoders = new Cache();
+const encoders = new Cache();
+let ready;
+let loaded = false;
+function decoder(options) {
+    const { validateCrc = true, preserveMetadata = false, preserveChunks = false, strictAncillary = false } = options;
+    const key = [validateCrc, preserveMetadata, preserveChunks, strictAncillary].join();
+    return decoders.get(key, () => new PngDecoder({ validateCrc, preserveMetadata, preserveChunks, strictAncillary }));
+}
+function encoder(options) {
+    const { compression, compressionStrategy, filter, keepUnsafeChunks, palette, strip, threads } = options;
+    const normalized = { compression, compressionStrategy, filter, keepUnsafeChunks, palette, strip, threads };
+    return encoders.get(JSON.stringify(normalized), () => new PngEncoder(normalized));
+}
+/** The images this worker prepared, by handle, until they're finished or freed. */
+const handles = new Map();
+/** Prepares `image`, keeping it as `handle` if it has segments to compress. */
+function prepareImage(image, options, handle) {
+    const prepared = prepare(encoder(options), image);
+    try {
+        if (prepared.segmentCount === 0)
+            return { png: finish(prepared, []) };
+        const segments = Array.from({ length: prepared.segmentCount }, (_, i) => prepared.segment(i));
+        const result = { segments, level: prepared.compressionLevel, strategy: prepared.compressionStrategy };
+        handles.set(handle, prepared);
+        return result;
+    }
+    finally {
+        if (!handles.has(handle))
+            prepared.free();
+    }
+}
+/** Takes the prepared image `handle` out of `handles`, so it's freed whatever happens next. */
+function takeHandle(handle) {
+    const prepared = handles.get(handle);
+    if (!prepared)
+        throw new Error(`format-png: no prepared image ${handle} in this worker`);
+    handles.delete(handle);
+    return prepared;
+}
+/** The chunks' data are views into the input; they're sent as lengths and rebuilt on the other side. */
+function withoutChunkData(chunks) {
+    return { ...chunks, chunks: chunks.chunks.map((chunk) => ({ ...chunk, data: chunk.data.byteLength })) };
+}
+function run(request) {
+    const { op, args } = request;
+    switch (op) {
+        case "decode":
+            return decoder(args[1]).decode(args[0]);
+        case "decodeRgba8":
+            return decoder(args[1]).decodeRgba8(args[0]);
+        case "readChunks": {
+            const { validateCrc, strictAncillary } = args[1];
+            const chunks = withoutChunkData(decoder({ validateCrc, strictAncillary }).readChunks(args[0]));
+            return request.returnInput ? { chunks, input: args[0] } : { chunks };
+        }
+        case "readHeader":
+            return readHeader(args[0]);
+        case "parseText":
+            return parseText(args[0], args[1]);
+        case "encode":
+        case "encodeRgba8": {
+            const image = op === "encode" ? args[0] : rgbaToPngImage(args[0]);
+            const options = args[1];
+            if (request.split)
+                return prepareImage(image, options, request.handle);
+            return encoder(options).encode(image);
+        }
+        case "compressSegment":
+            return compressSegment(args[0], args[1], args[2]);
+        case "finish": {
+            const prepared = takeHandle(args[0]);
+            try {
+                return finish(prepared, args[1]);
+            }
+            finally {
+                prepared.free();
+            }
+        }
+        case "free":
+            takeHandle(args[0]).free();
+            return null;
+        case "handles":
+            return handles.size;
+    }
+}
+listen(async (request) => {
+    let response;
+    try {
+        await (ready ??= init());
+        loaded = true;
+        const value = run(request);
+        post({ id: request.id, ok: true, value }, buffersIn(value));
+        return;
+    }
+    catch (error) {
+        // A trap (a Rust panic, or running out of memory) can leave the wasm
+        // instance broken, and a worker whose module didn't load is no use, so
+        // the pool replaces this worker.
+        const cause = error instanceof PngError ? error.cause : error;
+        const retire = cause instanceof WebAssembly.RuntimeError || !loaded;
+        response = {
+            id: request.id,
+            ok: false,
+            error: error instanceof Error ? { name: error.name, message: error.message } : { name: "Error", message: String(error) },
+            retire,
+        };
+    }
+    post(response, []);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "format-png",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "A fast, lossless PNG decoder and encoder for the browser and Node, compiled from Rust to WebAssembly: every color type and bit depth, metadata, chunk inspection, palette optimization and chunk stripping.",
   "keywords": [
     "png",
@@ -33,15 +33,28 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./worker.js": "./dist/worker.js",
     "./package.json": "./package.json"
   },
+  "imports": {
+    "#spawn": {
+      "node": "./dist/spawn-node.js",
+      "default": "./dist/spawn-web.js"
+    },
+    "#port": {
+      "node": "./dist/port-node.js",
+      "default": "./dist/port-web.js"
+    }
+  },
   "files": [
     "dist",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"
   ],
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/worker.js"
+  ],
   "engines": {
     "node": ">=20.6"
   },
@@ -50,11 +63,18 @@
     "build:wasm": "cargo build -p format-png-wasm --release --target wasm32-unknown-unknown && wasm-bindgen --target web --out-dir src/wasm ../../target/wasm32-unknown-unknown/release/format_png_wasm.wasm && node scripts/inline-wasm.mjs",
     "build:ts": "tsc -p tsconfig.json",
     "build": "npm run clean && npm run build:wasm && npm run build:ts && node scripts/copy-wasm.mjs",
-    "test": "vitest run",
+    "test": "vitest run --project node",
+    "test:browser": "vitest run --project browser",
     "test:package": "node scripts/test-package.mjs",
-    "prepublishOnly": "npm run build && npm test && npm run test:package"
+    "bench": "node scripts/bench.mjs",
+    "bench:pool": "node scripts/bench-pool.mjs",
+    "prepublishOnly": "npm run build && npm test && npm run test:browser && npm run test:package"
   },
   "devDependencies": {
+    "@types/node": "^20.19.43",
+    "@vitest/browser-playwright": "^4.1.11",
+    "esbuild": "^0.25.12",
+    "playwright": "^1.63.0",
     "typescript": "^7.0.2",
     "vitest": "^4.1.11"
   }