@zwa73/utils 1.0.90 → 1.0.93

package/src/UtilCodecs.ts

@@ -1,4 +1,4 @@
-import * as he from 'html-entities';
+import he from 'html-entities';
 import {get_encoding,Tiktoken} from 'tiktoken';
 
 
@@ -11,27 +11,11 @@ let encoderTurbo:Tiktoken|null = null;
 let encoderDavinci:Tiktoken|null = null;
 const textDecoder = new TextDecoder();
 
-// 定义一个对象，存储常见的HTML实体和对应的字符
-let htmlEntities:Record<string,string> = {
-    "&lt;": "<",
-    "&gt;": ">",
-    "&amp;": "&",
-    "&quot;": "\"",
-    "&#39;": "'",
-    "&#91;": "[",
-    "&#93;": "]"
-};
-
 /**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
  * @param str - 要转换的字符串
  * @returns 转换后的字符串
  */
 export function decodeHtmlEntities(str:string) {
-    //for(let code in htmlEntities){
-	//	let cha = htmlEntities[code]
-	//	str = str.replaceAll(code, cha);
-	//}
-	//return str
     return he.decode(str);
 }
 
@@ -40,15 +24,10 @@ export function decodeHtmlEntities(str:string) {
  * @returns 转换后的字符串
  */
 export function encodeHtmlEntities(str:string) {
-    //for(let code in htmlEntities){
-	//	let cha = htmlEntities[code]
-	//	str = str.replaceAll(cha, code);
-	//}
-	//return str
     return he.encode(str);
 }
 
-
+//#region LAM
 //token长度计算器
 //cl100k_base	ChatGPT models, text-embedding-ada-002
 //p50k_base	Code models, text-davinci-002, text-davinci-003
@@ -114,5 +93,5 @@ export function decodeTokenDavinci(arr:Uint32Array):string{
 	initTikTokenEncoder();
 	return textDecoder.decode(encoderDavinci?.decode(arr));
 }
-
+//#endregion
 }

package/src/UtilFP.ts

@@ -1,18 +1,21 @@
+import { Keyable, LiteralCheck } from "./UtilInterfaces";
+import { None } from "./UtilSymbol";
 
 /**常用函数式编程库 */
 export namespace UtilFP {
 
 /**柯里化函数类型 */
-type CurryFunc<T, PrevArgs extends unknown[] = []> = T extends (...args: infer Args) => infer Result
-? Args extends [infer Arg, ...infer RestArgs]
-    ? RestArgs extends []
-        ? (...args: [...PrevArgs, Arg]) => Result
-        : (...args: [...PrevArgs, Arg]) => CurryFunc<(...rest:RestArgs) => Result>
-        & CurryFunc<(...args: RestArgs) => Result, [...PrevArgs, Arg]>
-    : Args extends []
-        ? () => Result
-        : "CurryFunc错误 可选无法被识别" & Error
-: never;
+type CurryFunc<T, PrevArgs extends unknown[] = []> =
+T extends (...args: infer Args) => infer Result
+    ? Args extends [infer Arg, ...infer RestArgs]
+        ? RestArgs extends []
+            ? ((...args: [...PrevArgs, Arg]) => Result)
+            : ((...args: [...PrevArgs, Arg]) => CurryFunc<(...rest:RestArgs) => Result>)
+            & (CurryFunc<(...args: RestArgs) => Result, [...PrevArgs, Arg]>)
+        : Args extends []
+            ? () => Result
+            : "CurryFunc错误 默认参数可选无法被识别" & Error
+    : "CurryFunc错误 传入的并非函数" & Error;
 
 /**柯里化转换  
 * @param {T} fn - 将要转换的函数
@@ -76,15 +79,88 @@ export function pipe<T>(input: T, ...fs: ((arg: T) => T)[]): T {
 }
 
 
-/**将一个字段加入一个对象中，返回新类型 */
-export function bindTo<K extends string, T, B extends {} = {}>
-    (key:K,value:T,base?:B): B & Record<K,T>{
-    let out = base as any;
-    out = out??{};
-    out[key]=value;
-    return out;
+/**将一个字段加入一个对象中, 返回新类型 */
+//#region bind重载
+/**绑定一个键和一个值到一个基础对象上, 并返回一个新的对象  
+ * 新的对象包含了基础对象的所有属性, 以及一个新的属性,  
+ * 这个新的属性的键是`key`, 值是`value`  
+ * @template K  - 要添加到对象的键的类型 必须为字面量
+ * @template V  - 要添加到对象的值的类型
+ * @param key   - 要添加到对象的键 必须为字面量
+ * @param value - 要添加到对象的值
+ * @returns 一个函数, 这个函数接受一个基础对象,  
+ * 然后返回一个新的对象新的对象包含了基础对象的所有属性,  
+ * 以及一个新的属性, 这个新的属性的键是`key`, 值是`value`  
+ */
+export function bind<K extends Keyable, V>
+    (key: LiteralCheck<K>,value: V): <B extends {}>
+    (base?: B) => keyof B extends K
+        ? "Base中已有对应键"&Error
+        : {[P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;};
+/**绑定一个键到一个基础对象上,  
+ * 并返回一个新的对象新的对象包含了基础对象的所有属性,  
+ * 以及一个新的属性, 这个新的属性的键是`key`, 值是基础对象  
+ * @template K - 要添加到对象的键的类型 必须为字面量
+ * @param key  - 要添加到对象的键 必须为字面量
+ * @returns 一个函数, 这个函数接受一个基础对象,  
+ * 然后返回一个新的对象新的对象包含了基础对象的所有属性,  
+ * 以及一个新的属性, 这个新的属性的键是`key`, 值是基础对象
+ */
+export function bind<K extends Keyable>
+    (key: LiteralCheck<K>): <B extends {}>
+    (base?: B) => { [P in K]: B };
+/**绑定一个键和一个值到一个基础对象上, 并返回一个新的对象  
+ * 新的对象包含了基础对象的所有属性, 以及一个新的属性,  
+ * 这个新的属性的键是`key`, 值是`value`  
+ * @template K  - 要添加到对象的键的类型 必须为字面量
+ * @template V  - 要添加到对象的值的类型
+ * @template B  - 基础对象的类型
+ * @param key   - 要添加到对象的键 必须为字面量
+ * @param value - 要添加到对象的值
+ * @param base  - 基础对象
+ * @returns 完成绑定的基础对象
+ */
+export function bind<K extends Keyable, V, B extends {}>
+    (key: LiteralCheck<K>,value: V, base:B):keyof B extends K
+        ? "Base中已有对应键"&Error
+        : {[P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;};
+//#endregion
+export function bind
+    <K extends Keyable, V, B>(key: LiteralCheck<K>, value?: V, base?:B){
+    if(base !== undefined)
+        return { ...base, [key as Keyable]: value };
+    if(value ===undefined)
+        return <B>(base?: B) =>
+            ({[key as Keyable]:base});
+
+    return <B extends {}>
+        (base?: B):{
+            [P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;
+        } => base !== undefined
+            ? { ...base, [key as Keyable]: value }
+            : ({ [key as Keyable]: value } as any);
 }
 
+/**创建一个对对象的每个属性进行映射的函数
+ * @param func   - 映射函数, 接受一个属性值和它的键, 返回一个新的属性值
+ * @returns 一个函数, 这个函数接受一个对象, 然后返回一个新的对象新的对象的每个属性都是原始对象的属性经过映射函数处理后的结果
+ */
+export function map<VAL, OUT, KEY extends symbol|string = string>
+    (func:(input:VAL,k:KEY)=>OUT):
+    <OM extends Record<KEY,VAL>>
+    (input:OM)=>keyof OM extends KEY
+        ? {[P in keyof OM]:OUT}
+        : "map函数传入的键类型无法处理此对象"&Error{
+    return (input) => {
+        return Reflect
+            .ownKeys(input as Record<Keyable,unknown>)
+            .reduce((sum,curr)=>({ ...sum,
+                [curr] : func((input as any)[curr],curr as any)
+            }),{}) as any;
+    };
+}
+
+
 /**
 let asd = bindTo("sss",123,{abc:223});//?
 let sumvoid = ()=>10;
@@ -99,5 +175,11 @@ let sumz = sumCu(1,"b",3)(false);//?
 console.log(suma(2,true));
 console.log(sumb(true));
 console.log(sumc("s",3,false));
- */
+
+Reflect.ownKeys({[1]:1,[None]:2});//?
+let as = "ssa" as string;//?
+let asv = {"s":1};//?
+let a = map((v:number,k)=>v*21);//?
+let b = a({["ss"]:1})//?
+*/
 }

package/src/UtilFfmpegTools.ts

@@ -1,9 +1,9 @@
-import { FfmpegCommand, FfprobeData } from "fluent-ffmpeg";
-import * as fluentFfmpeg from "fluent-ffmpeg";
+import { FfprobeData } from "fluent-ffmpeg";
+import fluentFfmpeg from "fluent-ffmpeg";
 import * as path from "path";
 import * as fs from "fs";
-import { SList, SStream } from "@src/UtilClass";
 import { SLogger } from "@src/UtilLogger";
+import { Stream } from "./UtilClass";
 
 /**输入输出路径映射
  * 输入路径:输入路径
@@ -13,8 +13,7 @@ export type IOMap = { [key: string]: string };
 /**ffmpeg工具类
  */
 class SFfmpegTool {
-    /**静态构造函数
-     */
+    /**静态构造函数 */
     static init() {
         let ffmpegPath = process.env.FFMPEG_PATH;
         if(ffmpegPath!=null){
@@ -22,8 +21,7 @@ class SFfmpegTool {
             SFfmpegTool.setFfmpegPath(exepath);
         }
     }
-    /**设置ffmpeg路径
-     */
+    /**设置ffmpeg路径 */
     static setFfmpegPath(ffmpegPath: string) {
         fluentFfmpeg.setFfmpegPath(ffmpegPath);
     }
@@ -168,13 +166,12 @@ class SFfmpegTool {
      * @param cpCount - 并发数
      */
     static async wav2oggMP(ioMap: IOMap, quality = 10, cpCount = 16) {
-        await new SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
                 SLogger.info("SFfmpegTool.wav2oggMP 正在处理:" + outPath);
                 await SFfmpegTool.wav2ogg(inPath, outPath, quality);
             })
-            .appendOperations();
+            .append();
     }
     /**flac转ogg多线程
      * @param ioMap   - 输入输出路径映射
@@ -186,13 +183,12 @@ class SFfmpegTool {
         quality: number = 10,
         cpCount: number = 16
     ) {
-        await new SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
                 SLogger.info("SFfmpegTool.flac2oggMP 正在处理:" + outPath);
                 await SFfmpegTool.flac2ogg(inPath, outPath, quality);
             })
-            .appendOperations();
+            .append();
     }
     /**删除静音多线程
      * @param ioMap     - 输入输出路径映射
@@ -205,13 +201,12 @@ class SFfmpegTool {
         silence: number = 0.2,
         cpCount: number = 16
     ) {
-        await new SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
                 SLogger.info("SFfmpegTool.trimSilenceMP 正在处理:" + outPath);
                 await SFfmpegTool.trimSilence(inPath, outPath, threshold, silence);
             })
-            .appendOperations();
+            .append();
     }
 
     /**重采样多线程
@@ -220,13 +215,12 @@ class SFfmpegTool {
      * @param cpCount - 并发数
      */
     static async resampleMP(ioMap: IOMap, rate: number = 22050, cpCount: number = 16) {
-        await new SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
                 SLogger.info("SFfmpegTool.resampleMP 正在处理:" + outPath);
                 await SFfmpegTool.resample(inPath, outPath, rate);
             })
-            .appendOperations();
+            .append();
     }
 }
 SFfmpegTool.init();

package/src/UtilFunctions.ts

@@ -3,7 +3,7 @@ import { AnyFunc, ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObj
 import * as cp from "child_process";
 import { SLogger } from "@src/UtilLogger";
 import { Completed, Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Terminated, Timeout } from "./UtilSymbol";
-import { DeferAsync, LogTimeAsync } from "./UtilDecorators";
+import { Catch, DeferAsync, LogTimeAsync } from "./UtilDecorators";
 
 
 type SuccessOut<T> = Outcome<Success,T>;
@@ -356,30 +356,47 @@ static pendingMap:Record<Keyable,AnyFunc[]> = {};
  * @param task - 任务逻辑
  * @returns 处理结果
  */
-static async queueProc<T>(flag:Keyable,task:(()=>Promise<T>)):Promise<T> {
-    this.pendingMap[flag] = this.pendingMap[flag]??[];
-    const pending = this.pendingMap[flag];
-
-    //尝试解除下个任务的等待
-    const tryRes = () => {
-        const thispd = pending;
-        const resolve = thispd.shift();
-        if(resolve) resolve();
-    }
+static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T> {
+    // 如果当前标签的队列不存在，则创建一个新的队列
+    if (!this.pendingMap[flag]) this.pendingMap[flag] = [];
+
+    // 创建一个新的Promise，并保存resolve函数以便后续调用
+    let resolveFunc: (value: T | PromiseLike<T>) => void;
+    const promise = new Promise<T>((resolve) => {
+        resolveFunc = resolve;
+    });
 
-    //空时直接运行 非空时等待
-    if (pending.length <= 0)
-        pending.push(()=>tryRes());
-    else await new Promise((resolve) => pending.push(resolve));
-
-    try {
-        return await task();;
-    } catch(e){
-        SLogger.fatal(`queuePromise 出现错误`,e);
-        throw e;
-    }finally {
-        tryRes();
-    }
+    // 定义处理任务的函数
+    const processTask = async () => {
+        let result: T;
+        try {
+            // 执行任务并等待结果
+            result = await task();
+            // 使用保存的resolve函数来解决Promise
+            resolveFunc(result);
+        } catch (error) {
+            // 如果任务执行出错，记录错误日志
+            SLogger.warn(`queueProc 错误: `,error,`flag: ${String(flag)}`);
+        } finally {
+            // 无论任务是否成功，都从队列中移除当前任务
+            this.pendingMap[flag].shift();
+            // 如果队列中还有任务，执行下一个任务
+            if (this.pendingMap[flag].length > 0) {
+                this.pendingMap[flag][0]();
+            } else {
+                // 如果队列中没有任务，删除队列
+                delete this.pendingMap[flag];
+            }
+        }
+    };
+
+    // 将处理任务的函数添加到队列中
+    this.pendingMap[flag].push(processTask);
+    // 如果队列中只有当前任务，立即执行
+    if (this.pendingMap[flag].length === 1) processTask();
+
+    // 返回Promise，以便调用者可以等待任务完成
+    return promise;
 }
 /**队列获取目标的代办事件数  
  * @param flag - 队列标签
@@ -417,15 +434,13 @@ static matchProc<
     if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol'){
         if ((procObj as any)[t])
             return (procObj as any)[t](t);
-        SLogger.fatal(`matchProc 传入了一个预料之外的值: `,t);
-        throw None;
-    }
-    else{
-        if ((procObj as any)[t.status])
-            return (procObj as any)[t.status](t.status,(t as any).result);
-        SLogger.fatal(`matchProc 传入了一个预料之外的值: `,t);
-        throw None;
     }
+    else if ((procObj as any)[t.status])
+        return (procObj as any)[t.status](t.status,(t as any).result);
+
+    const err = new Error(`matchProc 传入了一个预料之外的值: ${String(t)}`);
+    SLogger.fatal(err);
+    throw err;
 }
 
 /**根据典型的成功或失败状态运行函数  
@@ -464,7 +479,7 @@ static isFailed<T>
 /**是成功的 */
 static isSuccess<T>
 (tg:T):T extends Matchable<SuccessLike>
-    ? true: MatchableFlag<T> extends Exclude<MatchableFlag<T>,SuccessLike>
+    ? true : MatchableFlag<T> extends Exclude<MatchableFlag<T>,SuccessLike>
         ? false : boolean{
     const test = (t:any)=>t === Success || t === Completed;
     if(tg!=null && typeof tg === 'object' && 'status' in tg)
@@ -487,6 +502,17 @@ static likeNone(t:unknown,strictLog=true):t is None{
     return t == null;
 }
 
+/**验证一个值是否为空  
+ * 为空则抛异  
+ * @param t      - 验证目标
+ * @param errLog - 异常信息
+ * @returns 排除None的原值
+ */
+static expect<T>(t:T,errLog?:string):Exclude<T,None>{
+    if(t===None) throw new Error(errLog);
+    return t as Exclude<T,None>;
+}
+
 /**验证一个变量的类型是否为 T
  * @template T - 验证类型
  * @param t    - 验证目标
@@ -523,4 +549,15 @@ static isSafeNumber(num: unknown): boolean {
     return false;
 }
 
+/**将一个字段加入一个对象中，将改变对象，返回新类型 */
+static bindTo<K extends Keyable, V, B extends {} = {}>
+    (key: LiteralCheck<K>,value: V, base?:B):keyof B extends K
+        ? "Base中已有对应键"&Error
+        : {[P in K | keyof B]: P extends K ? V : P extends keyof B ? B[P] : never;}{
+    let out = base as any;
+    out = out??{};
+    out[key]=value;
+    return out;
+}
+
 }

package/src/UtilInterfaces.ts

@@ -45,6 +45,11 @@ export type LiteralCheck<L> =
     ProperSubset<Record<any,any>, L> |
     null | undefined;
 
+/**返回将Mixin分配给Base的结果,相同字段时Mixin覆盖Base */
+export type AssignObject<Base extends {}, Mixin extends {}> = {
+    [P in keyof Mixin | keyof Base]: P extends keyof Mixin ? Mixin[P] : P extends keyof Base ? Base[P] : never;
+}
+
 /**转为可写的 */
 export type Writeable<T> = {
 	-readonly [P in keyof T]: T[P]

package/src/UtilLogger.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 import * as winston from 'winston';
-import * as DailyRotateFile from 'winston-daily-rotate-file';
+import DailyRotateFile from 'winston-daily-rotate-file';
 import {inspect} from 'util';
 
 
@@ -253,17 +253,16 @@ export class SLogger{
             let acc = 0;
             const maxAcc = 3;
 
-            let concat = function(num:number,sep:string,
-                formatText:string,resultText:string):void{
-                let hasResult = result.length>0;
-                let need = (hasResult || num>0) && (acc < maxAcc);
-                if(need){
-                    if(result.length>0) result+=sep;
-                    if(format.length>0) format+=sep;
-                    result += resultText;
-                    format += formatText;
-                    acc++;
-                }
+            const concat = (num:number,sep:string,
+                formatText:string,resultText:string): void => {
+                const hasResult = result.length>0;
+                const need = (hasResult || num>0) && (acc < maxAcc);
+                if(!need) return;
+                if(result.length>0) result+=sep;
+                if(format.length>0) format+=sep;
+                result += resultText;
+                format += formatText;
+                acc++;
             }
             concat(Days,':','dd',
                 `${Days.toString()}`);
@@ -285,7 +284,7 @@ export class SLogger{
         }
 
         if(level!==null)
-            this.log(level,flag+": "+out);
+            this.log(level,`${flag}: ${out}`);
         delete SLogger.timeTable[flag];
         return out;
     }
@@ -301,7 +300,7 @@ export class SLogger{
     }
     /**让名称为default的logger 产生一条对应等级的log 返回自身
      * @param level    - log等级
-     * @param messages -  log消息
+     * @param messages - log消息
      * @returns 自身
      */
     static log(level: LogLevel, ...messages:Array<any>):SLogger{

package/tsconfig.json

@@ -3,7 +3,9 @@
 	"allowJs": true,
     "strict": true,
     "target": "ES2022",
-    "module": "commonjs",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
     "outDir": "./dist",
     "declaration": true,
     "baseUrl": ".",

package/schema/TestType1.schema.json

@@ -1,4 +0,0 @@
-{
-	"$schema": "http://json-schema.org/draft-07/schema#",
-	"$ref": "schemas.json#/definitions/TestType1"
-}

package/schema/TestType2.schema.json

@@ -1,4 +0,0 @@
-{
-	"$schema": "http://json-schema.org/draft-07/schema#",
-	"$ref": "schemas.json#/definitions/TestType2"
-}

package/schema/schemas.json

@@ -1,35 +0,0 @@
-{
-	"$schema": "http://json-schema.org/draft-07/schema#",
-	"definitions": {
-		"TestType2": {
-			"type": "object",
-			"properties": {
-				"a": {
-					"type": "string"
-				},
-				"b": {
-					"type": "number"
-				}
-			},
-			"required": [
-				"a",
-				"b"
-			]
-		},
-		"TestType1": {
-			"type": "object",
-			"properties": {
-				"a": {
-					"type": "string"
-				},
-				"b": {
-					"type": "number"
-				}
-			},
-			"required": [
-				"a",
-				"b"
-			]
-		}
-	}
-}