next-imagetools 0.0.0-stage → 0.0.0

package/dist/shared-DNQObFGr.cjs

@@ -0,0 +1,300 @@
+// \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_url = require("node:url");
+let imagetools_core = require("imagetools-core");
+let sharp = require("sharp");
+sharp = __toESM(sharp, 1);
+let node_crypto = require("node:crypto");
+let node_fs = require("node:fs");
+// package.json
+var version = "0.0.0";
+// src/shared.ts
+const toParams = (directives) => directives === void 0 ? void 0 : new URLSearchParams(directives);
+const DEFAULT_CACHE_DIR = "node_modules/.cache/next-imagetools";
+function hash(parts) {
+	const h = (0, node_crypto.createHash)("sha1");
+	for (const p of parts) h.update(p);
+	return h.digest("hex");
+}
+const sweeps = /* @__PURE__ */ new Map();
+/**
+* The cache directory to use, or `undefined` when caching is disabled. With `retention` set, the
+* first call in a process for a directory removes entries that haven't been used for that long;
+* loaders have no end-of-build hook, so this is the one point every worker passes through.
+*/
+async function prepareCache(ctx, options) {
+	const { enabled = true, dir = DEFAULT_CACHE_DIR, retention } = options.cache ?? {};
+	if (!enabled) return void 0;
+	const resolved = node_path.default.resolve(ctx.rootContext ?? process.cwd(), dir);
+	(0, node_fs.mkdirSync)(resolved, { recursive: true });
+	if (retention !== void 0) {
+		let sweep = sweeps.get(resolved);
+		if (!sweep) sweeps.set(resolved, sweep = removeExpired(resolved, retention));
+		await sweep;
+	}
+	return resolved;
+}
+async function removeExpired(dir, retentionSeconds) {
+	const cutoff = Date.now() - retentionSeconds * 1e3;
+	const names = await (0, node_fs_promises.readdir)(dir);
+	await Promise.all(names.map(async (name) => {
+		const file = node_path.default.join(dir, name);
+		const info = await (0, node_fs_promises.stat)(file).catch(() => void 0);
+		if (info?.isFile() && info.mtimeMs < cutoff) await (0, node_fs_promises.rm)(file, { force: true });
+	}));
+}
+/**
+* A cached encoding, or `undefined` to process the image again. Any read failure counts as a miss —
+* including an entry another worker's retention sweep removed a moment ago.
+*/
+async function readCached(file) {
+	try {
+		const data = await (0, node_fs_promises.readFile)(file);
+		if (data.length === 0) return void 0;
+		const now = /* @__PURE__ */ new Date();
+		await (0, node_fs_promises.utimes)(file, now, now).catch(() => {});
+		return data;
+	} catch {
+		return;
+	}
+}
+async function writeCache(file, data) {
+	const tmp = `${file}.${process.pid}-${Math.random().toString(36).slice(2)}.tmp`;
+	try {
+		await (0, node_fs_promises.writeFile)(tmp, data);
+		await (0, node_fs_promises.rename)(tmp, file);
+	} catch {
+		await (0, node_fs_promises.rm)(tmp, { force: true });
+	}
+}
+const inflight = /* @__PURE__ */ new Map();
+/**
+* Everything besides the config and the source that decides the encoded bytes: this package
+* (transform behavior), and sharp with every codec it bundles (`sharp.versions` lists libvips,
+* mozjpeg, libwebp, aom, …). Upgrading any of them must not serve images encoded by the old one.
+*/
+const ENGINE = JSON.stringify({
+	package: version,
+	sharp: sharp.default.versions
+});
+function cacheKey(config, sourceHash, removeMetadata, engine = ENGINE) {
+	return hash([
+		JSON.stringify(config),
+		sourceHash,
+		String(removeMetadata),
+		engine
+	]);
+}
+/**
+* Runs one resolved config through imagetools-core, memoized in-process and on disk. Both the
+* module loader (needs dimensions) and the asset loader (needs bytes) call this. The cache key
+* covers the source, the config, the options that change the output and the engine versions, so
+* editing any of them never hits a stale entry.
+*/
+function processImage(args) {
+	const engine = args.configHash ? `${ENGINE}|config:${args.configHash}` : ENGINE;
+	const id = cacheKey(args.config, args.sourceHash, args.removeMetadata, engine);
+	let p = inflight.get(id);
+	if (!p) {
+		p = run(id, args);
+		inflight.set(id, p);
+		p.finally(() => inflight.delete(id)).catch(() => {});
+	}
+	return p;
+}
+async function run(id, args) {
+	const file = args.cacheDir === void 0 ? void 0 : node_path.default.join(args.cacheDir, id);
+	let data = file === void 0 ? void 0 : await readCached(file);
+	let transforms = {};
+	if (!data) {
+		const { transforms: steps } = (0, imagetools_core.generateTransforms)(args.config, args.factories, args.searchParams, args.logger);
+		const animation = await animationOf(args.source, args.config);
+		const input = (0, sharp.default)(args.source, { animated: animation.kept });
+		const res = await (0, imagetools_core.applyTransforms)(animation.kept ? [frameSize(animation.frameHeight), ...steps] : steps, input, args.removeMetadata);
+		data = (await res.image.toBuffer({ resolveWithObject: true })).data;
+		transforms = res.metadata.transforms;
+		if (file !== void 0) await writeCache(file, data);
+	}
+	const meta = await (0, sharp.default)(data).metadata();
+	const format = args.config["format"] ?? transforms.format ?? meta.format;
+	if (format !== void 0) transforms.format = format;
+	return {
+		id,
+		data,
+		meta,
+		transforms
+	};
+}
+const NO_CONFIG = {
+	config: {},
+	hash: "",
+	factories: imagetools_core.builtins
+};
+const loadedConfigs = /* @__PURE__ */ new Map();
+/**
+* Imports the `configFile` module, if any. Three caches could otherwise serve an outdated config:
+*
+* - Turbopack, which reruns a loader only when its inputs change: the file is registered as a
+*   dependency of every module that uses it.
+* - Node's module cache, which returns the first import forever: the file is imported with its
+*   content hash in the URL, so an edit loads a new module.
+* - The disk cache: the hash is part of every cache key (see processImage).
+*/
+async function loadConfig(ctx, options) {
+	if (!options.configFile) return NO_CONFIG;
+	const file = node_path.default.resolve(ctx.rootContext ?? process.cwd(), options.configFile);
+	ctx.addDependency?.(file);
+	const contentHash = hash([await (0, node_fs_promises.readFile)(file).catch(() => {
+		throw new Error(`next-imagetools: configFile not found at ${file}`);
+	})]);
+	let loaded = loadedConfigs.get(contentHash);
+	if (!loaded) {
+		loaded = import(`${(0, node_url.pathToFileURL)(file).href}?v=${contentHash}`).then((mod) => {
+			const config = mod.default ?? mod;
+			return {
+				config,
+				hash: contentHash,
+				factories: config.extendTransforms?.(imagetools_core.builtins) ?? imagetools_core.builtins
+			};
+		});
+		loadedConfigs.set(contentHash, loaded);
+	}
+	return loaded;
+}
+/**
+* Runs a loader, prefixing any error with the file and query it was processing: in a large app,
+* "Expected positive integer for width" alone doesn't say which of hundreds of imports to fix.
+*/
+async function withContext(ctx, task) {
+	try {
+		return await task();
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`next-imagetools: ${where(ctx)}: ${message}`, { cause: error });
+	}
+}
+/** The import being processed, as the user wrote it: app-relative path plus query. */
+function where(ctx) {
+	return `${node_path.default.relative(ctx.rootContext ?? process.cwd(), ctx.resourcePath).split(node_path.default.sep).join("/")}${ctx.resourceQuery}`;
+}
+/**
+* Emits a build warning about the current import. Turbopack prints a warning's name and stack, so
+* the stack is replaced by the message: it's about the user's import, not our code.
+*/
+function warn(ctx, message) {
+	const warning = /* @__PURE__ */ new Error(`${where(ctx)}: ${message}`);
+	warning.name = "next-imagetools";
+	warning.stack = `${warning.name}: ${warning.message}`;
+	ctx.emitWarning?.(warning);
+}
+/** Output formats sharp can encode with several frames. */
+const ANIMATED_FORMATS = /* @__PURE__ */ new Set(["gif", "webp"]);
+/**
+* Whether a source is an animation. Several pages alone don't make one: a multi-page TIFF has them
+* too, and must not turn into an animated WebP. Only animations carry frame delays.
+*/
+const isAnimated = (meta) => (meta.pages ?? 1) > 1 && meta.delay !== void 0;
+/**
+* Whether an image keeps its animation — an animated source, and an output that can hold the frames
+* — and the height of one frame.
+*/
+async function animationOf(source, config) {
+	const meta = await (0, sharp.default)(source).metadata();
+	const format = config["format"] ?? meta.format;
+	return {
+		kept: isAnimated(meta) && format !== void 0 && ANIMATED_FORMATS.has(format),
+		frameHeight: meta.height
+	};
+}
+/**
+* An animated image is read as one tall strip of frames, so the pipeline would start from the
+* strip's height and resize every frame to the wrong aspect ratio. This first step puts one frame's
+* height in place; sharp then applies the resize to each frame.
+*/
+const frameSize = (frameHeight) => (state, image) => {
+	state.info.height = frameHeight;
+	state.info.autoOriented.height = frameHeight;
+	return image;
+};
+Object.defineProperty(exports, "ANIMATED_FORMATS", {
+	enumerable: true,
+	get: function() {
+		return ANIMATED_FORMATS;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "hash", {
+	enumerable: true,
+	get: function() {
+		return hash;
+	}
+});
+Object.defineProperty(exports, "isAnimated", {
+	enumerable: true,
+	get: function() {
+		return isAnimated;
+	}
+});
+Object.defineProperty(exports, "loadConfig", {
+	enumerable: true,
+	get: function() {
+		return loadConfig;
+	}
+});
+Object.defineProperty(exports, "prepareCache", {
+	enumerable: true,
+	get: function() {
+		return prepareCache;
+	}
+});
+Object.defineProperty(exports, "processImage", {
+	enumerable: true,
+	get: function() {
+		return processImage;
+	}
+});
+Object.defineProperty(exports, "toParams", {
+	enumerable: true,
+	get: function() {
+		return toParams;
+	}
+});
+Object.defineProperty(exports, "warn", {
+	enumerable: true,
+	get: function() {
+		return warn;
+	}
+});
+Object.defineProperty(exports, "withContext", {
+	enumerable: true,
+	get: function() {
+		return withContext;
+	}
+});

package/package.json

@@ -1,6 +1,111 @@
 {
   "name": "next-imagetools",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "Build-time image transforms for Next.js: import './a.jpg?w=400;800&format=webp&as=srcset' and get optimized files, no image server needed.",
+  "keywords": [
+    "avif",
+    "imagetools",
+    "next",
+    "nextjs",
+    "responsive-images",
+    "sharp",
+    "srcset",
+    "static-export",
+    "turbopack",
+    "webp"
+  ],
+  "homepage": "https://github.com/awdr74100/next-imagetools#readme",
+  "bugs": {
+    "url": "https://github.com/awdr74100/next-imagetools/issues"
+  },
+  "license": "MIT",
+  "author": "Roya <a78945612385238@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/awdr74100/next-imagetools.git"
+  },
+  "files": [
+    "dist",
+    "client.d.ts"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.mts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./config": {
+      "types": {
+        "import": "./dist/config.d.mts",
+        "require": "./dist/config.d.cts"
+      },
+      "import": "./dist/config.mjs",
+      "require": "./dist/config.cjs"
+    },
+    "./core": {
+      "types": {
+        "import": "./dist/core.d.mts",
+        "require": "./dist/core.d.cts"
+      },
+      "import": "./dist/core.mjs",
+      "require": "./dist/core.cjs"
+    },
+    "./loader": "./dist/loader.cjs",
+    "./asset-loader": "./dist/asset-loader.cjs",
+    "./client": {
+      "types": "./client.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "imagetools-core": "^12.0.0",
+    "picomatch": "^4.0.7",
+    "sharp": "^0.35.5"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "@types/picomatch": "^4.0.3",
+    "changelogen": "^0.6.2",
+    "knip": "^6.44.2",
+    "next": "^16.4.5",
+    "oxfmt": "^0.78.0",
+    "oxlint": "^1.93.0",
+    "playwright": "^1.65.0",
+    "publint": "^0.3.25",
+    "tsdown": "^0.23.7",
+    "typescript": "^6.0.3",
+    "vitest": "^5.1.0"
+  },
+  "peerDependencies": {
+    "next": ">=16.2.0"
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "check": "pnpm typecheck && pnpm lint && pnpm lint:english && pnpm format:check && pnpm knip",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "knip": "knip",
+    "knip:fix": "knip --fix",
+    "lint": "oxlint --deny-warnings .",
+    "lint:english": "node scripts/check-english.mjs",
+    "lint:fix": "oxlint --fix .",
+    "playground": "pnpm build && pnpm -C playground run dev",
+    "release": "node scripts/release.mjs",
+    "test": "vitest run",
+    "test:e2e": "vitest run --project e2e",
+    "test:unit": "vitest run --project unit",
+    "typecheck": "pnpm -r run typecheck && tsc --noEmit -p tsconfig.json"
+  }
 }