@zwa73/utils 1.0.76 → 1.0.77

package/dist/UtilCom.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilCom = void 0;
-const UtilInterfaces_1 = require("./UtilInterfaces");
 const https = require("https");
 const http = require("http");
 const UtilLogger_1 = require("./UtilLogger");
@@ -21,7 +20,7 @@ var UtilCom;
         const hasTimeLimit = (timeLimit >= 10);
         if (hasTimeLimit)
             timeLimit *= 1000;
-        const jsonStr = (0, UtilInterfaces_1.stringifyJToken)(json);
+        const jsonStr = UtilFunctions_1.UtilFunc.stringifyJToken(json);
         const funcName = `s${posttype}Psot`;
         return new Promise((resolve, rejecte) => {
             const resFunc = (res) => {
@@ -51,7 +50,7 @@ var UtilCom;
                         }
                         try {
                             let obj = JSON.parse(resdata);
-                            UtilLogger_1.SLogger.http(funcName + " 接受信息:", (0, UtilInterfaces_1.stringifyJToken)(obj));
+                            UtilLogger_1.SLogger.http(funcName + " 接受信息:", UtilFunctions_1.UtilFunc.stringifyJToken(obj));
                             resolve(obj);
                             return;
                         }

package/dist/UtilFP.js

@@ -16,12 +16,14 @@ var UtilFP;
         });
     }
     UtilFP.curry = curry;
+    //#endregion
     function flow(...fs) {
         return (arg) => {
             return fs.reduce((value, func) => func(value), arg);
         };
     }
     UtilFP.flow = flow;
+    //#endregion
     function pipe(input, ...fs) {
         return fs.reduce((value, func) => func(value), input);
     }

package/dist/UtilFileTools.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilFT = void 0;
 const fs = require("fs");
 const path = require("path");
-const UtilInterfaces_1 = require("./UtilInterfaces");
 const UtilLogger_1 = require("./UtilLogger");
 const JSON5 = require("json5");
 const glob_1 = require("glob");
+const UtilFunctions_1 = require("./UtilFunctions");
 /**文件工具 */
 var UtilFT;
 (function (UtilFT) {
@@ -149,7 +149,7 @@ var UtilFT;
      * @param token    - 所要写入的JToken
      */
     async function writeJSONFile(filePath, token) {
-        let str = (0, UtilInterfaces_1.stringifyJToken)(token);
+        let str = UtilFunctions_1.UtilFunc.stringifyJToken(token);
         if (path.extname(filePath) !== '.json')
             filePath += '.json';
         // 判断文件路径是否存在 不存在则创建

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { ComposedClass, ComposedMixinable, JObject, JToken, Mixinable, PromiseProcFn, PromiseVerifyFn } from "./UtilInterfaces";
+import { ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObject, JToken, Mixinable, Outcome, PromiseVerifyFn } from "./UtilInterfaces";
 /**常用函数 */
 export declare namespace UtilFunc {
     /**获取当前时间戳
@@ -62,9 +62,9 @@ export declare namespace UtilFunc {
      * @param verifyFn    - 验证函数
      * @param repeatCount - 重试次数
      * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @returns           - 结果 null 为全部失败/超时
+     * @returns 结果 null 为全部失败/超时
      */
-    function repeatPromise<T>(procFn: PromiseProcFn<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
+    function repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: PromiseVerifyFn<T>, repeatCount?: number, repeatTime?: number): Promise<T | null>;
     /**部分类组合
      * 将mixin的部分字段混入base
      * @param base   - 基础类
@@ -83,4 +83,30 @@ export declare namespace UtilFunc {
      * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
      */
     function mapEntries<T extends Object>(obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T;
+    /**处理联合 Outcome
+     * @param t       - 目标值
+     * @param procObj - 所有可能的id组成的处理函数映射
+     * @returns 任意处理函数的返回值
+     */
+    function matchOutcome<T extends Outcome<string, unknown>, P extends {
+        [K in T['status']]: (k: K, v: ExtractOutcome<T, K>['result']) => unknown;
+    }>(t: T, procObj: P): {
+        [K in keyof P]: ReturnType<P[K]>;
+    }[keyof P];
+    /**处理联合 字符串
+     * @param t       - 目标值
+     * @param procObj - 所有可能的id组成的处理函数映射
+     * @returns 任意处理函数的返回值
+     */
+    function matchStr<T extends string, P extends {
+        [K in T]: (k: K) => unknown;
+    }>(t: T, procObj: P): {
+        [K in keyof P]: ReturnType<P[K]>;
+    }[keyof P];
+    /**将JToken转换为字符串
+     * @param token - 待转换的Token
+     * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+     * @returns 转换完成的字符串
+     */
+    function stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
 }

package/dist/UtilFunctions.js

@@ -125,71 +125,76 @@ var UtilFunc;
      * @param verifyFn    - 验证函数
      * @param repeatCount - 重试次数
      * @param repeatTime  - 超时时间/秒  最小为10秒
-     * @returns           - 结果 null 为全部失败/超时
+     * @returns 结果 null 为全部失败/超时
      */
     async function repeatPromise(procFn, verifyFn, repeatCount = 3, repeatTime = 180) {
         //计时
         const timeflag = "repeatPromise " + UtilFunc.genUUID();
         UtilLogger_1.SLogger.time(timeflag);
-        //转换为毫秒
+        /**是否含有超时时间 */
         const hasRepeatTime = (repeatTime >= 10);
+        //转换为毫秒
         if (hasRepeatTime)
             repeatTime *= 1000;
         //验证处理函数
         if (verifyFn === undefined)
             verifyFn = () => "Completed";
-        //计时器
+        /**计时器 */
         let timer = null;
+        /**计时器 Promise */
         let timerP = null;
+        /**计时器 Promise 的返回函数 */
         let resolveFn = null;
         /**清理计时器 */
         const clearTimer = () => {
-            if (timer != null)
+            if (timer)
                 clearInterval(timer);
-            if (resolveFn != null)
+            if (resolveFn)
                 resolveFn("Timeout");
-            timerP = null;
-            timer = null;
-            resolveFn = null;
+            timerP = timer = resolveFn = null;
         };
         //进行中的请求
         const plist = [];
         //开始处理
         try {
+            //根据最大重试次数限制进行循环
             for (let i = 0; i < repeatCount;) {
                 UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
-                //创建当前任务
+                //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {
                     plist.push(procFn().then(result => ({ result, stat: verifyFn(result), index: i })));
                 }
                 //创建定时器
                 if (timerP == null) {
-                    timerP = new Promise(function (resolve, rejecte) {
+                    timerP = new Promise((resolve, rejecte) => {
                         resolveFn = resolve;
                         timer = setTimeout(() => resolve("Timeout"), hasRepeatTime ? repeatTime : Infinity); //无限制则无限时间
                     });
                 }
-                //等待完成
+                //等待任意任务 或当前计时器完成
                 const currObj = await Promise.race([...plist, timerP]);
                 //超时处理
-                if (currObj == "Timeout") {
+                if (currObj === "Timeout") {
                     UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
                     clearTimer();
                     i++;
                     continue;
                 }
+                //路由请求状态
                 const poststat = await currObj.stat;
-                switch (poststat) {
-                    case "Completed": //完成
+                const result = matchStr(poststat, {
+                    Completed() {
                         UtilLogger_1.SLogger.info(`第 ${currObj.index + 1} 次 repeatPromise 成功`);
                         //非当前
                         if (currObj.index != i)
                             UtilLogger_1.SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
                         return currObj.result;
-                    case "Terminated": //终止
+                    },
+                    Terminated() {
                         UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 终止 停止重试`);
                         return currObj.result;
-                    case "Failed": //验证失败
+                    },
+                    Failed() {
                         //抛弃失败
                         plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
                         //是当前
@@ -197,12 +202,14 @@ var UtilFunc;
                             UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 失败 开始重试`);
                             clearTimer();
                             i++;
-                            continue;
+                            return;
                         }
                         //非当前
                         UtilLogger_1.SLogger.warn(`第 ${currObj.index + 1} 次 repeatPromise 失败`);
-                        continue;
-                }
+                    },
+                });
+                if (result !== undefined)
+                    return result;
             }
             //全部失败或超时则返回null
             UtilLogger_1.SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
@@ -291,4 +298,33 @@ var UtilFunc;
         }, {});
     }
     UtilFunc.mapEntries = mapEntries;
+    /**处理联合 Outcome
+     * @param t       - 目标值
+     * @param procObj - 所有可能的id组成的处理函数映射
+     * @returns 任意处理函数的返回值
+     */
+    function matchOutcome(t, procObj) {
+        return procObj[t.status](t.status, t?.result);
+    }
+    UtilFunc.matchOutcome = matchOutcome;
+    /**处理联合 字符串
+     * @param t       - 目标值
+     * @param procObj - 所有可能的id组成的处理函数映射
+     * @returns 任意处理函数的返回值
+     */
+    function matchStr(t, procObj) {
+        return procObj[t](t);
+    }
+    UtilFunc.matchStr = matchStr;
+    /**将JToken转换为字符串
+     * @param token - 待转换的Token
+     * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+     * @returns 转换完成的字符串
+     */
+    function stringifyJToken(token, space = "\t") {
+        if (space == null)
+            space = undefined;
+        return JSON.stringify(token, null, space);
+    }
+    UtilFunc.stringifyJToken = stringifyJToken;
 })(UtilFunc = exports.UtilFunc || (exports.UtilFunc = {}));

package/dist/UtilInterfaces.d.ts

@@ -14,12 +14,6 @@ export interface IJData {
      */
     toJSON(): JToken;
 }
-/**将JToken转换为字符串
- * @param token - 待转换的Token
- * @param space - 插入的空格 数字为空格数量 默认为制表符\t
- * @returns 转换完成的字符串
- */
-export declare function stringifyJToken(token: JToken | IJData, space?: string | number | null | undefined): string;
 /**转为可写的 */
 export type Writeable<T> = {
     -readonly [P in keyof T]: T[P];
@@ -55,24 +49,23 @@ export type ExclusiveRecord<B, T, K extends string[], TMP = ExclusiveRecursive<B
 /**符合JObject约束的互斥表 */
 export type ExclusiveJObject<B extends JObject, T extends JToken, K extends string[], TMP extends JArray = ExclusiveRecursive<B, T, K>> = TMP[number];
 /**请求完成状态 成功/失败/终止
- * 成功/终止 将直接返回
+ * 成功 将直接返回  结果
+ * 终止 将直接返回  null
  * 失败 将重试
  */
 export type PromiseStat = "Completed" | "Failed" | "Terminated";
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj: T) => Promise<PromiseStat> | PromiseStat;
-/**发起promise的函数 */
-export type PromiseProcFn<T> = () => Promise<T>;
 /**类型中任意函数的字符串名称 */
 export type FuncPropNames<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+    [K in keyof T]: T[K] extends (...args: unknown[]) => unknown ? K : never;
 }[keyof T];
 /**部分组合的类
  * @template Base     - 基类
  * @template Mixin    - 待混入的类
  * @template PropKeys - 需要混入的成员key
  */
-export type ComposedClass<Base extends object, Mixin extends object, Key extends string, PropKeys extends keyof Mixin> = Base & Pick<Mixin, PropKeys> & {
+export type ComposedClass<Base, Mixin, Key extends string, PropKeys extends keyof Mixin> = Base & Pick<Mixin, PropKeys> & {
     [P in Key]: Mixin;
 };
 /**可自动混入的类型 */
@@ -87,5 +80,39 @@ export type Mixinable<Mixin> = {
     readonly MIXIN_FIELDS: readonly (keyof Mixin)[];
 };
 /**自动组合可混入的类 */
-export type ComposedMixinable<B extends object, Ms extends unknown[]> = Ms extends [infer M, ...infer Rest] ? M extends Mixinable<M> ? ComposedMixinable<ComposedClass<B, M, M['MIXIN_KEY'], M['MIXIN_FIELDS'][number]>, Rest> : "一个混入类没有实现 Mixinable<self>" & Error : B;
+export type ComposedMixinable<B, Ms extends unknown[]> = Ms extends [infer M, ...infer Rest] ? M extends Mixinable<M> ? ComposedMixinable<ComposedClass<B, M, M['MIXIN_KEY'], M['MIXIN_FIELDS'][number]>, Rest> : "一个混入类没有实现 Mixinable<self>" & Error : B;
+/** extends封装
+ * @template B - 基础类型
+ * @template T - 判断的目标类型
+ * @template Y - 如果为真的返回值
+ * @template N - 如果为假的返回值
+ */
+export type ExtendThen<B, T, Y, N = never> = B extends T ? Y : N;
+/** 一个联合类型 B 中如果包含 T
+ * @template B - 基础类型
+ * @template T - 判断的目标类型
+ * @template Y - 如果为真的返回值
+ * @template N - 如果为假的返回值
+ */
+export type UnionInclude<B, T, Y, N = never> = B extends Exclude<B, T> ? Y : N;
+/**排除可选字段 */
+export type RequiredOnly<T> = {
+    [K in keyof T as UnionInclude<T[K], undefined, never, K>]: T[K];
+};
+/**添加前缀 */
+export type WithPrefix<T, P extends string> = {
+    [K in (keyof T) as K extends string ? `${P}_${K}` : K]: T[K];
+};
+/**返回结果
+ * @template K - 类型键值
+ * @template V - 值
+ */
+export type Outcome<K extends string, V> = {
+    /**状态类型 */
+    status: K;
+    /**值 */
+    result: V;
+};
+/**从联合 Outcome 中 根据 id 提取对应 value 的 type */
+export type ExtractOutcome<T, K extends string> = T extends Outcome<K, unknown> ? T : never;
 export {};

package/dist/UtilInterfaces.js

@@ -1,14 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyJToken = void 0;
-/**将JToken转换为字符串
- * @param token - 待转换的Token
- * @param space - 插入的空格 数字为空格数量 默认为制表符\t
- * @returns 转换完成的字符串
- */
-function stringifyJToken(token, space = "\t") {
-    if (space == null)
-        space = undefined;
-    return JSON.stringify(token, null, space);
-}
-exports.stringifyJToken = stringifyJToken;

package/package.json

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

package/src/UtilCom.ts

@@ -1,4 +1,4 @@
-import { JObject, PromiseVerifyFn, stringifyJToken } from "@src/UtilInterfaces";
+import { JObject, PromiseVerifyFn } from "@src/UtilInterfaces";
 import * as https from 'https';
 import * as http from 'http';
 import { SLogger } from "@src/UtilLogger";
@@ -21,7 +21,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
     if(hasTimeLimit)
         timeLimit*=1000
 
-    const jsonStr = stringifyJToken(json);
+    const jsonStr = UtilFunc.stringifyJToken(json);
     const funcName = `s${posttype}Psot`;
 
     return new Promise((resolve, rejecte)=>{
@@ -55,7 +55,7 @@ function sPost(posttype:"http"|"https",json:JObject,options:Object,timeLimit:num
                     }
                     try{
                         let obj = JSON.parse(resdata);
-                        SLogger.http(funcName+" 接受信息:",stringifyJToken(obj));
+                        SLogger.http(funcName+" 接受信息:",UtilFunc.stringifyJToken(obj));
                         resolve(obj);
                         return;
                     }

package/src/UtilFP.ts

@@ -29,11 +29,13 @@ export function curry<T extends Function>(fn: T): CurryFunc<T> {
 /**可组合的函数 */
 type CompFunc<T, R> = (arg: T) => R;
 
+
 /**函数管道组合  
  * 从左到右执行  
  * @param fs - 待组合的函数
  * @returns 组合完成的函数
  */
+//#region flow重载
 export function flow<I>(...fs: CompFunc<I, I>[]): CompFunc<I, I>;
 export function flow<I, R1>(f1: CompFunc<I, R1>,...fs: CompFunc<R1, R1>[]): CompFunc<I, R1>;
 export function flow<I, R1, R2>(f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>,...fs: CompFunc<R2, R2>[]): CompFunc<I, R2>;
@@ -44,6 +46,7 @@ export function flow<I, R1, R2, R3, R4, R5, R6>(f1: CompFunc<I, R1>, f2: CompFun
 export function flow<I, R1, R2, R3, R4, R5, R6, R7>(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>[]): CompFunc<I, R7>;
 export function flow<I, R1, R2, R3, R4, R5, R6, R7, R8>(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>[]): CompFunc<I, R8>;
 export function flow<I, R1, R2, R3, R4, R5, R6, R7, R8, R9>(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>[]): CompFunc<I, R9>;
+//#endregion
 export function flow<T>(...fs: ((arg: T) => T)[]): (arg: T) => T {
     return (arg: T): T => {
         return fs.reduce((value, func) => func(value), arg);
@@ -56,6 +59,7 @@ export function flow<T>(...fs: ((arg: T) => T)[]): (arg: T) => T {
  * @param fs    - 待组合的函数
  * @returns 经过所有函数处理后的结果
  */
+//#region pipe重载
 export function pipe<I>(input: I, ...fs: CompFunc<I, I>[]): I;
 export function pipe<I, R1>(input: I, f1: CompFunc<I, R1>,...fs: CompFunc<R1, R1>[]): R1;
 export function pipe<I, R1, R2>(input: I, f1: CompFunc<I, R1>, f2: CompFunc<R1, R2>,...fs: CompFunc<R2, R2>[]): R2;
@@ -66,6 +70,7 @@ export function pipe<I, R1, R2, R3, R4, R5, R6>(input: I, f1: CompFunc<I, R1>, f
 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;
+//#endregion
 export function pipe<T>(input: T, ...fs: ((arg: T) => T)[]): T {
     return fs.reduce((value, func) => func(value), input);
 }

package/src/UtilFileTools.ts

@@ -1,9 +1,10 @@
 import * as fs from "fs";
 import * as path from "path";
-import { JToken, stringifyJToken } from "@src/UtilInterfaces";
+import { JToken } from "@src/UtilInterfaces";
 import { SLogger } from "@src/UtilLogger";
 import * as JSON5 from 'json5';
 import { globSync } from "glob";
+import { UtilFunc } from "./UtilFunctions";
 
 /**文件工具 */
 export namespace UtilFT{
@@ -178,7 +179,7 @@ export async function writeJSONFile(
     filePath: string,
     token: JToken
 ): Promise<void> {
-    let str = stringifyJToken(token);
+    let str = UtilFunc.stringifyJToken(token);
     if (path.extname(filePath) !== '.json') filePath += '.json';
 
     // 判断文件路径是否存在 不存在则创建

package/src/UtilFunctions.ts

@@ -1,5 +1,5 @@
 import * as crypto from "crypto";
-import { ComposedClass, ComposedMixinable, FuncPropNames, JObject, JToken, Mixinable, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
+import { ComposedClass, ComposedMixinable, ExtractOutcome, FuncPropNames, IJData, JObject, JToken, Mixinable, Outcome, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
 import * as cp from "child_process";
 import { SLogger } from "@src/UtilLogger";
 
@@ -133,36 +133,35 @@ type ProcessingPromise<T> = {
  * @param verifyFn    - 验证函数
  * @param repeatCount - 重试次数
  * @param repeatTime  - 超时时间/秒  最小为10秒
- * @returns           - 结果 null 为全部失败/超时
+ * @returns 结果 null 为全部失败/超时
  */
-export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:PromiseVerifyFn<T>,
+export async function repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>,
     repeatCount:number=3,repeatTime:number=180):Promise<T|null>{
 
     //计时
     const timeflag = "repeatPromise "+UtilFunc.genUUID();
     SLogger.time(timeflag);
 
-    //转换为毫秒
+    /**是否含有超时时间 */
     const hasRepeatTime = (repeatTime>=10);
+    //转换为毫秒
     if(hasRepeatTime) repeatTime*=1000;
 
     //验证处理函数
     if(verifyFn===undefined)
         verifyFn = ()=>"Completed";
 
-    //计时器
+    /**计时器 */
     let timer:NodeJS.Timer|null = null;
+    /**计时器 Promise */
     let timerP:Promise<"Timeout">|null=null;
-    let resolveFn:((value: "Timeout" | PromiseLike<"Timeout">)=>void)|null = null;
+    /**计时器 Promise 的返回函数 */
+    let resolveFn:((value: "Timeout")=>void)|null = null;
     /**清理计时器 */
     const clearTimer = ()=>{
-        if(timer!=null)
-            clearInterval(timer);
-        if(resolveFn!=null)
-            resolveFn("Timeout");
-        timerP=null;
-        timer=null;
-        resolveFn=null;
+        if(timer) clearInterval(timer);
+        if(resolveFn) resolveFn("Timeout");
+        timerP = timer = resolveFn = null;
     }
 
     //进行中的请求
@@ -170,9 +169,11 @@ export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:Promise
 
     //开始处理
     try{
+        //根据最大重试次数限制进行循环
         for(let i=0;i<repeatCount;){
             SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
-            //创建当前任务
+
+            //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
                 plist.push(procFn().then(result =>
                     ({result, stat:verifyFn!(result), index:i})));
@@ -180,46 +181,51 @@ export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:Promise
 
             //创建定时器
             if(timerP==null){
-                timerP = new Promise<"Timeout">(function(resolve, rejecte){
+                timerP = new Promise<"Timeout">((resolve, rejecte)=>{
                     resolveFn = resolve;
                     timer = setTimeout(()=>resolve("Timeout"),
-                        hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
+                        hasRepeatTime ? repeatTime : Infinity);//无限制则无限时间
                 })
             }
 
-            //等待完成
+            //等待任意任务 或当前计时器完成
             const currObj = await Promise.race([...plist, timerP]);
 
             //超时处理
-            if(currObj=="Timeout"){
+            if(currObj==="Timeout"){
                 SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
                 clearTimer(); i++;
                 continue;
             }
+
+            //路由请求状态
             const poststat = await currObj.stat;
-            switch(poststat){
-                case "Completed"://完成
+            const result = matchStr(poststat,{
+                Completed(){
                     SLogger.info(`第 ${currObj.index+1} 次 repeatPromise 成功`);
                     //非当前
                     if(currObj.index!=i)
                         SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
                     return currObj.result;
-                case "Terminated"://终止
+                },
+                Terminated(){
                     SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 终止 停止重试`);
                     return currObj.result;
-                case "Failed"://验证失败
+                },
+                Failed(){
                     //抛弃失败
                     plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
                     //是当前
                     if(currObj.index==i){
                         SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败 开始重试`);
                         clearTimer(); i++;
-                        continue;
+                        return;
                     }
                     //非当前
                     SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败`);
-                    continue;
-            }
+                },
+            });
+            if(result !== undefined) return result;
         }
         //全部失败或超时则返回null
         SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
@@ -312,4 +318,36 @@ export function mapEntries<T extends Object>
     }, {} as T);
 }
 
+/**处理联合 Outcome
+ * @param t       - 目标值
+ * @param procObj - 所有可能的id组成的处理函数映射
+ * @returns 任意处理函数的返回值
+ */
+export function matchOutcome<
+    T extends Outcome<string,unknown>,
+    P extends {[K in T['status']]:(k:K,v:ExtractOutcome<T,K>['result'])=>unknown}>
+    (t:T,procObj:P):{[K in keyof P]:ReturnType<P[K]>}[keyof P]{
+    return (procObj as any)[t.status](t.status,(t as any)?.result)
+}
+/**处理联合 字符串
+ * @param t       - 目标值
+ * @param procObj - 所有可能的id组成的处理函数映射
+ * @returns 任意处理函数的返回值
+ */
+export function matchStr<T extends string,P extends {[K in T]:(k:K)=>unknown}>
+    (t:T,procObj:P):{[K in keyof P]:ReturnType<P[K]>}[keyof P]{
+        return (procObj as any)[t](t)
+}
+
+/**将JToken转换为字符串
+ * @param token - 待转换的Token
+ * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+ * @returns 转换完成的字符串
+ */
+export function stringifyJToken(token:JToken|IJData,space:string|number|null|undefined="\t"){
+	if(space==null)
+		space=undefined;
+	return JSON.stringify(token,null,space);
+}
+
 }

package/src/UtilInterfaces.ts

@@ -16,16 +16,6 @@ export interface IJData{
 	 */
 	toJSON():JToken;
 }
-/**将JToken转换为字符串
- * @param token - 待转换的Token
- * @param space - 插入的空格 数字为空格数量 默认为制表符\t
- * @returns 转换完成的字符串
- */
-export function stringifyJToken(token:JToken|IJData,space:string|number|null|undefined="\t"){
-	if(space==null)
-		space=undefined;
-	return JSON.stringify(token,null,space);
-}
 
 /**转为可写的 */
 export type Writeable<T> = {
@@ -73,18 +63,17 @@ export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string
 
 
 /**请求完成状态 成功/失败/终止  
- * 成功/终止 将直接返回  
+ * 成功 将直接返回  结果  
+ * 终止 将直接返回  null  
  * 失败 将重试  
  */
 export type PromiseStat = "Completed"|"Failed"|"Terminated";
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj:T)=>Promise<PromiseStat>|PromiseStat;
-/**发起promise的函数 */
-export type PromiseProcFn<T> = ()=>Promise<T>;
 
 /**类型中任意函数的字符串名称 */
 export type FuncPropNames<T> = {
-    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+    [K in keyof T]: T[K] extends (...args: unknown[]) => unknown ? K : never;
 }[keyof T];
 
 /**部分组合的类 
@@ -92,7 +81,7 @@ export type FuncPropNames<T> = {
  * @template Mixin    - 待混入的类
  * @template PropKeys - 需要混入的成员key
  */
-export type ComposedClass<Base extends object, Mixin extends object, Key extends string, PropKeys extends keyof Mixin> = 
+export type ComposedClass<Base, Mixin, Key extends string, PropKeys extends keyof Mixin> = 
     Base & Pick<Mixin, PropKeys> & {[P in Key]:Mixin};
 
 /**可自动混入的类型 */
@@ -108,9 +97,56 @@ export type Mixinable<Mixin> = {
 };
 
 /**自动组合可混入的类 */
-export type ComposedMixinable<B extends object, Ms extends unknown[]> = 
+export type ComposedMixinable<B, Ms extends unknown[]> = 
     Ms extends [infer M, ...infer Rest]
         ? M extends Mixinable<M>
             ? ComposedMixinable<ComposedClass<B,M,M['MIXIN_KEY'],M['MIXIN_FIELDS'][number]>,Rest>
             : "一个混入类没有实现 Mixinable<self>" & Error
         : B
+
+/** extends封装  
+ * @template B - 基础类型
+ * @template T - 判断的目标类型
+ * @template Y - 如果为真的返回值
+ * @template N - 如果为假的返回值
+ */
+export type ExtendThen<B,T,Y,N = never> = B extends T ? Y : N;
+/** 一个联合类型 B 中如果包含 T  
+ * @template B - 基础类型
+ * @template T - 判断的目标类型
+ * @template Y - 如果为真的返回值
+ * @template N - 如果为假的返回值
+ */
+export type UnionInclude<B,T,Y,N = never> =
+    B extends Exclude<B,T>
+        ? Y
+        : N
+/**排除可选字段 */
+export type RequiredOnly<T> = {
+    [K in keyof T as
+        UnionInclude<T[K],undefined,never,K>
+    ]: T[K]
+};
+/**添加前缀 */
+export type WithPrefix<T,P extends string> = { 
+    [K in (keyof T) as
+        K extends string
+            ? `${P}_${K}`
+            : K
+    ]: T[K]
+};
+/**返回结果
+ * @template K - 类型键值
+ * @template V - 值
+ */
+export type Outcome<K extends string,V> = {
+    /**状态类型 */
+    status:K;
+    /**值 */
+    result:V;
+}
+
+/**从联合 Outcome 中 根据 id 提取对应 value 的 type */
+export type ExtractOutcome<T,K extends string> =
+    T extends Outcome<K,unknown> ? T : never;
+

package/src/test/composeTest.ts

@@ -104,4 +104,31 @@ let jot = {
 UtilFunc.initObject(jot,{
     c:()=>console.log("缺少c"+insd.getNum())
 })
-jot//?
+jot//?
+
+
+type IfUndefined<T, Y, N> = T extends undefined ? Y : N;
+
+type RequiredOnly<T> = {
+    [K in (keyof T) as
+        T[K] extends Exclude<T[K],undefined>
+            ? K
+            : never
+    ]: T[K]
+};
+
+
+type WithPrefix<T,P extends string> = { 
+    [K in (keyof T) as
+        K extends string
+            ? `${P}_${K}`
+            : K
+    ]: T[K]
+};
+
+type a= {
+    abc:123
+    def?:1
+}
+type d = RequiredOnly<a>;
+type b = WithPrefix<a,"prefix">;