@zwa73/utils 1.0.198 → 1.0.199

package/dist/UtilCom.d.ts

@@ -1,8 +1,9 @@
 import { AnyString, JToken, MPromise, PartialOption, StatusVerifyFn } from "./UtilInterfaces";
 import http from 'http';
-import { RepeatPromiseOpt } from "./UtilFunctions";
+import { PromiseRetries } from "./UtilFunctions";
+import FormData from "form-data";
 /**网络请求返回值 */
-export type ComResp<T> = {
+export type RequestResult<T> = {
     /**响应头 */
     headers: http.IncomingHttpHeaders;
     /**响应状态码 */
@@ -11,7 +12,7 @@ export type ComResp<T> = {
     data: T;
 };
 /**网络请求选项 */
-export type ComRequestOption = {
+export type RequestOption = {
     /**请求协议 */
     protocol: 'http:' | 'https:';
     /**超时时间/毫秒  最小为10_000 默认无限 */
@@ -27,41 +28,41 @@ export type ComRequestOption = {
     /**请求头 */
     headers?: {
         /**内容类型 */
-        'Content-Type'?: 'application/json' | AnyString;
+        'Content-Type'?: 'application/json' | 'multipart/form-data' | AnyString;
         /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
         'Content-Length'?: number;
     };
 } & http.RequestOptions;
-/**get请求所允许的数据 */
-export type GetReqData = NodeJS.Dict<string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>;
+/**getquery请求所允许的数据 */
+export type QueryRequestData = NodeJS.Dict<string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>;
 /**请求处理函数 需调用req.end() */
-export type ProcReqFn = ((req: http.ClientRequest) => MPromise<void>);
+export type RequestProcFn = ((req: http.ClientRequest) => MPromise<void>);
 /**数据处理函数 */
-export type ReduceDataFn<T> = (acc: T, data: string) => MPromise<T>;
-declare const AcceptTypeList: readonly ["json"];
+export type RequestReduceFn<T> = (acc: T, data: string) => MPromise<T>;
+declare const AcceptTypeList: readonly ["json", "raw"];
 /**可用的接受类型 */
 type AcceptType = typeof AcceptTypeList[number];
-declare const SendTypeList: readonly ["json", "none"];
+declare const SendTypeList: readonly ["json", "query", "formData", "none", "raw"];
 /**可用的发送类型 */
 type SendType = typeof SendTypeList[number];
 /**accept处理数据 */
 type AcceptProc<D, T> = {
     init: D;
-    reduce: ReduceDataFn<D>;
-    parse: (result: ComResp<D> | undefined) => MPromise<T>;
+    reduce: RequestReduceFn<D>;
+    parse: (result: RequestResult<D> | undefined) => MPromise<T>;
 };
 /**send处理数据 */
 type SendProc<T extends any[]> = {
-    proc: (opt: ComRequestOption, ...args: T) => MPromise<ProcReqFn>;
+    proc: (opt: RequestOption, ...args: T) => MPromise<RequestProcFn>;
 };
+declare const SendNoneProc: SendProc<[]>;
+declare const AcceptRawProc: AcceptProc<string, RequestResult<string> | undefined>;
 /**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>> {
+export declare class UtilCom<D extends Partial<RequestOption> & Required<Pick<RequestOption, 'protocol'>>, S extends SendProc<any>, A extends AcceptProc<any, any>> {
     private _data;
     private _send;
     private _accept;
@@ -69,73 +70,159 @@ export declare class UtilCom<D extends Partial<ComRequestOption>, S extends Send
     /**设为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;
-    }>;
+    }, SendProc<[]>, AcceptProc<string, RequestResult<string> | 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;
-    }>;
+    }, SendProc<[]>, AcceptProc<string, RequestResult<string> | undefined>>;
     /**设为get方式的请求 */
     get(): UtilCom<D & {
-        readonly method: "GET";
+        method: "GET";
     }, S, A>;
     /**设为Post方式的请求 */
     post(): UtilCom<D & {
-        readonly method: "POST";
+        method: "POST";
     }, S, A>;
-    /**补充参数 */
-    option<OPT extends Partial<ComRequestOption>>(opt: OPT): UtilCom<D & OPT, S, A>;
+    /**补充参数
+     * 将会替换对应字段, 修改headers请用header函数
+     */
+    option<OPT extends Partial<RequestOption>>(option: OPT): UtilCom<D & OPT, S, A>;
+    /**补充header */
+    header<HAD extends http.OutgoingHttpHeaders>(headers: HAD): UtilCom<D & {
+        headers: HAD;
+    }, S, A>;
+    /**设置agent */
+    proxyAgent(url: string): this;
+    /**添加一段query */
+    query(data: QueryRequestData): this;
+    /**收发皆为json的预设 */
+    json(): UtilCom<D & {
+        headers: {
+            "Content-Type": "application/json";
+        };
+    }, SendProc<[JToken]>, AcceptProc<string, JToken>>;
     /**收发皆为json的post预设 */
     postJson(): UtilCom<D & {
-        readonly method: "POST";
-    }, SendProc<[JsonType<D & {
-        readonly method: "POST";
-    }>]>, AcceptProc<string, JToken>>;
-    /**收发皆为json的预设 */
-    json(): UtilCom<D, SendProc<[JsonType<D>]>, AcceptProc<string, JToken>>;
+        method: "POST";
+    } & {
+        headers: {
+            'Content-Type': "application/json";
+        };
+    }, SendProc<[JToken]>, AcceptProc<string, JToken>>;
+    /**无查询参数获取json的get预设 */
+    getJson(): UtilCom<D & {
+        method: "GET";
+    }, SendProc<[]>, AcceptProc<string, JToken>>;
+    /**有查询参数获取json的get预设 */
+    queryJson(): UtilCom<D & {
+        method: "GET";
+    }, SendProc<[QueryRequestData]>, AcceptProc<string, JToken>>;
+    /**收发皆为json的https-post预设 */
+    static httpsPostJson(): UtilCom<{
+        readonly protocol: "https:";
+    } & {
+        method: "POST";
+    } & {
+        headers: {
+            'Content-Type': "application/json";
+        };
+    }, SendProc<[JToken]>, AcceptProc<string, JToken>>;
+    /**收发皆为json的http-post预设 */
+    static httpPostJson(): UtilCom<{
+        readonly protocol: "http:";
+    } & {
+        method: "POST";
+    } & {
+        headers: {
+            'Content-Type': "application/json";
+        };
+    }, SendProc<[JToken]>, AcceptProc<string, JToken>>;
+    /**无查询参数获取json的https-get预设 */
+    static httpsGetJson(): UtilCom<{
+        readonly protocol: "https:";
+    } & {
+        method: "GET";
+    }, SendProc<[]>, AcceptProc<string, JToken>>;
+    /**有查询参数获取json的https-get预设 */
+    static httpsQueryJson(): UtilCom<{
+        readonly protocol: "http:";
+    } & {
+        method: "GET";
+    }, SendProc<[QueryRequestData]>, AcceptProc<string, JToken>>;
+    /**无查询参数获取json的http-get预设 */
+    static httpGetJson(): UtilCom<{
+        readonly protocol: "http:";
+    } & {
+        method: "GET";
+    }, SendProc<[]>, AcceptProc<string, JToken>>;
+    /**有查询参数获取json的http-get预设 */
+    static httpQueryJson(): UtilCom<{
+        readonly protocol: "http:";
+    } & {
+        method: "GET";
+    }, SendProc<[QueryRequestData]>, AcceptProc<string, JToken>>;
     /**接收数据类型*/
     accept<T extends AcceptType>(t: T): {
         readonly json: UtilCom<D, S, AcceptProc<string, JToken>>;
-        readonly log: UtilCom<D, S, AcceptProc<string, string>>;
+        readonly raw: UtilCom<D, S, AcceptProc<string, RequestResult<string> | undefined>>;
     }[T];
     acceptJson(): UtilCom<D, S, AcceptProc<string, JToken>>;
-    acceptLog(): UtilCom<D, S, AcceptProc<string, string>>;
+    acceptRaw(): UtilCom<D, S, typeof AcceptRawProc>;
     /**发送数据类型*/
     send<T extends SendType>(t: T): {
-        readonly json: UtilCom<D, SendProc<[JsonType<D>]>, A>;
+        readonly json: UtilCom<D & {
+            headers: {
+                "Content-Type": "application/json";
+            };
+        }, SendProc<[JToken]>, A>;
+        readonly query: UtilCom<D, SendProc<[QueryRequestData]>, A>;
+        readonly formData: UtilCom<D & {
+            headers: {
+                "Content-Type": "multipart/form-data";
+            };
+        }, SendProc<[FormData]>, A>;
         readonly none: UtilCom<D, SendProc<[]>, A>;
+        readonly raw: UtilCom<D, SendProc<[(opt: RequestOption) => RequestProcFn]>, A>;
     }[T];
-    sendJson(): UtilCom<D, SendProc<[JsonType<D>]>, A>;
-    sendNone(): UtilCom<D, SendProc<[]>, A>;
+    /**利用 req.write 发送一段json */
+    sendJson(): UtilCom<D & {
+        headers: {
+            "Content-Type": "application/json";
+        };
+    }, SendProc<[JToken]>, A>;
+    /**利用 appendQuery 直接将数据附加在path上发送请求 */
+    sendQuery(): UtilCom<D, SendProc<[QueryRequestData]>, A>;
+    sendFormData(): UtilCom<D & {
+        headers: {
+            "Content-Type": "multipart/form-data";
+        };
+    }, SendProc<[FormData]>, A>;
+    sendRaw(): UtilCom<D, SendProc<[(opt: RequestOption) => RequestProcFn]>, A>;
+    sendNone(): UtilCom<D, typeof SendNoneProc, A>;
     /**发送请求
-     * @param option       - 网络请求选项
-     * @param datas     - 数据对象
+     * @param option - 网络请求选项
+     * @param datas  - 数据对象
      */
-    once(option: PartialOption<ComRequestOption, D>, ...datas: SendParams<S>): Promise<any>;
+    once(option: PartialOption<RequestOption, D>, ...datas: SendParams<S>): Promise<any>;
     /**重复发送网络请求
-     * @param option       - 网络请求选项
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @param datas     - 数据对象
+     * @param option  - 网络请求选项
+     * @param verify  - 有效性验证函数
+     * @param retries - 重试选项 默认 延迟: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   - 初始数据
+    retry(opt: {
+        option: PartialOption<RequestOption, D>;
+        verify?: StatusVerifyFn<ParseResult<A>>;
+        retries?: PromiseRetries;
+    }, ...datas: SendParams<S>): Promise<import("./UtilFunctions").PromiseRetryResult<ParseResult<A>>>;
+    /**发送网络请求
+     * @param option  - 网络请求选项
+     * @param proc    - 请求处理函数 需调用req.end()
+     * @param reduce  - 数据处理函数
+     * @param init    - 初始数据
      */
-    static comReq<T>(comReqOpt: ComRequestOption, procReq: ProcReqFn, reduceData: ReduceDataFn<T>, initData: T): Promise<ComResp<T> | undefined>;
+    static request<T>(option: RequestOption, proc: RequestProcFn, reduce: RequestReduceFn<T>, init: T): Promise<RequestResult<T> | undefined>;
+    /**构建query */
+    static buildQuery(base: string, data: QueryRequestData): string;
 }
 export {};

package/dist/UtilCom.js

@@ -4,21 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilCom = void 0;
-const https_1 = __importDefault(require("https"));
 const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
 const UtilLogger_1 = require("./UtilLogger");
 const UtilFunctions_1 = require("./UtilFunctions");
 const querystring_1 = __importDefault(require("querystring"));
 const UtilSymbol_1 = require("./UtilSymbol");
-const AcceptTypeList = ["json"];
-const SendTypeList = ["json", "none"];
-const defSend = {
-    proc: () => (req) => void req.end()
+const http_proxy_agent_1 = __importDefault(require("http-proxy-agent"));
+const https_proxy_agent_1 = __importDefault(require("https-proxy-agent"));
+const AcceptTypeList = ["json", "raw"];
+const SendTypeList = ["json", "query", "formData", "none", "raw"];
+const SendNoneProc = {
+    proc: (opt) => (req) => void req.end()
 };
-const defAccept = {
+const AcceptRawProc = {
     init: '',
     reduce: (acc, dat) => acc + dat,
-    parse: (result) => void console.log(result)
+    parse: (result) => result
 };
 /**网络请求工具 */
 class UtilCom {
@@ -30,36 +32,94 @@ class UtilCom {
         this._send = _send;
         this._accept = _accept;
     }
-    //#region 快速流式创建
+    //#region 流式创建
     /**设为https请求 */
     static https() {
-        return new UtilCom({ protocol: 'https:' }, defSend, defAccept);
+        return new UtilCom({ protocol: 'https:' }, SendNoneProc, AcceptRawProc);
     }
     /**设为http请求 */
     static http() {
-        return new UtilCom({ protocol: 'http:' }, defSend, defAccept);
+        return new UtilCom({ protocol: 'http:' }, SendNoneProc, AcceptRawProc);
     }
     /**设为get方式的请求 */
     get() {
-        return new UtilCom({ ...this._data, method: 'GET' }, this._send, this._accept);
+        this._data.method = 'GET';
+        return this;
     }
     /**设为Post方式的请求 */
     post() {
-        return new UtilCom({ ...this._data, method: 'POST' }, this._send, this._accept);
+        this._data.method = 'POST';
+        return this;
+    }
+    /**补充参数
+     * 将会替换对应字段, 修改headers请用header函数
+     */
+    option(option) {
+        this._data = { ...this._data, ...option };
+        return this;
+    }
+    /**补充header */
+    header(headers) {
+        this._data.headers = {
+            ...this._data.headers,
+            ...headers,
+        };
+        return this;
     }
-    /**补充参数 */
-    option(opt) {
-        return new UtilCom({ ...this._data, ...opt }, this._send, this._accept);
+    /**设置agent */
+    proxyAgent(url) {
+        this._data.agent = UtilFunctions_1.UtilFunc.matchProc(this._data['protocol'], {
+            'http:': () => (0, http_proxy_agent_1.default)(url),
+            'https:': () => (0, https_proxy_agent_1.default)(url),
+        });
+        return this;
+    }
+    /**添加一段query */
+    query(data) {
+        this._data.path = UtilCom.buildQuery(this._data.path ?? '', data);
+        return this;
     }
     //#endregion
     //#region 快速预设
+    /**收发皆为json的预设 */
+    json() {
+        return this.sendJson().acceptJson();
+    }
     /**收发皆为json的post预设 */
     postJson() {
         return this.post().json();
     }
-    /**收发皆为json的预设 */
-    json() {
-        return this.sendJson().acceptJson();
+    /**无查询参数获取json的get预设 */
+    getJson() {
+        return this.get().sendNone().acceptJson();
+    }
+    /**有查询参数获取json的get预设 */
+    queryJson() {
+        return this.get().sendQuery().acceptJson();
+    }
+    /**收发皆为json的https-post预设 */
+    static httpsPostJson() {
+        return UtilCom.https().postJson();
+    }
+    /**收发皆为json的http-post预设 */
+    static httpPostJson() {
+        return UtilCom.http().postJson();
+    }
+    /**无查询参数获取json的https-get预设 */
+    static httpsGetJson() {
+        return UtilCom.https().getJson();
+    }
+    /**有查询参数获取json的https-get预设 */
+    static httpsQueryJson() {
+        return UtilCom.http().queryJson();
+    }
+    /**无查询参数获取json的http-get预设 */
+    static httpGetJson() {
+        return UtilCom.http().getJson();
+    }
+    /**有查询参数获取json的http-get预设 */
+    static httpQueryJson() {
+        return UtilCom.http().queryJson();
     }
     //#endregion
     //#region 接收数据类型
@@ -67,7 +127,7 @@ class UtilCom {
     accept(t) {
         const map = {
             'json': this.acceptJson(),
-            'log': this.acceptLog(),
+            'raw': this.acceptRaw(),
         };
         return map[t];
     }
@@ -80,7 +140,7 @@ class UtilCom {
                     return undefined;
                 const { data, ...rest } = result;
                 if (data.trim() == "") {
-                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`);
+                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
                     return { ...result, raw: "", data: null };
                 }
                 try {
@@ -89,26 +149,17 @@ class UtilCom {
                     return { ...rest, data: obj };
                 }
                 catch (e) {
-                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误:${e}\n原始字符串:${data}`);
+                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误:${e}`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
                     return { ...result, raw: data, data: null };
                 }
             }
         };
-        return new UtilCom(this._data, this._send, proc);
+        this._accept = proc;
+        return this;
     }
-    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);
+    acceptRaw() {
+        this._accept = AcceptRawProc;
+        return this;
     }
     //#endregion
     //#region 发送数据类型
@@ -116,29 +167,21 @@ class UtilCom {
     send(t) {
         const map = {
             'json': this.sendJson(),
-            "none": this.sendNone(),
+            'query': this.sendQuery(),
+            'formData': this.sendFormData(),
+            'none': this.sendNone(),
+            'raw': this.sendRaw(),
         };
         return map[t];
     }
+    /**利用 req.write 发送一段json */
     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,
-                    };
-                }
+                this._data.headers ??= {};
+                this._data.headers['Content-Length'] = Buffer.byteLength(JSON.stringify(reqData));
                 const procReq = (req) => {
                     if (isPost)
                         req.write(JSON.stringify(reqData));
@@ -147,52 +190,85 @@ class UtilCom {
                 return procReq;
             }
         };
-        return new UtilCom(this._data, proc, this._accept);
+        this._send = proc;
+        this._data.headers ??= {};
+        this._data.headers['Content-Type'] = 'application/json';
+        return this;
     }
-    sendNone() {
+    /**利用 appendQuery 直接将数据附加在path上发送请求 */
+    sendQuery() {
         const proc = {
-            proc: (opt) => {
+            proc: (opt, reqData) => {
+                opt.path = UtilCom.buildQuery(opt.path ?? '', reqData);
+                const procReq = (req) => void req.end();
+                return procReq;
+            }
+        };
+        this._send = proc;
+        return this;
+    }
+    sendFormData() {
+        const proc = {
+            proc: (opt, formData) => {
+                opt.headers = formData.getHeaders();
                 const procReq = (req) => {
+                    formData.pipe(req);
                     req.end();
                 };
                 return procReq;
-            }
+            },
         };
-        return new UtilCom(this._data, proc, this._accept);
+        this._send = proc;
+        this._data.headers ??= {};
+        this._data.headers['Content-Type'] = 'multipart/form-data';
+        return this;
+    }
+    sendRaw() {
+        const proc = {
+            proc: (opt, fn) => fn(opt),
+        };
+        this._send = proc;
+        return this;
+    }
+    sendNone() {
+        this._send = SendNoneProc;
+        return this;
     }
     //#endregion
     /**发送请求
-     * @param option       - 网络请求选项
-     * @param datas     - 数据对象
+     * @param option - 网络请求选项
+     * @param datas  - 数据对象
      */
     async once(option, ...datas) {
         const fullopt = Object.assign({}, this._data, option);
-        const procReq = await this._send.proc(fullopt, ...datas);
+        const proc = await this._send.proc(fullopt, ...datas);
         const { reduce, init, parse } = this._accept;
-        const res = await UtilCom.comReq(fullopt, procReq, reduce, init);
+        const res = await UtilCom.request(fullopt, proc, reduce, init);
         return parse(res);
     }
     /**重复发送网络请求
-     * @param option       - 网络请求选项
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @param datas     - 数据对象
+     * @param option  - 网络请求选项
+     * @param verify  - 有效性验证函数
+     * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+     * @param datas   - 数据对象
      */
-    async repeat(option, verifyFn, repeatOpt = {}, ...datas) {
-        repeatOpt.tryDelay = repeatOpt.tryDelay ?? 1000;
+    async retry(opt, ...datas) {
+        let { option, retries, verify } = opt;
+        retries ??= {};
+        retries.tryDelay = retries.tryDelay ?? 1000;
         const procFn = () => this.once(option, ...datas);
-        return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatOpt);
+        return UtilFunctions_1.UtilFunc.retryPromise(procFn, verify, retries);
     }
-    /**网络请求
-     * @param comReqOpt  - 网络请求选项
-     * @param procReq    - 请求处理函数 需调用req.end()
-     * @param reduceData - 数据处理函数
-     * @param initData   - 初始数据
+    /**发送网络请求
+     * @param option  - 网络请求选项
+     * @param proc    - 请求处理函数 需调用req.end()
+     * @param reduce  - 数据处理函数
+     * @param init    - 初始数据
      */
-    static async comReq(comReqOpt, procReq, reduceData, initData) {
-        const { protocol, timeout, ...baseReqOpt } = comReqOpt;
+    static async request(option, proc, reduce, init) {
+        const { protocol, timeout, ...baseReqOpt } = option;
         const hasTimeLimit = (timeout ? timeout >= 10_000 : false);
-        const flagName = `UtilCom.comReq ${protocol}${baseReqOpt.method} ${UtilFunctions_1.UtilFunc.genUUID()}`;
+        const flagName = `UtilCom.request ${protocol}${baseReqOpt.method} ${UtilFunctions_1.UtilFunc.genUUID()}`;
         let dataPromise = null;
         return new Promise(async (resolve, rejecte) => {
             const resFunc = (res) => {
@@ -204,10 +280,10 @@ class UtilCom {
                             resolve(undefined);
                         });
                     }
-                    let mergedata = initData;
+                    let mergedata = init;
                     res.setEncoding('utf8');
                     res.on('data', chunk => {
-                        dataPromise = UtilFunctions_1.UtilFunc.queueProc(flagName, async () => mergedata = await reduceData(mergedata, chunk));
+                        dataPromise = UtilFunctions_1.UtilFunc.queueProc(flagName, async () => mergedata = await reduce(mergedata, chunk));
                     });
                     res.on('error', (e) => {
                         UtilLogger_1.SLogger.warn(`${flagName} 接收反馈错误:${e}`);
@@ -243,18 +319,32 @@ class UtilCom {
                 UtilLogger_1.SLogger.warn(`${flagName} 发送请求错误:${e}`);
                 resolve(undefined);
             });
-            await procReq(req);
+            await proc(req);
         });
     }
+    /**构建query */
+    static buildQuery(base, data) {
+        const queryString = querystring_1.default.stringify(data);
+        if (queryString) {
+            // 检查当前路径是否已经包含问号
+            const separator = base.includes('?') ? '&' : '?';
+            base += separator + queryString;
+        }
+        return base;
+    }
 }
 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 });
+        const t = await UtilCom.https().postJson()
+            .retry({
+            option: {
+                hostname: 'httpbin.org',
+                path: '/post',
+                timeout: 10000
+            },
+            verify: () => UtilSymbol_1.Success,
+            retries: {}
+        }, { test: 1 });
         console.log(t);
     })());

package/dist/UtilFileTools.d.ts

@@ -115,7 +115,6 @@ export declare namespace UtilFT {
      */
     function loadJSONFile<T extends JToken>(filePath: string, opt: LoadJsonFileOpt<T>): Promise<T>;
     /**写入JSON文件
-     * void (string,Object)
      * @async
      * @param filePath - 文件路径
      * @param token    - 所要写入的JToken