@zwa73/utils 1.0.14 → 1.0.16

package/src/UtilDecorators.ts

@@ -0,0 +1,59 @@
+/**用于打印方法的调用
+ * @returns {void}
+ */
+export function DLogger(){
+    return function (target:any, propertyKey:string, descriptor:PropertyDescriptor){
+        const originalMethod = descriptor.value;
+        descriptor.value = function(...args:any[]){
+            let result = originalMethod.apply(this, args);
+            console.log(`Call: ${propertyKey}(${args}) => ${result}`);
+            return result;
+        }
+    }
+}
+
+/**用于打印异步方法的调用
+ * @returns {void}
+ */
+export function DLoggerAsync(){
+    return function (target:any, propertyKey:string, descriptor:PropertyDescriptor){
+        const originalMethod = descriptor.value;
+        descriptor.value = async function(...args:any[]){
+            let result = await originalMethod.apply(this, args);
+            console.log(`Call: ${propertyKey}(${args}) => ${result}`);
+            return result;
+        }
+    }
+}
+
+/**用于捕获方法中的错误
+ * @returns {void}
+ */
+export function DCatchErrors() {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args: any[]) {
+            try {
+                originalMethod.apply(this, args);
+            } catch (err) {
+                console.log(`Error in method ${propertyKey}: ${err}`);
+            }
+        };
+    };
+}
+
+/**用于捕获异步方法中的错误
+ * @returns {void}
+ */
+export function DCatchErrorsAsync() {
+    return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
+        const originalMethod = descriptor.value;
+        descriptor.value = async function (...args: any[]) {
+            try {
+                await originalMethod.apply(this, args);
+            } catch (err) {
+                console.log(`Error in method ${propertyKey}: ${err}`);
+            }
+        };
+    };
+}

package/src/UtilFfmpegTools.ts

@@ -2,6 +2,7 @@ import { FfmpegCommand, FfprobeData } from "fluent-ffmpeg";
 import * as fluentFfmpeg from "fluent-ffmpeg";
 import * as path from "path";
 import * as fs from "fs";
+import { SList, SStream } from "./UtilClass";
 
 /**输入输出路径映射
  * 输入路径:输入路径
@@ -154,95 +155,70 @@ class SFfmpegTool {
 
     //多线程处理
     /**wav转ogg多线程
-     * @param {IOMap} iomap - 输入输出路径映射
+     * @param {IOMap} ioMap - 输入输出路径映射
      * @param {number} quality - 质量
      * @param {number} cpCount - 并发数
      */
-    static async wav2oggMP(iomap: IOMap, quality = 10, cpCount = 16) {
-        let cpList = MPClip(iomap, cpCount);
-        for (let cpMap of cpList) SFfmpegTool.wav2oggCP(cpMap, quality);
-    }
-    /**wav转ogg子线程
-     * @param {IOMap} iomap - 输入输出路径映射
-     * @param {number} quality - 质量
-     */
-    private static async wav2oggCP(iomap: IOMap, quality: number = 10) {
-        for (let inPath in iomap) {
-            let outpath = iomap[inPath];
-            console.log("正在处理:" + outpath);
-            await SFfmpegTool.wav2ogg(inPath, outpath, quality);
-        }
+    static async wav2oggMP(ioMap: IOMap, quality = 10, cpCount = 16) {
+        await new SList(Object.entries(ioMap))
+            .toSStream(cpCount)
+            .map(async ([inPath, outPath]) => {
+                console.log("正在处理:" + outPath);
+                await SFfmpegTool.wav2ogg(inPath, outPath, quality);
+            })
+            .appendOperations();
     }
     /**flac转ogg多线程
-     * @param {IOMap} iomap - 输入输出路径映射
+     * @param {IOMap} ioMap - 输入输出路径映射
      * @param {number} quality - 质量
      * @param {number} cpCount - 并发数
      */
     static async flac2oggMP(
-        iomap: IOMap,
+        ioMap: IOMap,
         quality: number = 10,
         cpCount: number = 16
     ) {
-        let cpList = MPClip(iomap, cpCount);
-        for (let cpMap of cpList) SFfmpegTool.flac2oggCP(cpMap, quality);
-    }
-    /**flac转ogg子线程
-     * @param {IOMap} iomap - 输入输出路径映射
-     * @param {number} quality - 质量
-     * @param {number} cpCount - 并发数
-     */
-    private static async flac2oggCP(iomap: IOMap, quality: number = 10) {
-        for (let inPath in iomap) {
-            let outpath = iomap[inPath];
-            console.log("正在处理:" + outpath);
-            await SFfmpegTool.flac2ogg(inPath, outpath, quality);
-        }
+        await new SList(Object.entries(ioMap))
+            .toSStream(cpCount)
+            .map(async ([inPath, outPath]) => {
+                console.log("正在处理:" + outPath);
+                await SFfmpegTool.flac2ogg(inPath, outPath, quality);
+            })
+            .appendOperations();
     }
     /**删除静音多线程
-     * @param {IOMap} iomap - 输入输出路径映射
+     * @param {IOMap} ioMap - 输入输出路径映射
      * @param {number} threshold - 静音阈值/dB
      * @param {number} silence - 保留静音时长
      */
     static async trimSilenceMP(
-        iomap: IOMap,
+        ioMap: IOMap,
         threshold: number = -50,
         silence: number = 0.2,
         cpCount: number = 16
     ) {
-        let cpList = MPClip(iomap, cpCount);
-        for (let cpMap of cpList)
-            SFfmpegTool.trimSilenceCP(cpMap, threshold, silence);
-    }
-    /**删除静音子线程
-     */
-    private static async trimSilenceCP(
-        iomap: IOMap,
-        threshold: number = -50,
-        silence: number = 0.2
-    ) {
-        for (let inPath in iomap) {
-            let outpath = iomap[inPath];
-            console.log("正在处理:" + outpath);
-            await SFfmpegTool.trimSilence(inPath, outpath, threshold, silence);
-        }
+        await new SList(Object.entries(ioMap))
+            .toSStream(cpCount)
+            .map(async ([inPath, outPath]) => {
+                console.log("正在处理:" + outPath);
+                await SFfmpegTool.trimSilence(inPath, outPath, threshold, silence);
+            })
+            .appendOperations();
     }
 
     /**重采样多线程
-     * @param {IOMap} iomap - 输入输出路径映射
+     * @param {IOMap} ioMap - 输入输出路径映射
      * @param {number} rate - 采样率
      * @param {number} cpCount - 并发数
      */
     static async resampleMP(ioMap: IOMap, rate: number = 22050, cpCount: number = 16) {
-        let cpList = MPClip(ioMap, cpCount);
-        for (let cpMap of cpList) SFfmpegTool.resampleCP(cpMap, rate);
-    }
-    /**重采样子线程*/
-    private static async resampleCP(ioMap: IOMap, rate: number = 22050) {
-        for (let inPath in ioMap) {
-            let outpath = ioMap[inPath];
-            console.log("正在处理:" + outpath);
-            await SFfmpegTool.resample(inPath, outpath, rate);
-        }
+        await new SList(Object.entries(ioMap))
+            .toSStream(cpCount)
+            .map(async ([inPath, outPath]) => {
+                console.log("正在处理:" + outPath);
+                await SFfmpegTool.resample(inPath, outPath, rate);
+            })
+            .appendOperations();
     }
 }
 

package/src/UtilFunctions.ts

@@ -1,39 +1,137 @@
-import * as fs from 'fs';
-import * as crypto from 'crypto';
-import * as path from 'path';
-import { JObject } from './UtilInterfaces';
+import * as fs from "fs";
+import * as crypto from "crypto";
+import * as path from "path";
+import { JObject } from "./UtilInterfaces";
 
-export function getTime():number{
-	return new Date().getTime();
+/**获取当前时间戳
+ * number ()
+ * @returns {number} 时间戳
+ */
+export function getTime(): number {
+    return new Date().getTime();
+}
+
+/**初始化对象的字段
+ * void (Object,string,any)
+ * @param {Record<string,T>} obj   - 所要初始化的对象
+ * @param {string} field 		   - 所要初始化的字段
+ * @param {T} defaultVal 		   - 默认值
+ * @returns {T} - 最终值
+ */
+export function initField<T>(
+    obj: Record<string, T>,
+    field: string,
+    defaultVal: T
+): T {
+    if (!(field in obj)) obj[field] = defaultVal;
+    return obj[field];
+}
+
+/**验证路径 文件或文件夹 是否存在 异步
+ * @param {string} filePath - 待验证的路径
+ * @returns {Promise<boolean>} - 是否存在
+ */
+export async function pathExists(filePath: string):Promise<boolean>{
+    try {
+        const stats = await fs.promises.stat(filePath);
+        await fs.promises.access(filePath);
+        return true;
+    } catch (e) {
+        return false;
+    }
+}
+
+/**验证路径 文件或文件夹 是否存在 同步
+ * @param {string} filePath - 待验证的路径
+ * @returns {boolean} - 是否存在
+ */
+export function pathExistsSync(filePath: string):boolean{
+    try {
+        fs.accessSync(filePath);
+        return true;
+    } catch (e) {
+        return false;
+    }
 }
 
-export function initField(obj:Record<string,any>,field:string,defaultVal:any):void{
-	if(!(field in obj))
-		obj[field] = defaultVal;
+/**创建路径 path.sep 结尾时创建文件夹 异步
+ * @param {string} filePath - 待创建的路径
+ * @returns {Promise<boolean>} - 是否成功创建
+ */
+export async function createPath(filePath: string):Promise<boolean>{
+    try{
+        if(filePath.endsWith(path.sep)){
+            await fs.promises.mkdir(filePath, {recursive: true});
+            return true;
+        }
+        await fs.promises.mkdir(path.dirname(filePath), {recursive: true});
+        await fs.promises.open(filePath, 'w');
+        return true;
+    }
+    catch(e){
+        console.log("createPath 错误");
+        console.log(e);
+        return false;
+    }
 }
 
-/**加载json文件
+/**创建路径 path.sep 结尾时创建文件夹 同步
+ * @param {string} filePath - 待创建的路径
+ * @returns {boolean} - 是否成功创建
+ */
+export function createPathSync(filePath: string):boolean{
+    try{
+        if(filePath.endsWith(path.sep)){
+            fs.mkdirSync(filePath, {recursive: true});
+            return true;
+        }
+        fs.mkdirSync(path.dirname(filePath), {recursive: true});
+        fs.openSync(filePath, 'w');
+        return true;
+    }
+    catch(e){
+        console.log("createPath 错误");
+        console.log(e);
+        return false;
+    }
+}
+
+/**加载json文件 同步
  * Object (string)
  * @param {string} filePath - 文件路径
  * @returns {JObject}
  */
-export function loadJSONFile(filePath:string):JObject{
-	if(filePath.indexOf(".json")==-1)
-        filePath += ".json";
-	// 判断文件路径是否存在
-	if (!fs.existsSync(filePath)) {
-		// 如果路径不存在，创建文件夹
-		try {
-			fs.mkdirSync(path.dirname(filePath), { recursive: true });
-		}catch(e){}
-		// 创建文件
-		fs.writeFileSync(filePath, '');
-	}
-    let str = fs.readFileSync(filePath) as any;
-	if(str=="" || str==null)
-		str = "{}";
+export function loadJSONFileSync(filePath: string): JObject {
+    if (path.extname(filePath) !== '.json') filePath += '.json';
+
+    let str = "";
+
+    // 判断文件路径是否存在
+    if(pathExistsSync(filePath))
+        str = fs.readFileSync(filePath, "utf-8");
+
+    if (str == "" || str == null) str = "{}";
     return JSON.parse(str);
 }
+/**加载json文件 异步
+ * Object (string)
+ * @async
+ * @param {string} filePath - 文件路径
+ * @returns {JObject}
+ */
+export async function loadJSONFile(filePath: string): Promise<JObject> {
+    if (path.extname(filePath) !== '.json') filePath += '.json';
+
+    let str = "";
+
+    // 判断文件路径是否存在
+    if(await pathExists(filePath))
+        str = await fs.promises.readFile(filePath, "utf-8");
+
+    if (str == "" || str == null) str = "{}";
+    return JSON.parse(str);
+}
+
 /**写入JSON文件
  * void (string,Object)
  * @async
@@ -41,43 +139,32 @@ export function loadJSONFile(filePath:string):JObject{
  * @param {JObject} obj 	    - 所要写入的JObject
  * @returns {Promise<void>}
  */
-export async function writeJSONFile(filePath:string, obj:JObject):Promise<void> {
-	let str = JSON.stringify(obj, null, "\t");
-	if (filePath.indexOf(".json") === -1) filePath += ".json";
-
-	// 判断文件路径是否存在
-	await new Promise((resolve, reject)=>{
-		fs.exists(filePath, (ex:boolean) => {
-			if(!ex){
-				try {
-					fs.mkdirSync(path.dirname(filePath), { recursive: true });
-				} catch (e) {
-					console.log("创建文件错误:"+e);
-				}
-			}
-			resolve(true);
-		});
-	})
-
-	return new Promise((resolve, reject) => {
-		fs.writeFile(filePath, str, function (err) {
-		if (err === null) {
-			console.log(`${filePath} writeJSONFile 成功`);
-			resolve();
-		} else {
-			console.log(`${filePath} writeJSONFile 错误`);
-			console.log(err);
-			reject(err);
-		}
-		});
-	});
+export async function writeJSONFile(
+    filePath: string,
+    obj: JObject
+): Promise<void> {
+    let str = JSON.stringify(obj, null, "\t");
+    if (path.extname(filePath) !== '.json') filePath += '.json';
+
+    // 判断文件路径是否存在 不存在则创建
+    if(!(await pathExists(filePath)))
+        await createPath(filePath);
+
+	// 写入文件
+    try {
+        await fs.promises.writeFile(filePath, str);
+        console.log(`${filePath} writeJSONFile 成功`);
+    } catch (err) {
+        console.log(`${filePath} writeJSONFile 错误`);
+        console.log(err);
+    }
 }
 /**生成一串uuid
  * string ()
  * @returns {string} uuid
  */
-export function genUUID(){
-	return crypto.randomBytes(16).toString('hex');
+export function genUUID() {
+    return crypto.randomBytes(16).toString("hex");
 }
 
 /**深克隆 序列化并反序列化
@@ -85,30 +172,30 @@ export function genUUID(){
  * @param {T} obj - 克隆目标
  * @returns {T}   克隆结果
  */
-export function deepClone<T>(obj:T):T{
-	return JSON.parse(JSON.stringify(obj));
+export function deepClone<T>(obj: T): T {
+    return JSON.parse(JSON.stringify(obj));
 }
 
 /**是否为安全的数字
  * @param {number} num - 所要检测的数字
  * @returns {boolean} 是否安全
  */
-export function isSafeNumber(num:number):boolean{
-	if(num === undefined || num==null || isNaN(num))
-		return false;
-	return true;
+export function isSafeNumber(num: number): boolean {
+    if (num === undefined || num == null || isNaN(num)) return false;
+    if(typeof num === 'number') return true;
+    return false;
 }
 
 /**等待 timeMs 毫秒
  * @param {number} timeMs - 等待的毫秒数
  * @returns {Promise<boolean>}
  */
-export function sleep(timeMs:number):Promise<boolean>{
-	return new Promise(function(resolve, rejecte){
-		let timer = setTimeout(function(){
-			resolve(true)
-		},timeMs);
-	});
+export function sleep(timeMs: number): Promise<boolean> {
+    return new Promise(function (resolve, rejecte) {
+        let timer = setTimeout(function () {
+            resolve(true);
+        }, timeMs);
+    });
 }
 
 /**搜索路径符合正则表达式的文件
@@ -122,17 +209,16 @@ export function fileSearch(folder: string, traitRegex: string) {
     let regex = new RegExp(traitRegex);
     for (let subFile of subFiles) {
         let subFilePath = path.join(folder, subFile);
-		subFilePath = subFilePath.replace(/\\/g,"/");
+        subFilePath = subFilePath.replace(/\\/g, "/");
         let stat = fs.lstatSync(subFilePath);
 
         //判断是否是文件夹，递归调用
         if (stat.isDirectory()) {
-            let subMap = fileSearch(path.join(subFilePath, "/"), traitRegex);
+            let subMap = fileSearch(path.join(subFilePath, path.sep), traitRegex);
             for (let key in subMap) outMap[key] = subMap[key];
             continue;
         }
-        if (regex.test(subFilePath))
-			outMap[subFile] = subFilePath;
+        if (regex.test(subFilePath)) outMap[subFile] = subFilePath;
     }
     return outMap;
 }

package/src/UtilInterfaces.ts

@@ -9,8 +9,6 @@ export type JObject = {
     [key:string]:JToken;
 }
 
-
-
 /**未知格式的Object*/
 export type AnyObject={
 	[key: string]:any;

package/src/index.ts

@@ -3,4 +3,5 @@ export * from './UtilInterfaces';
 export * from './UtilClass';
 export * from './UtilCom';
 export * from './UtilCodecs';
-export * from './UtilFfmpegTools';
+export * from './UtilFfmpegTools';
+export * from './UtilDecorators';

package/test.js

@@ -1,4 +1,4 @@
-let {SList,SHashMap,SEntry,SFfmpegTool} = require('./dist');
+let {SList,SHashMap,SEntry,SFfmpegTool,fileSearch} = require('./dist');
 
 let slist = new SList([1,2,3,3,4,5,6]);
 slist.each(val => console.log(val));
@@ -15,5 +15,14 @@ SFfmpegTool.setFfmpegPath("E:/系统工具/ffmpeg-master-latest-win64-gpl/bin/ff
 (async function(){
     let data = await SFfmpegTool.getAudioMetaData("input.wav");
     console.log(data);
+
+    let fileMap = fileSearch("F:/Sosarciel/SoulTide-Collection-VITS-TrainingSet/TrainingSet/Akaset/sliced_audio",'.*\\.wav');
+    let ioMap = {};
+    for(let key in fileMap){
+        let value = fileMap[key];
+        ioMap[value] = "./test/"+key;
+    }
+    //console.log(ioMap)
+    await SFfmpegTool.resampleMP(ioMap)
 }())