@xiping/node-utils 1.0.61 → 1.0.63

package/README.md

@@ -0,0 +1,45 @@
+# @xiping/node-utils
+
+Node.js 通用工具库，提供目录树、路径、SRT→VTT 字幕转换、FFmpeg 视频处理、文件信息与图片处理等能力。
+
+```bash
+npm install @xiping/node-utils
+```
+
+## 使用案例
+
+```typescript
+import {
+  buildDirectoryTree,
+  getParentDirectory,
+  convertSrtFileToVttFile,
+  getVideoInfo,
+  getThumbnail,
+  getFileConfig,
+  convertImage,
+  checkFFmpegAvailability,
+} from '@xiping/node-utils';
+
+// 目录树
+const tree = buildDirectoryTree('/path/to/dir');
+
+// 路径
+const parent = getParentDirectory('/Users/documents/folder');
+
+// SRT 转 VTT
+convertSrtFileToVttFile('/path/to/subtitle.srt');
+
+// 视频信息与缩略图（需系统安装 ffmpeg）
+if (checkFFmpegAvailability()) {
+  const info = getVideoInfo('/path/to/video.mp4');
+  const thumb = await getThumbnail('/path/to/video.mp4', { frames: 30 });
+}
+
+// 文件配置（含视频元数据）
+const config = getFileConfig('/path/to/file.mp4');
+
+// 图片格式转换
+await convertImage(inputPath, outputPath, 'webp', { quality: 80 });
+```
+
+更多说明见 [src/ffmpeg/README.md](./src/ffmpeg/README.md)、[src/image/README.md](./src/image/README.md)、[src/srt-to-vtt/README.md](./src/srt-to-vtt/README.md)。

package/lib/src/ffmpeg/README.md

@@ -12,14 +12,14 @@
 | 缩略图生成 | 多帧合成预览图（AVIF/WebP/JPEG/PNG） | ffmpeg + sharp |
 | 视频截取   | 按时间范围截取，流复制不重编码 | ffmpeg     |
 | 提取音频   | 从视频中提取音轨为 mp3/m4a/wav | ffmpeg     |
+| 视频转码   | HEVC/AV1 转码，支持转换进度回调 | ffmpeg     |
 | 环境检查   | 检测 ffmpeg/ffprobe 是否可用 | -          |
 
 ## 安装要求
 
 ### 依赖包
 
-- Node.js
-- [shelljs](https://www.npmjs.com/package/shelljs)
+- Node.js（使用内置 `child_process.spawnSync` 调用 ffmpeg/ffprobe，兼容 Electron、跨平台）
 - [sharp](https://www.npmjs.com/package/sharp)（仅缩略图功能需要）
 
 ### 系统要求
@@ -308,7 +308,79 @@ const result = await extractAudio('/path/to/video.mp4', {
 
 ---
 
-## 5. 环境检查（check）
+## 5. 视频转码（transcoding）
+
+将视频转码为 HEVC 或 AV1，不依赖 shelljs，仅使用 Node 内置 `child_process`（spawn）与 `fs`。默认生成新文件（如 `{原名}_hevc.mp4` 或 `{原名}_av1.mp4`），不替换原文件；可选开启“替换原文件”。支持转换进度回调。
+
+### 基本使用
+
+```typescript
+import { transcoding, getAvailableEncoders } from '@xiping/node-utils';
+
+// 转码为 HEVC（默认），生成新文件
+const result = await transcoding('/path/to/video.mp4');
+console.log(result.outputPath); // 如 /path/to/video_hevc.mp4
+
+// 指定 AV1、不生成缩略图
+const r2 = await transcoding('/path/to/video.mp4', {
+  format: 'av1',
+  generateThumbnail: false,
+});
+
+// 替换原文件（删除原文件并将输出重命名为原路径）
+const r3 = await transcoding('/path/to/video.mp4', {
+  format: 'hevc',
+  replaceOriginal: true,
+});
+```
+
+### 转换进度（onProgress）
+
+```typescript
+const result = await transcoding('/path/to/video.mp4', {
+  onProgress(progress) {
+    console.log(progress.phase, progress.percent, progress.message);
+    // phase: 'encoding' | 'done'
+    if (progress.currentTime != null && progress.duration != null) {
+      console.log(`已处理 ${progress.currentTime}/${progress.duration} 秒`);
+    }
+  },
+});
+```
+
+### TranscodingConfig
+
+| 选项               | 类型     | 默认值   | 说明 |
+|--------------------|----------|----------|------|
+| format             | string   | 'hevc'   | 目标编码：'hevc' \| 'av1' |
+| generateThumbnail  | boolean  | true     | 是否生成缩略图 |
+| replaceOriginal    | boolean  | false    | 是否替换原文件（删除原文件并将输出重命名为原路径） |
+| onProgress         | function | -        | 转换进度回调 |
+
+### TranscodeProgress（onProgress 回调参数）
+
+| 字段        | 类型   | 说明 |
+|-------------|--------|------|
+| phase       | string | 阶段：'encoding' \| 'done' |
+| percent     | number | 总进度 0–100 |
+| message     | string | 可读描述 |
+| currentTime | number | 当前已处理时长（秒） |
+| duration    | number | 视频总时长（秒） |
+
+### 编码器检测
+
+```typescript
+import { getAvailableEncoders } from '@xiping/node-utils';
+
+const encoders = getAvailableEncoders();
+// { av1Nvenc, libaomAv1, hevcNvenc, libx265 }
+```
+
+HEVC 优先使用 hevc_nvenc（NVIDIA），否则使用 libx265；AV1 优先使用 av1_nvenc，否则使用 libaom-av1。输入路径需为**绝对路径**。
+
+---
+
+## 6. 环境检查（check）
 
 ```typescript
 import { checkFFmpegAvailability, isFfprobeAvailable } from '@xiping/node-utils';
@@ -321,7 +393,7 @@ if (isFfprobeAvailable()) {
 }
 ```
 
-- **checkFFmpegAvailability()**：用于缩略图、视频截取、提取音频前检查。
+- **checkFFmpegAvailability()**：用于缩略图、视频截取、提取音频、视频转码前检查。
 - **isFfprobeAvailable()**：用于视频信息接口前检查。
 
 ---
@@ -367,5 +439,7 @@ ffprobe/ffmpeg 支持常见容器与编码，例如：
 | `cutVideoByDuration(path, start, duration, options)` | 按起始+时长截取 |
 | `cutVideoFromStart(path, durationSeconds, options)`   | 从开头截取 N 秒 |
 | `extractAudio(path, options)` | 从视频提取音频（异步） |
+| `transcoding(path, options)` | 视频转码为 HEVC/AV1（异步，支持进度） |
+| `getAvailableEncoders()`      | 检测可用编码器（av1_nvenc、libaom-av1、hevc_nvenc、libx265） |
 | `isFfprobeAvailable()`   | 检测 ffprobe 是否可用 |
 | `checkFFmpegAvailability()` | 检测 ffmpeg 是否可用 |

package/lib/src/ffmpeg/check.js

@@ -1,7 +1,7 @@
-import shell from "shelljs";
+import { runSync } from "./runSync.js";
 // 检查 ffmpeg 可用性
 export function checkFFmpegAvailability() {
-    const result = shell.exec('ffmpeg -version', { silent: true });
+    const result = runSync("ffmpeg", ["-version"]);
     return result.code === 0;
 }
 /**
@@ -9,6 +9,6 @@ export function checkFFmpegAvailability() {
  * @returns 是否可用
  */
 export function isFfprobeAvailable() {
-    const result = shell.exec("ffprobe -version", { silent: true });
+    const result = runSync("ffprobe", ["-version"]);
     return result.code === 0;
 }

package/lib/src/ffmpeg/cutVideo.js

@@ -1,5 +1,5 @@
-import shell from "shelljs";
 import * as fs from "fs";
+import { runSync } from "./runSync.js";
 import * as path from "node:path";
 import * as os from "node:os";
 import { checkFFmpegAvailability } from "./check.js";
@@ -40,7 +40,12 @@ function normalizeTimeFormat(time) {
 // 获取视频时长
 function getDurationInSeconds(videoPath) {
     log('Getting video duration', { videoPath });
-    const result = shell.exec(`ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${videoPath}"`, { silent: true });
+    const result = runSync("ffprobe", [
+        "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        videoPath,
+    ]);
     if (result.code !== 0) {
         throw new Error(`FFprobe failed to get duration: ${result.stderr}`);
     }
@@ -104,20 +109,6 @@ function timeToSeconds(timeStr) {
     }
     throw new Error(`Invalid time format: ${timeStr}`);
 }
-// 构建 FFmpeg 命令
-function buildFFmpegCommand(inputPath, outputPath, startTime, duration, options) {
-    const { overwrite = false } = options;
-    // 使用 copy 模式，保持原视频编码和质量
-    let command = `ffmpeg -ss ${startTime} -i "${inputPath}" -t ${duration}`;
-    // 复制视频和音频流，不重新编码
-    command += ' -c copy';
-    // 其他设置
-    command += ' -avoid_negative_ts make_zero';
-    command += ' -y'; // 自动覆盖输出文件
-    // 输出文件
-    command += ` "${outputPath}"`;
-    return command;
-}
 // 临时目录管理
 async function withTempDir(fn, customTempDir) {
     const tempDir = customTempDir || fs.mkdtempSync(path.join(os.tmpdir(), "video-cut-"));
@@ -169,11 +160,16 @@ export const cutVideo = async (videoPath, options = {}) => {
         // 使用临时目录处理
         await withTempDir(async (tempDir) => {
             const tempOutputPath = path.join(tempDir, `temp_output.${outputFormat}`);
-            // 构建 FFmpeg 命令
-            const command = buildFFmpegCommand(validatedPath, tempOutputPath, timeParams.startTime, timeParams.duration, options);
-            log('Executing FFmpeg command', { command });
-            // 执行 FFmpeg 命令
-            const result = shell.exec(command, { silent: true });
+            log('Executing FFmpeg command', { startTime: timeParams.startTime, duration: timeParams.duration });
+            const result = runSync("ffmpeg", [
+                "-ss", timeParams.startTime,
+                "-i", validatedPath,
+                "-t", timeParams.duration,
+                "-c", "copy",
+                "-avoid_negative_ts", "make_zero",
+                "-y",
+                tempOutputPath,
+            ]);
             if (result.code !== 0) {
                 throw new Error(`FFmpeg failed: ${result.stderr}`);
             }

package/lib/src/ffmpeg/extractAudio.js

@@ -1,5 +1,5 @@
-import shell from "shelljs";
 import { spawn } from "node:child_process";
+import { runSync } from "./runSync.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
@@ -18,7 +18,12 @@ function validateAndSanitizePath(inputPath) {
     return inputPath;
 }
 function getDurationInSeconds(videoPath) {
-    const result = shell.exec(`ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${videoPath}"`, { silent: true });
+    const result = runSync("ffprobe", [
+        "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        videoPath,
+    ]);
     if (result.code !== 0) {
         throw new Error(`FFprobe failed to get duration: ${result.stderr}`);
     }
@@ -57,13 +62,12 @@ function buildFfmpegArgs(outputPath, outputFormat, copyStream, audioCodec) {
     args.push("-y", outputPath);
     return args;
 }
-/** 执行 ffmpeg（shell.exec），无进度 */
+/** 执行 ffmpeg（runSync），无进度 */
 function runFfmpegSync(inputPath, outputPath, outputFormat, copyStream, audioCodec) {
     const args = buildFfmpegArgs(outputPath, outputFormat, copyStream, audioCodec);
     args[1] = inputPath;
-    const command = `ffmpeg ${args.map((a) => (a.includes(" ") ? `"${a}"` : a)).join(" ")}`;
-    log("Executing FFmpeg command", { command });
-    const result = shell.exec(command, { silent: true });
+    log("Executing FFmpeg command", { inputPath, outputPath });
+    const result = runSync("ffmpeg", args);
     if (result.code !== 0) {
         throw new Error(`FFmpeg failed: ${result.stderr}`);
     }

package/lib/src/ffmpeg/getThumbnail.js

@@ -1,5 +1,5 @@
-import shell from "shelljs";
 import Sharp from "sharp";
+import { runSync } from "./runSync.js";
 import * as fs from "fs";
 import * as path from "node:path";
 import * as os from "node:os";
@@ -22,7 +22,12 @@ function validateAndSanitizePath(inputPath) {
 // 获取视频时长
 function getDurationInSeconds(videoPath) {
     log('Getting video duration', { videoPath });
-    const result = shell.exec(`ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 "${videoPath}"`, { silent: true });
+    const result = runSync("ffprobe", [
+        "-v", "error",
+        "-show_entries", "format=duration",
+        "-of", "default=noprint_wrappers=1:nokey=1",
+        videoPath,
+    ]);
     if (result.code !== 0) {
         throw new Error(`FFprobe failed to get duration: ${result.stderr}`);
     }
@@ -40,7 +45,15 @@ async function extractFrames(videoPath, tempDir, frames, interval, maxConcurrenc
         const t = interval * i;
         const framePath = path.join(tempDir, `frame-${t}.jpg`);
         return new Promise((resolve, reject) => {
-            const result = shell.exec(`ffmpeg -ss ${t} -i "${videoPath}" -vframes 1 -q:v 10 -an -threads 4 "${framePath}"`, { silent: true });
+            const result = runSync("ffmpeg", [
+                "-ss", String(t),
+                "-i", videoPath,
+                "-vframes", "1",
+                "-q:v", "10",
+                "-an",
+                "-threads", "4",
+                framePath,
+            ]);
             if (result.code === 0) {
                 log(`Frame ${i + 1}/${total} extracted`, { time: t });
                 resolve();

package/lib/src/ffmpeg/getVideoInfo.js

@@ -1,4 +1,5 @@
-import shell from "shelljs";
+import * as fs from "node:fs";
+import { runSync } from "./runSync.js";
 /**
  * 格式化文件大小
  * @param bytes 字节数
@@ -32,12 +33,16 @@ function formatDuration(seconds) {
  * @returns 视频信息对象
  */
 export function getVideoInfo(videoPath) {
-    // 检查文件是否存在
-    if (!shell.test("-f", videoPath)) {
+    if (!fs.existsSync(videoPath)) {
         throw new Error(`视频文件不存在: ${videoPath}`);
     }
-    // 使用 ffprobe 获取 JSON 格式的视频信息
-    const result = shell.exec(`ffprobe -v quiet -print_format json -show_format -show_streams "${videoPath}"`, { silent: true });
+    const result = runSync("ffprobe", [
+        "-v", "quiet",
+        "-print_format", "json",
+        "-show_format",
+        "-show_streams",
+        videoPath,
+    ]);
     if (result.code !== 0) {
         throw new Error(`获取视频信息失败: ${result.stderr}`);
     }
@@ -98,10 +103,18 @@ export function getMultipleVideoInfo(videoPaths) {
  * @returns 详细的视频信息
  */
 export function getDetailedVideoInfo(videoPath) {
-    if (!shell.test("-f", videoPath)) {
+    if (!fs.existsSync(videoPath)) {
         throw new Error(`视频文件不存在: ${videoPath}`);
     }
-    const result = shell.exec(`ffprobe -v quiet -print_format json -show_format -show_streams -show_chapters -show_private_data "${videoPath}"`, { silent: true });
+    const result = runSync("ffprobe", [
+        "-v", "quiet",
+        "-print_format", "json",
+        "-show_format",
+        "-show_streams",
+        "-show_chapters",
+        "-show_private_data",
+        videoPath,
+    ]);
     if (result.code !== 0) {
         throw new Error(`获取详细视频信息失败: ${result.stderr}`);
     }

package/lib/src/ffmpeg/index.d.ts

@@ -3,3 +3,4 @@ export * from "./check.js";
 export * from "./cutVideo.js";
 export * from "./getVideoInfo.js";
 export * from "./extractAudio.js";
+export * from "./transcode.js";

package/lib/src/ffmpeg/index.js

@@ -3,3 +3,4 @@ export * from "./check.js";
 export * from "./cutVideo.js";
 export * from "./getVideoInfo.js";
 export * from "./extractAudio.js";
+export * from "./transcode.js";

package/lib/src/ffmpeg/runSync.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 同步执行外部命令（跨平台、兼容 Electron，不依赖 shell）。
+ * 使用 spawnSync + 参数数组，避免 shell 解析和路径/空格问题。
+ *
+ * @param command 可执行文件名（如 ffmpeg、ffprobe）
+ * @param args 参数列表（路径无需额外引号）
+ * @returns 与 shelljs.exec 兼容的 { code, stdout, stderr }
+ */
+export declare function runSync(command: string, args: string[], options?: {
+    encoding?: BufferEncoding;
+}): {
+    code: number;
+    stdout: string;
+    stderr: string;
+};

package/lib/src/ffmpeg/runSync.js

@@ -0,0 +1,20 @@
+import { spawnSync } from "node:child_process";
+/**
+ * 同步执行外部命令（跨平台、兼容 Electron，不依赖 shell）。
+ * 使用 spawnSync + 参数数组，避免 shell 解析和路径/空格问题。
+ *
+ * @param command 可执行文件名（如 ffmpeg、ffprobe）
+ * @param args 参数列表（路径无需额外引号）
+ * @returns 与 shelljs.exec 兼容的 { code, stdout, stderr }
+ */
+export function runSync(command, args, options) {
+    const encoding = options?.encoding ?? "utf8";
+    const result = spawnSync(command, args, {
+        encoding,
+        windowsHide: true,
+    });
+    const stdout = (result.stdout ?? "");
+    const stderr = (result.stderr ?? "");
+    const code = result.status ?? (result.signal ? -1 : 0);
+    return { code, stdout, stderr };
+}

package/lib/src/ffmpeg/transcode.d.ts

@@ -0,0 +1,40 @@
+/** 转码进度信息，用于 onProgress 回调 */
+export interface TranscodeProgress {
+    /** 当前阶段 */
+    phase: "encoding" | "done";
+    /** 总进度 0–100 */
+    percent: number;
+    /** 可读描述 */
+    message?: string;
+    /** 当前已处理时长（秒） */
+    currentTime?: number;
+    /** 视频总时长（秒） */
+    duration?: number;
+}
+export interface TranscodingConfig {
+    /** 是否生成缩略图，默认 true */
+    generateThumbnail?: boolean;
+    /** 目标编码格式，默认 'hevc' */
+    format?: "av1" | "hevc";
+    /** 是否替换原文件（删除原文件并将输出重命名为原路径），默认 false */
+    replaceOriginal?: boolean;
+    /** 转换进度回调 */
+    onProgress?: (progress: TranscodeProgress) => void;
+}
+export interface AvailableEncoders {
+    av1Nvenc: boolean;
+    libaomAv1: boolean;
+    hevcNvenc: boolean;
+    libx265: boolean;
+}
+/** 同步检测可用编码器 */
+export declare function getAvailableEncoders(): AvailableEncoders;
+export interface TranscodingResult {
+    /** 转码输出文件路径（替换原文件时为原路径，否则为 {base}_hevc.mp4 或 {base}_av1.mp4） */
+    outputPath: string;
+}
+/**
+ * 将视频转码为 HEVC 或 AV1，不依赖 shelljs，使用 Node 内置 child_process 与 fs。
+ * 支持转换进度回调；默认生成新文件，不替换原文件。
+ */
+export declare function transcoding(inputPath: string, config?: TranscodingConfig): Promise<TranscodingResult>;

package/lib/src/ffmpeg/transcode.js

@@ -0,0 +1,181 @@
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { runSync } from "./runSync.js";
+import { checkFFmpegAvailability } from "./check.js";
+import { getThumbnail } from "./getThumbnail.js";
+const defaultConfig = {
+    generateThumbnail: true,
+    format: "hevc",
+    replaceOriginal: false,
+};
+/** 同步检测可用编码器 */
+export function getAvailableEncoders() {
+    const result = runSync("ffmpeg", ["-encoders"]);
+    const stdout = result.code === 0 ? result.stdout : "";
+    return {
+        av1Nvenc: stdout.includes("av1_nvenc"),
+        libaomAv1: stdout.includes("libaom-av1"),
+        hevcNvenc: stdout.includes("hevc_nvenc"),
+        libx265: stdout.includes("libx265"),
+    };
+}
+function validateAndSanitizePath(inputPath) {
+    if (!inputPath || typeof inputPath !== "string") {
+        throw new Error("Invalid path provided");
+    }
+    if (!path.isAbsolute(inputPath)) {
+        throw new Error("Path must be absolute");
+    }
+    return inputPath;
+}
+function getDurationInSeconds(videoPath) {
+    const result = runSync("ffprobe", [
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "default=noprint_wrappers=1:nokey=1",
+        videoPath,
+    ]);
+    if (result.code !== 0) {
+        throw new Error(`FFprobe failed to get duration: ${result.stderr}`);
+    }
+    const duration = parseFloat(result.stdout);
+    if (isNaN(duration) || duration <= 0) {
+        throw new Error("Invalid video duration");
+    }
+    return duration;
+}
+/** 解析 ffmpeg stderr 中的 time=HH:MM:SS.xx 为秒数 */
+function parseTimeFromStderr(line) {
+    const match = line.match(/time=(\d{2}):(\d{2}):(\d{2}\.\d+)/);
+    if (!match)
+        return null;
+    const [, h, m, s] = match;
+    return parseInt(h, 10) * 3600 + parseInt(m, 10) * 60 + parseFloat(s);
+}
+/** 根据格式与可用编码器构建 ffmpeg 参数数组 */
+function buildTranscodeArgs(inputPath, outputPath, format, encoders) {
+    const args = ["-i", inputPath];
+    if (format === "av1") {
+        if (encoders.av1Nvenc) {
+            args.push("-c:v", "av1_nvenc", "-preset", "slow", "-rc", "constqp", "-qp", "28");
+        }
+        else if (encoders.libaomAv1) {
+            args.push("-c:v", "libaom-av1", "-crf", "30", "-b:v", "0");
+        }
+        else {
+            throw new Error("没有可用的 AV1 编码器");
+        }
+    }
+    else {
+        if (encoders.hevcNvenc) {
+            args.push("-c:v", "hevc_nvenc", "-preset", "slow", "-rc", "constqp", "-qp", "28");
+        }
+        else if (encoders.libx265) {
+            args.push("-c:v", "libx265", "-crf", "28");
+        }
+        else {
+            throw new Error("没有可用的 HEVC 编码器");
+        }
+    }
+    args.push("-y", outputPath);
+    return args;
+}
+/** 使用 spawn 执行 ffmpeg 转码，解析 stderr 并回调 onProgress */
+function runTranscodeWithProgress(inputPath, outputPath, format, encoders, totalDuration, onProgress) {
+    return new Promise((resolve, reject) => {
+        const args = buildTranscodeArgs(inputPath, outputPath, format, encoders);
+        const child = spawn("ffmpeg", args, { stdio: ["ignore", "pipe", "pipe"] });
+        let lastPercent = -1;
+        const report = (progress) => {
+            if (progress.percent !== lastPercent) {
+                lastPercent = progress.percent;
+                onProgress(progress);
+            }
+        };
+        if (child.stderr) {
+            let buffer = "";
+            child.stderr.setEncoding("utf8");
+            child.stderr.on("data", (chunk) => {
+                buffer += chunk;
+                const lines = buffer.split(/\r?\n/);
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    const currentTime = parseTimeFromStderr(line);
+                    if (currentTime != null && totalDuration > 0) {
+                        const percent = Math.min(99, Math.round((currentTime / totalDuration) * 100));
+                        report({
+                            phase: "encoding",
+                            percent,
+                            message: "正在转码...",
+                            currentTime,
+                            duration: totalDuration,
+                        });
+                    }
+                }
+            });
+        }
+        child.on("error", (err) => reject(err));
+        child.on("close", (code, signal) => {
+            if (signal) {
+                reject(new Error(`FFmpeg killed by signal: ${signal}`));
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`FFmpeg exited with code ${code}`));
+                return;
+            }
+            report({
+                phase: "done",
+                percent: 100,
+                message: "完成",
+                currentTime: totalDuration,
+                duration: totalDuration,
+            });
+            resolve();
+        });
+    });
+}
+/**
+ * 将视频转码为 HEVC 或 AV1，不依赖 shelljs，使用 Node 内置 child_process 与 fs。
+ * 支持转换进度回调；默认生成新文件，不替换原文件。
+ */
+export async function transcoding(inputPath, config = {}) {
+    const finalConfig = { ...defaultConfig, ...config };
+    if (!checkFFmpegAvailability()) {
+        throw new Error("FFmpeg is not available. Please install FFmpeg first.");
+    }
+    const validatedPath = validateAndSanitizePath(inputPath);
+    if (!fs.existsSync(validatedPath)) {
+        throw new Error(`Video file not found: ${validatedPath}`);
+    }
+    const encoders = getAvailableEncoders();
+    const format = finalConfig.format;
+    const duration = getDurationInSeconds(validatedPath);
+    const dir = path.dirname(validatedPath);
+    const baseName = path.basename(validatedPath, path.extname(validatedPath));
+    const suffix = format === "av1" ? "_av1" : "_hevc";
+    const outputFileName = `${baseName}${suffix}.mp4`;
+    const tempOutputPath = path.join(dir, outputFileName);
+    const reportProgress = (progress) => {
+        finalConfig.onProgress?.(progress);
+    };
+    await runTranscodeWithProgress(validatedPath, tempOutputPath, format, encoders, duration, reportProgress);
+    if (finalConfig.generateThumbnail) {
+        await getThumbnail(validatedPath);
+    }
+    let resultPath;
+    if (finalConfig.replaceOriginal) {
+        fs.unlinkSync(validatedPath);
+        const originalPath = path.join(dir, path.basename(validatedPath));
+        fs.renameSync(tempOutputPath, originalPath);
+        resultPath = originalPath;
+    }
+    else {
+        resultPath = tempOutputPath;
+    }
+    return { outputPath: resultPath };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiping/node-utils",
-  "version": "1.0.61",
+  "version": "1.0.63",
   "description": "node-utils",
   "type": "module",
   "author": "The-End-Hero <527409987@qq.com>",
@@ -16,16 +16,16 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/The-End-Hero/wang-ping.git"
+    "url": "git+https://github.com/The-End-Hero/xiping.git"
   },
   "scripts": {
     "test": "echo \"Error: run tests from root\" && exit 1",
     "build": "tsc && node scripts/copy-readmes.js"
   },
   "bugs": {
-    "url": "https://github.com/The-End-Hero/wang-ping/issues"
+    "url": "https://github.com/The-End-Hero/xiping/issues"
   },
-  "gitHead": "6cb2ac8c64a780abb18ec793978d3adfff71fba7",
+  "gitHead": "466588a53ef8fa8bc6562a9933f1c9d707e978e5",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
@@ -33,14 +33,12 @@
   "dependencies": {
     "@xiping/subtitle": "1.0.52",
     "chalk": "^5.6.2",
-    "fs-extra": "^11.3.3",
-    "sharp": "^0.34.4",
-    "shelljs": "0.10.0",
+    "sharp": "^0.34.5",
     "srt-parser-2": "^1.2.3"
   },
   "devDependencies": {
-    "@types/node": "^24.10.4",
+    "@types/node": "^24.10.13",
     "tslib": "^2.8.1",
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.3"
   }
 }