@zwa73/utils 1.0.187 → 1.0.189

package/dist/UtilFfmpegTools.d.ts

@@ -53,6 +53,10 @@ declare class SFfmpegTool {
      * @param outputWavPath - 输出wav文件路径
      */
     static resample(inputWavPath: string, outputWavPath: string, rate?: number): Promise<boolean>;
+    /**检查WAV文件是否为单声道
+     * @param filePath - 要检查的WAV文件路径
+     */
+    static isMono(filePath: string): Promise<boolean>;
     /**wav转ogg多线程
      * @param ioMap   - 输入输出路径映射
      * @param quality - 质量

package/dist/UtilFfmpegTools.js

@@ -32,6 +32,7 @@ const pathe_1 = __importDefault(require("pathe"));
 const fs = __importStar(require("fs"));
 const UtilLogger_1 = require("./UtilLogger");
 const UtilClass_1 = require("./UtilClass");
+const QuickFunction_1 = require("./QuickFunction");
 /**ffmpeg工具类
  */
 class SFfmpegTool {
@@ -73,13 +74,7 @@ class SFfmpegTool {
         const wavPath = pathe_1.default.join(pathe_1.default.dirname(inputFlacFile), `tmp_${pathe_1.default.basename(inputFlacFile, ".flac")}.wav`);
         await SFfmpegTool.flac2wav(inputFlacFile, wavPath);
         await SFfmpegTool.wav2ogg(wavPath, outputOggPath, quality);
-        await new Promise((resolve, reject) => {
-            fs.unlink(wavPath, function (err) {
-                if (err)
-                    UtilLogger_1.SLogger.error("SFfmpegTool.flac2ogg unlink 错误", err);
-                resolve(null);
-            });
-        });
+        await fs.promises.unlink(wavPath);
         return true;
     }
     /**flac转wav
@@ -192,6 +187,19 @@ class SFfmpegTool {
             });
         });
     }
+    /**检查WAV文件是否为单声道
+     * @param filePath - 要检查的WAV文件路径
+     */
+    static async isMono(filePath) {
+        const metadata = await SFfmpegTool.getAudioMetaData(filePath);
+        if (metadata == null)
+            (0, QuickFunction_1.throwError)("SFfmpegTool.isMono 获取音频元数据失败");
+        // 检查音频流的声道数
+        const audioStream = metadata.streams.find(stream => stream.codec_type === 'audio');
+        if (audioStream == null)
+            (0, QuickFunction_1.throwError)("SFfmpegTool.isMono 未找到音频流");
+        return audioStream.channels === 1;
+    }
     //多线程处理
     /**wav转ogg多线程
      * @param ioMap   - 输入输出路径映射

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends } from "./UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment } from "./UtilInterfaces";
 import { LogLevel } from "./UtilLogger";
 import { Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Timeout } from "./UtilSymbol";
 declare const HashMethodList: readonly ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "blake3"];
@@ -303,5 +303,13 @@ export declare class UtilFunc {
      * @returns 返回一个新的函数，这个函数在调用时会尝试从缓存中获取结果，如果缓存不存在或已过期，就会调用原函数并缓存其结果。
      */
     static memoize<T extends (...args: any[]) => any>(fn: T, expiry?: number): T extends (...args: infer In) => any ? AllExtends<In, JToken> extends true ? T : never : never;
+    /**将hh:mm:ss,ms格式转换为毫秒 */
+    static parseSrtTime(time: string): number;
+    /**将毫秒转换为hh:mm:ss,ms格式 */
+    static formatSrtTime(milliseconds: number): string;
+    /**解析srt文本为SrtSegment[] */
+    static parseSrt(srtText: string): SrtSegment[];
+    /**转换json为srt文本 */
+    static createSrt(segments: SrtSegment[]): string;
 }
 export {};

package/dist/UtilFunctions.js

@@ -188,7 +188,7 @@ class UtilFunc {
             //根据最大重试次数限制进行循环
             for (let i = 0; i < count;) {
                 if (i > 0 && opt.tryDelay)
-                    await this.sleep(opt.tryDelay);
+                    await UtilFunc.sleep(opt.tryDelay);
                 UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
                 //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {
@@ -396,11 +396,12 @@ class UtilFunc {
      */
     static queueProc(flag, task) {
         // 如果当前标签的队列不存在，则创建一个新的队列
-        if (!this.pendingMap[flag])
-            this.pendingMap[flag] = [];
+        if (!UtilFunc.pendingMap[flag])
+            UtilFunc.pendingMap[flag] = [];
         // 创建一个新的Promise，并保存resolve函数以便后续调用
         let resolveFunc;
-        const promise = new Promise((resolve) => {
+        let rejectFunc;
+        const promise = new Promise((resolve, reject) => {
             resolveFunc = resolve;
         });
         // 定义处理任务的函数
@@ -414,25 +415,26 @@ class UtilFunc {
             }
             catch (error) {
                 // 如果任务执行出错，记录错误日志
-                UtilLogger_1.SLogger.warn(`queueProc 错误: `, error, `flag: ${String(flag)}`);
+                UtilLogger_1.SLogger.warn(`queueProc 错误 flag: ${String(flag)} 已抛出`);
+                rejectFunc(error);
             }
             finally {
                 // 无论任务是否成功，都从队列中移除当前任务
-                this.pendingMap[flag].shift();
+                UtilFunc.pendingMap[flag].shift();
                 // 如果队列中还有任务，执行下一个任务
-                if (this.pendingMap[flag].length > 0) {
-                    this.pendingMap[flag][0]();
+                if (UtilFunc.pendingMap[flag].length > 0) {
+                    UtilFunc.pendingMap[flag][0]();
                 }
                 else {
                     // 如果队列中没有任务，删除队列
-                    delete this.pendingMap[flag];
+                    delete UtilFunc.pendingMap[flag];
                 }
             }
         };
         // 将处理任务的函数添加到队列中
-        this.pendingMap[flag].push(processTask);
+        UtilFunc.pendingMap[flag].push(processTask);
         // 如果队列中只有当前任务，立即执行
-        if (this.pendingMap[flag].length === 1)
+        if (UtilFunc.pendingMap[flag].length === 1)
             processTask();
         // 返回Promise，以便调用者可以等待任务完成
         return promise;
@@ -441,7 +443,7 @@ class UtilFunc {
      * @param flag - 队列标签
      */
     static queueLength(flag) {
-        const pd = this.pendingMap[flag];
+        const pd = UtilFunc.pendingMap[flag];
         return pd != null ? pd.length : 0;
     }
     /**创建一个Outcome */
@@ -724,6 +726,49 @@ class UtilFunc {
             return result;
         });
     }
+    /**将hh:mm:ss,ms格式转换为毫秒 */
+    static parseSrtTime(time) {
+        const [hours, minutes, seconds] = time.split(':');
+        const [secs, milliseconds] = seconds.split(',');
+        return parseInt(hours) * 3600000 +
+            parseInt(minutes) * 60000 +
+            parseInt(secs) * 1000 +
+            parseInt(milliseconds);
+    }
+    /**将毫秒转换为hh:mm:ss,ms格式 */
+    static formatSrtTime(milliseconds) {
+        const hours = Math.floor(milliseconds / 3_600_000);
+        const minutes = Math.floor((milliseconds % 3_600_000) / 60_000);
+        const seconds = Math.floor((milliseconds % 60_000) / 1000);
+        const ms = Math.floor(milliseconds % 1000);
+        return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')},${String(ms).padStart(3, '0')}`;
+    }
+    /**解析srt文本为SrtSegment[] */
+    static parseSrt(srtText) {
+        const segments = [];
+        const srtLines = srtText.split('\n');
+        let index = 0;
+        while (index < srtLines.length) {
+            const id = srtLines[index++].trim();
+            if (!id)
+                continue;
+            const timeRange = srtLines[index++].trim();
+            const [start, end] = timeRange.split(' --> ')
+                .map(time => UtilFunc.parseSrtTime(time));
+            let text = '';
+            while (index < srtLines.length && srtLines[index].trim())
+                text += `${srtLines[index++]}\n`;
+            index++;
+            segments.push({ start, end, text: text.trim() });
+        }
+        return segments;
+    }
+    /**转换json为srt文本 */
+    static createSrt(segments) {
+        return segments.map((segment, index) => {
+            return `${index + 1}\n${UtilFunc.formatSrtTime(segment.start)} --> ${UtilFunc.formatSrtTime(segment.end)}\n${segment.text}\n`;
+        }).join('\n');
+    }
 }
 exports.UtilFunc = UtilFunc;
 __decorate([

package/dist/UtilInterfaces.d.ts

@@ -166,4 +166,13 @@ export type CmtTuple<T extends {
 }, Tuple extends unknown[] = []> = unknown extends T[Tuple['length']] ? T & Tuple : CmtTuple<T, [...Tuple, T[Tuple['length']]]>;
 /**非严格模式下将会判断为false的值, 不包含NaN */
 export type Flasy = false | 0 | -0 | "" | null | undefined;
+/**srt段 */
+export type SrtSegment = {
+    /**开始时间, 以毫秒为单位 */
+    start: number;
+    /**结束时间, 以毫秒为单位 */
+    end: number;
+    /**字幕文本 */
+    text: string;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.187",
+	"version": "1.0.189",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {

package/src/UtilFfmpegTools.ts

@@ -4,6 +4,7 @@ import path from "pathe";
 import * as fs from "fs";
 import { SLogger } from "@/src/UtilLogger";
 import { Stream } from "./UtilClass";
+import { throwError } from "./QuickFunction";
 
 /**输入输出路径映射
  * 输入路径:输入路径
@@ -59,12 +60,7 @@ class SFfmpegTool {
         );
         await SFfmpegTool.flac2wav(inputFlacFile, wavPath);
         await SFfmpegTool.wav2ogg(wavPath, outputOggPath, quality);
-        await new Promise((resolve, reject) => {
-            fs.unlink(wavPath, function (err) {
-                if (err) SLogger.error("SFfmpegTool.flac2ogg unlink 错误",err);
-                resolve(null);
-            });
-        });
+        await fs.promises.unlink(wavPath);
         return true;
     }
 
@@ -202,6 +198,18 @@ class SFfmpegTool {
         });
     }
 
+    /**检查WAV文件是否为单声道
+     * @param filePath - 要检查的WAV文件路径
+     */
+    static async isMono(filePath: string): Promise<boolean> {
+        const metadata = await SFfmpegTool.getAudioMetaData(filePath);
+        if (metadata==null) throwError("SFfmpegTool.isMono 获取音频元数据失败");
+        // 检查音频流的声道数
+        const audioStream = metadata!.streams.find(stream => stream.codec_type === 'audio');
+        if (audioStream==null) throwError("SFfmpegTool.isMono 未找到音频流");
+        return audioStream!.channels === 1;
+    }
+
     //多线程处理
     /**wav转ogg多线程
      * @param ioMap   - 输入输出路径映射

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends } from "@/src/UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqStat, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment } from "@/src/UtilInterfaces";
 import * as cp from "child_process";
 import { LogLevel, SLogger } from "@/src/UtilLogger";
 import { Completed, Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
@@ -249,7 +249,7 @@ Promise<RepeatPromiseResult<T>>{
     try{
         //根据最大重试次数限制进行循环
         for(let i=0;i<count;){
-            if(i>0 && opt.tryDelay) await this.sleep(opt.tryDelay);
+            if(i>0 && opt.tryDelay) await UtilFunc.sleep(opt.tryDelay);
             SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
@@ -468,11 +468,12 @@ static pendingMap:Record<Keyable,AnyFunc[]> = {};
  */
 static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
     // 如果当前标签的队列不存在，则创建一个新的队列
-    if (!this.pendingMap[flag]) this.pendingMap[flag] = [];
+    if (!UtilFunc.pendingMap[flag]) UtilFunc.pendingMap[flag] = [];
 
     // 创建一个新的Promise，并保存resolve函数以便后续调用
     let resolveFunc: (value: T | PromiseLike<T>) => void;
-    const promise = new Promise<T>((resolve) => {
+    let rejectFunc: (value: any | PromiseLike<any>) => void;
+    const promise = new Promise<T>((resolve,reject) => {
         resolveFunc = resolve;
     });
 
@@ -486,24 +487,25 @@ static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
             resolveFunc(result);
         } catch (error) {
             // 如果任务执行出错，记录错误日志
-            SLogger.warn(`queueProc 错误: `,error,`flag: ${String(flag)}`);
+            SLogger.warn(`queueProc 错误 flag: ${String(flag)} 已抛出`);
+            rejectFunc(error);
         } finally {
             // 无论任务是否成功，都从队列中移除当前任务
-            this.pendingMap[flag].shift();
+            UtilFunc.pendingMap[flag].shift();
             // 如果队列中还有任务，执行下一个任务
-            if (this.pendingMap[flag].length > 0) {
-                this.pendingMap[flag][0]();
+            if (UtilFunc.pendingMap[flag].length > 0) {
+                UtilFunc.pendingMap[flag][0]();
             } else {
                 // 如果队列中没有任务，删除队列
-                delete this.pendingMap[flag];
+                delete UtilFunc.pendingMap[flag];
             }
         }
     };
 
     // 将处理任务的函数添加到队列中
-    this.pendingMap[flag].push(processTask);
+    UtilFunc.pendingMap[flag].push(processTask);
     // 如果队列中只有当前任务，立即执行
-    if (this.pendingMap[flag].length === 1) processTask();
+    if (UtilFunc.pendingMap[flag].length === 1) processTask();
 
     // 返回Promise，以便调用者可以等待任务完成
     return promise;
@@ -512,7 +514,7 @@ static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
  * @param flag - 队列标签
  */
 static queueLength(flag:Keyable){
-    const pd = this.pendingMap[flag]
+    const pd = UtilFunc.pendingMap[flag]
     return pd!=null ? pd.length : 0;
 }
 
@@ -855,4 +857,55 @@ static memoize<T extends (...args:any[])=>any> (fn: T, expiry = Infinity):
 }
 
 
+
+/**将hh:mm:ss,ms格式转换为毫秒 */
+static parseSrtTime(time: string): number {
+    const [hours, minutes, seconds] = time.split(':');
+    const [secs, milliseconds] = seconds.split(',');
+
+    return parseInt(hours) * 3600000 +
+        parseInt(minutes) * 60000 +
+        parseInt(secs) * 1000 +
+        parseInt(milliseconds);
+}
+/**将毫秒转换为hh:mm:ss,ms格式 */
+static formatSrtTime(milliseconds: number): string {
+    const hours = Math.floor(milliseconds / 3_600_000);
+    const minutes = Math.floor((milliseconds % 3_600_000) / 60_000);
+    const seconds = Math.floor((milliseconds % 60_000) / 1000);
+    const ms = Math.floor(milliseconds % 1000);
+
+    return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}:${String(seconds).padStart(2, '0')},${String(ms).padStart(3, '0')}`;
+}
+/**解析srt文本为SrtSegment[] */
+static parseSrt(srtText: string): SrtSegment[] {
+    const segments: SrtSegment[] = [];
+    const srtLines = srtText.split('\n');
+
+    let index = 0;
+    while (index < srtLines.length) {
+        const id = srtLines[index++].trim();
+        if (!id) continue;
+
+        const timeRange = srtLines[index++].trim();
+        const [start, end] = timeRange.split(' --> ')
+            .map(time => UtilFunc.parseSrtTime(time));
+
+        let text = '';
+        while (index < srtLines.length && srtLines[index].trim())
+            text += `${srtLines[index++]}\n`;
+        index++;
+
+        segments.push({ start, end, text: text.trim() });
+    }
+
+    return segments;
+}
+/**转换json为srt文本 */
+static createSrt(segments: SrtSegment[]): string {
+    return segments.map((segment, index) => {
+        return `${index + 1}\n${UtilFunc.formatSrtTime(segment.start)} --> ${UtilFunc.formatSrtTime(segment.end)}\n${segment.text}\n`;
+    }).join('\n');
+}
+
 }

package/src/UtilInterfaces.ts

@@ -250,4 +250,15 @@ export type CmtTuple<T extends {[K:number]:unknown},Tuple extends unknown[]=[]>
         : CmtTuple<T,[...Tuple,T[Tuple['length']]]>;
 
 /**非严格模式下将会判断为false的值, 不包含NaN */
-export type Flasy = false | 0 | -0 | "" | null | undefined;
+export type Flasy = false | 0 | -0 | "" | null | undefined;
+
+
+/**srt段 */
+export type SrtSegment = {
+    /**开始时间, 以毫秒为单位 */
+    start: number;
+    /**结束时间, 以毫秒为单位 */
+    end  : number;
+    /**字幕文本 */
+    text : string;
+};