@zwa73/utils 1.0.194 → 1.0.196

package/dist/UtilCom.js

@@ -9,37 +9,203 @@ const http_1 = __importDefault(require("http"));
 const UtilLogger_1 = require("./UtilLogger");
 const UtilFunctions_1 = require("./UtilFunctions");
 const querystring_1 = __importDefault(require("querystring"));
-/**网络工具 */
-var UtilCom;
-(function (UtilCom) {
+const UtilSymbol_1 = require("./UtilSymbol");
+const AcceptTypeList = ["json"];
+const SendTypeList = ["json", "none"];
+const defSend = {
+    proc: () => (req) => void req.end()
+};
+const defAccept = {
+    init: '',
+    reduce: (acc, dat) => acc + dat,
+    parse: (result) => void console.log(result)
+};
+/**网络请求工具 */
+class UtilCom {
+    _data;
+    _send;
+    _accept;
+    constructor(_data, _send, _accept) {
+        this._data = _data;
+        this._send = _send;
+        this._accept = _accept;
+    }
+    //#region 快速流式创建
+    /**设为https请求 */
+    static https() {
+        return new UtilCom({ protocol: 'https:' }, defSend, defAccept);
+    }
+    /**设为http请求 */
+    static http() {
+        return new UtilCom({ protocol: 'http:' }, defSend, defAccept);
+    }
+    /**设为get方式的请求 */
+    get() {
+        return new UtilCom({ ...this._data, method: 'GET' }, this._send, this._accept);
+    }
+    /**设为Post方式的请求 */
+    post() {
+        return new UtilCom({ ...this._data, method: 'POST' }, this._send, this._accept);
+    }
+    /**补充参数 */
+    option(opt) {
+        return new UtilCom({ ...this._data, ...opt }, this._send, this._accept);
+    }
+    //#endregion
+    //#region 接收数据类型
+    /**接收数据类型*/
+    accept(t) {
+        const map = {
+            'json': this.acceptJson(),
+            'log': this.acceptLog(),
+        };
+        return map[t];
+    }
+    acceptJson() {
+        const proc = {
+            init: '',
+            reduce: (acc, curr) => acc + curr,
+            parse: (result) => {
+                if (result == undefined)
+                    return undefined;
+                const { data, ...rest } = result;
+                if (data.trim() == "") {
+                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`);
+                    return { ...result, raw: "", data: null };
+                }
+                try {
+                    const obj = JSON.parse(data.trim());
+                    UtilLogger_1.SLogger.http(`json accept 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }));
+                    return { ...rest, data: obj };
+                }
+                catch (e) {
+                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误:${e}\n原始字符串:${data}`);
+                    return { ...result, raw: data, data: null };
+                }
+            }
+        };
+        return new UtilCom(this._data, this._send, proc);
+    }
+    acceptLog() {
+        const proc = {
+            init: '',
+            reduce: (acc, curr) => acc + curr,
+            parse: (result) => {
+                UtilLogger_1.SLogger.http(`log accept 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
+                if (result == undefined)
+                    return '';
+                const { data, ...rest } = result;
+                return data;
+            }
+        };
+        return new UtilCom(this._data, this._send, proc);
+    }
+    //#endregion
+    //#region 发送数据类型
+    /**发送数据类型*/
+    send(t) {
+        const map = {
+            'json': this.sendJson(),
+            "none": this.sendNone(),
+        };
+        return map[t];
+    }
+    sendJson() {
+        const proc = {
+            proc: (opt, reqData) => {
+                const { method } = opt;
+                const isPost = (method == "POST");
+                if (!isPost && reqData != undefined) {
+                    const queryString = querystring_1.default.stringify(reqData);
+                    if (queryString) {
+                        // 检查当前路径是否已经包含问号
+                        const separator = opt?.path?.includes('?') ? '&' : '?';
+                        opt.path += separator + queryString;
+                    }
+                }
+                if (isPost) {
+                    this._data.headers ??= {
+                        'Content-Type': 'application/json',
+                        'Content-Length': Buffer.from(JSON.stringify(reqData)).length,
+                    };
+                }
+                const procReq = (req) => {
+                    if (isPost)
+                        req.write(JSON.stringify(reqData));
+                    req.end();
+                };
+                return procReq;
+            }
+        };
+        return new UtilCom(this._data, proc, this._accept);
+    }
+    sendNone() {
+        const proc = {
+            proc: (opt) => {
+                const procReq = (req) => {
+                    req.end();
+                };
+                return procReq;
+            }
+        };
+        return new UtilCom(this._data, proc, this._accept);
+    }
+    //#endregion
+    /**发送请求
+     * @param option       - 网络请求选项
+     * @param datas     - 数据对象
+     */
+    async once(option, ...datas) {
+        const fullopt = Object.assign({}, this._data, option);
+        const procReq = await this._send.proc(fullopt, ...datas);
+        const { reduce, init, parse } = this._accept;
+        const res = await UtilCom.comReq(fullopt, procReq, reduce, init);
+        return parse(res);
+    }
+    /**重复发送网络请求
+     * @param option       - 网络请求选项
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+     * @param datas     - 数据对象
+     */
+    async repeat(option, verifyFn, repeatOpt = {}, ...datas) {
+        repeatOpt.tryDelay = repeatOpt.tryDelay ?? 1000;
+        const procFn = () => this.once(option, ...datas);
+        return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatOpt);
+    }
     /**网络请求
      * @param comReqOpt  - 网络请求选项
      * @param procReq    - 请求处理函数 需调用req.end()
      * @param reduceData - 数据处理函数
      * @param initData   - 初始数据
      */
-    async function comReq(comReqOpt, procReq, reduceData, initData) {
-        const { protocol, timeLimit, ...baseReqOpt } = comReqOpt;
-        const hasTimeLimit = (timeLimit ? timeLimit >= 10_000 : false);
-        const flagName = `${comReq.name}.${protocol}${baseReqOpt.method}`;
+    static async comReq(comReqOpt, procReq, reduceData, initData) {
+        const { protocol, timeout, ...baseReqOpt } = comReqOpt;
+        const hasTimeLimit = (timeout ? timeout >= 10_000 : false);
+        const flagName = `UtilCom.${protocol}${baseReqOpt.method}`;
+        const postflag = `comReq:${UtilFunctions_1.UtilFunc.genUUID()}`;
+        let dataPromise = null;
         return new Promise(async (resolve, rejecte) => {
             const resFunc = (res) => {
                 try {
                     //请求超时
                     if (hasTimeLimit) {
-                        res.setTimeout(timeLimit, () => {
-                            UtilLogger_1.SLogger.warn(`${flagName} 接收反馈超时: ${timeLimit} ms`);
+                        res.setTimeout(timeout, () => {
+                            UtilLogger_1.SLogger.warn(`${flagName} 接收反馈超时: ${timeout} ms`);
                             resolve(undefined);
                         });
                     }
                     let mergedata = initData;
                     res.setEncoding('utf8');
-                    res.on('data', chunk => mergedata = reduceData(mergedata, chunk));
+                    res.on('data', chunk => {
+                        dataPromise = UtilFunctions_1.UtilFunc.queueProc(postflag, async () => mergedata = await reduceData(mergedata, chunk));
+                    });
                     res.on('error', (e) => {
                         UtilLogger_1.SLogger.warn(`${flagName} 接收反馈错误:${e}`);
                         resolve(undefined);
                     });
-                    res.on('end', () => {
+                    res.on('end', async () => {
+                        await dataPromise;
                         resolve({
                             headers: res.headers,
                             statusCode: res.statusCode,
@@ -54,19 +220,15 @@ var UtilCom;
                 }
             };
             //路由 http/https
-            const req = protocol == "https"
+            const req = protocol == "https:"
                 ? https_1.default.request(baseReqOpt, resFunc)
                 : http_1.default.request(baseReqOpt, resFunc);
             //请求超时
             if (hasTimeLimit) {
-                req.setTimeout(timeLimit, () => {
-                    UtilLogger_1.SLogger.warn(`${flagName} 发送请求超时: ${timeLimit} ms`);
+                req.setTimeout(timeout, () => {
+                    UtilLogger_1.SLogger.warn(`${flagName} 发送请求超时: ${timeout} ms`);
                     req.destroy();
                 });
-                //req.on('timeout', ()=>{
-                //    SLogger.warn(`${flagName} 发送请求超时(timeout): ${timeLimit} ms`);
-                //    req.destroy();
-                //});
             }
             req.on('error', (e) => {
                 UtilLogger_1.SLogger.warn(`${flagName} 发送请求错误:${e}`);
@@ -75,178 +237,15 @@ var UtilCom;
             await procReq(req);
         });
     }
-    UtilCom.comReq = comReq;
-    /**发送json的网络请求
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    async function jsonReq(comReqOpt, reqData) {
-        const { method } = comReqOpt;
-        const isPost = (method == "POST");
-        if (!isPost && reqData != undefined) {
-            const queryString = querystring_1.default.stringify(reqData);
-            if (queryString) {
-                // 检查当前路径是否已经包含问号
-                const separator = comReqOpt?.path?.includes('?') ? '&' : '?';
-                comReqOpt.path += separator + queryString;
-            }
-        }
-        const procReq = (req) => {
-            if (isPost)
-                req.write(JSON.stringify(reqData));
-            req.end();
-        };
-        const reduceData = (acc, data) => acc + data;
-        const result = await comReq(comReqOpt, procReq, reduceData, "");
-        if (result == undefined)
-            return undefined;
-        const { data, ...rest } = result;
-        if (data.trim() == "") {
-            UtilLogger_1.SLogger.warn(`${jsonReq.name} 接收反馈错误: 原始字符串为空`);
-            return undefined;
-        }
-        try {
-            const obj = JSON.parse(data.trim());
-            UtilLogger_1.SLogger.http(`${jsonReq.name} 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }));
-            return { ...rest, data: obj };
-        }
-        catch (e) {
-            UtilLogger_1.SLogger.warn(`${jsonReq.name} 接收反馈错误:${e}\n原始字符串:${data}`);
-            return undefined;
-        }
-    }
-    /**重复发送json的网络请求
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    async function repeatJsonComReq(comReqOpt, reqData, verifyFn, repeatOpt = {}) {
-        repeatOpt.tryDelay = repeatOpt.tryDelay ?? 1000;
-        const procFn = () => jsonReq(comReqOpt, reqData);
-        return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatOpt);
-    }
-    /**发送一个 https POST 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData     - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsPost(comReqOpt, reqData) {
-        return jsonReq({
-            ...comReqOpt,
-            method: "POST",
-            protocol: "https",
-        }, reqData);
-    }
-    UtilCom.httpsPost = httpsPost;
-    /**发送一个 http POST 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData 	  - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpPost(comReqOpt, reqData) {
-        return jsonReq({
-            ...comReqOpt,
-            method: "POST",
-            protocol: "http",
-        }, reqData);
-    }
-    UtilCom.httpPost = httpPost;
-    /**发送一个 https GET 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData     - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsGet(comReqOpt, reqData) {
-        return jsonReq({
-            ...comReqOpt,
-            method: "GET",
-            protocol: "https",
-        }, reqData);
-    }
-    UtilCom.httpsGet = httpsGet;
-    /**发送一个 http GET 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData 	  - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpGet(comReqOpt, reqData) {
-        return jsonReq({
-            ...comReqOpt,
-            method: "GET",
-            protocol: "http",
-        }, reqData);
-    }
-    UtilCom.httpGet = httpGet;
-    /**重复一个 https POST请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsRepeatPost(comReqOpt, reqData, verifyFn, repeatOpt) {
-        return repeatJsonComReq({
-            ...comReqOpt,
-            method: "POST",
-            protocol: "https",
-        }, reqData, verifyFn, repeatOpt);
-    }
-    UtilCom.httpsRepeatPost = httpsRepeatPost;
-    /**重复一个 http POST请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpRepeatPost(comReqOpt, reqData, verifyFn, repeatOpt) {
-        return repeatJsonComReq({
-            ...comReqOpt,
-            method: "POST",
-            protocol: "http",
-        }, reqData, verifyFn, repeatOpt);
-    }
-    UtilCom.httpRepeatPost = httpRepeatPost;
-    /**重复一个 https GET 请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsRepeatGet(comReqOpt, reqData, verifyFn, repeatOpt) {
-        return repeatJsonComReq({
-            ...comReqOpt,
-            method: "GET",
-            protocol: "https",
-        }, reqData, verifyFn, repeatOpt);
-    }
-    UtilCom.httpsRepeatGet = httpsRepeatGet;
-    /**重复一个 http GET 请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpRepeatGet(comReqOpt, reqData, verifyFn, repeatOpt) {
-        return repeatJsonComReq({
-            ...comReqOpt,
-            method: "GET",
-            protocol: "http",
-        }, reqData, verifyFn, repeatOpt);
-    }
-    UtilCom.httpRepeatGet = httpRepeatGet;
-})(UtilCom || (exports.UtilCom = UtilCom = {}));
+}
+exports.UtilCom = UtilCom;
+if (false)
+    ((async () => {
+        const t = await UtilCom.https().post().accept('json').send('json')
+            .repeat({
+            hostname: 'httpbin.org',
+            path: '/post',
+            timeout: 10000
+        }, () => UtilSymbol_1.Success, {}, { test: 1 });
+        console.log(t);
+    })());

package/dist/UtilFunctions.d.ts

@@ -1,4 +1,4 @@
-import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, ReqVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment } from "./UtilInterfaces";
+import { PRecord, AnyFunc, ExtractOutcome, IJData, JObject, JToken, Keyable, Literal, Matchable, MatchableFlag, Outcome, StatusVerifyFn, ProperSubsetCheck, UnionToIntersection, AnyRecord, AllExtends, SrtSegment, MPromise } from "./UtilInterfaces";
 import { LogLevel } from "./UtilLogger";
 import { Failed, FailedLike, None, StatusSymbol, Success, SuccessLike, Timeout } from "./UtilSymbol";
 declare const HashMethodList: readonly ["md5", "sha1", "sha256", "sha512", "sha3", "blake2", "blake3"];
@@ -113,13 +113,13 @@ export declare class UtilFunc {
      * @param opt         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
      * @returns 重复结果
      */
-    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: ReqVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<T>>;
+    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: StatusVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<T>>;
     /**创建一个限时的Promise
      * @param func      - 处理函数
      * @param timeLimit - 毫秒限时
      * @returns 超时则返回 处理函数委托 完成则返回结果
      */
-    static timelimitPromise<T>(func: () => Promise<T> | T, timeLimit?: number): Promise<SuccessOut<T> | TimeoutOut<T>>;
+    static timelimitPromise<T>(func: () => MPromise<T>, timeLimit?: number): Promise<SuccessOut<T> | TimeoutOut<T>>;
     /**对对象的每个属性应用映射函数，并返回一个新的对象。
      * @template T      - 对象的类型
      * @param obj       - 要处理的对象

package/dist/UtilInterfaces.d.ts

@@ -93,14 +93,14 @@ type ExclusiveRecursive<B, T, K extends string[], R extends unknown[] = []> = R[
 export type ExclusiveRecord<B, T, K extends string[], TMP = ExclusiveRecursive<B, T, K>> = TMP[keyof TMP];
 /**符合JObject约束的互斥表 */
 export type ExclusiveJObject<B extends JObject, T extends JToken, K extends string[], TMP extends JArray = ExclusiveRecursive<B, T, K>> = TMP[number];
-/**请求完成状态 成功/失败/终止
- * 成功 将直接返回  结果
- * 终止 将直接返回  null
+/**Promise完成状态 成功/失败/终止
+ * 成功 将直接返回 结果
+ * 终止 将直接返回 结果
  * 失败 将重试
  */
-export type ReqStat = Success | Failed | Terminated;
-/**请求状态验证函数 */
-export type ReqVerifyFn<T> = (obj: T) => Promise<ReqStat> | ReqStat;
+export type PromiseStatus = Success | Failed | Terminated;
+/**状态验证函数 */
+export type StatusVerifyFn<T> = (obj: T) => Promise<PromiseStatus> | PromiseStatus;
 /**获取Promise的结果类型 如同await那样
  * @deprecated 请使用官方的 Awaited<T> 类型
  */
@@ -154,8 +154,10 @@ export type NeedInit = {
     /**完成初始化的标记 */
     inited: Promise<any>;
 };
-/**可选的record */
+/**可选的record PartialRecord */
 export type PRecord<K extends Keyable, V> = Partial<Record<K, V>>;
+/** 可以是Promise MaybePromise*/
+export type MPromise<T> = T | Promise<T>;
 /**任何Record */
 export type AnyRecord = Record<Keyable, any>;
 /**注释元组

package/package.json

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

package/src/UtilClass.ts

@@ -1,5 +1,5 @@
 import { matchProc } from "./QuickExport";
-import { Keyable, Literal } from "./UtilInterfaces";
+import { Keyable, Literal, MPromise } from "./UtilInterfaces";
 import Handlebars from 'handlebars';
 import { SLogger } from "./UtilLogger";
 
@@ -38,7 +38,8 @@ export class Piper<Arg, Result = Arg> {
 }
 
 
-type StreamOperation<T, U> = (item: T)=>Promise<U>|U;
+//#region 并行流
+type StreamOperation<T, U> = (item: T)=>MPromise<U>;
 /**并行流 */
 export class Stream<T> implements Iterable<T>{
     /**并发数*/
@@ -52,13 +53,16 @@ export class Stream<T> implements Iterable<T>{
         else this._list = new Array(...base);
         this._concurrent = concurrent;
     }
-    /**从arraylike创建流 */
-    static from<T>(args:Parameters<typeof Array.from<T>>[0],concurrent:number=1){
-        return new Stream<T>(Array.from(args),concurrent);
+    /**从arraylike创建流
+     * @param args - arraylike
+     * @param concurrent - 并发数 默认 1
+     */
+    static from<T>(args:ArrayLike<T>,concurrent:number=1){
+        return new Stream(Array.from(args),concurrent);
     }
     /**从数组创建流 */
     static of<T>(...args:T[]){
-        return new Stream<T>(args);
+        return new Stream(args);
     }
     /**设置并发数 */
     concurrent(count: number): Stream<T> {
@@ -204,6 +208,8 @@ export class Stream<T> implements Iterable<T>{
         return this._list.length;
     }
 }
+//#endregion
+
 
 /**文本模板渲染器
  * @template T - 上下文对象的类型，默认为记录类型
@@ -248,3 +254,6 @@ export class Hbs<T extends Record<Keyable,any> = Record<Keyable,any>>{
         }
     }
 }
+
+
+