@zwa73/utils 1.0.78 → 1.0.80

package/dist/QuickFunction.d.ts

@@ -1,15 +1,15 @@
-import { ExtractOutcome, Keyable, Outcome } from "./UtilInterfaces";
-/**创建一个outcome */
+import { ExtractOutcome, Keyable, Outcome, UnionToIntersection } from "./UtilInterfaces";
+/**创建一个Outcome */
 export declare function outcome<K extends Keyable, V>(key: K, value: V): Outcome<K, V>;
-/**处理联合 简单值
+/**处理联合值
  * @param t       - 目标值
  * @param procObj - 所有可能的id组成的处理函数映射
  * @returns 任意处理函数的返回值
  */
-export declare function match<T extends Keyable | Outcome<Keyable, unknown>, P extends (T extends Keyable ? {
+export declare function match<T extends Keyable | Outcome<Keyable, unknown>, P extends UnionToIntersection<(T extends Keyable ? {
     [K in T]: (k: K) => unknown;
 } : T extends Outcome<Keyable, unknown> ? {
     [K in T['status']]: (k: K, v: ExtractOutcome<T, K>['result']) => unknown;
-} : never)>(t: T, procObj: P): P extends Record<any, (...args: any) => any> ? {
+} : never)>>(t: T, procObj: P): P extends Record<any, (...args: any) => any> ? {
     [K in keyof P]: ReturnType<P[K]>;
 }[keyof P] : never;

package/dist/QuickFunction.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.match = exports.outcome = void 0;
-/**创建一个outcome */
+/**创建一个Outcome */
 function outcome(key, value) {
     return { status: key, result: value };
 }
 exports.outcome = outcome;
-/**处理联合 简单值
+/**处理联合值
  * @param t       - 目标值
  * @param procObj - 所有可能的id组成的处理函数映射
  * @returns 任意处理函数的返回值

package/dist/UtilFunctions.js

@@ -131,7 +131,7 @@ class UtilFunc {
             repeatTime *= 1000;
         //验证处理函数
         if (verifyFn === undefined)
-            verifyFn = () => UtilSymbol_1.Completed;
+            verifyFn = () => UtilSymbol_1.Success;
         //进行中的请求
         const plist = [];
         //开始处理
@@ -142,10 +142,11 @@ class UtilFunc {
                 //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {
                     plist.push(UtilFunc.timelimitPromise(async () => {
+                        const index = i;
                         const result = await procFn();
                         const stat = await verifyFn(result);
-                        return { result, stat, index: i };
-                    }));
+                        return { result, stat, index };
+                    }, hasRepeatTime ? repeatTime : undefined));
                 }
                 //等待任意任务 或当前计时器完成
                 const currObj = await Promise.race([...plist]);
@@ -163,7 +164,7 @@ class UtilFunc {
                 //路由请求状态
                 const postresult = currObj.result;
                 const result = (0, QuickFunction_1.match)(postresult.stat, {
-                    [UtilSymbol_1.Completed]() {
+                    [UtilSymbol_1.Success]() {
                         UtilLogger_1.SLogger.info(`第 ${postresult.index + 1} 次 repeatPromise 成功`);
                         //非当前
                         if (postresult.index != i)
@@ -208,18 +209,18 @@ class UtilFunc {
     static timelimitPromise(func, timeLimit) {
         return new Promise((reslove) => {
             let clearTimer = null;
-            let proc = (async () => await func())();
+            const procer = (async () => await func())();
             const procerP = new Promise(async (resolve) => {
-                const res = await proc;
+                const res = await procer;
+                resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Completed, res));
                 if (clearTimer)
                     clearTimer();
-                resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Completed, res));
             });
             const timerP = timeLimit
                 ? new Promise((resolve) => {
-                    const timer = setTimeout(() => resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, proc)), timeLimit); //无限制则无限时间
+                    const timer = setTimeout(() => resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, procer)), timeLimit); //无限制则无限时间
                     clearTimer = () => {
-                        resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, proc));
+                        resolve((0, QuickFunction_1.outcome)(UtilSymbol_1.Timeout, procer));
                         clearInterval(timer);
                     };
                 })

package/dist/UtilInterfaces.d.ts

@@ -1,4 +1,4 @@
-import { Completed, Failed, Terminated } from "./UtilSymbol";
+import { Failed, Success, Terminated } from "./UtilSymbol";
 /**可以序列化为JSON文件的对象 */
 export type JToken = JObject | JArray | JValue | IJData;
 /**在stringify输出时 undefine 会被转为 null */
@@ -32,6 +32,11 @@ export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> = R[
  * (string&String)
  */
 export type AnyString = (string & {});
+/**联合类型转为交叉类型
+ * 将联合类型映射为联合函数
+ * 再取得可以传递给任意联合函数的类型
+ */
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
 /**创建一个新的类型，这个新的类型包含了基础类型 B 的所有属性，
  * 以及一个名为 K[N] 类型为 T 的新属性。
  * 所有 K 中非 K[N] 的其他属性都是可选的并且不能被赋值（因为它们的类型是 never）。
@@ -56,7 +61,7 @@ export type ExclusiveJObject<B extends JObject, T extends JToken, K extends stri
  * 终止 将直接返回  null
  * 失败 将重试
  */
-export type PromiseStat = Completed | Failed | Terminated;
+export type PromiseStat = Success | Failed | Terminated;
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj: T) => Promise<PromiseStat> | PromiseStat;
 /**类型中任意函数的字符串名称 */

package/dist/UtilSymbol.d.ts

@@ -1,6 +1,9 @@
 /**完成 */
 export declare const Completed: unique symbol;
 export type Completed = typeof Completed;
+/**成功 */
+export declare const Success: unique symbol;
+export type Success = typeof Success;
 /**失败 */
 export declare const Failed: unique symbol;
 export type Failed = typeof Failed;

package/dist/UtilSymbol.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Timeout = exports.None = exports.Terminated = exports.Failed = exports.Completed = void 0;
+exports.Timeout = exports.None = exports.Terminated = exports.Failed = exports.Success = exports.Completed = void 0;
 /**完成 */
 exports.Completed = Symbol("Completed");
+/**成功 */
+exports.Success = Symbol("Success");
 /**失败 */
 exports.Failed = Symbol("Failed");
 /**终止 */

package/dist/test/repeatTest.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/repeatTest.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const __1 = require("..");
+// 模拟的异步函数，有一定几率失败
+async function mockAsyncFunction() {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            Math.random() > 0.5 ? resolve("Success") : reject("Failure");
+        }, Math.random() % 2000);
+    });
+}
+// 验证函数，只有当结果为 "Success" 时才认为成功
+function mockVerifyFunction(result) {
+    return result === "Success" ? __1.Success : __1.Failed;
+}
+// 测试 repeatPromise 函数
+__1.UtilFunc.repeatPromise(mockAsyncFunction, mockVerifyFunction, 3, 10)
+    .then(result => {
+    console.log("then");
+    if (result === null) {
+        console.log("全部超时");
+    }
+    else {
+        console.log("成功:", result);
+    }
+})
+    .catch(err => {
+    console.error("出现错误", err);
+});

package/package.json

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

package/src/QuickFunction.ts

@@ -1,22 +1,23 @@
-import { ExtractOutcome, Keyable, Outcome } from "./UtilInterfaces";
+import { ExtractOutcome, Keyable, Outcome, UnionToIntersection } from "./UtilInterfaces";
 
-/**创建一个outcome */
+/**创建一个Outcome */
 export function outcome<K extends Keyable,V> (key:K,value:V):Outcome<K,V>{
     return {status:key,result:value}
 }
 
-/**处理联合 简单值
+
+/**处理联合值
  * @param t       - 目标值
  * @param procObj - 所有可能的id组成的处理函数映射
  * @returns 任意处理函数的返回值
  */
 export function match<
     T extends Keyable | Outcome<Keyable, unknown>,
-    P extends (T extends Keyable
+    P extends UnionToIntersection<(T extends Keyable
         ? {[K in T]:(k:K)=>unknown}
         : T extends Outcome<Keyable,unknown> 
-            ? {[K in T['status']]:(k:K,v:ExtractOutcome<T,K>['result'])=>unknown}
-            : never)>
+            ? { [K in T['status']] : (k:K,v:ExtractOutcome<T,K>['result'])=>unknown }
+            : never)>>
     (t:T, procObj:P):
     P extends Record<any,(...args:any)=>any>
         ? {[K in keyof P]: ReturnType<P[K]>}[keyof P]

package/src/UtilFunctions.ts

@@ -2,7 +2,7 @@ import * as crypto from "crypto";
 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 { Completed, Failed, None, Success, Terminated, Timeout } from "./UtilSymbol";
 import { match, outcome } from "./QuickFunction";
 import { LogTimeAsync } from "./UtilDecorators";
 
@@ -160,7 +160,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
 
     //验证处理函数
     if(verifyFn===undefined)
-        verifyFn = ()=>Completed;
+        verifyFn = ()=>Success;
 
     //进行中的请求
 	const plist:Promise<
@@ -177,10 +177,11 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
             //如果 plist 中当前下标的任务还未创建 则 创建当前任务
             if(plist.length<i+1){
                 plist.push(UtilFunc.timelimitPromise<ProcessingPromise<T>>(async ()=>{
+                    const index = i;
                     const result = await procFn();
                     const stat = await verifyFn!(result);
-                    return {result, stat, index:i}
-                }));
+                    return {result, stat, index}
+                },hasRepeatTime?repeatTime:undefined));
             }
 
             //等待任意任务 或当前计时器完成
@@ -201,7 +202,7 @@ static async repeatPromise<T>(procFn:()=>Promise<T>,verifyFn?:PromiseVerifyFn<T>
             //路由请求状态
             const postresult = currObj.result;
             const result = match(postresult.stat,{
-                [Completed](){
+                [Success](){
                     SLogger.info(`第 ${postresult.index+1} 次 repeatPromise 成功`);
                     //非当前
                     if(postresult.index!=i)
@@ -247,22 +248,22 @@ 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 procer = (async ()=>await func())();
 
         const procerP = new Promise<CompleteCome<T>>(async (resolve)=>{
-            const res = await proc;
+            const res = await procer;
+            resolve(outcome(Completed,res));
             if(clearTimer) clearTimer();
-            resolve(outcome(Completed,res))
         });
 
         const timerP = timeLimit
             ? new Promise<TimeoutCome<T>>((resolve)=>{
                 const timer = setTimeout(()=>
-                    resolve(outcome(Timeout,proc))
+                    resolve(outcome(Timeout,procer))
                 ,timeLimit);//无限制则无限时间
 
                 clearTimer = ()=>{
-                    resolve(outcome(Timeout,proc))
+                    resolve(outcome(Timeout,procer))
                     clearInterval(timer)
                 }
             })

package/src/UtilInterfaces.ts

@@ -1,4 +1,4 @@
-import { Completed, Failed, Terminated } from "./UtilSymbol";
+import { Completed, Failed, Success, Terminated } from "./UtilSymbol";
 
 
 /**可以序列化为JSON文件的对象 */
@@ -40,7 +40,16 @@ export type FixedLengthTuple<T, N extends number, R extends unknown[] = []> =
  */
 export type AnyString = (string&{});
 
-
+/**联合类型转为交叉类型  
+ * 将联合类型映射为联合函数  
+ * 再取得可以传递给任意联合函数的类型  
+ */
+export type UnionToIntersection<U> =
+    (U extends any
+        ? (k: U)=>void
+        : never) extends ((k: infer I)=>void)
+            ? I
+            : never
 
 /**创建一个新的类型，这个新的类型包含了基础类型 B 的所有属性，
  * 以及一个名为 K[N] 类型为 T 的新属性。
@@ -71,7 +80,7 @@ export type ExclusiveJObject<B extends JObject,T extends JToken,K extends string
  * 终止 将直接返回  null  
  * 失败 将重试  
  */
-export type PromiseStat = Completed|Failed|Terminated;
+export type PromiseStat = Success|Failed|Terminated;
 /**promise验证函数 */
 export type PromiseVerifyFn<T> = (obj:T)=>Promise<PromiseStat>|PromiseStat;
 

package/src/UtilSymbol.ts

@@ -1,6 +1,9 @@
 /**完成 */
 export const Completed = Symbol("Completed");
 export type Completed = typeof Completed;
+/**成功 */
+export const Success = Symbol("Success");
+export type Success = typeof Success;
 /**失败 */
 export const Failed = Symbol("Failed");
 export type Failed = typeof Failed;

package/src/test/repeatTest.ts

@@ -0,0 +1,29 @@
+import { Completed, Failed, PromiseStat, PromiseVerifyFn, Success, UtilFunc } from "..";
+
+// 模拟的异步函数，有一定几率失败
+async function mockAsyncFunction(): Promise<string> {
+    return new Promise((resolve, reject) => {
+        setTimeout(() => {
+            Math.random() > 0.5 ? resolve("Success") : reject("Failure");
+        }, Math.random()%2000);
+    });
+}
+
+// 验证函数，只有当结果为 "Success" 时才认为成功
+function mockVerifyFunction(result: string): PromiseStat {
+    return result === "Success" ? Success : Failed;
+}
+
+// 测试 repeatPromise 函数
+UtilFunc.repeatPromise(mockAsyncFunction, mockVerifyFunction, 3, 10)
+    .then(result => {
+        console.log("then")
+        if (result === null) {
+            console.log("全部超时");
+        } else {
+            console.log("成功:", result);
+        }
+    })
+    .catch(err => {
+        console.error("出现错误", err);
+    });

package/test/test.bat

@@ -0,0 +1,2 @@
+node test.js
+pause

package/test/test.js

@@ -0,0 +1,37 @@
+const { Completed, Failed, PromiseStat, PromiseVerifyFn, UtilFunc } = require("../dist");
+
+
+let timeList = [21000,5000,1000000]
+let resList  = ["Success","Failure","Failure"]
+let index = 0;
+// 模拟的异步函数，有一定几率失败
+async function mockAsyncFunction() {
+    return new Promise((resolve, reject) => {
+		
+		let delay =timeList[index];
+		let result = resList[index];
+		console.log("延迟: "+delay,"结果: "+result)
+        setTimeout(() => {
+            resolve(result);
+        }, delay);
+		index++;
+    });
+}
+
+// 验证函数，只有当结果为 "Success" 时才认为成功
+function mockVerifyFunction(result) {
+    return result === "Success" ? Completed : Failed;
+}
+
+// 测试 repeatPromise 函数
+UtilFunc.repeatPromise(mockAsyncFunction, mockVerifyFunction, 3, 10)
+    .then(result => {
+        if (result === null) {
+            console.log("全部超时");
+        } else {
+            console.log("成功:", result);
+        }
+    })
+    .catch(err => {
+        console.error("出现错误", err);
+    });