@takazudo/zudo-image-tweaker 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.3
+
+### Features
+
+- b4push: queue heavy steps through the machine-wide heavy-guard (4b15f51)
+
+### Fixed
+
+- product-photo: pass Buffer input to imgly as a MIME-typed Blob, so `removeBackground()` no longer fails with "Unsupported format" ([#126](https://github.com/zudolab/zudo-image-tweaker/pull/126), closes [#123](https://github.com/zudolab/zudo-image-tweaker/issues/123)) (140168c)
+- deps: resolve root-workspace pnpm audit advisories ([#116](https://github.com/zudolab/zudo-image-tweaker/issues/116)) (993351d)
+- deps: limit audit overrides to their current major/minor lines (87c3255)
+
+### Other Changes
+
+- ci: bump actions/checkout v7.0.1, actions/setup-node v7.1.0, pnpm/action-setup v6.1.0 (8998428)
+- docs(doc): re-scaffold the doc site onto create-zudo-doc 8.1.0 / zfb 5.1.2 (f92c5d6, 7fde2a5, ff0c72d)
+- ci: gate the doc build, links, wind audit and dependency audit; doc jobs move to Node 24 (4651d4e)
+- build(doc): clear the high doc audit advisories (wrangler 4.152.0, zod 4.6.7, undici override) (aa5f7cf)
+- chore: follow-ups from the code review (8bdd50e)
+- chore(ci): record the NPM_TOKEN rotation on 2026-10-26 (760b1d1)
+
 ## 0.1.2
 
 ### Fixed

package/dist/product-photo/index.js

@@ -1,110 +1,110 @@
 import P from "node:path";
 import { pathToFileURL as L } from "node:url";
-import m from "sharp";
-const Y = { r: 0, g: 0, b: 0, alpha: 0 }, D = { lightX: 0.3, lightY: 0.25, strength: 0.12, spread: 1.3 }, j = [
+import i from "sharp";
+const Y = { r: 0, g: 0, b: 0, alpha: 0 }, j = { lightX: 0.3, lightY: 0.25, strength: 0.12, spread: 1.3 }, D = [
   { blur: 100, opacity: 0.25, offsetX: 10, offsetY: 8, fadeStartRatio: -0.1 },
   { blur: 40, opacity: 0.35, offsetX: 8, offsetY: 6, fadeStartRatio: 0 }
-], x = { blur: 8, opacity: 0.55, offsetX: 4, offsetY: 3 }, F = {
+], F = { blur: 8, opacity: 0.55, offsetX: 4, offsetY: 3 }, G = {
   squash: 0.25,
   offsetX: 65,
   offsetY: 35,
   blur: 75,
   opacity: 0.45
-}, G = [
+}, x = [
   { blur: 120, opacity: 0.3, offsetX: 62, offsetY: 55, fadeStartRatio: -0.1 },
   { blur: 52, opacity: 0.45, offsetX: 58, offsetY: 50, fadeStartRatio: 0 }
 ], X = { blur: 12, opacity: 0.5, offsetX: 55, offsetY: 45 };
-async function q(o, t = {}) {
-  const { mode: n = "grounded", vignette: e, contactShadow: f, bottomShadows: s, projectedShadow: u } = t, { width: r, height: a } = await m(o).metadata();
-  if (!r || !a)
+async function U(o, t = {}) {
+  const { mode: n = "grounded", vignette: e, contactShadow: f, bottomShadows: s, projectedShadow: u } = t, { width: a, height: r } = await i(o).metadata();
+  if (!a || !r)
     throw new Error("generateShadowLayers: could not read alphaImage dimensions.");
-  const c = await m(o).extractChannel(3).toColourspace("b-w").raw().toBuffer(), l = U(c, r, a), w = { ...D, ...e }, d = W(r, a, w);
+  const c = await i(o).extractChannel(3).toColourspace("b-w").raw().toBuffer(), l = q(c, a, r), b = { ...j, ...e }, d = W(a, r, b);
   if (n === "floating") {
-    const p = { ...F, ...u }, [g, B] = _(G, s), i = { ...X, ...f };
+    const m = { ...G, ...u }, [B, g] = _(x, s), p = { ...X, ...f };
     return Promise.all([
       d,
-      H(c, r, a, l, p),
-      h(c, r, a, l, g),
-      h(c, r, a, l, B),
-      M(c, r, a, i)
+      H(c, a, r, l, m),
+      A(c, a, r, l, B),
+      A(c, a, r, l, g),
+      N(c, a, r, p)
     ]);
   }
-  const [y, b] = _(j, s), S = { ...x, ...f };
+  const [y, w] = _(D, s), S = { ...F, ...f };
   return Promise.all([
     d,
-    h(c, r, a, l, y),
-    h(c, r, a, l, b),
-    M(c, r, a, S)
+    A(c, a, r, l, y),
+    A(c, a, r, l, w),
+    N(c, a, r, S)
   ]);
 }
 function _(o, t) {
   return o.map((n, e) => ({ ...n, ...t?.[e] }));
 }
-function A(o) {
+function h(o) {
   return Number.isFinite(o) ? Math.min(1, Math.max(0, o)) : 0;
 }
-function U(o, t, n) {
+function q(o, t, n) {
   let e = n, f = 0, s = t, u = 0;
-  for (let r = 0; r < n; r++)
-    for (let a = 0; a < t; a++)
-      o[r * t + a] > 0 && (r < e && (e = r), r > f && (f = r), a < s && (s = a), a > u && (u = a));
+  for (let a = 0; a < n; a++)
+    for (let r = 0; r < t; r++)
+      o[a * t + r] > 0 && (a < e && (e = a), a > f && (f = a), r < s && (s = r), r > u && (u = r));
   return e > f ? null : { top: e, bottom: f + 1, left: s, right: u + 1 };
 }
-async function M(o, t, n, { blur: e, opacity: f, offsetX: s, offsetY: u }) {
-  const r = k(o, t, n, s, u), a = await m(r, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").blur(Math.max(e, 0.3)).linear(A(f), 0).png().toBuffer();
-  return C(a, t, n);
-}
-async function H(o, t, n, e, { squash: f, offsetX: s, offsetY: u, blur: r, opacity: a }) {
-  if (!e) return I(t, n);
-  const c = e.right - e.left, l = e.bottom - e.top, w = Buffer.alloc(c * l);
-  for (let B = 0; B < l; B++)
-    for (let i = 0; i < c; i++)
-      w[B * c + i] = o[(e.top + B) * t + (e.left + i)];
-  const d = Math.max(1, Math.round(l * f)), y = await m(w, { raw: { width: c, height: l, channels: 1 } }).toColourspace("b-w").resize(c, d, { fit: "fill" }).raw().toBuffer(), b = Buffer.alloc(t * n, 0), S = e.left + s, p = e.bottom + u;
-  for (let B = 0; B < d; B++) {
-    const i = p + B;
-    if (!(i < 0 || i >= n))
+async function N(o, t, n, { blur: e, opacity: f, offsetX: s, offsetY: u }) {
+  const a = I(o, t, n, s, u), r = await i(a, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").blur(Math.max(e, 0.3)).linear(h(f), 0).png().toBuffer();
+  return E(r, t, n);
+}
+async function H(o, t, n, e, { squash: f, offsetX: s, offsetY: u, blur: a, opacity: r }) {
+  if (!e) return k(t, n);
+  const c = e.right - e.left, l = e.bottom - e.top, b = Buffer.alloc(c * l);
+  for (let g = 0; g < l; g++)
+    for (let p = 0; p < c; p++)
+      b[g * c + p] = o[(e.top + g) * t + (e.left + p)];
+  const d = Math.max(1, Math.round(l * f)), y = await i(b, { raw: { width: c, height: l, channels: 1 } }).toColourspace("b-w").resize(c, d, { fit: "fill" }).raw().toBuffer(), w = Buffer.alloc(t * n, 0), S = e.left + s, m = e.bottom + u;
+  for (let g = 0; g < d; g++) {
+    const p = m + g;
+    if (!(p < 0 || p >= n))
       for (let T = 0; T < c; T++) {
-        const E = S + T;
-        E < 0 || E >= t || (b[i * t + E] = y[B * c + T]);
+        const C = S + T;
+        C < 0 || C >= t || (w[p * t + C] = y[g * c + T]);
       }
   }
-  const g = await m(b, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").blur(Math.max(r, 0.3)).linear(A(a), 0).png().toBuffer();
-  return C(g, t, n);
-}
-async function h(o, t, n, e, { blur: f, opacity: s, offsetX: u, offsetY: r, fadeStartRatio: a }) {
-  if (!e) return I(t, n);
-  const c = A(s), l = k(o, t, n, u, r), w = await m(l, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").blur(Math.max(f, 0.3)).raw().toBuffer(), d = e.top + (e.bottom - e.top) * (0.5 + a), y = (e.bottom - d) * 0.5, b = Buffer.alloc(t * n, 0);
-  for (let p = 0; p < n; p++) {
-    let g;
-    p <= d ? g = 0 : y > 0 && p <= d + y ? g = (p - d) / y : g = 1;
-    const B = g * c;
-    for (let i = 0; i < t; i++)
-      b[p * t + i] = Math.round(w[p * t + i] * B);
+  const B = await i(w, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").blur(Math.max(a, 0.3)).linear(h(r), 0).png().toBuffer();
+  return E(B, t, n);
+}
+async function A(o, t, n, e, { blur: f, opacity: s, offsetX: u, offsetY: a, fadeStartRatio: r }) {
+  if (!e) return k(t, n);
+  const c = h(s), l = I(o, t, n, u, a), b = await i(l, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").blur(Math.max(f, 0.3)).raw().toBuffer(), d = e.top + (e.bottom - e.top) * (0.5 + r), y = (e.bottom - d) * 0.5, w = Buffer.alloc(t * n, 0);
+  for (let m = 0; m < n; m++) {
+    let B;
+    m <= d ? B = 0 : y > 0 && m <= d + y ? B = (m - d) / y : B = 1;
+    const g = B * c;
+    for (let p = 0; p < t; p++)
+      w[m * t + p] = Math.round(b[m * t + p] * g);
   }
-  const S = await m(b, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").png().toBuffer();
-  return C(S, t, n);
+  const S = await i(w, { raw: { width: t, height: n, channels: 1 } }).toColourspace("b-w").png().toBuffer();
+  return E(S, t, n);
 }
 async function W(o, t, { lightX: n, lightY: e, strength: f, spread: s }) {
-  const u = A(f), r = Buffer.alloc(o * t, 0), a = o * n, c = t * e, l = Math.min(o, t) / 2, w = s * s;
+  const u = h(f), a = Buffer.alloc(o * t, 0), r = o * n, c = t * e, l = Math.min(o, t) / 2, b = s * s;
   for (let y = 0; y < t; y++) {
-    const b = (y - c) / l, S = b * b;
-    for (let p = 0; p < o; p++) {
-      const g = (p - a) / l, B = g * g + S, i = Math.min(1, (B / w) ** 0.75) * u * 255;
-      r[y * o + p] = Math.round(i);
+    const w = (y - c) / l, S = w * w;
+    for (let m = 0; m < o; m++) {
+      const B = (m - r) / l, g = B * B + S, p = Math.min(1, (g / b) ** 0.75) * u * 255;
+      a[y * o + m] = Math.round(p);
     }
   }
-  const d = await m(r, { raw: { width: o, height: t, channels: 1 } }).toColourspace("b-w").png().toBuffer();
-  return C(d, o, t);
+  const d = await i(a, { raw: { width: o, height: t, channels: 1 } }).toColourspace("b-w").png().toBuffer();
+  return E(d, o, t);
 }
-function k(o, t, n, e, f) {
+function I(o, t, n, e, f) {
   const s = Buffer.alloc(t * n, 0);
   for (let u = 0; u < n; u++) {
-    const r = u + f;
-    if (!(r < 0 || r >= n))
-      for (let a = 0; a < t; a++) {
-        const c = a + e;
-        c < 0 || c >= t || (s[r * t + c] = o[u * t + a]);
+    const a = u + f;
+    if (!(a < 0 || a >= n))
+      for (let r = 0; r < t; r++) {
+        const c = r + e;
+        c < 0 || c >= t || (s[a * t + c] = o[u * t + r]);
       }
   }
   return s;
@@ -113,18 +113,18 @@ const R = /* @__PURE__ */ new Map();
 function $(o, t) {
   const n = `${o}x${t}`;
   let e = R.get(n);
-  return e || (e = m({ create: { width: o, height: t, channels: 3, background: { r: 0, g: 0, b: 0 } } }).png().toBuffer(), R.set(n, e)), e;
+  return e || (e = i({ create: { width: o, height: t, channels: 3, background: { r: 0, g: 0, b: 0 } } }).png().toBuffer(), R.set(n, e)), e;
 }
-async function C(o, t, n) {
+async function E(o, t, n) {
   const e = await $(t, n);
-  return { buffer: await m(e).joinChannel(o).png().toBuffer(), blend: "multiply", offset: { x: 0, y: 0 } };
+  return { buffer: await i(e).joinChannel(o).png().toBuffer(), blend: "multiply", offset: { x: 0, y: 0 } };
 }
-async function I(o, t) {
-  return { buffer: await m({ create: { width: o, height: t, channels: 4, background: Y } }).png().toBuffer(), blend: "multiply", offset: { x: 0, y: 0 } };
+async function k(o, t) {
+  return { buffer: await i({ create: { width: o, height: t, channels: 4, background: Y } }).png().toBuffer(), blend: "multiply", offset: { x: 0, y: 0 } };
 }
-const v = 1600, V = 1440, Z = 90, N = { r: 0, g: 0, b: 0, alpha: 0 }, O = "@imgly/background-removal-node";
-async function ct(o) {
-  const t = await z(), n = Q(o), f = await (await t.removeBackground(n)).arrayBuffer();
+const v = 1600, V = 1440, Z = 90, M = { r: 0, g: 0, b: 0, alpha: 0 }, O = "@imgly/background-removal-node";
+async function ft(o) {
+  const t = await z(), n = await tt(o), f = await (await t.removeBackground(n)).arrayBuffer();
   return Buffer.from(f);
 }
 async function z() {
@@ -145,45 +145,53 @@ function K(o) {
   }
   return !1;
 }
-function Q(o) {
-  return Buffer.isBuffer(o) || o instanceof URL ? o : L(P.resolve(o)).href;
+const Q = {
+  png: "image/png",
+  jpeg: "image/jpeg",
+  webp: "image/webp"
+};
+async function tt(o) {
+  if (o instanceof URL) return o;
+  if (!Buffer.isBuffer(o)) return L(P.resolve(o)).href;
+  const { format: t } = await i(o).metadata(), n = t ? Q[t] : void 0;
+  return n ? new Blob([new Uint8Array(o)], { type: n }) : new Blob([new Uint8Array(await i(o).png().toBuffer())], { type: "image/png" });
 }
-async function ft(o, t = {}) {
+async function st(o, t = {}) {
   const { threshold: n = 10 } = t;
-  return m(o).trim({ background: N, threshold: n }).png().toBuffer();
+  return i(o).trim({ background: M, threshold: n }).png().toBuffer();
 }
-async function st(o, t) {
+async function ut(o, t) {
   const { background: n, size: e = v, quality: f = Z, shadow: s = !1 } = t, u = t.fit ?? Math.round(e * (V / v));
   if (n == null)
     throw new Error(
       "composeProductPhoto requires a `background`: an image path/Buffer, or a flat `{ color }` fill."
     );
-  const r = Math.round((e - u) / 2), a = await m(o).resize(u, u, { fit: "contain", background: N }).png().toBuffer(), c = nt(n, e);
+  const a = Math.round((e - u) / 2), r = await i(o).resize(u, u, { fit: "contain", background: M }).png().toBuffer(), c = et(n, e);
   let l;
   if (s) {
-    const y = await m({
-      create: { width: e, height: e, channels: 4, background: N }
-    }).composite([{ input: a, left: r, top: r }]).png().toBuffer();
-    l = [...(await q(y, s === !0 ? {} : s)).map(tt), { input: y, left: 0, top: 0 }];
+    const y = await i({
+      create: { width: e, height: e, channels: 4, background: M }
+    }).composite([{ input: r, left: a, top: a }]).png().toBuffer();
+    l = [...(await U(y, s === !0 ? {} : s)).map(ot), { input: y, left: 0, top: 0 }];
   } else
-    l = [{ input: a, left: r, top: r }];
-  const { data: w, info: d } = await c.composite(l).jpeg({ quality: f }).toBuffer({ resolveWithObject: !0 });
-  return { buffer: w, width: d.width, height: d.height, format: "jpeg" };
+    l = [{ input: r, left: a, top: a }];
+  const { data: b, info: d } = await c.composite(l).jpeg({ quality: f }).toBuffer({ resolveWithObject: !0 });
+  return { buffer: b, width: d.width, height: d.height, format: "jpeg" };
 }
-function tt(o) {
+function ot(o) {
   return { input: o.buffer, left: o.offset.x, top: o.offset.y, blend: o.blend };
 }
-function ot(o) {
+function nt(o) {
   return typeof o == "object" && !Buffer.isBuffer(o) && "color" in o;
 }
-function nt(o, t) {
-  return ot(o) ? m({
+function et(o, t) {
+  return nt(o) ? i({
     create: { width: t, height: t, channels: 3, background: o.color }
-  }) : m(o).resize(t, t, { fit: "cover" });
+  }) : i(o).resize(t, t, { fit: "cover" });
 }
 export {
-  ft as alphaTrim,
-  st as composeProductPhoto,
-  q as generateShadowLayers,
-  ct as removeBackground
+  st as alphaTrim,
+  ut as composeProductPhoto,
+  U as generateShadowLayers,
+  ft as removeBackground
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@takazudo/zudo-image-tweaker",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "sharp-based image-tweaking toolkit: variants, HEIF conversion, OGP cards, byte-budget encoding, square crops, product-photo background removal, calibration, compositing, blurhash, EXIF, and browser upload prep.",
   "private": false,
   "license": "MIT",