siuuu 0.0.0

package/README.md

@@ -0,0 +1,38 @@
+# Siuuu
+
+Compress images (PNG / JPEG / WebP) with WebAssembly codecs (imagequant + oxipng, mozjpeg, libwebp).
+
+## Usage
+
+```bash
+npx siuuu <files or directories...> [options]
+```
+
+Options:
+
+- `-o, --out <filename>` — output filename for the input right before it (repeatable)
+- `-d, --out-dir <dir>` — output directory (default: `siuuu-output/` in the current directory)
+- `-f, --format <format>` — output format: `png` / `jpeg` / `webp` (default: same as input)
+- `-h, --help` — show help
+- `-v, --version` — show version
+
+Inputs without an explicit `-o` are written to the output directory under their original name; existing files are never overwritten (falls back to `name (n)`). With `-f`, every output is converted to that format; `-o` only sets the filename, not the format.
+
+## Examples
+
+```bash
+# Compress one or more files (default: ./siuuu-output/, original names)
+npx siuuu a.png b.jpg c.webp
+
+# Recursively compress all images in a directory
+npx siuuu photos/
+
+# Convert everything to WebP
+npx siuuu photos/ -f webp
+
+# Per-file output names (-o binds to the input before it)
+npx siuuu a.png -o x.png b.png -o y.png
+
+# Custom output directory
+npx siuuu imgs/ -d dist/
+```

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+import { t as compress } from "./src-CqREwc6F.mjs";
+import { createRequire } from "node:module";
+import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import * as os from "node:os";
+import { Worker } from "node:worker_threads";
+//#region src/batch.ts
+const IMAGE_EXTENSIONS = new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".webp"
+]);
+const OUTPUT_EXTENSION = {
+	png: "png",
+	jpeg: "jpg",
+	webp: "webp"
+};
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+function isImage(path) {
+	return IMAGE_EXTENSIONS.has(extname(path).toLowerCase());
+}
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function exists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isInside(file, dir) {
+	const rel = relative(resolve(dir), resolve(file));
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+async function listImages(dir) {
+	return (await readdir(dir, { recursive: true })).filter((name) => isImage(name)).map((name) => join(dir, name)).sort();
+}
+const workerUrl = new URL(import.meta.url.endsWith(".ts") ? "./worker.ts" : "./worker.mjs", import.meta.url);
+function compressOnWorker(worker, task) {
+	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			worker.off("message", onMessage);
+			worker.off("error", onError);
+			worker.off("exit", onExit);
+		};
+		const onMessage = (msg) => {
+			cleanup();
+			resolve(msg);
+		};
+		const onError = (error) => {
+			cleanup();
+			reject(error);
+		};
+		const onExit = (code) => {
+			cleanup();
+			reject(/* @__PURE__ */ new Error(`worker 异常退出（code ${code}）`));
+		};
+		worker.on("message", onMessage);
+		worker.on("error", onError);
+		worker.on("exit", onExit);
+		worker.postMessage(task);
+	});
+}
+async function runBatch(jobs, handlers) {
+	const done = /* @__PURE__ */ new Set();
+	const persist = async (id, format, data, before) => {
+		const outPath = await handlers.resolveOutPath(jobs[id], format);
+		await mkdir(dirname(outPath), { recursive: true });
+		await writeFile(outPath, data);
+		handlers.onWritten?.(jobs[id], {
+			before,
+			after: data.length,
+			outPath
+		});
+	};
+	let writes = Promise.resolve();
+	const write = (id, run) => {
+		writes = writes.then(async () => {
+			try {
+				await run();
+			} catch (error) {
+				handlers.onFailed?.(jobs[id], error.message);
+			}
+			done.add(id);
+		});
+		return writes;
+	};
+	const spawn = () => new Worker(workerUrl, { execArgv: process.execArgv });
+	let next = 0;
+	let proven = false;
+	const consume = async () => {
+		let worker = null;
+		for (let id = next++; id < jobs.length; id = next++) {
+			if (!worker) try {
+				worker = spawn();
+			} catch {
+				return;
+			}
+			try {
+				const result = await compressOnWorker(worker, {
+					id,
+					source: jobs[id].source,
+					format: jobs[id].format
+				});
+				proven = true;
+				await write(id, () => result.ok ? persist(id, result.format, new Uint8Array(result.data), result.before) : Promise.reject(new Error(result.error)));
+			} catch (crash) {
+				await worker.terminate().catch(() => {});
+				worker = null;
+				if (!proven) return;
+				await write(id, () => Promise.reject(crash));
+			}
+		}
+		await worker?.terminate().catch(() => {});
+	};
+	const runOnMain = async () => {
+		for (let id = 0; id < jobs.length; id++) {
+			if (done.has(id)) continue;
+			await write(id, async () => {
+				const data = await readFile(jobs[id].source);
+				const result = await compress(new Uint8Array(data), { format: jobs[id].format });
+				await persist(id, result.format, result.data, data.length);
+			});
+		}
+	};
+	const parallelism = os.availableParallelism?.() ?? os.cpus().length;
+	const concurrency = handlers.concurrency ?? Math.min(jobs.length, Math.max(1, parallelism));
+	if (concurrency > 1) {
+		await Promise.all(Array.from({ length: concurrency }, consume));
+		await writes.catch(() => {});
+		const leftover = jobs.length - done.size;
+		if (leftover > 0) console.warn(`并行压缩不可用，已回退主线程串行处理 ${leftover} 张`);
+	}
+	await runOnMain();
+}
+//#endregion
+//#region src/cli.ts
+const pkg = createRequire(import.meta.url)("../package.json");
+const DEFAULT_OUT_DIR = "siuuu-output";
+const HELP = `${pkg.name} v${pkg.version} — 压缩 PNG / JPEG / WebP 图片
+
+用法:
+  npx ${pkg.name} <文件或目录...> [选项]
+
+选项:
+  -o, --out <文件名>     为紧邻的前一个输入单独指定输出文件名（可多次）
+  -d, --out-dir <目录>   全局输出目录（默认：当前目录下的 ${DEFAULT_OUT_DIR}/）
+  -f, --format <格式>    输出格式 png | jpeg | webp（默认与输入一致，不做转换）
+  -h, --help             显示帮助
+  -v, --version          显示版本
+
+说明:
+  传入目录时会递归压缩其中所有 PNG / JPEG / WebP，多文件时自动用多线程并行。
+  未用 -o 单独命名的，按原文件名输出到输出目录；同名不覆盖，自动改用「名称 (n)」。
+  指定 -f 后所有输出都转为该格式；-o 只决定文件名，不影响格式。
+  压缩参数：PNG 高画质（量化 ≤200 色 + oxipng）、JPEG 中画质（mozjpeg 75）、WebP 高画质（libwebp 90）。
+
+示例:
+  npx ${pkg.name} a.png b.jpg                  # 压缩到 ${DEFAULT_OUT_DIR}/a.png、${DEFAULT_OUT_DIR}/b.jpg
+  npx ${pkg.name} photos/ -f webp              # 递归压缩 photos/ 并全部转 webp
+  npx ${pkg.name} a.png -o x.png b.png -o y.png # 分别指定输出文件名
+  npx ${pkg.name} imgs/ -d dist/               # 输出到 dist/
+`;
+function parseFormat(value) {
+	const v = value.toLowerCase();
+	if (v === "png" || v === "jpeg" || v === "webp") return v;
+	if (v === "jpg") return "jpeg";
+}
+async function uniqueOutPath(dir, filename, used) {
+	const ext = extname(filename);
+	const base = basename(filename, ext);
+	let candidate = join(dir, filename);
+	let n = 1;
+	while (used.has(candidate) || await exists(candidate)) {
+		candidate = join(dir, `${base} (${n})${ext}`);
+		n++;
+	}
+	used.add(candidate);
+	return candidate;
+}
+async function main() {
+	let parsed;
+	try {
+		parsed = parseArgs({
+			allowPositionals: true,
+			tokens: true,
+			options: {
+				"out": {
+					type: "string",
+					short: "o",
+					multiple: true
+				},
+				"out-dir": {
+					type: "string",
+					short: "d"
+				},
+				"format": {
+					type: "string",
+					short: "f"
+				},
+				"help": {
+					type: "boolean",
+					short: "h"
+				},
+				"version": {
+					type: "boolean",
+					short: "v"
+				}
+			}
+		});
+	} catch (error) {
+		console.error(`参数错误：${error.message}\n`);
+		process.stdout.write(HELP);
+		process.exitCode = 1;
+		return;
+	}
+	const { values, positionals, tokens } = parsed;
+	if (values.version) {
+		console.log(pkg.version);
+		return;
+	}
+	if (values.help || positionals.length === 0) {
+		process.stdout.write(HELP);
+		if (positionals.length === 0 && !values.help) process.exitCode = 1;
+		return;
+	}
+	let format;
+	if (values.format !== void 0) {
+		format = parseFormat(values.format);
+		if (!format) {
+			console.error(`错误：不支持的格式「${values.format}」，可选 png / jpeg / webp`);
+			process.exitCode = 1;
+			return;
+		}
+	}
+	const outDir = values["out-dir"] ?? DEFAULT_OUT_DIR;
+	const specs = [];
+	for (const token of tokens) if (token.kind === "positional") specs.push({ input: token.value });
+	else if (token.kind === "option" && token.name === "out") {
+		const last = specs[specs.length - 1];
+		if (!last) {
+			console.error("错误：-o 必须跟在某个输入文件之后");
+			process.exitCode = 1;
+			return;
+		}
+		last.output = token.value;
+	}
+	const jobs = [];
+	for (const spec of specs) if (await isDirectory(spec.input)) {
+		if (spec.output !== void 0) {
+			console.error(`错误：目录输入 ${spec.input} 不能用 -o 指定单个输出文件名`);
+			process.exitCode = 1;
+			return;
+		}
+		for (const file of await listImages(spec.input)) if (!isInside(file, resolve(outDir))) jobs.push({
+			source: file,
+			format
+		});
+	} else jobs.push({
+		source: spec.input,
+		format,
+		output: spec.output
+	});
+	if (jobs.length === 0) {
+		console.error("没有找到可压缩的图片");
+		process.exitCode = 1;
+		return;
+	}
+	const used = /* @__PURE__ */ new Set();
+	let failed = 0;
+	await runBatch(jobs, {
+		resolveOutPath: (job, fmt) => job.output ?? uniqueOutPath(outDir, `${basename(job.source, extname(job.source))}.${OUTPUT_EXTENSION[fmt]}`, used),
+		onWritten: (job, { before, after, outPath }) => {
+			const ratio = before > 0 ? Math.round((1 - after / before) * 100) : 0;
+			console.log(`${job.source}  ${formatSize(before)} → ${formatSize(after)}  (-${ratio}%)  → ${outPath}`);
+		},
+		onFailed: (job, message) => {
+			failed++;
+			console.error(`${job.source}  失败：${message}`);
+		}
+	});
+	if (failed > 0) process.exitCode = 1;
+}
+main();
+//#endregion
+export {};

package/dist/index.d.mts

@@ -0,0 +1,40 @@
+//#region src/types.d.ts
+type ImageFormat = 'png' | 'jpeg' | 'webp';
+/** 解码后的原始像素，与 jSquash 的 ImageData 结构一致。 */
+interface RawImage {
+  data: Uint8Array | Uint8ClampedArray;
+  width: number;
+  height: number;
+}
+//#endregion
+//#region src/codecs.d.ts
+declare const PRESETS: {
+  readonly png: {
+    readonly maxColors: 200;
+    readonly oxipngLevel: 2;
+  };
+  readonly jpeg: {
+    readonly quality: 75;
+  };
+  readonly webp: {
+    readonly quality: 90;
+    readonly method: 6;
+    readonly lossless: 0;
+  };
+};
+//#endregion
+//#region src/index.d.ts
+interface CompressOptions {
+  /** 输出格式，默认与输入一致（第一版不做格式转换）。 */
+  format?: ImageFormat;
+}
+interface CompressResult {
+  data: Uint8Array;
+  format: ImageFormat;
+}
+/** 通过魔数识别图片格式，无法识别时返回 undefined。 */
+declare function detectFormat(data: Uint8Array): ImageFormat | undefined;
+/** 压缩单张图片。 */
+declare function compress(input: Uint8Array, options?: CompressOptions): Promise<CompressResult>;
+//#endregion
+export { CompressOptions, CompressResult, type ImageFormat, PRESETS, type RawImage, compress, detectFormat };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import { n as detectFormat, r as PRESETS, t as compress } from "./src-CqREwc6F.mjs";
+export { PRESETS, compress, detectFormat };

package/dist/src-CqREwc6F.mjs

@@ -0,0 +1,119 @@
+import { createRequire } from "node:module";
+import { readFile } from "node:fs/promises";
+import jpegDecode, { init } from "@jsquash/jpeg/decode.js";
+import jpegEncode, { init as init$1 } from "@jsquash/jpeg/encode.js";
+import pngDecode, { init as init$2 } from "@jsquash/png/decode.js";
+import webpDecode, { init as init$3 } from "@jsquash/webp/decode.js";
+import webpEncode, { init as init$4 } from "@jsquash/webp/encode.js";
+import oxipngOptimise, { init as init$5 } from "@jsquash/oxipng/optimise.js";
+import * as imagequant from "imagequant/imagequant_bg.js";
+//#region src/codecs.ts
+const PRESETS = {
+	png: {
+		maxColors: 200,
+		oxipngLevel: 2
+	},
+	jpeg: { quality: 75 },
+	webp: {
+		quality: 90,
+		method: 6,
+		lossless: 0
+	}
+};
+const require = createRequire(import.meta.url);
+async function wasmBytes(spec) {
+	return new Uint8Array(await readFile(require.resolve(spec)));
+}
+async function wasmModule(spec) {
+	return WebAssembly.compile(await wasmBytes(spec));
+}
+let jpegDecodeReady;
+let jpegEncodeReady;
+let pngDecodeReady;
+let webpDecodeReady;
+let webpEncodeReady;
+let oxipngReady;
+let imagequantReady;
+async function ensureImagequant() {
+	imagequantReady ??= (async () => {
+		const { instance } = await WebAssembly.instantiate(await wasmBytes("imagequant/imagequant_bg.wasm"), { "./imagequant_bg.js": imagequant });
+		imagequant.__wbg_set_wasm(instance.exports);
+	})();
+	return imagequantReady;
+}
+function asBuffer(data) {
+	return data;
+}
+function asImageData(image) {
+	return image;
+}
+function toUint8(data) {
+	return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+}
+async function decode(data, format) {
+	switch (format) {
+		case "png":
+			pngDecodeReady ??= init$2(await wasmBytes("@jsquash/png/codec/pkg/squoosh_png_bg.wasm"));
+			await pngDecodeReady;
+			return pngDecode(asBuffer(data));
+		case "jpeg":
+			jpegDecodeReady ??= init(await wasmModule("@jsquash/jpeg/codec/dec/mozjpeg_dec.wasm"));
+			await jpegDecodeReady;
+			return jpegDecode(asBuffer(data));
+		case "webp":
+			webpDecodeReady ??= init$3(await wasmModule("@jsquash/webp/codec/dec/webp_dec.wasm"));
+			await webpDecodeReady;
+			return webpDecode(asBuffer(data));
+	}
+}
+async function encodePng(image) {
+	await ensureImagequant();
+	const source = imagequant.Imagequant.new_image(toUint8(image.data), image.width, image.height, 0);
+	const quantizer = new imagequant.Imagequant();
+	quantizer.set_max_colors(PRESETS.png.maxColors);
+	const quantized = quantizer.process(source);
+	oxipngReady ??= init$5(await wasmBytes("@jsquash/oxipng/codec/pkg/squoosh_oxipng_bg.wasm"));
+	await oxipngReady;
+	const optimised = await oxipngOptimise(asBuffer(quantized), {
+		level: PRESETS.png.oxipngLevel,
+		interlace: false
+	});
+	return new Uint8Array(optimised);
+}
+async function encodeJpeg(image) {
+	jpegEncodeReady ??= init$1(await wasmModule("@jsquash/jpeg/codec/enc/mozjpeg_enc.wasm"));
+	await jpegEncodeReady;
+	return new Uint8Array(await jpegEncode(asImageData(image), { quality: PRESETS.jpeg.quality }));
+}
+async function encodeWebp(image) {
+	webpEncodeReady ??= init$4(await wasmModule("@jsquash/webp/codec/enc/webp_enc_simd.wasm"));
+	await webpEncodeReady;
+	return new Uint8Array(await webpEncode(asImageData(image), { ...PRESETS.webp }));
+}
+async function encode(image, format) {
+	switch (format) {
+		case "png": return encodePng(image);
+		case "jpeg": return encodeJpeg(image);
+		case "webp": return encodeWebp(image);
+	}
+}
+//#endregion
+//#region src/index.ts
+/** 通过魔数识别图片格式，无法识别时返回 undefined。 */
+function detectFormat(data) {
+	if (data.length >= 8 && data[0] === 137 && data[1] === 80 && data[2] === 78 && data[3] === 71) return "png";
+	if (data.length >= 3 && data[0] === 255 && data[1] === 216 && data[2] === 255) return "jpeg";
+	if (data.length >= 12 && data[0] === 82 && data[1] === 73 && data[2] === 70 && data[3] === 70 && data[8] === 87 && data[9] === 69 && data[10] === 66 && data[11] === 80) return "webp";
+}
+/** 压缩单张图片。 */
+async function compress(input, options = {}) {
+	const inputFormat = detectFormat(input);
+	if (!inputFormat) throw new Error("无法识别的图片格式，第一版仅支持 PNG / JPEG / WebP");
+	const format = options.format ?? inputFormat;
+	return {
+		data: await encode(await decode(input, inputFormat), format),
+		format
+	};
+}
+//#endregion
+export { detectFormat as n, PRESETS as r, compress as t };

package/dist/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/worker.mjs

@@ -0,0 +1,29 @@
+import { t as compress } from "./src-CqREwc6F.mjs";
+import { readFile } from "node:fs/promises";
+import { parentPort } from "node:worker_threads";
+//#region src/worker.ts
+const port = parentPort;
+if (!port) throw new Error("worker.ts 必须在 worker 线程中运行");
+port.on("message", async (task) => {
+	try {
+		const data = await readFile(task.source);
+		const result = await compress(new Uint8Array(data), { format: task.format });
+		const view = result.data;
+		const buffer = view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+		port.postMessage({
+			id: task.id,
+			ok: true,
+			format: result.format,
+			before: data.length,
+			data: buffer
+		}, [buffer]);
+	} catch (error) {
+		port.postMessage({
+			id: task.id,
+			ok: false,
+			error: error.message
+		});
+	}
+});
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "siuuu",
+  "type": "module",
+  "version": "0.0.0",
+  "description": "A CLI that compresses images (PNG / JPEG / WebP) with WebAssembly codecs.",
+  "author": "Author Name <author.name@mail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "homepage": "https://github.com/WBBB0730/siuu#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/WBBB0730/siuu.git"
+  },
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli.mjs",
+    "./worker": "./dist/worker.mjs",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "siuuu": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "play": "tsx scripts/play.ts",
+    "typecheck": "tsc --noEmit",
+    "release": "bumpp",
+    "prepublishOnly": "pnpm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "@typescript/native-preview": "7.0.0-dev.20260509.2",
+    "bumpp": "^11.1.0",
+    "tsdown": "^0.22.0",
+    "tsx": "^4.22.3",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "dependencies": {
+    "@jsquash/jpeg": "^1.6.0",
+    "@jsquash/oxipng": "^2.3.0",
+    "@jsquash/png": "^3.1.1",
+    "@jsquash/webp": "^1.5.0",
+    "imagequant": "^0.1.2"
+  }
+}