next-image-transformer 0.2.2 → 0.2.4

package/dist/server.d.ts

@@ -0,0 +1 @@
+export { createImageTransformRouteHandler } from "./createImageTransformRouteHandler";

package/dist/server.js

@@ -0,0 +1,198 @@
+import h from "node:path";
+import { z as C, c as B } from "./index-C4FbrW_M.js";
+import { createHash as U } from "node:crypto";
+import m from "node:fs/promises";
+import b from "sharp";
+function j({
+  canonicalUrl: r
+}) {
+  return U("sha256").update(r).digest("hex");
+}
+function P({
+  cacheKey: r,
+  cacheDir: n
+}) {
+  const s = r.slice(0, 2), a = r.slice(2), e = h.join(n, s);
+  return {
+    dir: e,
+    bodyPath: h.join(e, `${a}.bin`),
+    metaPath: h.join(e, `${a}.json`)
+  };
+}
+async function q({
+  cacheKey: r,
+  cacheDir: n
+}) {
+  const { bodyPath: s, metaPath: a } = P({ cacheKey: r, cacheDir: n });
+  try {
+    const [e, u] = await Promise.all([
+      m.readFile(s),
+      m.readFile(a, "utf8")
+    ]), o = (() => {
+      try {
+        const i = JSON.parse(u), t = C.object({
+          contentType: C.string()
+        }).loose().safeParse(i);
+        return t.success ? t.data : null;
+      } catch {
+        return null;
+      }
+    })();
+    return o ? { body: new Uint8Array(e), contentType: o.contentType } : null;
+  } catch (e) {
+    if (e instanceof Error && "code" in e && e.code === "ENOENT")
+      return null;
+    throw e;
+  }
+}
+function x(r, n, s, a, e, u, o, i, t) {
+  switch (arguments.length) {
+    case 1:
+      return r;
+    case 2:
+      return n(r);
+    case 3:
+      return s(n(r));
+    case 4:
+      return a(s(n(r)));
+    case 5:
+      return e(a(s(n(r))));
+    case 6:
+      return u(e(a(s(n(r)))));
+    case 7:
+      return o(u(e(a(s(n(r))))));
+    case 8:
+      return i(o(u(e(a(s(n(r)))))));
+    case 9:
+      return t(i(o(u(e(a(s(n(r))))))));
+    default: {
+      for (var c = arguments[0], f = 1; f < arguments.length; f++)
+        c = arguments[f](c);
+      return c;
+    }
+  }
+}
+async function A({
+  cacheKey: r,
+  body: n,
+  meta: s,
+  cacheDir: a
+}) {
+  const { dir: e, bodyPath: u, metaPath: o } = P({
+    cacheKey: r,
+    cacheDir: a
+  });
+  await m.mkdir(e, { recursive: !0 });
+  const i = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`, t = `${u}.${i}.tmp`, c = `${o}.${i}.tmp`;
+  await Promise.all([
+    m.writeFile(t, n),
+    m.writeFile(c, JSON.stringify(s), "utf8")
+  ]), await Promise.all([
+    m.rename(t, u),
+    m.rename(c, o)
+  ]);
+}
+const O = ({
+  apiRouteUrl: r,
+  cacheDir: n = h.join(process.cwd(), ".transform-cache"),
+  cacheControl: s = "public, max-age=31536000, immutable",
+  allowedHosts: a
+}) => {
+  const e = B({ apiRouteUrl: r }), u = (o) => {
+    if (!a) return !0;
+    const i = o.hostname.toLowerCase(), t = o.host.toLowerCase();
+    return a.some((c) => {
+      if (c instanceof RegExp)
+        return c.test(i) || c.test(t);
+      const f = c.toLowerCase();
+      return f.includes(":") ? t === f : i === f;
+    });
+  };
+  return async function(i) {
+    const { data: t, error: c } = e.safeDecode(i.url);
+    if (c)
+      return new Response("Bad Request", { status: 400 });
+    const f = e.encode(
+      // encode() accepts the decoded transform config shape; we only call this
+      // after decoding has succeeded.
+      t
+    ), y = t.q ?? 100, g = j({ canonicalUrl: f }), d = await q({ cacheKey: g, cacheDir: n });
+    if (d)
+      return new Response(d.body, {
+        headers: {
+          "Content-Type": d.contentType,
+          "Cache-Control": s
+        }
+      });
+    let l;
+    try {
+      l = new URL(t.source);
+    } catch {
+      return new Response("Bad Request", { status: 400 });
+    }
+    if (l.protocol !== "http:" && l.protocol !== "https:")
+      return new Response("Bad Request", { status: 400 });
+    if (l.username || l.password)
+      return new Response("Bad Request", { status: 400 });
+    if (!u(l))
+      return new Response("Forbidden", { status: 403 });
+    const w = await fetch(l);
+    if (!w.ok)
+      return new Response("Upstream fetch failed", { status: 502 });
+    const v = b(Buffer.from(await w.arrayBuffer())), R = await x(
+      v,
+      /**
+       * auto-orient: read's the image's EXIF data and rotates it to the correct
+       * orientation.
+       */
+      (p) => p.rotate(),
+      /**
+       * Resize
+       */
+      (p) => t.w || t.h ? p.resize({
+        width: t.w,
+        height: t.h,
+        fit: "inside",
+        withoutEnlargement: !0
+      }) : p,
+      /**
+       * Change format
+       */
+      (p) => {
+        switch (t.fmt) {
+          case "preserve":
+            return p;
+          case "avif":
+            return p.avif({ quality: y });
+          case "webp":
+            return p.webp({ quality: y });
+          default:
+            throw new Error(`Unreachable case: ${t.fmt}`);
+        }
+      }
+    ).toBuffer(), $ = new Uint8Array(R), T = (() => {
+      switch (t.fmt) {
+        case "preserve":
+          return w.headers.get("content-type") ?? "application/octet-stream";
+        case "avif":
+          return "image/avif";
+        case "webp":
+          return "image/webp";
+      }
+    })();
+    return await A({
+      cacheKey: g,
+      body: R,
+      meta: { contentType: T },
+      cacheDir: n
+    }), new Response($, {
+      headers: {
+        "Content-Type": T,
+        "Cache-Control": s
+      }
+    });
+  };
+};
+export {
+  O as createImageTransformRouteHandler
+};

package/package.json

@@ -1,12 +1,16 @@
 {
   "name": "next-image-transformer",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     }
   },
   "type": "module",
@@ -25,16 +29,17 @@
     "@types/node": "24",
     "np": "^10.2.0",
     "prettier": "^3.7.4",
+    "sharp": "^0.34.5",
     "typescript": "^5.9.3",
     "vite": "^7.3.0"
   },
   "dependencies": {
     "fp-ts": "^2.16.11",
-    "sharp": "^0.34.5",
     "zod": "^4.3.5"
   },
   "peerDependencies": {
-    "next": ">=13.4 <17"
+    "next": ">=13.4 <17",
+    "sharp": "<1"
   },
   "scripts": {
     "build": "vite build && tsc",