@zwa73/utils 1.0.91 → 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>;
@@ -434,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;
 }
 
 /**根据典型的成功或失败状态运行函数  
@@ -481,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)
@@ -504,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    - 验证目标
@@ -540,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"
-			]
-		}
-	}
-}