@zwa73/utils 1.0.76 → 1.0.78

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,14 +1,31 @@
 import * as crypto from "crypto";
-import { ComposedClass, ComposedMixinable, FuncPropNames, JObject, JToken, Mixinable, PromiseProcFn, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
+import { ComposedClass, ComposedMixinable, ExtractOutcome, IJData, JObject, JToken, Keyable, Mixinable, Outcome, PromiseStat, PromiseVerifyFn } from "@src/UtilInterfaces";
 import * as cp from "child_process";
 import { SLogger } from "@src/UtilLogger";
+import { Completed, Failed, None, Terminated, Timeout } from "./UtilSymbol";
+import { match, outcome } from "./QuickFunction";
+import { LogTimeAsync } from "./UtilDecorators";
 
+
+type CompleteCome<T> = Outcome<Completed,T>;
+type TimeoutCome<T> = Outcome<Timeout,Promise<T>>;
+/**永不完成的Promise单例 */
+const NeverResolvedPromise = new Promise(()=>{});
+/**进行中的请求 */
+type ProcessingPromise<T> = {
+    /**主体请求 */
+    result:T;
+    /**请求状态 */
+    stat:PromiseStat;
+    /**请求下标/序号 */
+    index:number;
+};
 /**常用函数 */
-export namespace UtilFunc{
+export class UtilFunc{
 /**获取当前时间戳  
  * @returns 时间戳
  */
-export function getTime(): number {
+static getTime(): number {
     return new Date().getTime();
 }
 
@@ -19,7 +36,7 @@ export function getTime(): number {
  * @param defaultVal - 默认值
  * @returns 最终值
  */
-export function initField<T extends object,K extends keyof T>(
+static initField<T extends object,K extends keyof T>(
     obj: T,
     field: K,
     defaultVal: T[K]
@@ -33,7 +50,7 @@ export function initField<T extends object,K extends keyof T>(
  * @param checkObj  - 用于检测的对象 在对应key缺失时赋予对应值 如果值为函数, 则赋予执行结果 如果结果为 undefined 则不赋值
  * @returns 完成初始化的对象
  */
-export function initObject<T extends JObject>
+static initObject<T extends JObject>
     (obj:T,checkObj:{[P in keyof T]:T[P]|(()=>void|T[P])}){
     const fixobj = obj as any;
     for(const key in checkObj){
@@ -52,14 +69,14 @@ export function initObject<T extends JObject>
 /**生成一串uuid  
  * @returns uuid
  */
-export function genUUID() {
+static genUUID() {
     return crypto.randomBytes(16).toString("hex");
 }
 /**计算Hash  
  * @param str - 待计算的字符串
  * @returns hash
  */
-export function calcHash(str:string) {
+static calcHash(str:string) {
     return crypto.createHash('md5').update(str).digest('hex');
 }
 
@@ -68,7 +85,7 @@ export function calcHash(str:string) {
  * @param obj  - 克隆目标
  * @returns 克隆结果
  */
-export function deepClone<T extends JToken>(obj: T): T {
+static deepClone<T extends JToken>(obj: T): T {
     return JSON.parse(JSON.stringify(obj));
 }
 
@@ -76,7 +93,7 @@ export function deepClone<T extends JToken>(obj: T): T {
  * @param num - 所要检测的数字
  * @returns 是否安全
  */
-export function isSafeNumber(num: number): boolean {
+static isSafeNumber(num: number): boolean {
     if (num === undefined || num == null || isNaN(num)) return false;
     if(typeof num === 'number') return true;
     return false;
@@ -87,10 +104,18 @@ export function isSafeNumber(num: number): boolean {
  * @param timeMs - 等待的毫秒数
  * @returns
  */
-export async function sleep(timeMs: number): Promise<boolean> {
+static async sleep<T>(timeMs: number): Promise<void>
+/**等待 timeMs 毫秒  
+ * @async
+ * @param timeMs - 等待的毫秒数
+ * @param result - 结果
+ * @returns
+ */
+static async sleep<T>(timeMs: number, result:T): Promise<T>
+static async sleep<T>(timeMs: number, result?:T): Promise<T|undefined> {
     return new Promise(function (resolve, rejecte) {
         let timer = setTimeout(function () {
-            resolve(true);
+            resolve(result);
         }, timeMs);
     });
 }
@@ -98,7 +123,7 @@ export async function sleep(timeMs: number): Promise<boolean> {
 /**封装的 cp.exec 执行一段指令 指令完成后返回 Promise  
  * @param command 指令文本
  */
-export function exec(command: string) {
+static exec(command: string) {
 	return new Promise<{ stdout:string, stderr:string }>
         ((resolve, reject) => {
 		cp.exec(command, (error, stdout, stderr) => {
@@ -110,116 +135,98 @@ export function exec(command: string) {
 	});
 }
 
-/**永不完成的Promise单例 */
-const NeverResolvedPromise = new Promise(()=>{});
+
 /**获得一个永不完成的Promise单例 */
-export function getNeverResolvedPromise<T>():Promise<T>{
+static getNeverResolvedPromise<T>():Promise<T>{
     return NeverResolvedPromise as Promise<T>;
 }
 
-/**进行中的请求 */
-type ProcessingPromise<T> = {
-    /**主体请求 */
-    result:T;
-    /**请求状态 */
-    stat:PromiseStat|Promise<PromiseStat>;
-    /**请求下标/序号 */
-    index:number;
-};
-
 /**重复尝试promise  
  * @async
  * @param procFn      - 发起函数
  * @param verifyFn    - 验证函数
  * @param repeatCount - 重试次数
  * @param repeatTime  - 超时时间/秒  最小为10秒
- * @returns           - 结果 null 为全部失败/超时
+ * @returns 结果 null 为全部失败/超时
  */
-export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:PromiseVerifyFn<T>,
+@LogTimeAsync("repeatPromise ",true)
+static async 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;
-    let timerP:Promise<"Timeout">|null=null;
-    let resolveFn:((value: "Timeout" | PromiseLike<"Timeout">)=>void)|null = null;
-    /**清理计时器 */
-    const clearTimer = ()=>{
-        if(timer!=null)
-            clearInterval(timer);
-        if(resolveFn!=null)
-            resolveFn("Timeout");
-        timerP=null;
-        timer=null;
-        resolveFn=null;
-    }
+        verifyFn = ()=>Completed;
 
     //进行中的请求
-	const plist:Promise<ProcessingPromise<T>>[] = [];
+	const plist:Promise<
+        CompleteCome<ProcessingPromise<T>>|
+        TimeoutCome<ProcessingPromise<T>>
+    >[] = [];
 
     //开始处理
     try{
+        //根据最大重试次数限制进行循环
         for(let i=0;i<repeatCount;){
             SLogger.info(`开始第 ${i+1} 次 repeatPromise`);
-            //创建当前任务
-            if(plist.length<i+1){
-                plist.push(procFn().then(result =>
-                    ({result, stat:verifyFn!(result), index:i})));
-            }
 
-            //创建定时器
-            if(timerP==null){
-                timerP = new Promise<"Timeout">(function(resolve, rejecte){
-                    resolveFn = resolve;
-                    timer = setTimeout(()=>resolve("Timeout"),
-                        hasRepeatTime? repeatTime:Infinity);//无限制则无限时间
-                })
+            //如果 plist 中当前下标的任务还未创建 则 创建当前任务
+            if(plist.length<i+1){
+                plist.push(UtilFunc.timelimitPromise<ProcessingPromise<T>>(async ()=>{
+                    const result = await procFn();
+                    const stat = await verifyFn!(result);
+                    return {result, stat, index:i}
+                }));
             }
 
-            //等待完成
-            const currObj = await Promise.race([...plist, timerP]);
+            //等待任意任务 或当前计时器完成
+            const currObj = await Promise.race([...plist]);
 
             //超时处理
-            if(currObj=="Timeout"){
+            if(currObj.status===Timeout){
+                //解除timeout替换原参数
+                plist[i]=new Promise(async (rslove)=>{
+                    const res = await currObj.result;
+                    rslove(outcome(Completed,res));
+                })
                 SLogger.warn(`第 ${i+1} 次 repeatPromise 超时 ${repeatTime} ms 开始重试`);
-                clearTimer(); i++;
+                i++;
                 continue;
             }
-            const poststat = await currObj.stat;
-            switch(poststat){
-                case "Completed"://完成
-                    SLogger.info(`第 ${currObj.index+1} 次 repeatPromise 成功`);
+
+            //路由请求状态
+            const postresult = currObj.result;
+            const result = match(postresult.stat,{
+                [Completed](){
+                    SLogger.info(`第 ${postresult.index+1} 次 repeatPromise 成功`);
                     //非当前
-                    if(currObj.index!=i)
+                    if(postresult.index!=i)
                         SLogger.info(`成功的 promise 非当前 promise 考虑增大重试间隔\n当前index: ${i}\n当前间隔: ${repeatTime}`);
-                    return currObj.result;
-                case "Terminated"://终止
-                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 终止 停止重试`);
-                    return currObj.result;
-                case "Failed"://验证失败
+                    return postresult.result;
+                },
+                [Terminated](){
+                    SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 终止 停止重试`);
+                    return postresult.result;
+                },
+                [Failed]():None{
                     //抛弃失败
-                    plist[currObj.index] = UtilFunc.getNeverResolvedPromise();
+                    plist[postresult.index] = UtilFunc.getNeverResolvedPromise();
                     //是当前
-                    if(currObj.index==i){
-                        SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败 开始重试`);
-                        clearTimer(); i++;
-                        continue;
+                    if(postresult.index==i){
+                        SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 失败 开始重试`);
+                        i++;
+                        return None;
                     }
                     //非当前
-                    SLogger.warn(`第 ${currObj.index+1} 次 repeatPromise 失败`);
-                    continue;
-            }
+                    SLogger.warn(`第 ${postresult.index+1} 次 repeatPromise 失败`);
+                    return None;
+                },
+            });
+            if(result !== None) return result;
         }
         //全部失败或超时则返回null
         SLogger.warn(`${repeatCount} 次 repeatPromise 尝试均失败`);
@@ -227,13 +234,47 @@ export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:Promise
     }catch(err){
         SLogger.warn(`repeatPromise 发生错误`,err);
         return null;
-    }finally{
-        //清理
-        clearTimer();
-        SLogger.timeEnd(timeflag);
     }
 }
 
+
+/**创建一个限时的Promise  
+ * @param func      - 处理函数
+ * @param timeLimit - 毫秒限时
+ * @returns 超时则返回 处理函数委托 完成则返回结果
+ */
+static timelimitPromise<T>
+    (func:()=>Promise<T>|T,timeLimit?:number):Promise<CompleteCome<T>|TimeoutCome<T>>{
+    return new Promise<CompleteCome<T>|TimeoutCome<T>>((reslove)=>{
+        let clearTimer:(()=>void)| null = null;
+        let proc = (async ()=>await func())();
+
+        const procerP = new Promise<CompleteCome<T>>(async (resolve)=>{
+            const res = await proc;
+            if(clearTimer) clearTimer();
+            resolve(outcome(Completed,res))
+        });
+
+        const timerP = timeLimit
+            ? new Promise<TimeoutCome<T>>((resolve)=>{
+                const timer = setTimeout(()=>
+                    resolve(outcome(Timeout,proc))
+                ,timeLimit);//无限制则无限时间
+
+                clearTimer = ()=>{
+                    resolve(outcome(Timeout,proc))
+                    clearInterval(timer)
+                }
+            })
+            : UtilFunc.getNeverResolvedPromise<TimeoutCome<T>>();
+
+        const result = Promise.race([procerP,timerP]);
+        reslove(result);
+    })
+}
+
+
+
 /**部分类组合  
  * 将mixin的部分字段混入base  
  * @param base   - 基础类
@@ -242,7 +283,7 @@ export async function repeatPromise<T>(procFn:PromiseProcFn<T>,verifyFn?:Promise
  * @param fields - 需要混入的字段
  * @returns 混合完成的类
  */
-export function composeClassPart
+static composeClassPart
     <Base extends object,Mixin extends object,Field extends keyof Mixin>
     (base:Base,mixin:Mixin,key:string,...fields:Field[]):ComposedClass<Base,Mixin,typeof key,Field>{
     const compObj = base as any;
@@ -277,7 +318,7 @@ export function composeClassPart
 }
 
 /**根据 MIXIN_FIELDS 自动混入 */
-export function composeMixinable
+static composeMixinable
     <Base extends object, Mixins extends Mixinable<any>[]>
     (base:Base,...mixins:Mixins):
     ComposedMixinable<Base,Mixins>{
@@ -292,7 +333,7 @@ export function composeMixinable
             else
                 fieldsSet.add(fixField);
         }
-        out = composeClassPart(base,mixin,mixin.MIXIN_KEY,...mixin.MIXIN_FIELDS);
+        out = UtilFunc.composeClassPart(base,mixin,mixin.MIXIN_KEY,...mixin.MIXIN_FIELDS);
     }
     return out as any;
 }
@@ -304,7 +345,7 @@ export function composeMixinable
  * @param mapper    - 映射函数，接受一个值和一个键，返回一个新的值
  * @returns         - 一个新的对象，它的属性是原对象的属性经过映射函数处理后的结果
  */
-export function mapEntries<T extends Object>
+static mapEntries<T extends Object>
     (obj: T, mapper: (key: keyof T, value: T[keyof T]) => T[keyof T]): T {
     return Object.entries(obj).reduce((result, [key, value]) => {
         result[key as keyof T] = mapper(key as keyof T, value);
@@ -312,4 +353,15 @@ export function mapEntries<T extends Object>
     }, {} as T);
 }
 
+/**将JToken转换为字符串
+ * @param token - 待转换的Token
+ * @param space - 插入的空格 数字为空格数量 默认为制表符\t
+ * @returns 转换完成的字符串
+ */
+static 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

@@ -1,3 +1,4 @@
+import { Completed, Failed, Terminated } from "./UtilSymbol";
 
 
 /**可以序列化为JSON文件的对象 */
@@ -16,16 +17,9 @@ 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 Keyable = string | number | symbol;
 
 /**转为可写的 */
 export type Writeable<T> = {
@@ -73,18 +67,17 @@ export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string
 
 
 /**请求完成状态 成功/失败/终止  
- * 成功/终止 将直接返回  
+ * 成功 将直接返回  结果  
+ * 终止 将直接返回  null  
  * 失败 将重试  
  */
-export type PromiseStat = "Completed"|"Failed"|"Terminated";
+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 +85,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 +101,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 Keyable,V> = {
+    /**状态类型 */
+    status:K;
+    /**值 */
+    result:V;
+}
+
+/**从联合 Outcome 中 根据 id 提取对应 value 的 type */
+export type ExtractOutcome<T,K extends Keyable> =
+    T extends Outcome<K,unknown> ? T : never;
+

package/src/UtilSymbol.ts

@@ -0,0 +1,15 @@
+/**完成 */
+export const Completed = Symbol("Completed");
+export type Completed = typeof Completed;
+/**失败 */
+export const Failed = Symbol("Failed");
+export type Failed = typeof Failed;
+/**终止 */
+export const Terminated = Symbol("Terminated");
+export type Terminated = typeof Terminated;
+/**不存在 */
+export const None = Symbol("None");
+export type None = typeof None;
+/**超时 */
+export const Timeout = Symbol("Timeout");
+export type Timeout = typeof Timeout;

package/src/index.ts

@@ -1,5 +1,6 @@
 export * from './UtilFunctions';
 export * from './UtilInterfaces';
+export * from './UtilSymbol';
 export * from './UtilClass';
 export * from './UtilCom';
 export * from './UtilCodecs';
@@ -7,4 +8,5 @@ export * from './UtilFfmpegTools';
 export * from './UtilDecorators';
 export * from './UtilFileTools';
 export * from './UtilLogger';
-export * from './UtilFP';
+export * from './UtilFP';
+export * from './QuickFunction';

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">;