@zwa73/utils 1.0.90 → 1.0.93

package/dist/UtilCodecs.js

@@ -1,7 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilCodec = void 0;
-const he = require("html-entities");
+const html_entities_1 = __importDefault(require("html-entities"));
 const tiktoken_1 = require("tiktoken");
 /**编码/解码器 */
 var UtilCodec;
@@ -9,27 +12,12 @@ var UtilCodec;
     let encoderTurbo = null;
     let encoderDavinci = null;
     const textDecoder = new TextDecoder();
-    // 定义一个对象，存储常见的HTML实体和对应的字符
-    let htmlEntities = {
-        "&lt;": "<",
-        "&gt;": ">",
-        "&amp;": "&",
-        "&quot;": "\"",
-        "&#39;": "'",
-        "&#91;": "[",
-        "&#93;": "]"
-    };
     /**HTML实体解码 将一个字符串中的HTML实体转换为对应的字符
      * @param str - 要转换的字符串
      * @returns 转换后的字符串
      */
     function decodeHtmlEntities(str) {
-        //for(let code in htmlEntities){
-        //	let cha = htmlEntities[code]
-        //	str = str.replaceAll(code, cha);
-        //}
-        //return str
-        return he.decode(str);
+        return html_entities_1.default.decode(str);
     }
     UtilCodec.decodeHtmlEntities = decodeHtmlEntities;
     /**HTML实体编码 将一个字符串中的 需编码字符转换为 HTML实体
@@ -37,14 +25,10 @@ var UtilCodec;
      * @returns 转换后的字符串
      */
     function encodeHtmlEntities(str) {
-        //for(let code in htmlEntities){
-        //	let cha = htmlEntities[code]
-        //	str = str.replaceAll(cha, code);
-        //}
-        //return str
-        return he.encode(str);
+        return html_entities_1.default.encode(str);
     }
     UtilCodec.encodeHtmlEntities = encodeHtmlEntities;
+    //#region LAM
     //token长度计算器
     //cl100k_base	ChatGPT models, text-embedding-ada-002
     //p50k_base	Code models, text-davinci-002, text-davinci-003
@@ -111,4 +95,5 @@ var UtilCodec;
         return textDecoder.decode(encoderDavinci?.decode(arr));
     }
     UtilCodec.decodeTokenDavinci = decodeTokenDavinci;
+    //#endregion
 })(UtilCodec || (exports.UtilCodec = UtilCodec = {}));

package/dist/UtilCom.js

@@ -1,8 +1,31 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilCom = void 0;
-const https = require("https");
-const http = require("http");
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
 const UtilLogger_1 = require("./UtilLogger");
 const UtilFunctions_1 = require("./UtilFunctions");
 /**网络工具 */

package/dist/UtilFP.d.ts

@@ -1,7 +1,8 @@
+import { Keyable, LiteralCheck } from "./UtilInterfaces";
 /**常用函数式编程库 */
 export declare 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 - 将要转换的函数
     * @returns {CurryFunc<T>} 柯里化的函数
@@ -40,7 +41,53 @@ export declare namespace UtilFP {
     export function pipe<I, R1, R2, R3, R4, R5, R6, R7>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, ...fs: CompFunc<R7, R7>[]): R7;
     export function pipe<I, R1, R2, R3, R4, R5, R6, R7, R8>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, f8: CompFunc<R7, R8>, ...fs: CompFunc<R8, R8>[]): R8;
     export function pipe<I, R1, R2, R3, R4, R5, R6, R7, R8, R9>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>, f3: CompFunc<R2, R3>, f4: CompFunc<R3, R4>, f5: CompFunc<R4, R5>, f6: CompFunc<R5, R6>, f7: CompFunc<R6, R7>, f8: CompFunc<R7, R8>, f9: CompFunc<R8, R9>, ...fs: CompFunc<R9, R9>[]): R9;
-    /**将一个字段加入一个对象中，返回新类型 */
-    export function bindTo<K extends string, T, B extends {} = {}>(key: K, value: T, base?: B): B & Record<K, T>;
+    /**将一个字段加入一个对象中, 返回新类型 */
+    /**绑定一个键和一个值到一个基础对象上, 并返回一个新的对象
+     * 新的对象包含了基础对象的所有属性, 以及一个新的属性,
+     * 这个新的属性的键是`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;
+    };
+    /**创建一个对对象的每个属性进行映射的函数
+     * @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;
     export {};
 }

package/dist/UtilFP.js

@@ -28,14 +28,31 @@ var UtilFP;
         return fs.reduce((value, func) => func(value), input);
     }
     UtilFP.pipe = pipe;
-    /**将一个字段加入一个对象中，返回新类型 */
-    function bindTo(key, value, base) {
-        let out = base;
-        out = out ?? {};
-        out[key] = value;
-        return out;
+    //#endregion
+    function bind(key, value, base) {
+        if (base !== undefined)
+            return { ...base, [key]: value };
+        if (value === undefined)
+            return (base) => ({ [key]: base });
+        return (base) => base !== undefined
+            ? { ...base, [key]: value }
+            : { [key]: value };
+    }
+    UtilFP.bind = bind;
+    /**创建一个对对象的每个属性进行映射的函数
+     * @param func   - 映射函数, 接受一个属性值和它的键, 返回一个新的属性值
+     * @returns 一个函数, 这个函数接受一个对象, 然后返回一个新的对象新的对象的每个属性都是原始对象的属性经过映射函数处理后的结果
+     */
+    function map(func) {
+        return (input) => {
+            return Reflect
+                .ownKeys(input)
+                .reduce((sum, curr) => ({ ...sum,
+                [curr]: func(input[curr], curr)
+            }), {});
+        };
     }
-    UtilFP.bindTo = bindTo;
+    UtilFP.map = map;
     /**
     let asd = bindTo("sss",123,{abc:223});//?
     let sumvoid = ()=>10;
@@ -50,5 +67,11 @@ var UtilFP;
     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})//?
+    */
 })(UtilFP || (exports.UtilFP = UtilFP = {}));

package/dist/UtilFfmpegTools.d.ts

@@ -8,11 +8,9 @@ export type IOMap = {
 /**ffmpeg工具类
  */
 declare class SFfmpegTool {
-    /**静态构造函数
-     */
+    /**静态构造函数 */
     static init(): void;
-    /**设置ffmpeg路径
-     */
+    /**设置ffmpeg路径 */
     static setFfmpegPath(ffmpegPath: string): void;
     /**获取音频文件的元数据
      * @param inputWavPath - 输入音频文件路径

package/dist/UtilFfmpegTools.js

@@ -1,16 +1,41 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SFfmpegTool = void 0;
-const fluentFfmpeg = require("fluent-ffmpeg");
-const path = require("path");
-const fs = require("fs");
-const UtilClass_1 = require("./UtilClass");
+const fluent_ffmpeg_1 = __importDefault(require("fluent-ffmpeg"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const UtilLogger_1 = require("./UtilLogger");
+const UtilClass_1 = require("./UtilClass");
 /**ffmpeg工具类
  */
 class SFfmpegTool {
-    /**静态构造函数
-     */
+    /**静态构造函数 */
     static init() {
         let ffmpegPath = process.env.FFMPEG_PATH;
         if (ffmpegPath != null) {
@@ -18,10 +43,9 @@ class SFfmpegTool {
             SFfmpegTool.setFfmpegPath(exepath);
         }
     }
-    /**设置ffmpeg路径
-     */
+    /**设置ffmpeg路径 */
     static setFfmpegPath(ffmpegPath) {
-        fluentFfmpeg.setFfmpegPath(ffmpegPath);
+        fluent_ffmpeg_1.default.setFfmpegPath(ffmpegPath);
     }
     /**获取音频文件的元数据
      * @param inputWavPath - 输入音频文件路径
@@ -29,7 +53,7 @@ class SFfmpegTool {
      */
     static async getAudioMetaData(inputWavPath) {
         return new Promise((resolve, reject) => {
-            fluentFfmpeg.ffprobe(inputWavPath, function (err, metadata) {
+            fluent_ffmpeg_1.default.ffprobe(inputWavPath, function (err, metadata) {
                 if (err) {
                     UtilLogger_1.SLogger.error("SFfmpegTool.getAudioMetaData 错误", err);
                     resolve(null);
@@ -48,7 +72,7 @@ class SFfmpegTool {
     static async flac2ogg(inputFlacFile, outputOggPath, quality = 10) {
         let wavPath = path.join(path.dirname(inputFlacFile), `tmp_${path.basename(inputFlacFile, ".flac")}.wav`);
         await new Promise((resolve, reject) => {
-            fluentFfmpeg(inputFlacFile)
+            (0, fluent_ffmpeg_1.default)(inputFlacFile)
                 .audioCodec("pcm_s16le")
                 .save(wavPath)
                 .on("end", function () {
@@ -76,7 +100,7 @@ class SFfmpegTool {
         //.audioChannels(channels)
         //.noMetadata()
         return new Promise((resolve, reject) => {
-            fluentFfmpeg(inputWavPath)
+            (0, fluent_ffmpeg_1.default)(inputWavPath)
                 .audioQuality(quality)
                 .audioCodec("libvorbis")
                 .save(outputOggPath)
@@ -92,7 +116,7 @@ class SFfmpegTool {
      */
     static async cutAudio(audioPath, outPath, start, time) {
         return new Promise((resolve, reject) => {
-            fluentFfmpeg(audioPath)
+            (0, fluent_ffmpeg_1.default)(audioPath)
                 .setStartTime(start)
                 .setDuration(time)
                 .save(outPath)
@@ -108,7 +132,7 @@ class SFfmpegTool {
      */
     static async trimSilence(inputWavPath, outputWavPath, threshold = -50, silence = 0.2) {
         return new Promise((resolve, reject) => {
-            fluentFfmpeg(inputWavPath)
+            (0, fluent_ffmpeg_1.default)(inputWavPath)
                 .audioFilters(`silenceremove=start_periods=1:start_threshold=${threshold}dB:start_silence=${silence}`)
                 .audioFilters("areverse")
                 .audioFilters(`silenceremove=start_periods=1:start_threshold=${threshold}dB:start_silence=${silence}`)
@@ -124,7 +148,7 @@ class SFfmpegTool {
      */
     static async resample(inputWavPath, outputWavPath, rate = 22050) {
         return new Promise((resolve, reject) => {
-            fluentFfmpeg(inputWavPath)
+            (0, fluent_ffmpeg_1.default)(inputWavPath)
                 .audioFrequency(rate)
                 .save(outputWavPath)
                 .on("end", () => resolve(true))
@@ -138,13 +162,12 @@ class SFfmpegTool {
      * @param cpCount - 并发数
      */
     static async wav2oggMP(ioMap, quality = 10, cpCount = 16) {
-        await new UtilClass_1.SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new UtilClass_1.Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
             UtilLogger_1.SLogger.info("SFfmpegTool.wav2oggMP 正在处理:" + outPath);
             await SFfmpegTool.wav2ogg(inPath, outPath, quality);
         })
-            .appendOperations();
+            .append();
     }
     /**flac转ogg多线程
      * @param ioMap   - 输入输出路径映射
@@ -152,13 +175,12 @@ class SFfmpegTool {
      * @param cpCount - 并发数
      */
     static async flac2oggMP(ioMap, quality = 10, cpCount = 16) {
-        await new UtilClass_1.SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new UtilClass_1.Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
             UtilLogger_1.SLogger.info("SFfmpegTool.flac2oggMP 正在处理:" + outPath);
             await SFfmpegTool.flac2ogg(inPath, outPath, quality);
         })
-            .appendOperations();
+            .append();
     }
     /**删除静音多线程
      * @param ioMap     - 输入输出路径映射
@@ -166,13 +188,12 @@ class SFfmpegTool {
      * @param silence   - 保留静音时长
      */
     static async trimSilenceMP(ioMap, threshold = -50, silence = 0.2, cpCount = 16) {
-        await new UtilClass_1.SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new UtilClass_1.Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
             UtilLogger_1.SLogger.info("SFfmpegTool.trimSilenceMP 正在处理:" + outPath);
             await SFfmpegTool.trimSilence(inPath, outPath, threshold, silence);
         })
-            .appendOperations();
+            .append();
     }
     /**重采样多线程
      * @param ioMap   - 输入输出路径映射
@@ -180,13 +201,12 @@ class SFfmpegTool {
      * @param cpCount - 并发数
      */
     static async resampleMP(ioMap, rate = 22050, cpCount = 16) {
-        await new UtilClass_1.SList(Object.entries(ioMap))
-            .toSStream(cpCount)
+        await new UtilClass_1.Stream(Object.entries(ioMap))
             .map(async ([inPath, outPath]) => {
             UtilLogger_1.SLogger.info("SFfmpegTool.resampleMP 正在处理:" + outPath);
             await SFfmpegTool.resample(inPath, outPath, rate);
         })
-            .appendOperations();
+            .append();
     }
 }
 exports.SFfmpegTool = SFfmpegTool;

package/dist/UtilFileTools.js

@@ -1,10 +1,33 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFT = void 0;
-const fs = require("fs");
-const path = require("path");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const UtilLogger_1 = require("./UtilLogger");
-const JSON5 = require("json5");
+const JSON5 = __importStar(require("json5"));
 const glob_1 = require("glob");
 const UtilFunctions_1 = require("./UtilFunctions");
 /**文件工具 */

package/dist/UtilFunctions.d.ts

@@ -103,7 +103,7 @@ export declare class UtilFunc {
      * @param task - 任务逻辑
      * @returns 处理结果
      */
-    static queueProc<T>(flag: Keyable, task: (() => Promise<T>)): Promise<T>;
+    static queueProc<T>(flag: Keyable, task: () => Promise<T>): Promise<T>;
     /**队列获取目标的代办事件数
      * @param flag - 队列标签
      */
@@ -137,6 +137,13 @@ export declare class UtilFunc {
      * @param strictLog  - 应该严格等于None 否则将输出警告 但任然返回true
      */
     static likeNone(t: unknown, strictLog?: boolean): t is None;
+    /**验证一个值是否为空
+     * 为空则抛异
+     * @param t      - 验证目标
+     * @param errLog - 异常信息
+     * @returns 排除None的原值
+     */
+    static expect<T>(t: T, errLog?: string): Exclude<T, None>;
     /**验证一个变量的类型是否为 T
      * @template T - 验证类型
      * @param t    - 验证目标
@@ -161,5 +168,9 @@ export declare class UtilFunc {
      * @returns 是否安全
      */
     static isSafeNumber(num: unknown): boolean;
+    /**将一个字段加入一个对象中，将改变对象，返回新类型 */
+    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;
+    };
 }
 export {};

package/dist/UtilFunctions.js

@@ -1,17 +1,40 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFunc = void 0;
-const crypto = require("crypto");
-const cp = require("child_process");
+const crypto = __importStar(require("crypto"));
+const cp = __importStar(require("child_process"));
 const UtilLogger_1 = require("./UtilLogger");
 const UtilSymbol_1 = require("./UtilSymbol");
 const UtilDecorators_1 = require("./UtilDecorators");
@@ -297,32 +320,48 @@ class UtilFunc {
      * @param task - 任务逻辑
      * @returns 处理结果
      */
-    static async queueProc(flag, task) {
-        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(flag, task) {
+        // 如果当前标签的队列不存在，则创建一个新的队列
+        if (!this.pendingMap[flag])
+            this.pendingMap[flag] = [];
+        // 创建一个新的Promise，并保存resolve函数以便后续调用
+        let resolveFunc;
+        const promise = new Promise((resolve) => {
+            resolveFunc = resolve;
+        });
+        // 定义处理任务的函数
+        const processTask = async () => {
+            let result;
+            try {
+                // 执行任务并等待结果
+                result = await task();
+                // 使用保存的resolve函数来解决Promise
+                resolveFunc(result);
+            }
+            catch (error) {
+                // 如果任务执行出错，记录错误日志
+                UtilLogger_1.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];
+                }
+            }
         };
-        //空时直接运行 非空时等待
-        if (pending.length <= 0)
-            pending.push(() => tryRes());
-        else
-            await new Promise((resolve) => pending.push(resolve));
-        try {
-            return await task();
-            ;
-        }
-        catch (e) {
-            UtilLogger_1.SLogger.fatal(`queuePromise 出现错误`, e);
-            throw e;
-        }
-        finally {
-            tryRes();
-        }
+        // 将处理任务的函数添加到队列中
+        this.pendingMap[flag].push(processTask);
+        // 如果队列中只有当前任务，立即执行
+        if (this.pendingMap[flag].length === 1)
+            processTask();
+        // 返回Promise，以便调用者可以等待任务完成
+        return promise;
     }
     /**队列获取目标的代办事件数
      * @param flag - 队列标签
@@ -347,15 +386,12 @@ class UtilFunc {
         if (typeof t === 'string' || typeof t === 'number' || typeof t === 'symbol') {
             if (procObj[t])
                 return procObj[t](t);
-            UtilLogger_1.SLogger.fatal(`matchProc 传入了一个预料之外的值: `, t);
-            throw UtilSymbol_1.None;
-        }
-        else {
-            if (procObj[t.status])
-                return procObj[t.status](t.status, t.result);
-            UtilLogger_1.SLogger.fatal(`matchProc 传入了一个预料之外的值: `, t);
-            throw UtilSymbol_1.None;
         }
+        else if (procObj[t.status])
+            return procObj[t.status](t.status, t.result);
+        const err = new Error(`matchProc 传入了一个预料之外的值: ${String(t)}`);
+        UtilLogger_1.SLogger.fatal(err);
+        throw err;
     }
     /**根据典型的成功或失败状态运行函数
      * @param t - 目标值
@@ -405,6 +441,17 @@ class UtilFunc {
             UtilLogger_1.SLogger.warn(`输入值不严格等于 None , 已作为 None 处理`, `具体类型: ${t}`);
         return t == null;
     }
+    /**验证一个值是否为空
+     * 为空则抛异
+     * @param t      - 验证目标
+     * @param errLog - 异常信息
+     * @returns 排除None的原值
+     */
+    static expect(t, errLog) {
+        if (t === UtilSymbol_1.None)
+            throw new Error(errLog);
+        return t;
+    }
     /**验证一个变量的类型是否为 T
      * @template T - 验证类型
      * @param t    - 验证目标
@@ -440,6 +487,13 @@ class UtilFunc {
         }
         return false;
     }
+    /**将一个字段加入一个对象中，将改变对象，返回新类型 */
+    static bindTo(key, value, base) {
+        let out = base;
+        out = out ?? {};
+        out[key] = value;
+        return out;
+    }
 }
 exports.UtilFunc = UtilFunc;
 __decorate([

package/dist/UtilInterfaces.d.ts

@@ -29,6 +29,10 @@ export type PartialOption<B, D> = keyof D extends keyof B ? Omit<B, keyof D> & P
 export type ProperSubset<B, T = B> = T extends B ? B extends T ? never : T : never;
 /**字面量检测 */
 export type LiteralCheck<L> = ProperSubset<string, L> | ProperSubset<number, L> | ProperSubset<boolean, L> | ProperSubset<symbol, L> | ProperSubset<any[], 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];