@zwa73/utils 1.0.195 → 1.0.196

package/dist/UtilClass.js

@@ -203,6 +203,7 @@ class Stream {
     }
 }
 exports.Stream = Stream;
+//#endregion
 /**文本模板渲染器
  * @template T - 上下文对象的类型，默认为记录类型
  */

package/dist/UtilCom.d.ts

@@ -1,6 +1,6 @@
-import { AnyString, JObject, ReqVerifyFn } from "./UtilInterfaces";
+import { AnyString, JToken, MPromise, PartialOption, StatusVerifyFn } from "./UtilInterfaces";
 import http from 'http';
-import { RepeatPromiseOpt, RepeatPromiseResult } from "./UtilFunctions";
+import { RepeatPromiseOpt } from "./UtilFunctions";
 /**网络请求返回值 */
 export type ComResp<T> = {
     /**响应头 */
@@ -11,12 +11,11 @@ export type ComResp<T> = {
     data: T;
 };
 /**网络请求选项 */
-export type ComReqOpt = {
+export type ComRequestOption = {
     /**请求协议 */
-    protocol: 'http' | 'https';
+    protocol: 'http:' | 'https:';
     /**超时时间/毫秒  最小为10_000 默认无限 */
-    timeLimit?: number;
-} & {
+    timeout?: number;
     /**请求域名 */
     hostname: string;
     /**请求路径 */
@@ -35,125 +34,100 @@ export type ComReqOpt = {
 } & http.RequestOptions;
 /**get请求所允许的数据 */
 export type GetReqData = NodeJS.Dict<string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>;
-/**网络工具 */
-export declare namespace UtilCom {
+/**请求处理函数 需调用req.end() */
+export type ProcReqFn = ((req: http.ClientRequest) => MPromise<void>);
+/**数据处理函数 */
+export type ReduceDataFn<T> = (acc: T, data: string) => MPromise<T>;
+declare const AcceptTypeList: readonly ["json"];
+/**可用的接受类型 */
+type AcceptType = typeof AcceptTypeList[number];
+declare const SendTypeList: readonly ["json", "none"];
+/**可用的发送类型 */
+type SendType = typeof SendTypeList[number];
+/**accept处理数据 */
+type AcceptProc<D, T> = {
+    init: D;
+    reduce: ReduceDataFn<D>;
+    parse: (result: ComResp<D> | undefined) => MPromise<T>;
+};
+/**send处理数据 */
+type SendProc<T extends any[]> = {
+    proc: (opt: ComRequestOption, ...args: T) => MPromise<ProcReqFn>;
+};
+/**send处理的参数 */
+type SendParams<T extends SendProc<any>> = T extends SendProc<infer T> ? T : never;
+/**accept处理的结果 */
+type ParseResult<D extends AcceptProc<any, any>> = D extends AcceptProc<any, infer T> ? Awaited<T> : never;
+/**根据方式自动推断json请求的可用数据类型 */
+type JsonType<OPT extends Record<string, any>> = OPT['method'] extends "POST" ? JToken : GetReqData;
+/**网络请求工具 */
+export declare class UtilCom<D extends Partial<ComRequestOption>, S extends SendProc<any>, A extends AcceptProc<any, any>> {
+    private _data;
+    private _send;
+    private _accept;
+    private constructor();
+    /**设为https请求 */
+    static https(): UtilCom<{
+        readonly protocol: "https:";
+    }, {
+        proc: () => (req: http.ClientRequest) => undefined;
+    }, {
+        init: string;
+        reduce: (acc: string, dat: string) => string;
+        parse: (result: ComResp<string> | undefined) => undefined;
+    }>;
+    /**设为http请求 */
+    static http(): UtilCom<{
+        readonly protocol: "http:";
+    }, {
+        proc: () => (req: http.ClientRequest) => undefined;
+    }, {
+        init: string;
+        reduce: (acc: string, dat: string) => string;
+        parse: (result: ComResp<string> | undefined) => undefined;
+    }>;
+    /**设为get方式的请求 */
+    get(): UtilCom<D & {
+        readonly method: "GET";
+    }, S, A>;
+    /**设为Post方式的请求 */
+    post(): UtilCom<D & {
+        readonly method: "POST";
+    }, S, A>;
+    /**补充参数 */
+    option<OPT extends Partial<ComRequestOption>>(opt: OPT): UtilCom<D & OPT, S, A>;
+    /**接收数据类型*/
+    accept<T extends AcceptType>(t: T): {
+        readonly json: UtilCom<D, S, AcceptProc<string, JToken>>;
+        readonly log: UtilCom<D, S, AcceptProc<string, string>>;
+    }[T];
+    acceptJson(): UtilCom<D, S, AcceptProc<string, JToken>>;
+    acceptLog(): UtilCom<D, S, AcceptProc<string, string>>;
+    /**发送数据类型*/
+    send<T extends SendType>(t: T): {
+        readonly json: UtilCom<D, SendProc<[JsonType<D>]>, A>;
+        readonly none: UtilCom<D, SendProc<[]>, A>;
+    }[T];
+    sendJson(): UtilCom<D, SendProc<[JsonType<D>]>, A>;
+    sendNone(): UtilCom<D, SendProc<[]>, A>;
+    /**发送请求
+     * @param option       - 网络请求选项
+     * @param datas     - 数据对象
+     */
+    once(option: PartialOption<ComRequestOption, D>, ...datas: SendParams<S>): Promise<any>;
+    /**重复发送网络请求
+     * @param option       - 网络请求选项
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+     * @param datas     - 数据对象
+     */
+    repeat(option: PartialOption<ComRequestOption, D>, verifyFn?: StatusVerifyFn<ParseResult<A>>, repeatOpt?: RepeatPromiseOpt, ...datas: SendParams<S>): Promise<import("./UtilFunctions").RepeatPromiseResult<ParseResult<A>>>;
     /**网络请求
      * @param comReqOpt  - 网络请求选项
      * @param procReq    - 请求处理函数 需调用req.end()
      * @param reduceData - 数据处理函数
      * @param initData   - 初始数据
      */
-    function comReq<T>(comReqOpt: ComReqOpt, procReq: ((req: http.ClientRequest) => void | Promise<void>), reduceData: (acc: T, data: string) => T, initData: T): Promise<ComResp<T> | undefined>;
-    /**发送一个 https POST 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData     - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**发送一个 http POST 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData 	  - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**发送一个 https GET 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData     - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**发送一个 http GET 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData 	  - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**重复一个 https POST请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsRepeatPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
-    /**重复一个 http POST请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpRepeatPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
-    /**重复一个 https GET 请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsRepeatGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
-    /**重复一个 http GET 请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpRepeatGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
+    static comReq<T>(comReqOpt: ComRequestOption, procReq: ProcReqFn, reduceData: ReduceDataFn<T>, initData: T): Promise<ComResp<T> | undefined>;
 }
+export {};

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);
+    })());