ipx 3.1.1 → 4.0.0-alpha.2

package/dist/_chunks/node-fs.mjs

@@ -0,0 +1,690 @@
+import { __exportAll, __toESM } from "./rolldown-runtime.mjs";
+import { decode, hasProtocol, joinURL, withLeadingSlash } from "./libs/ufo.mjs";
+import { HTTPError, defineEventHandler } from "./libs/h3.mjs";
+import { imageMeta } from "./libs/image-meta.mjs";
+import { require_etag } from "./libs/etag.mjs";
+import { require_accept_negotiator } from "./libs/@fastify/accept-negotiator.mjs";
+import { join, parse, resolve } from "pathe";
+function VArg(argument) {
+	if (argument === "Infinity") return Infinity;
+	if (argument === "undefined") return;
+	try {
+		const val = JSON.parse(argument);
+		const t = typeof val;
+		if (t === "boolean" || t === "number" || t === "string" || val === null) return val;
+	} catch {}
+	return argument;
+}
+function parseArgs(arguments_, mappers) {
+	const vargs = arguments_.split("_");
+	return mappers.map((v, index) => v(vargs[index]));
+}
+function getHandler(key) {
+	return handlers_exports[key];
+}
+function applyHandler(context, pipe, handler, argumentsString) {
+	const arguments_ = handler.args ? parseArgs(argumentsString, handler.args) : [];
+	return handler.apply(context, pipe, ...arguments_);
+}
+function clampDimensionsPreservingAspectRatio(sourceDimensions, desiredDimensions) {
+	const desiredAspectRatio = desiredDimensions.width / desiredDimensions.height;
+	let { width, height } = desiredDimensions;
+	if (sourceDimensions.width && width > sourceDimensions.width) {
+		width = sourceDimensions.width;
+		height = Math.round(sourceDimensions.width / desiredAspectRatio);
+	}
+	if (sourceDimensions.height && height > sourceDimensions.height) {
+		height = sourceDimensions.height;
+		width = Math.round(sourceDimensions.height * desiredAspectRatio);
+	}
+	return {
+		width,
+		height
+	};
+}
+var handlers_exports = /* @__PURE__ */ __exportAll({
+	b: () => b,
+	background: () => background,
+	blur: () => blur,
+	crop: () => crop,
+	enlarge: () => enlarge,
+	extend: () => extend,
+	extract: () => extract,
+	fit: () => fit,
+	flatten: () => flatten,
+	flip: () => flip,
+	flop: () => flop,
+	gamma: () => gamma,
+	grayscale: () => grayscale,
+	h: () => h,
+	height: () => height,
+	kernel: () => kernel,
+	median: () => median,
+	modulate: () => modulate,
+	negate: () => negate,
+	normalize: () => normalize,
+	pos: () => pos,
+	position: () => position,
+	q: () => q,
+	quality: () => quality,
+	resize: () => resize,
+	rotate: () => rotate,
+	s: () => s,
+	sharpen: () => sharpen,
+	threshold: () => threshold,
+	tint: () => tint,
+	trim: () => trim,
+	w: () => w,
+	width: () => width
+});
+const quality = {
+	args: [VArg],
+	order: -1,
+	apply: (context, _pipe, quality) => {
+		context.quality = quality;
+	}
+};
+const fit = {
+	args: [VArg],
+	order: -1,
+	apply: (context, _pipe, fit) => {
+		context.fit = fit;
+	}
+};
+const position = {
+	args: [VArg],
+	order: -1,
+	apply: (context, _pipe, position) => {
+		context.position = position;
+	}
+};
+const HEX_RE = /^([\da-f]{2})([\da-f]{2})([\da-f]{2})$/i;
+const SHORTHEX_RE = /^([\da-f])([\da-f])([\da-f])$/i;
+const background = {
+	args: [VArg],
+	order: -1,
+	apply: (context, _pipe, background) => {
+		background = String(background);
+		if (!background.startsWith("#") && (HEX_RE.test(background) || SHORTHEX_RE.test(background))) background = "#" + background;
+		context.background = background;
+	}
+};
+const enlarge = {
+	args: [],
+	apply: (context) => {
+		context.enlarge = true;
+	}
+};
+const kernel = {
+	args: [VArg],
+	apply: (context, _pipe, kernel) => {
+		context.kernel = kernel;
+	}
+};
+const width = {
+	args: [VArg],
+	apply: (context, pipe, width) => {
+		return pipe.resize(width, void 0, { withoutEnlargement: !context.enlarge });
+	}
+};
+const height = {
+	args: [VArg],
+	apply: (context, pipe, height) => {
+		return pipe.resize(void 0, height, { withoutEnlargement: !context.enlarge });
+	}
+};
+const resize = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (context, pipe, size) => {
+		let [width, height] = String(size).split("x").map(Number);
+		if (!width) return;
+		if (!height) height = width;
+		if (!context.enlarge) {
+			const clamped = clampDimensionsPreservingAspectRatio(context.meta, {
+				width,
+				height
+			});
+			width = clamped.width;
+			height = clamped.height;
+		}
+		return pipe.resize(width, height, {
+			fit: context.fit,
+			position: context.position,
+			background: context.background,
+			kernel: context.kernel
+		});
+	}
+};
+const trim = {
+	args: [VArg],
+	apply: (_context, pipe, threshold) => {
+		return pipe.trim(threshold);
+	}
+};
+const extend = {
+	args: [
+		VArg,
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (context, pipe, top, right, bottom, left) => {
+		return pipe.extend({
+			top,
+			left,
+			bottom,
+			right,
+			background: context.background
+		});
+	}
+};
+const extract = {
+	args: [
+		VArg,
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (_context, pipe, left, top, width, height) => {
+		return pipe.extract({
+			left,
+			top,
+			width,
+			height
+		});
+	}
+};
+const rotate = {
+	args: [VArg],
+	apply: (context, pipe, angel) => {
+		return pipe.rotate(angel, { background: context.background });
+	}
+};
+const flip = {
+	args: [],
+	apply: (_context, pipe) => {
+		return pipe.flip();
+	}
+};
+const flop = {
+	args: [],
+	apply: (_context, pipe) => {
+		return pipe.flop();
+	}
+};
+const sharpen = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (_context, pipe, sigma, flat, jagged) => {
+		return pipe.sharpen({
+			sigma,
+			m1: flat,
+			m2: jagged
+		});
+	}
+};
+const median = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (_context, pipe, size) => {
+		return pipe.median(size);
+	}
+};
+const blur = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (_context, pipe, sigma) => {
+		return pipe.blur(sigma);
+	}
+};
+const flatten = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (context, pipe) => {
+		return pipe.flatten({ background: context.background });
+	}
+};
+const gamma = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (_context, pipe, gamma, gammaOut) => {
+		return pipe.gamma(gamma, gammaOut);
+	}
+};
+const negate = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (_context, pipe) => {
+		return pipe.negate();
+	}
+};
+const normalize = {
+	args: [
+		VArg,
+		VArg,
+		VArg
+	],
+	apply: (_context, pipe) => {
+		return pipe.normalize();
+	}
+};
+const threshold = {
+	args: [VArg],
+	apply: (_context, pipe, threshold) => {
+		return pipe.threshold(threshold);
+	}
+};
+const modulate = {
+	args: [VArg],
+	apply: (_context, pipe, brightness, saturation, hue) => {
+		return pipe.modulate({
+			brightness,
+			saturation,
+			hue
+		});
+	}
+};
+const tint = {
+	args: [VArg],
+	apply: (_context, pipe, rgb) => {
+		return pipe.tint(rgb);
+	}
+};
+const grayscale = {
+	args: [VArg],
+	apply: (_context, pipe) => {
+		return pipe.grayscale();
+	}
+};
+const crop = extract;
+const q = quality;
+const b = background;
+const w = width;
+const h = height;
+const s = resize;
+const pos = position;
+function getEnv(name) {
+	const value = globalThis.process?.env?.[name];
+	if (value !== void 0) return JSON.parse(value);
+}
+function requireModule(id) {
+	const { createRequire } = globalThis.process.getBuiltinModule("node:module");
+	return createRequire(import.meta.url)(id);
+}
+function cachedPromise(function_) {
+	let p;
+	return (...arguments_) => {
+		if (p) return p;
+		p = Promise.resolve(function_(...arguments_));
+		return p;
+	};
+}
+const SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+	"jpeg",
+	"png",
+	"webp",
+	"avif",
+	"tiff",
+	"heif",
+	"gif",
+	"heic"
+]);
+function createIPX(userOptions) {
+	const options = {
+		...userOptions,
+		alias: userOptions.alias || getEnv("IPX_ALIAS") || {},
+		maxAge: userOptions.maxAge ?? getEnv("IPX_MAX_AGE") ?? 60,
+		sharpOptions: {
+			jpegProgressive: true,
+			...userOptions.sharpOptions
+		}
+	};
+	options.alias = Object.fromEntries(Object.entries(options.alias || {}).map((e) => [withLeadingSlash(e[0]), e[1]]));
+	const getSharp = cachedPromise(async () => {
+		return await import("sharp").then((r) => r.default || r);
+	});
+	const getSVGO = cachedPromise(async () => {
+		const { optimize } = await import("./svgo-node.mjs").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+		return { optimize };
+	});
+	return function ipx(id, modifiers = {}, opts = {}) {
+		if (!id) throw new HTTPError({
+			statusCode: 400,
+			statusText: `IPX_MISSING_ID`,
+			message: `Resource id is missing`
+		});
+		id = hasProtocol(id) ? id : withLeadingSlash(id);
+		for (const base in options.alias) if (id.startsWith(base)) id = joinURL(options.alias[base], id.slice(base.length));
+		const storage = hasProtocol(id) ? options.httpStorage || options.storage : options.storage || options.httpStorage;
+		if (!storage) throw new HTTPError({
+			statusCode: 500,
+			statusText: `IPX_NO_STORAGE`,
+			message: "No storage configured!"
+		});
+		const getSourceMeta = cachedPromise(async () => {
+			const sourceMeta = await storage.getMeta(id, opts);
+			if (!sourceMeta) throw new HTTPError({
+				statusCode: 404,
+				statusText: `IPX_RESOURCE_NOT_FOUND`,
+				message: `Resource not found: ${id}`
+			});
+			const _maxAge = sourceMeta.maxAge ?? options.maxAge;
+			return {
+				maxAge: typeof _maxAge === "string" ? Number.parseInt(_maxAge) : _maxAge,
+				mtime: sourceMeta.mtime ? new Date(sourceMeta.mtime) : void 0
+			};
+		});
+		const getSourceData = cachedPromise(async () => {
+			const sourceData = await storage.getData(id, opts);
+			if (!sourceData) throw new HTTPError({
+				statusCode: 404,
+				statusText: `IPX_RESOURCE_NOT_FOUND`,
+				message: `Resource not found: ${id}`
+			});
+			return Buffer.from(sourceData);
+		});
+		return {
+			getSourceMeta,
+			process: cachedPromise(async () => {
+				const sourceData = await getSourceData();
+				let imageMeta$1;
+				try {
+					imageMeta$1 = imageMeta(sourceData);
+				} catch {
+					throw new HTTPError({
+						statusCode: 400,
+						statusText: `IPX_INVALID_IMAGE`,
+						message: `Cannot parse image metadata: ${id}`
+					});
+				}
+				let mFormat = modifiers.f || modifiers.format;
+				if (mFormat === "jpg") mFormat = "jpeg";
+				const format = mFormat && SUPPORTED_FORMATS.has(mFormat) ? mFormat : SUPPORTED_FORMATS.has(imageMeta$1.type || "") ? imageMeta$1.type : "jpeg";
+				if (imageMeta$1.type === "svg" && !mFormat) if (options.svgo === false) return {
+					data: sourceData,
+					format: "svg+xml",
+					meta: imageMeta$1
+				};
+				else {
+					const { optimize } = await getSVGO();
+					return {
+						data: optimize(sourceData.toString("utf8"), {
+							...options.svgo,
+							plugins: ["removeScripts", ...options.svgo?.plugins || []]
+						}).data,
+						format: "svg+xml",
+						meta: imageMeta$1
+					};
+				}
+				const animated = modifiers.animated !== void 0 || modifiers.a !== void 0 || format === "gif";
+				let sharp = (await getSharp())(sourceData, {
+					animated,
+					...options.sharpOptions
+				});
+				Object.assign(sharp.options, options.sharpOptions);
+				const handlers = Object.entries(modifiers).map(([name, arguments_]) => ({
+					handler: getHandler(name),
+					name,
+					args: arguments_
+				})).filter((h) => h.handler).sort((a, b) => {
+					const aKey = (a.handler.order || a.name || "").toString();
+					const bKey = (b.handler.order || b.name || "").toString();
+					return aKey.localeCompare(bKey);
+				});
+				const handlerContext = { meta: imageMeta$1 };
+				for (const h of handlers) sharp = applyHandler(handlerContext, sharp, h.handler, h.args.toString()) || sharp;
+				if (SUPPORTED_FORMATS.has(format || "")) sharp = sharp.toFormat(format, { quality: handlerContext.quality });
+				return {
+					data: await sharp.toBuffer(),
+					format,
+					meta: imageMeta$1
+				};
+			})
+		};
+	};
+}
+var import_etag = /* @__PURE__ */ __toESM(require_etag(), 1);
+var import_accept_negotiator = require_accept_negotiator();
+function createIPXFetchHandler(ipx) {
+	return createIPXHandler(ipx).fetch;
+}
+function createIPXNodeHandler(ipx) {
+	const { toNodeHandler } = requireModule("srvx/node");
+	return toNodeHandler(createIPXFetchHandler(ipx));
+}
+function serveIPX(ipx, opts) {
+	const { serve } = requireModule("srvx");
+	const fetch = createIPXFetchHandler(ipx);
+	return serve({
+		...opts,
+		fetch
+	});
+}
+const MODIFIER_SEP = /[&,]/g;
+const MODIFIER_VAL_SEP = /[:=_]/;
+function createIPXHandler(ipx) {
+	return defineEventHandler(async (event) => {
+		const [modifiersString = "", ...idSegments] = event.url.pathname.slice(1).split("/");
+		const id = safeString(decode(idSegments.join("/")));
+		if (!modifiersString) throw new HTTPError({
+			statusCode: 400,
+			statusText: "IPX_MISSING_MODIFIERS",
+			message: `Modifiers are missing: ${id}`
+		});
+		if (!id || id === "/") throw new HTTPError({
+			statusCode: 400,
+			statusText: "IPX_MISSING_ID",
+			message: `Resource id is missing: ${event.path}`
+		});
+		const modifiers = Object.create(null);
+		if (modifiersString !== "_") for (const p of modifiersString.split(MODIFIER_SEP)) {
+			const [key, ...values] = p.split(MODIFIER_VAL_SEP);
+			modifiers[safeString(key)] = values.map((v) => safeString(decode(v))).join("_");
+		}
+		if ((modifiers.f || modifiers.format) === "auto") {
+			const acceptHeader = event.req.headers.get("accept") || "";
+			const animated = modifiers.animated ?? modifiers.a;
+			const autoFormat = autoDetectFormat(acceptHeader, !!animated || animated === "");
+			delete modifiers.f;
+			delete modifiers.format;
+			if (autoFormat) {
+				modifiers.format = autoFormat;
+				event.res.headers.append("vary", "Accept");
+			}
+		}
+		const img = ipx(id, modifiers);
+		const sourceMeta = await img.getSourceMeta();
+		sendResponseHeaderIfNotSet(event, "content-security-policy", "default-src 'none'");
+		if (sourceMeta.mtime) {
+			sendResponseHeaderIfNotSet(event, "last-modified", sourceMeta.mtime.toUTCString());
+			const _ifModifiedSince = event.req.headers.get("if-modified-since");
+			if (_ifModifiedSince && new Date(_ifModifiedSince) >= sourceMeta.mtime) {
+				event.res.status = 304;
+				return;
+			}
+		}
+		const { data, format } = await img.process();
+		if (typeof sourceMeta.maxAge === "number") sendResponseHeaderIfNotSet(event, "cache-control", `max-age=${+sourceMeta.maxAge}, public, s-maxage=${+sourceMeta.maxAge}`);
+		const etag = (0, import_etag.default)(data);
+		sendResponseHeaderIfNotSet(event, "etag", etag);
+		if (etag && event.req.headers.get("if-none-match") === etag) {
+			event.res.status = 304;
+			return;
+		}
+		if (format) sendResponseHeaderIfNotSet(event, "content-type", `image/${format}`);
+		return data;
+	});
+}
+function sendResponseHeaderIfNotSet(event, name, value) {
+	if (!event.res.headers.has(name)) event.res.headers.set(name, value);
+}
+function autoDetectFormat(acceptHeader, animated) {
+	if (animated) return (0, import_accept_negotiator.negotiate)(acceptHeader, ["image/webp", "image/gif"])?.split("/")[1] || "gif";
+	return (0, import_accept_negotiator.negotiate)(acceptHeader, [
+		"image/avif",
+		"image/webp",
+		"image/jpeg",
+		"image/png",
+		"image/tiff",
+		"image/heif",
+		"image/gif"
+	])?.split("/")[1] || "jpeg";
+}
+function safeString(input) {
+	return JSON.stringify(input).replace(/^"|"$/g, "").replace(/\\+/g, "\\").replace(/\\"/g, "\"");
+}
+const HTTP_RE = /^https?:\/\//;
+function ipxHttpStorage(_options = {}) {
+	const allowAllDomains = _options.allowAllDomains ?? getEnv("IPX_HTTP_ALLOW_ALL_DOMAINS") ?? false;
+	let _domains = _options.domains || getEnv("IPX_HTTP_DOMAINS") || [];
+	const defaultMaxAge = _options.maxAge || getEnv("IPX_HTTP_MAX_AGE") || 300;
+	const fetchOptions = _options.fetchOptions || getEnv("IPX_HTTP_FETCH_OPTIONS") || {};
+	if (typeof _domains === "string") _domains = _domains.split(",").map((s) => s.trim());
+	const domains = new Set(_domains.map((d) => {
+		if (!HTTP_RE.test(d)) d = "http://" + d;
+		return new URL(d).hostname;
+	}).filter(Boolean));
+	function validateId(id) {
+		const url = new URL(decodeURIComponent(id));
+		if (!url.hostname) throw new HTTPError({
+			statusCode: 403,
+			statusText: `IPX_MISSING_HOSTNAME`,
+			message: `Hostname is missing: ${id}`
+		});
+		if (!allowAllDomains && !domains.has(url.hostname)) throw new HTTPError({
+			statusCode: 403,
+			statusText: `IPX_FORBIDDEN_HOST`,
+			message: `Forbidden host: ${url.hostname}`
+		});
+		return url.toString();
+	}
+	function parseResponse(response) {
+		let maxAge = defaultMaxAge;
+		if (_options.ignoreCacheControl !== true) {
+			const _cacheControl = response.headers.get("cache-control");
+			if (_cacheControl) {
+				const m = _cacheControl.match(/max-age=(\d+)/);
+				if (m && m[1]) maxAge = Number.parseInt(m[1]);
+			}
+		}
+		let mtime;
+		const _lastModified = response.headers.get("last-modified");
+		if (_lastModified) mtime = new Date(_lastModified);
+		return {
+			maxAge,
+			mtime
+		};
+	}
+	return {
+		name: "ipx:http",
+		async getMeta(id) {
+			const url = validateId(id);
+			try {
+				const response = await fetch(url, {
+					...fetchOptions,
+					method: "HEAD"
+				});
+				if (!response.ok) return {};
+				const { maxAge, mtime } = parseResponse(response);
+				return {
+					mtime,
+					maxAge
+				};
+			} catch {
+				return {};
+			}
+		},
+		async getData(id) {
+			const url = validateId(id);
+			const response = await fetch(url, fetchOptions);
+			if (!response.ok) throw new HTTPError({
+				statusCode: response.status,
+				statusText: response.statusText,
+				message: `Failed to fetch ${id}: ${response.status} ${response.statusText}`
+			});
+			return await response.arrayBuffer();
+		}
+	};
+}
+function ipxFSStorage(_options = {}) {
+	const dirs = resolveDirs(_options.dir);
+	const maxAge = _options.maxAge || getEnv("IPX_FS_MAX_AGE");
+	const fs = globalThis.process.getBuiltinModule("node:fs/promises");
+	const resolveFile = async (id) => {
+		for (const dir of dirs) {
+			const filePath = join(dir, id);
+			if (!isValidPath(filePath) || !filePath.startsWith(dir + "/")) throw new HTTPError({
+				statusCode: 403,
+				statusText: `IPX_FORBIDDEN_PATH`,
+				message: `Forbidden path: ${id}`
+			});
+			try {
+				const stats = await fs.stat(filePath);
+				if (!stats.isFile()) continue;
+				return {
+					stats,
+					read: () => fs.readFile(filePath)
+				};
+			} catch (error) {
+				if (error.code === "ENOENT") continue;
+				throw new HTTPError({
+					statusCode: 403,
+					statusText: `IPX_FORBIDDEN_FILE`,
+					message: `Cannot access file: ${id}`
+				});
+			}
+		}
+		throw new HTTPError({
+			statusCode: 404,
+			statusText: `IPX_FILE_NOT_FOUND`,
+			message: `File not found: ${id}`
+		});
+	};
+	return {
+		name: "ipx:node-fs",
+		async getMeta(id) {
+			const { stats } = await resolveFile(id);
+			return {
+				mtime: stats.mtime,
+				maxAge
+			};
+		},
+		async getData(id) {
+			const { read } = await resolveFile(id);
+			return read();
+		}
+	};
+}
+const isWindows = process.platform === "win32";
+function isValidPath(fp) {
+	if (isWindows) fp = fp.slice(parse(fp).root.length);
+	if (/["*:<>?|]/.test(fp)) return false;
+	return true;
+}
+function resolveDirs(dirs) {
+	if (!dirs || !Array.isArray(dirs)) return [resolve(dirs || getEnv("IPX_FS_DIR") || ".")];
+	return dirs.map((dirs) => resolve(dirs));
+}
+export { createIPX, createIPXFetchHandler, createIPXNodeHandler, ipxFSStorage, ipxHttpStorage, serveIPX };