next-image-transformer 1.0.0 → 1.0.1

package/dist/index.js

@@ -1,5 +1,5 @@
-import { c as r } from "./createImageUrlCodec-Cpmqn0AP.js";
-const a = (...e) => r(...e).encode;
-export {
-  a as createImageUrlBuilder
-};
+import { t as e } from "./createImageUrlCodec-CIiY-UWp.js";
+//#region src/createImageUrlBuilder.ts
+var t = (...t) => e(...t).encode;
+//#endregion
+export { t as createImageUrlBuilder };

package/dist/server.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-image-transformer",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
@@ -24,18 +24,18 @@
     "README.md",
     "LICENSE*"
   ],
-  "packageManager": "yarn@4.12.0",
+  "packageManager": "yarn@4.17.0",
   "devDependencies": {
-    "@types/node": "24",
-    "prettier": "^3.7.4",
-    "release-it": "^19.2.3",
-    "sharp": "^0.34.5",
-    "typescript": "^5.9.3",
-    "vite": "^7.3.0"
+    "@types/node": "24.13.2",
+    "prettier": "^3.8.4",
+    "release-it": "^20.2.0",
+    "sharp": "^0.35.1",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16"
   },
   "dependencies": {
     "fp-ts": "^2.16.11",
-    "zod": "^4.3.5"
+    "zod": "^4.4.3"
   },
   "peerDependencies": {
     "next": ">=13.4 <17",