zerobucket 0.5.0 → 0.6.1

package/dist/index.js

@@ -8,7 +8,7 @@ import {
   StorageError,
   UnsupportedFormatError,
   ZeroBucketError
-} from "./chunk-W2C37XYV.js";
+} from "./chunk-SCPC3QDR.js";
 
 // src/client.ts
 import { createHash } from "crypto";
@@ -1880,11 +1880,191 @@ var SQLiteBackend = class {
   }
 };
 
+// src/heic.ts
+import { createRequire } from "module";
+import { join } from "path";
+import { Worker } from "worker_threads";
+var HEIC_BRANDS = /* @__PURE__ */ new Set([
+  "heic",
+  "heix",
+  "hevc",
+  "heim",
+  "heis",
+  "mif1",
+  "msf1"
+]);
+function looksLikeHeic(data) {
+  if (data.length < 12) return false;
+  if (String.fromCharCode(data[4], data[5], data[6], data[7]) !== "ftyp")
+    return false;
+  return HEIC_BRANDS.has(
+    String.fromCharCode(data[8], data[9], data[10], data[11])
+  );
+}
+var HEIC_INSTALL_HINT = "npm install libheif-js";
+var WORKER_SOURCE = `
+const { parentPort, workerData } = require("node:worker_threads");
+const libheif = require(workerData.libPath);
+// libheif-js reports decode problems by dumping a raw error object to the console. Capture that text instead:
+// it becomes part of the error we return (the useful diagnosis), and nothing is printed to the host's stderr.
+let diag = "";
+for (const level of ["log", "info", "warn", "error"]) {
+  console[level] = (...args) => {
+    diag = args.map((a) => (a && a.message) || (typeof a === "string" ? a : "")).filter(Boolean).join(" ").trim();
+  };
+}
+const describe = (e) => {
+  const base = String((e && e.message) || e);
+  return diag && !base.includes(diag) ? base + ": " + diag : base;
+};
+function open(bytes) {
+  const images = new libheif.HeifDecoder().decode(bytes);
+  if (!images || images.length === 0) throw new Error("no images found in HEIF container");
+  return images[0];
+}
+parentPort.on("message", async ({ id, op, data }) => {
+  diag = "";
+  try {
+    const img = open(new Uint8Array(data));
+    const width = img.get_width();
+    const height = img.get_height();
+    if (op === "info") return parentPort.postMessage({ id, ok: true, width, height });
+    const out = await new Promise((resolve, reject) =>
+      img.display({ data: new Uint8ClampedArray(width * height * 4), width, height }, (d) =>
+        d ? resolve(d) : reject(new Error("HEIF processing error")),
+      ),
+    );
+    if (op === "validate") return parentPort.postMessage({ id, ok: true, width, height });
+    const rgba = out.data.buffer;
+    parentPort.postMessage({ id, ok: true, width, height, rgba }, [rgba]);
+  } catch (e) {
+    parentPort.postMessage({ id, ok: false, error: describe(e) });
+  }
+});
+`;
+var HeicWorkerError = class extends StorageError {
+};
+var worker;
+var nextId = 1;
+var pending = /* @__PURE__ */ new Map();
+var stats = { info: 0, validate: 0, decode: 0, workersStarted: 0 };
+var resolveLib = () => {
+  const attempts = [
+    () => createRequire(import.meta.url).resolve("libheif-js/wasm-bundle"),
+    // next to / above this package
+    () => createRequire(join(process.cwd(), "noop.js")).resolve(
+      "libheif-js/wasm-bundle"
+    )
+    // the app's own node_modules
+  ];
+  let last;
+  for (const attempt of attempts) {
+    try {
+      return attempt();
+    } catch (e) {
+      last = e;
+    }
+  }
+  throw last;
+};
+function heicAvailable() {
+  try {
+    resolveLib();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function releaseIfIdle(w) {
+  for (const p of pending.values()) if (p.owner === w) return;
+  w.unref();
+}
+function startWorker() {
+  let libPath;
+  try {
+    libPath = resolveLib();
+  } catch (cause) {
+    throw new StorageError(
+      `HEIC support requires the optional dependency 'libheif-js'. Install it with: ${HEIC_INSTALL_HINT}`,
+      { cause }
+    );
+  }
+  const w = new Worker(WORKER_SOURCE, { eval: true, workerData: { libPath } });
+  stats.workersStarted += 1;
+  w.on(
+    "message",
+    (m) => {
+      const p = pending.get(m.id);
+      if (!p) return;
+      pending.delete(m.id);
+      releaseIfIdle(w);
+      if (m.ok) p.resolve(m);
+      else p.reject(new Error(m.error));
+    }
+  );
+  const fail = (err) => {
+    if (worker === w) worker = void 0;
+    for (const [id, p] of pending) {
+      if (p.owner !== w) continue;
+      pending.delete(id);
+      p.reject(err);
+    }
+  };
+  w.on(
+    "error",
+    (e) => fail(
+      new HeicWorkerError(
+        `HEIC decoder worker crashed: ${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
+      )
+    )
+  );
+  w.on(
+    "exit",
+    (code) => fail(
+      new HeicWorkerError(
+        `HEIC decoder worker exited unexpectedly (code ${code})`
+      )
+    )
+  );
+  w.unref();
+  return w;
+}
+function call(op, data) {
+  stats[op] += 1;
+  const w = worker ??= startWorker();
+  const id = nextId++;
+  const copy = new Uint8Array(data).buffer;
+  return new Promise((resolve, reject) => {
+    pending.set(id, { owner: w, resolve, reject });
+    w.ref();
+    w.postMessage({ id, op, data: copy }, [copy]);
+  });
+}
+async function heicInfo(data) {
+  const r = await call("info", data);
+  return { width: r.width, height: r.height };
+}
+async function heicValidate(data) {
+  const r = await call("validate", data);
+  return { width: r.width, height: r.height };
+}
+async function decodeHeic(data) {
+  const r = await call("decode", data);
+  return {
+    width: r.width,
+    height: r.height,
+    rgba: Buffer.from(r.rgba)
+  };
+}
+
 // src/validation.ts
 var FORMAT_TO_MIME = {
   jpeg: "image/jpeg",
   png: "image/png",
-  webp: "image/webp"
+  webp: "image/webp",
+  heic: "image/heic"
+  // optional: needs `npm install libheif-js` (see heic.ts)
 };
 var SUPPORTED_FORMATS = Object.keys(FORMAT_TO_MIME);
 var DEFAULT_MAX_PIXELS = 89e6;
@@ -1912,6 +2092,8 @@ async function validateImage(data, opts) {
   const sizeBytes = data.length;
   if (sizeBytes > maxBytes) throw new ImageTooLargeError(sizeBytes, maxBytes);
   if (sizeBytes === 0) throw new CorruptedImageError("Image data is empty");
+  if (looksLikeHeic(data))
+    return validateHeic(data, { maxBytes, maxPixels, allowedFormats });
   const sharp = await loadSharp();
   const make = () => sharp(data, { limitInputPixels: maxPixels, failOn: "error" });
   let format;
@@ -1947,6 +2129,45 @@ async function validateImage(data, opts) {
   }
   return { mimeType: FORMAT_TO_MIME[format], width, height, sizeBytes };
 }
+async function validateHeic(data, {
+  maxBytes,
+  maxPixels,
+  allowedFormats
+}) {
+  const sizeBytes = data.length;
+  if (!heicAvailable()) {
+    throw new ImageValidationError(
+      `This looks like a HEIC/HEIF image, which requires an optional dependency. Install it with: ${HEIC_INSTALL_HINT}`
+    );
+  }
+  if (!allowedFormats.includes("heic"))
+    throw new UnsupportedFormatError("heic", allowedFormats);
+  let width;
+  let height;
+  try {
+    ({ width, height } = await heicInfo(data));
+  } catch (exc) {
+    if (exc instanceof StorageError) throw exc;
+    throw new CorruptedImageError(
+      `Could not decode image: ${errMessage(exc)}`,
+      { cause: exc }
+    );
+  }
+  if (!width || !height)
+    throw new CorruptedImageError("Image has no readable dimensions");
+  if (width * height > maxPixels)
+    throw new ImageTooLargeError(sizeBytes, maxBytes);
+  try {
+    await heicValidate(data);
+  } catch (exc) {
+    if (exc instanceof StorageError) throw exc;
+    throw new CorruptedImageError(
+      `Image data is truncated or corrupted: ${errMessage(exc)}`,
+      { cause: exc }
+    );
+  }
+  return { mimeType: FORMAT_TO_MIME.heic, width, height, sizeBytes };
+}
 function isPixelLimit(exc) {
   return /pixel limit/i.test(errMessage(exc));
 }
@@ -1955,28 +2176,53 @@ function errMessage(exc) {
 }
 
 // src/optimize.ts
+var ENCODABLE_FORMATS = ["jpeg", "png", "webp"];
 var DEFAULT_JPEG_QUALITY = 90;
 var DEFAULT_WEBP_QUALITY = 88;
-var FORMAT_ALIASES = { jpg: "jpeg" };
 async function optimizeImage(data, opts) {
   const { maxWidth, quality, maxBytes, maxPixels = DEFAULT_MAX_PIXELS } = opts;
   const sharp = await loadSharp();
   const originalSizeBytes = data.length;
-  const base = sharp(data, { limitInputPixels: maxPixels, failOn: "error" });
-  const meta = await base.metadata();
-  const requested = (opts.format ?? meta.format ?? "jpeg").toLowerCase();
-  const target = FORMAT_ALIASES[requested] ?? requested;
-  if (!SUPPORTED_FORMATS.includes(target)) {
+  const requestedRaw = opts.format?.toLowerCase();
+  const requested = requestedRaw === "jpg" ? "jpeg" : requestedRaw;
+  if (requested === "heic" || requested === "heif") {
     throw new ImageValidationError(
-      `Cannot re-encode to unsupported format ${JSON.stringify(target)}. Supported: ${JSON.stringify(
-        [...SUPPORTED_FORMATS].sort()
-      )}`
+      "Encoding to HEIC is not available in the Node package (there is no HEVC encoder for Node). Optimize to jpeg, webp or png instead, or store the original HEIC without `optimize`."
     );
   }
-  let pipeline = sharp(data, {
+  let input = data;
+  let inputOptions = {
     limitInputPixels: maxPixels,
     failOn: "error"
-  }).rotate();
+  };
+  let sourceFormat;
+  if (looksLikeHeic(data)) {
+    if (!heicAvailable()) {
+      throw new ImageValidationError(
+        `This looks like a HEIC/HEIF image, which requires an optional dependency. Install it with: ${HEIC_INSTALL_HINT}`
+      );
+    }
+    if (!requested) {
+      throw new ImageValidationError(
+        "Optimizing a HEIC image needs an explicit output format, because re-encoding to HEIC is not available in the Node package. Pass optimize: { format: 'jpeg' | 'webp' | 'png' } (for example { format: 'webp', maxWidth: 1600 })."
+      );
+    }
+    const decoded = await decodeHeic(data);
+    input = decoded.rgba;
+    inputOptions = {
+      raw: { width: decoded.width, height: decoded.height, channels: 4 }
+    };
+    sourceFormat = "heic";
+  } else {
+    sourceFormat = (await sharp(data, inputOptions).metadata()).format;
+  }
+  const target = requested ?? sourceFormat ?? "jpeg";
+  if (!ENCODABLE_FORMATS.includes(target)) {
+    throw new ImageValidationError(
+      `Cannot re-encode to unsupported format ${JSON.stringify(target)}. Supported: ${JSON.stringify([...ENCODABLE_FORMATS].sort())}`
+    );
+  }
+  let pipeline = sharp(input, inputOptions).rotate();
   if (maxWidth !== void 0) {
     pipeline = pipeline.resize({
       width: maxWidth,