lubanpng 0.1.0 → 0.2.0

package/dist/api.js

@@ -89,9 +89,13 @@ export class ApiClient {
     me(signal) {
         return this.request("GET", "/v1/me", { signal });
     }
-    async uploadImage(filePath, signal) {
+    async uploadImage(filePath, options = {}, signal) {
         const data = await readFile(filePath);
         const form = new FormData();
+        if (options.convert !== undefined)
+            form.append("convert", options.convert);
+        if (options.background !== undefined)
+            form.append("background", options.background);
         form.append("file", new Blob([new Uint8Array(data)]), basename(filePath));
         return this.request("POST", "/v1/images/compress", { formData: form, signal });
     }

package/dist/args.js

@@ -1,7 +1,8 @@
 import { UsageError } from "./errors.js";
+export const TARGET_FORMATS = ["png", "jpeg", "webp", "avif"];
 export const DEFAULT_CONCURRENCY = 4;
 export const MAX_CONCURRENCY = 16;
-const STRING_OPTIONS = new Set(["--api-base", "--out", "--concurrency"]);
+const STRING_OPTIONS = new Set(["--api-base", "--out", "--concurrency", "--convert", "--background"]);
 const BOOLEAN_OPTIONS = new Set(["--in-place", "--recursive", "--help", "-h", "--version", "-v"]);
 const COMMANDS = new Set(["login", "logout", "compress", "usage"]);
 const readConcurrency = (raw) => {
@@ -13,6 +14,20 @@ const readConcurrency = (raw) => {
     }
     return value;
 };
+const readTarget = (raw) => {
+    const lowered = raw.trim().toLowerCase();
+    const normalized = lowered === "jpg" ? "jpeg" : lowered;
+    if (!TARGET_FORMATS.includes(normalized)) {
+        throw new UsageError(`--convert 只支持 png、jpeg、webp、avif，收到：${raw}`);
+    }
+    return normalized;
+};
+const readBackground = (raw) => {
+    const match = /^#?([0-9a-fA-F]{6})$/.exec(raw.trim());
+    if (!match)
+        throw new UsageError(`--background 需要是 #RRGGBB 形式的颜色，收到：${raw}`);
+    return `#${match[1].toLowerCase()}`;
+};
 export const parseArgv = (argv) => {
     const options = new Map();
     const positionals = [];
@@ -66,9 +81,19 @@ export const parseArgv = (argv) => {
         const inPlace = options.get("--in-place") === true;
         const recursive = options.get("--recursive") === true;
         const concurrency = options.get("--concurrency");
+        const convertRaw = options.get("--convert");
+        const backgroundRaw = options.get("--background");
         if (inPlace && outValue !== undefined) {
             throw new UsageError("--in-place 与 --out 不能同时使用");
         }
+        const convert = typeof convertRaw === "string" ? readTarget(convertRaw) : undefined;
+        const background = typeof backgroundRaw === "string" ? readBackground(backgroundRaw) : undefined;
+        if (inPlace && convert !== undefined) {
+            throw new UsageError("--in-place 不能与 --convert 同时使用，转换结果请用 --out 或默认输出");
+        }
+        if (background !== undefined && convert === undefined) {
+            throw new UsageError("--background 需要与 --convert 一起使用");
+        }
         const paths = positionals.slice(1);
         if (paths.length === 0)
             throw new UsageError("compress 至少需要一个文件或目录路径");
@@ -80,6 +105,8 @@ export const parseArgv = (argv) => {
             inPlace,
             recursive,
             concurrency: typeof concurrency === "string" ? readConcurrency(concurrency) : DEFAULT_CONCURRENCY,
+            convert,
+            background,
         };
     }
     if (positionals.length > 1) {

package/dist/commands/compress.js

@@ -4,10 +4,27 @@ import { ApiClient, describeError, } from "../api.js";
 import { API_KEY_ENV, resolveApiKey } from "../config.js";
 import { UsageError } from "../errors.js";
 import { formatBytes, formatSavings, formatSizePair, periodNoun, savingsPercent } from "../format.js";
-const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif"]);
+import { HEIC_EXTENSIONS, HEIC_IN_PLACE_MESSAGE, isHeicPath, prepareHeicUpload } from "../heic.js";
+const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ...HEIC_EXTENSIONS]);
+const FORMAT_EXTENSIONS = { png: ".png", jpeg: ".jpg", gif: ".gif", webp: ".webp", avif: ".avif" };
+const SUPPORTED_FORMATS_LABEL = "PNG / JPEG / GIF / WebP / AVIF，macOS 上另支持 HEIC";
 const WAIT_SECONDS = 30;
 const MAX_POLL_ROUNDS = 40;
 const SIZE_COLUMN = 9;
+const sameFamily = (extension, format) => {
+    const current = extension.toLowerCase();
+    const target = FORMAT_EXTENSIONS[format];
+    return target !== undefined && (current === target || (target === ".jpg" && current === ".jpeg"));
+};
+export const outputExtensionFor = (sourcePath, format) => {
+    const current = extname(sourcePath);
+    if (!format)
+        return current;
+    const target = FORMAT_EXTENSIONS[format];
+    if (target === undefined || sameFamily(current, format))
+        return current;
+    return target;
+};
 const walk = async (root, current, push) => {
     const entries = await readdir(current, { withFileTypes: true });
     for (const entry of entries) {
@@ -52,13 +69,18 @@ export const collectFiles = async (inputs, recursive) => {
     }
     return collected;
 };
-const outputPathFor = (file, options) => {
+const withExtension = (path, extension) => {
+    const current = extname(path);
+    return `${path.slice(0, path.length - current.length)}${extension}`;
+};
+const outputPathFor = (file, options, format) => {
     if (options.inPlace)
         return file.path;
+    const extension = outputExtensionFor(file.path, format);
     if (options.out !== undefined)
-        return join(options.out, file.relative);
+        return join(options.out, withExtension(file.relative, extension));
     const ext = extname(file.path);
-    return `${file.path.slice(0, file.path.length - ext.length)}.min${ext}`;
+    return `${file.path.slice(0, file.path.length - ext.length)}.min${extension}`;
 };
 const writeFileAtomic = async (target, bytes) => {
     const temp = `${target}.lubanpng-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
@@ -74,7 +96,7 @@ const writeFileAtomic = async (target, bytes) => {
 const assertNoTargetConflicts = (files, options) => {
     const byTarget = new Map();
     for (const file of files) {
-        const target = resolve(outputPathFor(file, options));
+        const target = resolve(outputPathFor(file, options, options.convert));
         const sources = byTarget.get(target);
         if (sources === undefined) {
             byTarget.set(target, [file.path]);
@@ -126,7 +148,7 @@ export const compressCommand = async (context, options) => {
     };
     const files = await collectFiles(options.paths, options.recursive);
     if (files.length === 0) {
-        throw new UsageError("没有找到可压缩的图片（支持 PNG / JPEG / GIF）");
+        throw new UsageError(`没有找到可压缩的图片（支持 ${SUPPORTED_FORMATS_LABEL}）`);
     }
     assertNoTargetConflicts(files, options);
     const nameWidth = Math.max(...files.map((file) => file.name.length));
@@ -144,32 +166,61 @@ export const compressCommand = async (context, options) => {
             return;
         }
         const percent = savingsPercent(outcome.originalSize, outcome.compressedSize);
-        context.io.write(`  ${name}  ${original} → ${compressed}   ${formatSavings(percent)}\n`);
+        const converted = outcome.converted === null ? "" : `   → ${outcome.converted}`;
+        context.io.write(`  ${name}  ${original} → ${compressed}   ${formatSavings(percent)}${converted}\n`);
     };
     const processOne = async (file) => {
         const originalSize = (await stat(file.path)).size;
+        const failure = (error) => ({
+            file,
+            ok: false,
+            retained: false,
+            converted: null,
+            originalSize,
+            compressedSize: 0,
+            error,
+        });
+        let prepared = { path: file.path, name: file.name, cleanup: async () => undefined };
+        if (isHeicPath(file.path)) {
+            if (options.inPlace)
+                return failure(HEIC_IN_PLACE_MESSAGE);
+            try {
+                prepared = await prepareHeicUpload(file.path);
+            }
+            catch (error) {
+                return failure(error instanceof Error ? error.message : String(error));
+            }
+        }
         try {
-            const upload = await client.uploadImage(file.path);
+            const upload = await client.uploadImage(prepared.path, {
+                convert: options.convert,
+                background: options.background,
+            });
             onQuota(upload.quota);
             const view = await waitForCompletion(client, upload.data.task_id, onQuota);
             if (view.status !== "completed" || view.compressed_url === null) {
-                return { file, ok: false, retained: false, originalSize, compressedSize: 0, error: view.error_msg ?? "压缩失败" };
+                return failure(view.error_msg ?? "压缩失败");
             }
             if (options.inPlace && view.compressed_size !== null && view.compressed_size >= originalSize) {
-                return { file, ok: true, retained: true, originalSize, compressedSize: view.compressed_size, error: null };
+                return { file, ok: true, retained: true, converted: null, originalSize, compressedSize: view.compressed_size, error: null };
             }
             const bytes = await client.download(view.compressed_url);
             const compressedSize = view.compressed_size ?? bytes.byteLength;
             if (options.inPlace && compressedSize >= originalSize) {
-                return { file, ok: true, retained: true, originalSize, compressedSize, error: null };
+                return { file, ok: true, retained: true, converted: null, originalSize, compressedSize, error: null };
             }
-            const target = outputPathFor(file, options);
+            const outputFormat = view.output_format ?? options.convert ?? null;
+            const target = outputPathFor(file, options, outputFormat);
             await mkdir(dirname(target), { recursive: true });
             await writeFileAtomic(target, bytes);
-            return { file, ok: true, retained: false, originalSize, compressedSize, error: null };
+            const converted = extname(target).toLowerCase() === extname(file.path).toLowerCase() ? null : basename(target);
+            return { file, ok: true, retained: false, converted, originalSize, compressedSize, error: null };
         }
         catch (error) {
-            return { file, ok: false, retained: false, originalSize, compressedSize: 0, error: describeError(error) };
+            return failure(describeError(error));
+        }
+        finally {
+            await prepared.cleanup();
         }
     };
     const outcomes = [];
@@ -187,6 +238,9 @@ export const compressCommand = async (context, options) => {
         `节省 ${formatBytes(saved)}`,
         `${periodNoun(period)}剩余 ${remaining} 次`,
     ];
+    const converted = outcomes.filter((outcome) => outcome.converted !== null);
+    if (converted.length > 0)
+        parts.push(`${converted.length} 张已转换`);
     if (retained.length > 0)
         parts.push(`${retained.length} 张无收益保留原图`);
     if (failed.length > 0)

package/dist/heic.js

@@ -0,0 +1,29 @@
+import { execFile } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, extname, join } from "node:path";
+import { promisify } from "node:util";
+export const HEIC_EXTENSIONS = new Set([".heic", ".heif"]);
+export const HEIC_UNSUPPORTED_MESSAGE = "HEIC 只能在 macOS 上由系统转换后上传，其他系统请先导出为 JPEG";
+export const HEIC_IN_PLACE_MESSAGE = "HEIC 会转成 JPEG，不能就地覆盖，请用 --out 或默认输出";
+const SIPS_JPEG_QUALITY = "92";
+const runCommand = async (command, args) => {
+    await promisify(execFile)(command, args);
+};
+export const isHeicPath = (path) => HEIC_EXTENSIONS.has(extname(path).toLowerCase());
+export const prepareHeicUpload = async (sourcePath, platform = process.platform, run = runCommand) => {
+    if (platform !== "darwin")
+        throw new Error(HEIC_UNSUPPORTED_MESSAGE);
+    const dir = await mkdtemp(join(tmpdir(), "lubanpng-heic-"));
+    const name = `${basename(sourcePath, extname(sourcePath))}.jpg`;
+    const target = join(dir, name);
+    const cleanup = () => rm(dir, { recursive: true, force: true });
+    try {
+        await run("sips", ["-s", "format", "jpeg", "-s", "formatOptions", SIPS_JPEG_QUALITY, sourcePath, "--out", target]);
+    }
+    catch (error) {
+        await cleanup();
+        throw new Error(`HEIC 转换失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    return { path: target, name, cleanup };
+};

package/dist/help.js

@@ -10,7 +10,7 @@ export const HELP = [
     "命令：",
     "  login                粘贴 API Key，校验后保存到本机",
     "  logout               清除本机保存的 API Key",
-    "  compress <路径...>   压缩文件或目录",
+    "  compress <路径...>   压缩文件或目录，可选转换格式；macOS 上 HEIC 先由系统转成 JPEG",
     "  usage                查看套餐、本期用量与重置时间",
     "",
     "全局选项：",
@@ -23,6 +23,8 @@ export const HELP = [
     "  --in-place           覆盖原文件",
     "  --recursive          递归处理目录",
     "  --concurrency <n>    并发数（默认 4，最大 16）",
+    "  --convert <fmt>      转换输出格式：png、jpeg、webp、avif（额外计 1 次）",
+    "  --background <hex>   透明图转 JPEG 时的背景色，如 #ffffff",
     "",
     "环境变量：",
     `  ${API_KEY_ENV}     API Key（优先于本机配置）`,

package/dist/run.js

@@ -41,6 +41,8 @@ export const run = async (argv, options = {}) => {
                     inPlace: parsed.inPlace,
                     recursive: parsed.recursive,
                     concurrency: parsed.concurrency,
+                    convert: parsed.convert,
+                    background: parsed.background,
                 });
         }
         return 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lubanpng",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "LubanPNG command line image compressor",
   "type": "module",
   "bin": {