@xiping/node-utils 1.0.21 → 1.0.36

package/lib/index.d.ts

@@ -1,51 +1,4 @@
-/**
- * Represents a node in a directory tree structure
- * @interface Tree
- * @property {string} id - Unique identifier for the node (full path)
- * @property {string} label - Display name of the file or directory
- * @property {Tree[]} [children] - Optional array of child nodes for directories
- */
-export interface Tree {
-    id: string;
-    label: string;
-    children?: Tree[];
-}
-/**
- * Recursively builds a tree structure from a directory
- * @param {string} dirPath - The absolute path to the directory to process
- * @param {string} [basePath] - The base path for generating relative paths (defaults to dirPath)
- * @returns {Tree} A tree structure representing the directory hierarchy
- * @throws Will throw an error if directory access fails
- *
- * @example
- * // Create a tree from a directory
- * const tree = buildDirectoryTree('/path/to/directory');
- *
- * // Structure of returned tree:
- * // {
- * //   id: '/path/to/directory',
- * //   label: 'directory',
- * //   children: [
- * //     { id: '/path/to/directory/file.txt', label: 'file.txt' },
- * //     { id: '/path/to/directory/subdir', label: 'subdir', children: [...] }
- * //   ]
- * // }
- */
-export declare function buildDirectoryTree(dirPath: string, basePath?: string): Tree;
-/**
- * Gets the parent directory path of a given directory path
- * Cross-platform compatible (Windows, macOS, Linux)
- * @param {string} dirPath - The path to get the parent directory from
- * @returns {string} The parent directory path
- *
- * @example
- * // On Unix-like systems (Mac/Linux)
- * getParentDirectory('/Users/documents/folder') // returns '/Users/documents'
- *
- * // On Windows
- * getParentDirectory('C:\\Users\\Documents\\folder') // returns 'C:\\Users\\Documents'
- *
- * // Works with both forward and backward slashes
- * getParentDirectory('C:/Users/Documents/folder') // returns 'C:/Users/Documents'
- */
-export declare function getParentDirectory(dirPath: string): string;
+export * from "./src/directory-tree.js";
+export * from "./src/path-utils.js";
+export * from "./src/srt-to-vtt/index.js";
+export * from "./src/ffmpeg/index.js";

package/lib/index.js

@@ -1,85 +1,8 @@
-import { readdirSync, statSync } from "node:fs";
-import { join, dirname, normalize } from "node:path";
-/**
- * Recursively builds a tree structure from a directory
- * @param {string} dirPath - The absolute path to the directory to process
- * @param {string} [basePath] - The base path for generating relative paths (defaults to dirPath)
- * @returns {Tree} A tree structure representing the directory hierarchy
- * @throws Will throw an error if directory access fails
- *
- * @example
- * // Create a tree from a directory
- * const tree = buildDirectoryTree('/path/to/directory');
- *
- * // Structure of returned tree:
- * // {
- * //   id: '/path/to/directory',
- * //   label: 'directory',
- * //   children: [
- * //     { id: '/path/to/directory/file.txt', label: 'file.txt' },
- * //     { id: '/path/to/directory/subdir', label: 'subdir', children: [...] }
- * //   ]
- * // }
- */
-export function buildDirectoryTree(dirPath, basePath = dirPath) {
-    const stats = statSync(dirPath);
-    const normalizedDirPath = dirPath.replace(/\\/g, '/');
-    const normalizedBasePath = basePath.replace(/\\/g, '/');
-    const relativePath = normalizedDirPath.replace(normalizedBasePath, "").replace(/^\//, "") || "/";
-    const fileName = normalizedDirPath.split("/").pop() || "/";
-    const tree = {
-        id: normalizedDirPath,
-        label: fileName,
-    };
-    if (stats.isDirectory()) {
-        try {
-            const items = readdirSync(dirPath);
-            if (items.length > 0) {
-                tree.children = items
-                    .map((item) => {
-                    const itemPath = join(dirPath, item);
-                    try {
-                        return buildDirectoryTree(itemPath, basePath);
-                    }
-                    catch (error) {
-                        console.error(`Error processing ${itemPath}:`, error);
-                        return null;
-                    }
-                })
-                    .filter((item) => item !== null);
-            }
-        }
-        catch (error) {
-            console.error(`Error reading directory ${dirPath}:`, error);
-        }
-    }
-    console.log("tree=", tree);
-    return tree;
-}
-// buildDirectoryTree(
-//   "/Users/xipingwang/Documents/EF-code/e1-ai-assistant-it-web/src",
-// );
-/**
- * Gets the parent directory path of a given directory path
- * Cross-platform compatible (Windows, macOS, Linux)
- * @param {string} dirPath - The path to get the parent directory from
- * @returns {string} The parent directory path
- *
- * @example
- * // On Unix-like systems (Mac/Linux)
- * getParentDirectory('/Users/documents/folder') // returns '/Users/documents'
- *
- * // On Windows
- * getParentDirectory('C:\\Users\\Documents\\folder') // returns 'C:\\Users\\Documents'
- *
- * // Works with both forward and backward slashes
- * getParentDirectory('C:/Users/Documents/folder') // returns 'C:/Users/Documents'
- */
-export function getParentDirectory(dirPath) {
-    // Normalize the path to handle different path formats
-    const normalizedPath = normalize(dirPath);
-    // Get the parent directory using dirname
-    const parentPath = dirname(normalizedPath);
-    // If we're already at the root, return the normalized root
-    return normalizedPath === parentPath ? parentPath : parentPath;
-}
+// 目录树相关功能
+export * from "./src/directory-tree.js";
+// 路径操作相关功能
+export * from "./src/path-utils.js";
+// SRT到VTT转换相关功能
+export * from "./src/srt-to-vtt/index.js";
+// FFmpeg相关功能
+export * from "./src/ffmpeg/index.js";

package/lib/src/directory-tree.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Represents a node in a directory tree structure
+ * @interface Tree
+ * @property {string} id - Unique identifier for the node (full path)
+ * @property {string} label - Display name of the file or directory
+ * @property {Tree[]} [children] - Optional array of child nodes for directories
+ */
+export interface Tree {
+    id: string;
+    label: string;
+    children?: Tree[];
+}
+/**
+ * Recursively builds a tree structure from a directory
+ * @param {string} dirPath - The absolute path to the directory to process
+ * @param {string} [basePath] - The base path for generating relative paths (defaults to dirPath)
+ * @returns {Tree} A tree structure representing the directory hierarchy
+ * @throws Will throw an error if directory access fails
+ *
+ * @example
+ * // Create a tree from a directory
+ * const tree = buildDirectoryTree('/path/to/directory');
+ *
+ * // Structure of returned tree:
+ * // {
+ * //   id: '/path/to/directory',
+ * //   label: 'directory',
+ * //   children: [
+ * //     { id: '/path/to/directory/file.txt', label: 'file.txt' },
+ * //     { id: '/path/to/directory/subdir', label: 'subdir', children: [...] }
+ * //   ]
+ * // }
+ */
+export declare function buildDirectoryTree(dirPath: string, basePath?: string): Tree;

package/lib/src/directory-tree.js

@@ -0,0 +1,58 @@
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Recursively builds a tree structure from a directory
+ * @param {string} dirPath - The absolute path to the directory to process
+ * @param {string} [basePath] - The base path for generating relative paths (defaults to dirPath)
+ * @returns {Tree} A tree structure representing the directory hierarchy
+ * @throws Will throw an error if directory access fails
+ *
+ * @example
+ * // Create a tree from a directory
+ * const tree = buildDirectoryTree('/path/to/directory');
+ *
+ * // Structure of returned tree:
+ * // {
+ * //   id: '/path/to/directory',
+ * //   label: 'directory',
+ * //   children: [
+ * //     { id: '/path/to/directory/file.txt', label: 'file.txt' },
+ * //     { id: '/path/to/directory/subdir', label: 'subdir', children: [...] }
+ * //   ]
+ * // }
+ */
+export function buildDirectoryTree(dirPath, basePath = dirPath) {
+    const stats = statSync(dirPath);
+    const normalizedDirPath = dirPath.replace(/\\/g, "/");
+    const normalizedBasePath = basePath.replace(/\\/g, "/");
+    const relativePath = normalizedDirPath.replace(normalizedBasePath, "").replace(/^\//, "") || "/";
+    const fileName = normalizedDirPath.split("/").pop() || "/";
+    const tree = {
+        id: normalizedDirPath,
+        label: fileName,
+    };
+    if (stats.isDirectory()) {
+        try {
+            const items = readdirSync(dirPath);
+            if (items.length > 0) {
+                tree.children = items
+                    .map((item) => {
+                    const itemPath = join(dirPath, item);
+                    try {
+                        return buildDirectoryTree(itemPath, basePath);
+                    }
+                    catch (error) {
+                        console.error(`Error processing ${itemPath}:`, error);
+                        return null;
+                    }
+                })
+                    .filter((item) => item !== null);
+            }
+        }
+        catch (error) {
+            console.error(`Error reading directory ${dirPath}:`, error);
+        }
+    }
+    console.log("tree=", tree);
+    return tree;
+}

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

@@ -0,0 +1,6 @@
+export declare function checkFFmpegAvailability(): boolean;
+/**
+ * 检查 ffprobe 是否可用
+ * @returns 是否可用
+ */
+export declare function isFfprobeAvailable(): boolean;

package/lib/src/ffmpeg/check.js

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

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

@@ -0,0 +1,29 @@
+/**
+ * 视频缩略图生成器
+ * 使用 ffmpeg 提取视频帧，使用 sharp 合成缩略图
+ */
+interface ThumbnailOptions {
+    frames?: number;
+    outputWidth?: number;
+    columns?: number;
+    outputFileName?: string;
+    quality?: number;
+    format?: 'avif' | 'webp' | 'jpeg' | 'png';
+    batchSize?: number;
+    maxConcurrency?: number;
+    tempDir?: string;
+}
+interface ProcessingResult {
+    buffer: Buffer;
+    outputPath: string;
+    metadata: {
+        frames: number;
+        duration: number;
+        outputSize: {
+            width: number;
+            height: number;
+        };
+    };
+}
+export declare const getThumbnail: (videoPath: string, options?: ThumbnailOptions) => Promise<ProcessingResult>;
+export {};

package/lib/src/ffmpeg/getThumbnail.js

@@ -0,0 +1,226 @@
+import * as shell from "shelljs";
+import Sharp from "sharp";
+import * as fs from "fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { checkFFmpegAvailability } from "./check.js";
+// 日志函数
+const log = (message, data) => {
+    console.log(`[ThumbnailGenerator] ${message}`, data ? JSON.stringify(data, null, 2) : '');
+};
+// 验证和清理路径
+function validateAndSanitizePath(inputPath) {
+    if (!inputPath || typeof inputPath !== 'string') {
+        throw new Error('Invalid path provided');
+    }
+    const resolvedPath = path.resolve(inputPath);
+    // 检查路径是否在允许的目录内
+    const cwd = process.cwd();
+    if (!resolvedPath.startsWith(cwd)) {
+        throw new Error('Path traversal attack detected');
+    }
+    return resolvedPath;
+}
+// 获取视频时长
+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 });
+    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;
+}
+// 并行提取视频帧
+async function extractFrames(videoPath, tempDir, frames, interval, maxConcurrency = 4) {
+    log('Starting frame extraction', { frames, interval, maxConcurrency });
+    const framePromises = Array.from({ length: frames - 1 }, (_, i) => {
+        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 });
+            if (result.code === 0) {
+                log(`Frame ${i + 1}/${frames - 1} extracted`, { time: t });
+                resolve();
+            }
+            else {
+                reject(new Error(`FFmpeg failed for frame ${i + 1}: ${result.stderr}`));
+            }
+        });
+    });
+    // 分批执行以控制并发数
+    for (let i = 0; i < framePromises.length; i += maxConcurrency) {
+        const batch = framePromises.slice(i, i + maxConcurrency);
+        await Promise.all(batch);
+    }
+}
+// 创建缩略图
+async function createThumbnail(frameFiles, tempDir, options) {
+    const { columns = 4, outputWidth = 3840, format = 'avif', quality = 80 } = options;
+    log('Creating thumbnail', { frameCount: frameFiles.length, columns, outputWidth });
+    // 计算尺寸
+    const rows = Math.ceil(frameFiles.length / columns);
+    const singleWidth = Math.floor(outputWidth / columns);
+    // 获取第一帧的元数据来计算宽高比
+    const firstFrame = await Sharp(path.join(tempDir, frameFiles[0])).metadata();
+    const aspectRatio = (firstFrame.width || 1) / (firstFrame.height || 1);
+    const singleHeight = Math.floor(singleWidth / aspectRatio);
+    log('Calculated dimensions', {
+        rows,
+        singleWidth,
+        singleHeight,
+        aspectRatio: aspectRatio.toFixed(2)
+    });
+    // 创建合成图像
+    const composite = Sharp({
+        create: {
+            width: singleWidth * columns,
+            height: singleHeight * rows,
+            channels: 3,
+            background: { r: 0, g: 0, b: 0 },
+        },
+    });
+    // 分批处理帧以避免内存问题
+    const batchSize = options.batchSize || 10;
+    const overlays = [];
+    for (let i = 0; i < frameFiles.length; i += batchSize) {
+        const batch = frameFiles.slice(i, i + batchSize);
+        const batchOverlays = await Promise.all(batch.map(async (file, batchIndex) => {
+            const index = i + batchIndex;
+            const row = Math.floor(index / columns);
+            const col = index % columns;
+            const resized = await Sharp(path.join(tempDir, file))
+                .resize(singleWidth, singleHeight, { fit: 'cover' })
+                .toBuffer();
+            return {
+                input: resized,
+                top: row * singleHeight,
+                left: col * singleWidth,
+            };
+        }));
+        overlays.push(...batchOverlays);
+        log(`Processed batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(frameFiles.length / batchSize)}`);
+    }
+    // 生成最终图像
+    let finalImage = composite.composite(overlays);
+    // 根据格式设置输出
+    switch (format) {
+        case 'avif':
+            finalImage = finalImage.avif({ quality });
+            break;
+        case 'webp':
+            finalImage = finalImage.webp({ quality });
+            break;
+        case 'jpeg':
+            finalImage = finalImage.jpeg({ quality });
+            break;
+        case 'png':
+            finalImage = finalImage.png({ quality });
+            break;
+        default:
+            finalImage = finalImage.avif({ quality });
+    }
+    return await finalImage.toBuffer();
+}
+// 临时目录管理
+async function withTempDir(fn, customTempDir) {
+    const tempDir = customTempDir || fs.mkdtempSync(path.join(os.tmpdir(), "video-thumbnails-"));
+    try {
+        return await fn(tempDir);
+    }
+    finally {
+        if (fs.existsSync(tempDir) && !customTempDir) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            log('Cleaned up temporary directory', { tempDir });
+        }
+    }
+}
+// 主函数
+export const getThumbnail = async (videoPath, options = {}) => {
+    const startTime = Date.now();
+    try {
+        // 输入验证
+        const validatedPath = validateAndSanitizePath(videoPath);
+        if (!fs.existsSync(validatedPath)) {
+            throw new Error(`Video file not found: ${validatedPath}`);
+        }
+        // 检查 ffmpeg 可用性
+        if (!checkFFmpegAvailability()) {
+            throw new Error('FFmpeg is not available. Please install FFmpeg first.');
+        }
+        // 参数设置和验证
+        const { frames = 60, outputWidth = 3840, columns = 4, outputFileName = "thumbnail.avif", quality = 80, format = 'avif', batchSize = 10, maxConcurrency = 4, tempDir: customTempDir } = options;
+        // 参数验证
+        if (frames <= 0 || outputWidth <= 0 || columns <= 0) {
+            throw new Error('Invalid parameters: frames, outputWidth, and columns must be positive');
+        }
+        if (quality < 1 || quality > 100) {
+            throw new Error('Quality must be between 1 and 100');
+        }
+        log('Starting thumbnail generation', {
+            videoPath: validatedPath,
+            options: { frames, outputWidth, columns, format, quality }
+        });
+        // 获取视频信息
+        const durationInSeconds = getDurationInSeconds(validatedPath);
+        const interval = durationInSeconds / frames;
+        log('Video analysis complete', { durationInSeconds, interval });
+        // 准备输出路径
+        const videoDir = path.dirname(validatedPath);
+        const fileNameWithoutExt = path.basename(validatedPath, path.extname(validatedPath));
+        const outputPath = path.join(videoDir, `${fileNameWithoutExt}_${outputFileName}`);
+        // 使用临时目录处理
+        const result = await withTempDir(async (tempDir) => {
+            // 提取帧
+            await extractFrames(validatedPath, tempDir, frames, interval, maxConcurrency);
+            // 获取所有帧文件并排序
+            const frameFiles = fs
+                .readdirSync(tempDir)
+                .filter((file) => file.startsWith("frame-"))
+                .sort((a, b) => {
+                const numA = parseFloat(a.match(/\d+/)?.[0] || "0");
+                const numB = parseFloat(b.match(/\d+/)?.[0] || "0");
+                return numA - numB;
+            });
+            if (frameFiles.length === 0) {
+                throw new Error('No frames were extracted from the video');
+            }
+            log('Frame extraction complete', { extractedFrames: frameFiles.length });
+            // 创建缩略图
+            const buffer = await createThumbnail(frameFiles, tempDir, options);
+            return buffer;
+        }, customTempDir);
+        // 保存文件
+        fs.writeFileSync(outputPath, result);
+        const processingTime = Date.now() - startTime;
+        log('Thumbnail generation complete', {
+            outputPath,
+            processingTime: `${processingTime}ms`,
+            fileSize: `${(result.length / 1024).toFixed(2)}KB`
+        });
+        // 获取输出图像元数据
+        const metadata = await Sharp(result).metadata();
+        return {
+            buffer: result,
+            outputPath,
+            metadata: {
+                frames,
+                duration: durationInSeconds,
+                outputSize: {
+                    width: metadata.width || 0,
+                    height: metadata.height || 0
+                }
+            }
+        };
+    }
+    catch (error) {
+        log('Thumbnail generation failed', {
+            error: error instanceof Error ? error.message : String(error),
+            videoPath
+        });
+        throw error;
+    }
+};

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

@@ -0,0 +1,49 @@
+export * from "./getThumbnail.js";
+export * from "./check.js";
+/**
+ * 获取视频信息的接口定义
+ */
+export interface VideoInfo {
+    /** 视频文件路径 */
+    path: string;
+    /** 视频时长（秒） */
+    duration: number;
+    /** 视频时长格式化字符串 */
+    durationFormatted: string;
+    /** 视频宽度 */
+    width: number;
+    /** 视频高度 */
+    height: number;
+    /** 视频编码格式 */
+    videoCodec: string;
+    /** 音频编码格式 */
+    audioCodec: string;
+    /** 视频比特率 */
+    bitrate: number;
+    /** 帧率 */
+    fps: number;
+    /** 文件大小（字节） */
+    fileSize: number;
+    /** 文件大小格式化字符串 */
+    fileSizeFormatted: string;
+    /** 原始 ffprobe 输出信息 */
+    rawInfo: string;
+}
+/**
+ * 获取视频信息（使用 ffprobe）
+ * @param videoPath 视频文件路径
+ * @returns 视频信息对象
+ */
+export declare function getVideoInfo(videoPath: string): VideoInfo;
+/**
+ * 批量获取视频信息
+ * @param videoPaths 视频文件路径数组
+ * @returns 视频信息对象数组
+ */
+export declare function getMultipleVideoInfo(videoPaths: string[]): VideoInfo[];
+/**
+ * 获取详细的视频信息（包含更多元数据）
+ * @param videoPath 视频文件路径
+ * @returns 详细的视频信息
+ */
+export declare function getDetailedVideoInfo(videoPath: string): any;

package/lib/src/ffmpeg/index.js

@@ -0,0 +1,111 @@
+import shell from "shelljs";
+export * from "./getThumbnail.js";
+export * from "./check.js";
+/**
+ * 获取视频信息（使用 ffprobe）
+ * @param videoPath 视频文件路径
+ * @returns 视频信息对象
+ */
+export function getVideoInfo(videoPath) {
+    // 检查文件是否存在
+    if (!shell.test("-f", videoPath)) {
+        throw new Error(`视频文件不存在: ${videoPath}`);
+    }
+    // 使用 ffprobe 获取 JSON 格式的视频信息
+    const result = shell.exec(`ffprobe -v quiet -print_format json -show_format -show_streams "${videoPath}"`, { silent: true });
+    if (result.code !== 0) {
+        throw new Error(`获取视频信息失败: ${result.stderr}`);
+    }
+    let probeData;
+    try {
+        probeData = JSON.parse(result.stdout);
+    }
+    catch (error) {
+        throw new Error(`解析 ffprobe 输出失败: ${error}`);
+    }
+    const info = {
+        path: videoPath,
+        rawInfo: JSON.stringify(probeData, null, 2),
+    };
+    // 从 format 信息中获取时长和文件大小
+    if (probeData.format) {
+        if (probeData.format.duration) {
+            info.duration = parseFloat(probeData.format.duration);
+            info.durationFormatted = formatDuration(info.duration);
+        }
+        if (probeData.format.size) {
+            info.fileSize = parseInt(probeData.format.size);
+            info.fileSizeFormatted = formatFileSize(info.fileSize);
+        }
+    }
+    // 从视频流中获取信息
+    const videoStream = probeData.streams?.find((stream) => stream.codec_type === "video");
+    if (videoStream) {
+        info.videoCodec = videoStream.codec_name || "unknown";
+        info.width = videoStream.width || 0;
+        info.height = videoStream.height || 0;
+        if (videoStream.r_frame_rate) {
+            const [num, den] = videoStream.r_frame_rate.split("/");
+            info.fps = parseInt(num) / parseInt(den);
+        }
+        if (videoStream.bit_rate) {
+            info.bitrate = parseInt(videoStream.bit_rate);
+        }
+    }
+    // 从音频流中获取信息
+    const audioStream = probeData.streams?.find((stream) => stream.codec_type === "audio");
+    if (audioStream) {
+        info.audioCodec = audioStream.codec_name || "unknown";
+    }
+    return info;
+}
+/**
+ * 格式化文件大小
+ * @param bytes 字节数
+ * @returns 格式化后的文件大小字符串
+ */
+function formatFileSize(bytes) {
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let size = bytes;
+    let unitIndex = 0;
+    while (size >= 1024 && unitIndex < units.length - 1) {
+        size /= 1024;
+        unitIndex++;
+    }
+    return `${size.toFixed(2)} ${units[unitIndex]}`;
+}
+/**
+ * 格式化时长
+ * @param seconds 秒数
+ * @returns 格式化后的时长字符串
+ */
+function formatDuration(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    const ms = Math.floor((seconds % 1) * 100);
+    return `${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}.${ms.toString().padStart(2, "0")}`;
+}
+/**
+ * 批量获取视频信息
+ * @param videoPaths 视频文件路径数组
+ * @returns 视频信息对象数组
+ */
+export function getMultipleVideoInfo(videoPaths) {
+    return videoPaths.map((path) => getVideoInfo(path));
+}
+/**
+ * 获取详细的视频信息（包含更多元数据）
+ * @param videoPath 视频文件路径
+ * @returns 详细的视频信息
+ */
+export function getDetailedVideoInfo(videoPath) {
+    if (!shell.test("-f", 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 });
+    if (result.code !== 0) {
+        throw new Error(`获取详细视频信息失败: ${result.stderr}`);
+    }
+    return JSON.parse(result.stdout);
+}

package/lib/src/path-utils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gets the parent directory path of a given directory path
+ * Cross-platform compatible (Windows, macOS, Linux)
+ * @param {string} dirPath - The path to get the parent directory from
+ * @returns {string} The parent directory path
+ *
+ * @example
+ * // On Unix-like systems (Mac/Linux)
+ * getParentDirectory('/Users/documents/folder') // returns '/Users/documents'
+ *
+ * // On Windows
+ * getParentDirectory('C:\\Users\\Documents\\folder') // returns 'C:\\Users\\Documents'
+ *
+ * // Works with both forward and backward slashes
+ * getParentDirectory('C:/Users/Documents/folder') // returns 'C:/Users/Documents'
+ */
+export declare function getParentDirectory(dirPath: string): string;

package/lib/src/path-utils.js

@@ -0,0 +1,25 @@
+import { dirname, normalize } from "node:path";
+/**
+ * Gets the parent directory path of a given directory path
+ * Cross-platform compatible (Windows, macOS, Linux)
+ * @param {string} dirPath - The path to get the parent directory from
+ * @returns {string} The parent directory path
+ *
+ * @example
+ * // On Unix-like systems (Mac/Linux)
+ * getParentDirectory('/Users/documents/folder') // returns '/Users/documents'
+ *
+ * // On Windows
+ * getParentDirectory('C:\\Users\\Documents\\folder') // returns 'C:\\Users\\Documents'
+ *
+ * // Works with both forward and backward slashes
+ * getParentDirectory('C:/Users/Documents/folder') // returns 'C:/Users/Documents'
+ */
+export function getParentDirectory(dirPath) {
+    // Normalize the path to handle different path formats
+    const normalizedPath = normalize(dirPath);
+    // Get the parent directory using dirname
+    const parentPath = dirname(normalizedPath);
+    // If we're already at the root, return the normalized root
+    return normalizedPath === parentPath ? parentPath : parentPath;
+}

package/lib/src/srt-to-vtt/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * 从文件读取SRT内容并转换为VTT格式
+ * @param srtFilePath SRT文件路径
+ * @returns 转换后的VTT内容字符串
+ */
+export declare function convertSrtFileToVtt(srtFilePath: string): string;
+/**
+ * 从文件读取SRT内容并转换为VTT格式，同时保存到文件
+ * @param srtFilePath SRT文件路径
+ * @param outputPath 输出VTT文件路径（可选，默认与SRT文件同目录）
+ * @returns 输出文件路径
+ */
+export declare function convertSrtFileToVttFile(srtFilePath: string, outputPath?: string): string;
+/**
+ * 批量转换SRT文件到VTT格式
+ * @param srtFilePaths SRT文件路径数组
+ * @param outputDir 输出目录（可选）
+ * @returns 转换结果数组
+ */
+export declare function batchConvertSrtToVtt(srtFilePaths: string[], outputDir?: string): Array<{
+    input: string;
+    output: string;
+    success: boolean;
+    error?: string;
+}>;
+/**
+ * 从字符串内容直接转换为VTT格式
+ * @param srtContent SRT内容字符串
+ * @returns VTT格式字符串
+ */
+export declare function convertSrtStringToVtt(srtContent: string): string;
+export { srtToVtt, validateSRT } from "@xiping/srt-to-vtt";
+export default convertSrtFileToVtt;

package/lib/src/srt-to-vtt/index.js

@@ -0,0 +1,115 @@
+import { srtToVtt, validateSRT } from "@xiping/srt-to-vtt";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join, extname, basename } from "path";
+/**
+ * 从文件读取SRT内容并转换为VTT格式
+ * @param srtFilePath SRT文件路径
+ * @returns 转换后的VTT内容字符串
+ */
+export function convertSrtFileToVtt(srtFilePath) {
+    try {
+        // 检查文件是否存在
+        if (!existsSync(srtFilePath)) {
+            throw new Error(`SRT文件不存在: ${srtFilePath}`);
+        }
+        // 检查文件扩展名
+        const ext = extname(srtFilePath).toLowerCase();
+        if (ext !== ".srt") {
+            throw new Error(`文件扩展名必须是.srt，当前为: ${ext}`);
+        }
+        // 读取SRT文件内容
+        const srtContent = readFileSync(srtFilePath, "utf-8");
+        // 验证SRT格式
+        if (!validateSRT(srtContent)) {
+            throw new Error("SRT文件格式无效");
+        }
+        // 转换为VTT格式
+        const vttContent = srtToVtt(srtContent);
+        return vttContent;
+    }
+    catch (error) {
+        throw new Error(`转换失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * 从文件读取SRT内容并转换为VTT格式，同时保存到文件
+ * @param srtFilePath SRT文件路径
+ * @param outputPath 输出VTT文件路径（可选，默认与SRT文件同目录）
+ * @returns 输出文件路径
+ */
+export function convertSrtFileToVttFile(srtFilePath, outputPath) {
+    try {
+        // 转换SRT到VTT
+        const vttContent = convertSrtFileToVtt(srtFilePath);
+        // 确定输出路径
+        let vttFilePath;
+        if (outputPath) {
+            vttFilePath = outputPath;
+        }
+        else {
+            // 默认输出到同目录，文件名相同但扩展名为.vtt
+            const dir = srtFilePath.substring(0, srtFilePath.lastIndexOf("/") + 1);
+            const baseName = basename(srtFilePath, ".srt");
+            vttFilePath = join(dir, `${baseName}.vtt`);
+        }
+        // 写入VTT文件
+        writeFileSync(vttFilePath, vttContent, "utf-8");
+        return vttFilePath;
+    }
+    catch (error) {
+        throw new Error(`文件转换失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * 批量转换SRT文件到VTT格式
+ * @param srtFilePaths SRT文件路径数组
+ * @param outputDir 输出目录（可选）
+ * @returns 转换结果数组
+ */
+export function batchConvertSrtToVtt(srtFilePaths, outputDir) {
+    const results = [];
+    for (const srtFilePath of srtFilePaths) {
+        try {
+            let outputPath;
+            if (outputDir) {
+                const baseName = basename(srtFilePath, ".srt");
+                outputPath = join(outputDir, `${baseName}.vtt`);
+            }
+            const vttFilePath = convertSrtFileToVttFile(srtFilePath, outputPath);
+            results.push({
+                input: srtFilePath,
+                output: vttFilePath,
+                success: true,
+            });
+        }
+        catch (error) {
+            results.push({
+                input: srtFilePath,
+                output: "",
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    return results;
+}
+/**
+ * 从字符串内容直接转换为VTT格式
+ * @param srtContent SRT内容字符串
+ * @returns VTT格式字符串
+ */
+export function convertSrtStringToVtt(srtContent) {
+    try {
+        if (!validateSRT(srtContent)) {
+            throw new Error("SRT内容格式无效");
+        }
+        return srtToVtt(srtContent);
+    }
+    catch (error) {
+        throw new Error(`转换失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// 重新导出原始包的功能
+export { srtToVtt, validateSRT } from "@xiping/srt-to-vtt";
+// 默认导出主转换函数
+export default convertSrtFileToVtt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiping/node-utils",
-  "version": "1.0.21",
+  "version": "1.0.36",
   "description": "node-utils",
   "type": "module",
   "author": "The-End-Hero <527409987@qq.com>",
@@ -25,11 +25,17 @@
   "bugs": {
     "url": "https://github.com/The-End-Hero/wang-ping/issues"
   },
-  "gitHead": "7c9ee2b2805466754ebc085097797db105ee2283",
+  "gitHead": "79ba6360ab08693c43b9d0cc3dace1e7baba0421",
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "dependencies": {
+    "@xiping/srt-to-vtt": "1.0.35",
+    "chalk": "^5.5.0",
+    "sharp": "^0.34.3",
+    "shelljs": "0.10.0"
+  },
   "devDependencies": {
     "@types/node": "^22.15.34",
     "tslib": "^2.8.1",