@takazudo/zudo-image-tweaker 0.1.0

package/dist/presets-PTxNoMdy.js

@@ -0,0 +1,630 @@
+import m from "node:fs/promises";
+import u from "node:path";
+import j from "sharp";
+import { encodeImageToBlurhash as it } from "./blurhash/index.js";
+import { pickVariantWidths as st } from "./exif/index.js";
+import { convertHeifToJpeg as ct } from "./heif/index.js";
+import { generateSmartOgp as ut } from "./ogp/index.js";
+import { randomUUID as Y } from "node:crypto";
+import pt from "xxhash-wasm";
+import { r as R, i as J, a as Q } from "./run-BIjGA2Fu.js";
+import { constants as lt } from "node:fs";
+import ft from "node:os";
+let v = null;
+function ht() {
+  return v || (v = pt(), v.catch(() => {
+    v = null;
+  })), v;
+}
+async function mt(t) {
+  const [a, e] = await Promise.all([ht(), m.readFile(t)]);
+  return a.h64Raw(e).toString(16);
+}
+async function L(t, a) {
+  const e = u.join(
+    u.dirname(t),
+    `.${u.basename(t)}.${Y()}.tmp`
+  );
+  try {
+    const r = await a(e);
+    return await m.rename(e, t), r;
+  } catch (r) {
+    throw await m.rm(e, { force: !0 }), r;
+  }
+}
+async function wt(t, a) {
+  await L(t, (e) => m.writeFile(e, a));
+}
+async function dt(t) {
+  let a;
+  try {
+    a = await m.readFile(t, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const e = JSON.parse(a);
+    return typeof e?.hash != "string" ? null : e;
+  } catch {
+    return null;
+  }
+}
+function z(t, a) {
+  return wt(t, JSON.stringify(a, null, 2));
+}
+const B = /* @__PURE__ */ new Map();
+async function gt(t, a) {
+  try {
+    return await R(t, a), !0;
+  } catch (e) {
+    return !J(e);
+  }
+}
+async function U(t, a) {
+  const e = B.get(t);
+  if (e !== void 0) return e;
+  const r = await gt(t, a);
+  return B.set(t, r), r;
+}
+function yt() {
+  return U("file", ["--version"]);
+}
+function H() {
+  return U("magick", ["-version"]);
+}
+function V() {
+  return U("ffmpeg", ["-version"]);
+}
+const Et = /* @__PURE__ */ new Set([".heic", ".heif"]), bt = /* @__PURE__ */ new Set([".jpg", ".jpeg"]), St = /* @__PURE__ */ new Set(["image/heic", "image/heic-sequence", "image/heif", "image/heif-sequence"]), Ft = /* @__PURE__ */ new Set([
+  "application/json",
+  "application/ld+json",
+  "application/manifest+json",
+  "application/xml",
+  "application/xhtml+xml",
+  "application/rss+xml",
+  "application/atom+xml",
+  "application/javascript",
+  "application/ecmascript",
+  "application/yaml",
+  "application/x-yaml",
+  "application/x-sh",
+  "application/x-httpd-php"
+]);
+function Nt(t) {
+  return t.startsWith("text/") || Ft.has(t) ? !0 : t.startsWith("application/") && (t.endsWith("+xml") || t.endsWith("+json"));
+}
+async function K(t) {
+  if (!await yt()) return null;
+  try {
+    const { stdout: a } = await R("file", ["-b", "--mime-type", Q(t)]);
+    return a.trim();
+  } catch (a) {
+    return J(a), null;
+  }
+}
+async function Ot(t) {
+  const a = u.extname(t).toLowerCase();
+  if (Et.has(a)) return !0;
+  if (!bt.has(a)) return !1;
+  const e = await K(t);
+  return e !== null && St.has(e);
+}
+async function vt(t) {
+  const a = await K(t);
+  return a === null ? !1 : Nt(a);
+}
+const It = [
+  "premature end",
+  "bad huffman",
+  "corrupt jpeg",
+  "libspng read error"
+];
+function Z(t) {
+  const a = (t?.message ?? "").toLowerCase();
+  return It.some((e) => a.includes(e));
+}
+async function Pt(t) {
+  try {
+    return await j(t).metadata(), !0;
+  } catch {
+    return !1;
+  }
+}
+async function $(t, a, e, r = "jpg") {
+  const n = u.join(ft.tmpdir(), `zit-repair-${process.pid}-${Y()}.${r}`);
+  try {
+    await R(t, a(Q(e), n));
+    const o = await m.readFile(n);
+    return o.length > 0 && await Pt(o) ? o : null;
+  } catch {
+    return null;
+  } finally {
+    await m.rm(n, { force: !0 });
+  }
+}
+function _t(t) {
+  return u.extname(t).toLowerCase() === ".png" ? ["png", "jpg"] : ["jpg", "png"];
+}
+async function Tt(t) {
+  const a = `${t}.corrupted.bak`;
+  try {
+    await m.copyFile(t, a, lt.COPYFILE_EXCL);
+  } catch (e) {
+    if (e.code === "EEXIST") return;
+    console.warn(
+      `zit/variants: could not back up corrupt source "${u.basename(t)}": ${e.message}`
+    );
+  }
+}
+async function tt(t, a = {}) {
+  if (a.backupCorrupted && await Tt(t), await H()) {
+    const [e, r] = _t(t), n = await $(
+      "magick",
+      (s, l) => [s, "-strip", "-set", "colorspace", "sRGB", l],
+      t,
+      e
+    );
+    if (n) return n;
+    const o = await $(
+      "magick",
+      (s, l) => [s, l],
+      t,
+      r
+    );
+    if (o) return o;
+  }
+  if (await V()) {
+    const e = await $(
+      "ffmpeg",
+      (r, n) => [
+        "-v",
+        "error",
+        "-err_detect",
+        "ignore_err",
+        "-i",
+        r,
+        "-vf",
+        "format=yuv420p",
+        "-y",
+        n
+      ],
+      t
+    );
+    if (e) return e;
+  }
+  return !await H() && !await V() && console.warn(
+    `zit/variants: cannot repair "${u.basename(t)}" — neither magick nor ffmpeg is available; skipping repair.`
+  ), null;
+}
+const W = "__ogonly", G = "__og";
+function et(t) {
+  return u.basename(t, u.extname(t));
+}
+const jt = (t) => {
+  const a = et(t);
+  return a.endsWith(W) ? { mode: "ogonly", slug: a.slice(0, -W.length) } : a.endsWith(G) ? { mode: "og", slug: a.slice(0, -G.length) } : { mode: "full", slug: a };
+}, xt = (t) => ({
+  mode: "full",
+  slug: et(t)
+}), At = [600, 900, 1200, 1600, 2e3], Ct = 85, kt = ["webp"], Mt = 4, $t = "ogp.jpg", Dt = ".cache.json", Rt = ["jpg", "jpeg", "png", "webp", "heic", "heif", "gif", "avif"], Lt = new RegExp(`\\.(${Rt.join("|")})$`, "i"), Ut = (t, a) => `${t}w.${a}`;
+class f extends Error {
+  stage;
+  constructor(a, e) {
+    super(e instanceof Error ? e.message : String(e), { cause: e }), this.name = "VariantProcessingError", this.stage = a;
+  }
+}
+function at(t) {
+  return {
+    outputDir: t.outputDir,
+    widths: t.widths ?? At,
+    formats: t.formats ?? kt,
+    quality: t.quality ?? Ct,
+    outputName: t.outputName ?? Ut,
+    ogpFileName: t.ogpFileName ?? $t,
+    ogpOptions: t.ogpOptions ?? {},
+    cacheFileName: t.cacheFileName ?? Dt,
+    fallbackBlurhash: t.fallbackBlurhash,
+    tagParser: t.tagParser ?? jt,
+    autoRepair: t.autoRepair ?? !0,
+    backupCorrupted: t.backupCorrupted ?? !1,
+    bakeExifOrientation: t.bakeExifOrientation ?? !1,
+    stripMetadata: t.stripMetadata ?? !1,
+    onMetadata: t.onMetadata,
+    onError: t.onError
+  };
+}
+function rt(t, a) {
+  const e = st(t, a);
+  return e.length > 0 ? e : [t];
+}
+function zt(t, a) {
+  return Number(t.toFixed(a));
+}
+function I(t) {
+  return `original${u.extname(t).toLowerCase()}`;
+}
+const Bt = /* @__PURE__ */ new Set(["gif", "webp", "png"]);
+function Ht(t) {
+  return Bt.has(t.format ?? "") && (t.pages ?? 1) > 1;
+}
+function Vt(t) {
+  return t.length > 0 && t !== "." && t !== ".." && !t.includes("/") && !t.includes("\\") && !t.includes("\0");
+}
+const Wt = 4;
+function Gt(t) {
+  return JSON.stringify({
+    pipelineVersion: Wt,
+    quality: t.quality,
+    widths: t.widths,
+    formats: t.formats,
+    ogpFileName: t.ogpFileName,
+    ogpOptions: t.ogpOptions,
+    fallbackBlurhash: t.fallbackBlurhash ?? null,
+    // bakeExifOrientation is deliberately NOT fingerprinted: it is a no-op
+    // (orientation is always baked at encode time, issue #29), so toggling
+    // it must keep the cache hit rather than regenerate identical outputs.
+    stripMetadata: t.stripMetadata
+  });
+}
+function Xt(t, a) {
+  if (t.length !== a.length) return !1;
+  const e = [...t].sort(), r = [...a].sort();
+  return e.every((n, o) => n === r[o]);
+}
+const X = /* @__PURE__ */ new Set(["webp", "jpg", "jpeg", "png", "avif", "tiff", "gif"]);
+function qt(t, a, e) {
+  if (!X.has(a))
+    throw new Error(
+      `unsupported output format "${a}" — expected one of ${[...X].join(", ")}`
+    );
+  switch (a) {
+    case "webp":
+      return t.webp({ quality: e });
+    case "jpg":
+    case "jpeg":
+      return t.jpeg({ quality: e, progressive: !0, mozjpeg: !0 });
+    case "png":
+      return t.png();
+    case "avif":
+      return t.avif({ quality: e });
+    default:
+      return t.toFormat(a, { quality: e });
+  }
+}
+async function Yt(t, a, e) {
+  try {
+    return { metadata: await j(t).metadata(), input: t };
+  } catch (r) {
+    if (a && typeof t == "string" && Z(r)) {
+      const n = await tt(t, { backupCorrupted: e });
+      if (n)
+        return { metadata: await j(n).metadata(), input: n };
+    }
+    throw r;
+  }
+}
+async function q(t, a, e) {
+  try {
+    return await it(t);
+  } catch (r) {
+    return console.warn(`zit/variants: blurhash encoding failed for "${a}": ${r.message}`), e ?? null;
+  }
+}
+async function Jt(t, a, e, r) {
+  const n = [];
+  for (const o of rt(e, r.widths))
+    for (const s of r.formats) {
+      const l = r.outputName(o, s), y = u.join(a, l), w = j(t).rotate().resize({ width: o, withoutEnlargement: !0 });
+      r.stripMetadata || w.keepIccProfile();
+      const { size: d } = await L(
+        y,
+        (h) => qt(w, s, r.quality).toFile(h)
+      );
+      n.push({ width: o, format: s, filename: l, path: y, size: d });
+    }
+  return n;
+}
+async function D(t, a, e) {
+  const r = u.join(a, e.ogpFileName), n = await ut(t, {
+    quality: e.quality,
+    ...e.ogpOptions,
+    outPath: r
+  });
+  return {
+    filename: e.ogpFileName,
+    path: r,
+    size: n.buffer.length,
+    method: n.method
+  };
+}
+function Qt(t, a, e, r) {
+  if (t === "ogonly") return [r.ogpFileName];
+  if (a.animated)
+    return t === "og" ? [I(e), r.ogpFileName] : [I(e)];
+  const n = a.metadata?.width;
+  if (!n) return null;
+  const o = [];
+  for (const s of rt(n, r.widths))
+    for (const l of r.formats)
+      o.push(r.outputName(s, l));
+  return t === "og" && o.push(r.ogpFileName), o;
+}
+async function Kt(t, a, e) {
+  if (!e) return !1;
+  for (const r of a) {
+    const n = e[r];
+    if (typeof n != "number") return !1;
+    let o;
+    try {
+      o = await m.stat(u.join(t, r));
+    } catch {
+      return !1;
+    }
+    if (o.size !== n) return !1;
+  }
+  return !0;
+}
+async function Zt(t, a) {
+  const e = at(a), { inputPath: r } = t, { mode: n, slug: o } = t.tag ?? e.tagParser(u.basename(r));
+  if (!Vt(o))
+    throw new f(
+      "slug",
+      new Error(`unsafe output slug "${o}" derived from "${u.basename(r)}"`)
+    );
+  const s = u.join(e.outputDir, o), l = { slug: o, inputPath: r, outputDir: s, mode: n }, y = u.join(s, e.cacheFileName), w = Gt(e);
+  let d;
+  try {
+    d = await mt(r);
+  } catch (i) {
+    throw new f("io", i);
+  }
+  const h = await dt(y);
+  if (h && h.hash === d && h.configHash === w && h.mode === n) {
+    const i = Qt(n, h, r, e);
+    if (i && Array.isArray(h.outputs) && Xt(i, h.outputs) && await Kt(s, i, h.outputSizes))
+      return h.metadata && await e.onMetadata?.(h.metadata), {
+        ...l,
+        status: "skipped",
+        reason: "cache-hit",
+        animated: h.animated,
+        variants: [],
+        ogp: null,
+        metadata: h.metadata
+      };
+  }
+  if (await vt(r))
+    return { ...l, status: "skipped", reason: "not-an-image", animated: !1, variants: [], ogp: null, metadata: null };
+  try {
+    await m.mkdir(s, { recursive: !0 });
+  } catch (i) {
+    throw new f("io", i);
+  }
+  let c = r;
+  if (await Ot(r))
+    try {
+      c = (await ct(r, { quality: 90 })).buffer;
+    } catch (i) {
+      throw new f("heic", i);
+    }
+  let p;
+  try {
+    const i = await Yt(c, e.autoRepair, e.backupCorrupted);
+    p = i.metadata, c = i.input;
+  } catch (i) {
+    throw new f("probe", i);
+  }
+  const F = p.autoOrient?.width || p.width || 0, x = p.autoOrient?.height || p.height || 0;
+  if (!F || !x)
+    throw new f("probe", new Error(`could not determine dimensions for "${o}"`));
+  const E = Ht(p);
+  if (n === "ogonly") {
+    let i;
+    try {
+      i = await D(c, s, e);
+    } catch (S) {
+      throw new f("ogp", S);
+    }
+    return await z(y, {
+      hash: d,
+      configHash: w,
+      mode: n,
+      animated: E,
+      outputs: [i.filename],
+      outputSizes: { [i.filename]: i.size },
+      metadata: null
+    }), { ...l, status: "processed", animated: E, variants: [], ogp: i, metadata: null };
+  }
+  let A, O = [], b = null, C = null;
+  if (E) {
+    A = await q(c, o, e.fallbackBlurhash);
+    try {
+      const i = u.join(s, I(r));
+      await L(i, (S) => m.copyFile(r, S)), C = (await m.stat(i)).size;
+    } catch (i) {
+      throw new f("passthrough", i);
+    }
+    if (n === "og")
+      try {
+        b = await D(c, s, e);
+      } catch (i) {
+        throw new f("ogp", i);
+      }
+  } else {
+    const i = async (g) => {
+      const M = await q(g, o, e.fallbackBlurhash), T = await Jt(g, s, F, e);
+      let N = null;
+      if (n === "og")
+        try {
+          N = await D(g, s, e);
+        } catch (ot) {
+          throw new f("ogp", ot);
+        }
+      return { blurhash: M, variants: T, ogp: N };
+    };
+    let S;
+    try {
+      S = await i(c);
+    } catch (g) {
+      const M = g instanceof f ? g.cause : g, T = e.autoRepair && typeof c == "string" && Z(M) ? await tt(c, { backupCorrupted: e.backupCorrupted }) : null;
+      if (!T)
+        throw g instanceof f ? g : new f("variants", g);
+      try {
+        S = await i(T);
+      } catch (N) {
+        throw N instanceof f ? N : new f("variants", N);
+      }
+    }
+    ({ blurhash: A, variants: O, ogp: b } = S);
+  }
+  const k = u.extname(r).slice(1).toLowerCase(), P = {
+    slug: o,
+    blurhash: A,
+    width: F,
+    height: x,
+    aspectRatio: zt(x / F * 100, 2),
+    hasVariants: !E && O.length > 0,
+    hash: d,
+    processedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  k && k !== "webp" && (P.originalFormat = k);
+  const nt = [
+    ...O.map((i) => i.filename),
+    ...b ? [b.filename] : [],
+    ...E ? [I(r)] : []
+  ], _ = {};
+  for (const i of O) _[i.filename] = i.size;
+  b && (_[b.filename] = b.size), E && C !== null && (_[I(r)] = C);
+  try {
+    await z(y, { hash: d, configHash: w, mode: n, animated: E, outputs: nt, outputSizes: _, metadata: P });
+  } catch (i) {
+    throw new f("cache", i);
+  }
+  return await e.onMetadata?.(P), { ...l, status: "processed", animated: E, variants: O, ogp: b, metadata: P };
+}
+async function te(t) {
+  const a = /* @__PURE__ */ new Set(), e = [], r = (n) => {
+    const o = u.resolve(n);
+    a.has(o) || (a.add(o), e.push(n));
+  };
+  if (t.inputDir) {
+    const n = t.inputDir;
+    let o;
+    try {
+      o = await m.readdir(n);
+    } catch (s) {
+      throw new Error(`variants: could not read inputDir "${n}": ${s.message}`, {
+        cause: s
+      });
+    }
+    for (const s of o.sort())
+      Lt.test(s) && r(u.join(n, s));
+  }
+  if (t.files) for (const n of t.files) r(n);
+  return e;
+}
+async function ee(t, a, e) {
+  const r = Math.max(1, Math.min(a, t.length));
+  let n = 0;
+  const o = Array.from({ length: r }, async () => {
+    for (; n < t.length; ) {
+      const s = t[n++];
+      await e(s);
+    }
+  });
+  await Promise.all(o);
+}
+async function ae(t, a) {
+  const e = [];
+  let r;
+  try {
+    r = await m.readdir(t, { withFileTypes: !0 });
+  } catch {
+    return e;
+  }
+  const n = u.resolve(t);
+  for (const o of r) {
+    if (!o.isDirectory() || a.has(o.name)) continue;
+    const s = u.resolve(t, o.name);
+    u.dirname(s) === n && (await m.rm(s, { recursive: !0, force: !0 }), e.push(s));
+  }
+  return e;
+}
+async function de(t) {
+  const a = at(t), e = t.concurrency ?? Mt;
+  if (!Number.isFinite(e) || e < 1)
+    throw new Error(
+      `processImages: concurrency must be a finite number >= 1, received ${e}`
+    );
+  const r = await te(t), n = [], o = [], s = async (c) => {
+    o.push(c), await a.onError?.(c);
+  }, l = [];
+  let y = !1;
+  for (const c of r)
+    try {
+      l.push({ inputPath: c, tag: a.tagParser(u.basename(c)) });
+    } catch (p) {
+      y = !0, await s({
+        inputPath: c,
+        slug: u.basename(c),
+        stage: "slug",
+        error: p instanceof Error ? p.message : String(p)
+      });
+    }
+  const w = /* @__PURE__ */ new Map();
+  for (const c of l) {
+    const p = w.get(c.tag.slug);
+    p ? p.push(c) : w.set(c.tag.slug, [c]);
+  }
+  const d = [];
+  for (const [c, p] of w) {
+    if (p.length === 1) {
+      d.push(p[0]);
+      continue;
+    }
+    for (const F of p)
+      await s({
+        inputPath: F.inputPath,
+        slug: c,
+        stage: "slug",
+        error: `duplicate output slug "${c}" — ${p.length} inputs map to the same output directory`
+      });
+  }
+  await ee(d, e, async (c) => {
+    try {
+      n.push(await Zt(c, t));
+    } catch (p) {
+      await s({
+        inputPath: c.inputPath,
+        slug: c.tag?.slug ?? u.basename(c.inputPath),
+        stage: p instanceof f ? p.stage : "unknown",
+        error: p instanceof Error ? p.message : String(p)
+      });
+    }
+  });
+  const h = t.cleanupOrphans && !y ? await ae(a.outputDir, new Set(l.map((c) => c.tag.slug))) : [];
+  return { results: n, failed: o, removed: h };
+}
+const re = [400, 800, 1600], ge = {
+  widths: re,
+  bakeExifOrientation: !0,
+  stripMetadata: !0,
+  tagParser: xt
+};
+export {
+  Dt as D,
+  Lt as I,
+  re as P,
+  Rt as S,
+  f as V,
+  Mt as a,
+  kt as b,
+  $t as c,
+  Ct as d,
+  At as e,
+  jt as f,
+  de as g,
+  Zt as h,
+  xt as n,
+  ge as p,
+  rt as s
+};

package/dist/product-photo/index.d.ts

@@ -0,0 +1,50 @@
+import type { Color as SharpColor } from 'sharp';
+import { generateShadowLayers } from './shadow.js';
+import type { GenerateShadowLayersOptions } from './shadow.js';
+export { generateShadowLayers };
+export type { ShadowMode, ShadowBlend, ShadowLayer, ShadowTuning, BottomShadowTuning, ProjectedShadowTuning, VignetteTuning, GenerateShadowLayersOptions, } from './shadow.js';
+export type ImageInput = string | Buffer;
+export interface OptionalPeerMissingError extends Error {
+    code: 'ERR_OPTIONAL_PEER_MISSING';
+}
+export interface AlphaTrimOptions {
+    threshold?: number;
+}
+export interface FlatColorBackground {
+    color: SharpColor;
+}
+export type ProductPhotoBackground = ImageInput | FlatColorBackground;
+export interface ComposeProductPhotoOptions {
+    background: ProductPhotoBackground;
+    size?: number;
+    fit?: number;
+    quality?: number;
+    shadow?: boolean | GenerateShadowLayersOptions;
+}
+export interface ComposeProductPhotoResult {
+    buffer: Buffer;
+    width: number;
+    height: number;
+    format: 'jpeg';
+}
+/**
+ * Remove the background from a product image, returning an RGBA PNG buffer.
+ *
+ * Dynamic-imports the optional peer dependency `@imgly/background-removal-node`
+ * (an ONNX-based ML model, ~80MB download on first use) so consumers who
+ * never call this function never pay that cost. Accepts a file path,
+ * a Buffer, or a URL. Throws an error with `code: 'ERR_OPTIONAL_PEER_MISSING'`
+ * when the optional peer isn't installed.
+ */
+export declare function removeBackground(input: ImageInput | URL): Promise<Buffer>;
+/**
+ * Trim fully-transparent padding from an image with an alpha channel,
+ * tightly cropping to the opaque/semi-opaque content.
+ */
+export declare function alphaTrim(input: ImageInput, options?: AlphaTrimOptions): Promise<Buffer>;
+/**
+ * Compose a subject (typically background-removed and trimmed via
+ * `removeBackground`/`alphaTrim`) onto a background canvas, fitting it
+ * within a centered container and optionally adding synthesized shadows.
+ */
+export declare function composeProductPhoto(subject: ImageInput, options: ComposeProductPhotoOptions): Promise<ComposeProductPhotoResult>;