@zwa73/utils 1.0.232 → 1.0.234

package/dist/UtilHttp.d.ts

@@ -2,7 +2,6 @@ import { AnyString, JToken, MPromise, PartialOption, StatusVerifyFn } from "./Ut
 import http from 'http';
 import { PromiseRetries } from "./UtilFunctions";
 import FormData from "form-data";
-import { RequiredOnly } from "@zwa73/js-utils";
 /**网络请求返回值 */
 export type RequestResult<T> = {
     /**响应头 */
@@ -39,34 +38,41 @@ export type RequestOption = {
 /**getquery请求所允许的数据 */
 export type QueryRequestData = NodeJS.Dict<string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>;
 /**请求处理函数 需调用req.end() */
-export type RequestProcFn = ((req: http.ClientRequest) => MPromise<void>);
+export type RequestProcFn = (req: http.ClientRequest) => MPromise<void>;
+/**结果处理函数 */
+export type RequestParseFn<D, R> = (result: RequestResult<D> | undefined) => MPromise<R>;
 /**数据处理函数 */
 export type RequestReduceFn<T> = (acc: T, data: string) => MPromise<T>;
-declare const AcceptTypeList: readonly ["json", "string"];
-/**可用的接受类型 */
-type AcceptType = typeof AcceptTypeList[number];
-declare const SendTypeList: readonly ["json", "query", "formData", "none"];
-/**可用的发送类型 */
-type SendType = typeof SendTypeList[number];
-/**accept处理数据 */
-type AcceptProc<D, T> = {
-    init: D;
-    reduce: RequestReduceFn<D>;
-    parse: (result: RequestResult<D> | undefined) => MPromise<T>;
+/**数据初始化函数 */
+export type RequestInitFn<T> = (res: http.IncomingMessage) => MPromise<T>;
+/**accept处理数据
+ * @template D - 接受时转换的数据类型
+ * @template R - 完成处理的数据类型
+*/
+type AcceptProcCtor<D, R, T extends {}> = AcceptProcData<D, R> | ((arg: T) => MPromise<AcceptProcData<D, R>>);
+type AcceptProcData<D, R> = {
+    init: RequestInitFn<D>;
+    reduce?: RequestReduceFn<D>;
+    parse: RequestParseFn<D, R>;
 };
 /**send处理数据 */
-type SendProc<T extends any[]> = {
-    proc: (opt: RequestOption, ...args: T) => MPromise<RequestProcFn>;
+type SendProcCtor<T extends {}> = SendProcData | ((opt: RequestOption, arg: T) => MPromise<SendProcData>);
+type SendProcData = {
+    proc: RequestProcFn;
 };
-declare const SendNoneProc: SendProc<[]>;
-declare const AcceptStringProc: AcceptProc<string, RequestResult<string> | undefined>;
-declare const AcceptNoneProc: AcceptProc<undefined, undefined>;
+declare const SendNoneProc: SendProcCtor<{}>;
+declare const AcceptStringProc: AcceptProcCtor<string, RequestResult<string> | undefined, {}>;
+declare const AcceptNoneProc: AcceptProcCtor<undefined, RequestResult<undefined> | undefined, {}>;
 /**send处理的参数 */
-type SendParams<P extends SendProc<any>> = P extends SendProc<infer T> ? T : never;
+type SendParams<S extends SendProcCtor<any>> = S extends SendProcCtor<infer P> ? P : never;
+/**send处理的参数 */
+type AcceptParams<A extends AcceptProcCtor<any, any, any>> = A extends AcceptProcCtor<any, any, infer P> ? P : never;
+type HasConflict<A, B> = keyof A & keyof B extends never ? false : true;
+type ConflictCheck<A, B, C> = HasConflict<A, B> extends true ? A & B & C & Error & "❌ A 与 B 有字段冲突" : HasConflict<A, C> extends true ? A & B & C & Error & "❌ A 与 C 有字段冲突" : HasConflict<B, C> extends true ? A & B & C & Error & "❌ B 与 C 有字段冲突" : A & B & C;
 /**accept处理的结果 */
-type ParseResult<P extends AcceptProc<any, any>> = P extends AcceptProc<any, infer T> ? Awaited<T> : never;
+type ParseResult<P extends AcceptProcCtor<any, any, any>> = P extends AcceptProcCtor<any, infer T, any> ? Awaited<T> : never;
 /**http请求工具 */
-export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<RequestOption, 'protocol'>>, S extends SendProc<any>, A extends AcceptProc<any, any>> {
+export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<RequestOption, 'protocol'>>, S extends SendProcCtor<any>, A extends AcceptProcCtor<any, any, any>> {
     private _data;
     private _send;
     private _accept;
@@ -74,11 +80,11 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
     /**设为https请求 */
     static https(): UtilHttp<{
         readonly protocol: "https:";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<string> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<string> | undefined, {}>>;
     /**设为http请求 */
     static http(): UtilHttp<{
         readonly protocol: "http:";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<string> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<string> | undefined, {}>>;
     /**从url创建 */
     static url(urlStr: `${'http:' | 'https:'}//${string}`): UtilHttp<{
         protocol: "http:" | "https:";
@@ -86,7 +92,7 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         hostname: string;
         path: string;
         port: number | undefined;
-    }, SendProc<[]>, AcceptProc<string, RequestResult<string> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<string> | undefined, {}>>;
     /**设为get方式的请求 */
     get(): UtilHttp<D & {
         method: "GET";
@@ -100,11 +106,6 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
      * 将会替换对应字段, 修改headers请用header函数
      */
     option<OPT extends Partial<RequestOption>>(option: OPT): UtilHttp<D & OPT, S, A>;
-    /**完成参数
-     * 会检查必要参数完整性
-     * 将会替换对应字段, 修改headers请用header函数
-     */
-    finalize<OPT extends PartialOption<RequestOption, D>>(option: OPT): UtilHttp<D & OPT, S, A>;
     /**补充header */
     header<HAD extends http.OutgoingHttpHeaders>(headers: HAD): UtilHttp<D & {
         headers: HAD;
@@ -120,7 +121,10 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             "Content-Type": "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, (opt: RequestOption, arg: {
+        /**发送的json */
+        json: JToken;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的post预设 */
     postJson(): UtilHttp<D & {
         method: "POST";
@@ -128,15 +132,21 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, (opt: RequestOption, arg: {
+        /**发送的json */
+        json: JToken;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的get预设 */
     getJson(): UtilHttp<D & {
         method: "GET";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的get预设 */
     queryJson(): UtilHttp<D & {
         method: "GET";
-    }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, (opt: RequestOption, arg: {
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的https-post预设 */
     static httpsPostJson(): UtilHttp<{
         readonly protocol: "https:";
@@ -146,7 +156,10 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, (opt: RequestOption, arg: {
+        /**发送的json */
+        json: JToken;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的http-post预设 */
     static httpPostJson(): UtilHttp<{
         readonly protocol: "http:";
@@ -156,67 +169,57 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, (opt: RequestOption, arg: {
+        /**发送的json */
+        json: JToken;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的https-get预设 */
     static httpsGetJson(): UtilHttp<{
         readonly protocol: "https:";
     } & {
         method: "GET";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的https-get预设 */
     static httpsQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, (opt: RequestOption, arg: {
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的http-get预设 */
     static httpGetJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的http-get预设 */
     static httpQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
-    /**预设的接收数据类型*/
-    accept<T extends AcceptType>(t: T): {
-        readonly json: UtilHttp<D, S, AcceptProc<string, RequestResult<JToken> | undefined>>;
-        readonly string: UtilHttp<D, S, AcceptProc<string, RequestResult<string> | undefined>>;
-        readonly none: UtilHttp<D, S, AcceptProc<undefined, undefined>>;
-    }[T];
-    acceptJson(): UtilHttp<D, S, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, (opt: RequestOption, arg: {
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    acceptJson(): UtilHttp<D, S, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     acceptString(): UtilHttp<D, S, typeof AcceptStringProc>;
     acceptNone(): UtilHttp<D, S, typeof AcceptNoneProc>;
+    acceptFile(): UtilHttp<D, S, (arg: {
+        acceptFilepath: string;
+    }) => MPromise<AcceptProcData<{
+        promise: Promise<boolean>;
+    }, {
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+        /**保存文件路径 */
+        filepath: string;
+    } | undefined>>>;
     /**自定的接收数据类型*/
-    acceptRaw<AD, AT>(proc: AcceptProc<AD, AT>): UtilHttp<D, S, typeof proc>;
-    /**预设的发送数据类型 */
-    send<T extends SendType>(t: T): {
-        readonly json: UtilHttp<D & {
-            headers: {
-                "Content-Type": "application/json";
-            };
-        }, SendProc<[JToken]>, A>;
-        readonly query: UtilHttp<D, SendProc<[QueryRequestData]>, A>;
-        readonly formData: UtilHttp<D & {
-            headers: {
-                "Content-Type": "multipart/form-data";
-            };
-        }, SendProc<[FormData]>, A>;
-        readonly form: UtilHttp<D & {
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded";
-            };
-        }, SendProc<[QueryRequestData]>, A>;
-        readonly file: UtilHttp<D & {
-            headers: {
-                "Content-Type": "multipart/form-data";
-            };
-        }, SendProc<[string, (string | undefined)?]>, A>;
-        readonly none: UtilHttp<D, SendProc<[]>, A>;
-    }[T];
+    acceptRaw<AD, AR, AT extends {}>(proc: AcceptProcCtor<AD, AR, AT>): UtilHttp<D, S, typeof proc>;
     /**发送json
      * 请求参数为 (token:JToken)
      */
@@ -224,58 +227,74 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             "Content-Type": "application/json";
         };
-    }, SendProc<[JToken]>, A>;
-    /**利用 appendQuery 直接将数据附加在path上发送请求
-     * 请求参数为 (form:QueryRequestData)
-     */
-    sendQuery(): UtilHttp<D, SendProc<[QueryRequestData]>, A>;
-    /**发送表单数据
-     * 请求参数为 (formData: FormData)
-     */
+    }, (opt: RequestOption, arg: {
+        /**发送的json */
+        json: JToken;
+    }) => MPromise<SendProcData>, A>;
+    /**利用 appendQuery 直接将表单附加在path上发送请求 */
+    sendQuery(): UtilHttp<D, (opt: RequestOption, arg: {
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }) => MPromise<SendProcData>, A>;
+    /**发送form-data包提供的表单数据  */
     sendFormData(): UtilHttp<D & {
         headers: {
             "Content-Type": "multipart/form-data";
         };
-    }, SendProc<[FormData]>, A>;
-    /**发送表单
-     * 请求参数为 (form:QueryRequestData)
-     */
+    }, (opt: RequestOption, arg: {
+        /**form-data包提供的FormData表单数据 */
+        formdata: FormData;
+    }) => MPromise<SendProcData>, A>;
+    /**发送表单 */
     sendForm(): UtilHttp<D & {
         headers: {
             "Content-Type": "application/x-www-form-urlencoded";
         };
-    }, SendProc<[QueryRequestData]>, A>;
-    /**发送文件
-     * 请求参数为 (filepath:string, filename?: string)
-     */
+    }, (opt: RequestOption, arg: {
+        /**表单 */
+        form: QueryRequestData;
+    }) => MPromise<SendProcData>, A>;
+    /**发送文件 */
     sendFile(): UtilHttp<D & {
         headers: {
             "Content-Type": "multipart/form-data";
         };
-    }, SendProc<[string, (string | undefined)?]>, A>;
+    }, (opt: RequestOption, arg: {
+        /**文件路径 */
+        filepath: string;
+        /**文件名 */
+        filename?: string;
+    }) => MPromise<SendProcData>, A>;
     sendNone(): UtilHttp<D, typeof SendNoneProc, A>;
     /**自定的发送数据类型 */
-    sendRaw<T extends any[]>(proc: SendProc<T>): UtilHttp<D, typeof proc, A>;
+    sendRaw<T extends any[]>(proc: SendProcCtor<T>): UtilHttp<D, typeof proc, A>;
     /**发送请求
      * @param datas  - 数据对象
      */
-    once(...datas: {} extends RequiredOnly<PartialOption<RequestOption, D>> ? SendParams<S> : [Error & "RequestOption不完整, 请使用 finalize 完成必要项"]): Promise<ParseResult<A>>;
+    once<OPT extends PartialOption<RequestOption, D>>(arg: ConflictCheck<SendParams<S>, AcceptParams<A>, ({} extends OPT ? {
+        option?: OPT;
+    } : {
+        option: OPT;
+    })>): Promise<ParseResult<A>>;
     /**重复发送网络请求
      * @param verify  - 有效性验证函数
      * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
      * @param datas   - 数据对象
      */
-    retry(opt: {
+    retry<OPT extends PartialOption<RequestOption, D>>(arg: ConflictCheck<SendParams<S>, AcceptParams<A>, {
         verify?: StatusVerifyFn<ParseResult<A>>;
         retries?: PromiseRetries;
-    }, ...datas: {} extends RequiredOnly<PartialOption<RequestOption, D>> ? SendParams<S> : [Error & "RequestOption不完整, 请使用 finalize 完成必要项"]): Promise<import("@zwa73/js-utils").PromiseRetryResult<ParseResult<A>>>;
+    } & ({} extends OPT ? {
+        option?: OPT;
+    } : {
+        option: OPT;
+    })>): Promise<import("@zwa73/js-utils").PromiseRetryResult<ParseResult<A>>>;
     /**发送网络请求
-     * @param option  - 网络请求选项
-     * @param proc    - 请求处理函数 需调用req.end()
-     * @param reduce  - 数据处理函数
-     * @param init    - 初始数据
+     * @param option     - 网络请求选项
+     * @param reqProc    - 请求处理函数 需调用req.end()
+     * @param acceptProc - 响应处理数据
      */
-    static request<T>(option: RequestOption, proc: RequestProcFn, reduce: RequestReduceFn<T>, init: T): Promise<RequestResult<T> | undefined>;
+    static request<T>(option: RequestOption, sendProc: SendProcData, acceptProc: Omit<AcceptProcData<T, unknown>, 'parse'>): Promise<RequestResult<T> | undefined>;
     /**构建query */
     static buildQuery(base: string, data: QueryRequestData): string;
 }

package/dist/UtilHttp.js

@@ -16,20 +16,29 @@ const https_proxy_agent_1 = __importDefault(require("https-proxy-agent"));
 const js_utils_1 = require("@zwa73/js-utils");
 const fs_1 = __importDefault(require("fs"));
 const pathe_1 = __importDefault(require("pathe"));
-const AcceptTypeList = ["json", "string"];
-const SendTypeList = ["json", "query", "formData", "none"];
 const SendNoneProc = {
-    proc: (opt) => (req) => void req.end()
+    proc: req => void req.end()
 };
 const AcceptStringProc = {
-    init: '',
+    init: () => '',
     reduce: (acc, dat) => acc + dat,
-    parse: (result) => result
+    parse: result => {
+        if (result == undefined) {
+            UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 响应结果无效`);
+            return undefined;
+        }
+        return result;
+    }
 };
 const AcceptNoneProc = {
-    init: undefined,
-    reduce: () => undefined,
-    parse: () => undefined
+    init: () => undefined,
+    parse: result => {
+        if (result == undefined) {
+            UtilLogger_1.SLogger.warn(`accept none 接收反馈错误: 响应结果无效`);
+            return undefined;
+        }
+        return result;
+    }
 };
 /**http请求工具 */
 class UtilHttp {
@@ -80,14 +89,6 @@ class UtilHttp {
         this._data = { ...this._data, ...option };
         return this;
     }
-    /**完成参数
-     * 会检查必要参数完整性
-     * 将会替换对应字段, 修改headers请用header函数
-     */
-    finalize(option) {
-        this._data = { ...this._data, ...option };
-        return this;
-    }
     /**补充header */
     header(headers) {
         this._data.headers = {
@@ -157,41 +158,32 @@ class UtilHttp {
     }
     //#endregion
     //#region 接收数据类型
-    /**预设的接收数据类型*/
-    accept(t) {
-        const map = {
-            'json': this.acceptJson(),
-            'string': this.acceptString(),
-            'none': this.acceptNone(),
-        };
-        return map[t];
-    }
     acceptJson() {
-        const proc = {
-            init: '',
+        const acceptProc = {
+            init: () => '',
             reduce: (acc, curr) => acc + curr,
-            parse: (result) => {
+            parse: result => {
                 if (result == undefined) {
-                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误: 响应结果无效`);
+                    UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 响应结果无效`);
                     return undefined;
                 }
                 const { data, ...rest } = result;
                 if (data.trim() == "") {
-                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
+                    UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 原始字符串为空`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
                     return { ...result, raw: "", data: null };
                 }
                 try {
                     const obj = JSON.parse(data.trim());
-                    UtilLogger_1.SLogger.http(`json accept 接受信息 data:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }), `result:`, UtilFunctions_1.UtilFunc.stringifyJToken(rest, { compress: true, space: 2 }));
+                    UtilLogger_1.SLogger.http(`accept json 接受信息 data:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }), `result:`, UtilFunctions_1.UtilFunc.stringifyJToken(rest, { compress: true, space: 2 }));
                     return { ...rest, data: obj };
                 }
                 catch (err) {
-                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误:`, err, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
+                    UtilLogger_1.SLogger.warn(`accept json 接收反馈错误:`, err, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
                     return { ...result, raw: data, data: null };
                 }
             }
         };
-        this._accept = proc;
+        this._accept = acceptProc;
         return this;
     }
     acceptString() {
@@ -202,6 +194,36 @@ class UtilHttp {
         this._accept = AcceptNoneProc;
         return this;
     }
+    acceptFile() {
+        const acceptProc = (arg) => ({
+            init: res => {
+                const fileStream = fs_1.default.createWriteStream(arg.acceptFilepath);
+                const fileWritePromise = new Promise((resolve) => {
+                    fileStream.on('error', err => {
+                        UtilLogger_1.SLogger.warn(`accept file 文件流写入错误:`, err);
+                        resolve(false); // 标记写入已结束, 但失败
+                    });
+                    fileStream.on('finish', () => {
+                        resolve(true); // 标记写入成功
+                    });
+                });
+                res.pipe(fileStream);
+                return { promise: fileWritePromise };
+            },
+            parse: async (result) => {
+                if (result == undefined) {
+                    UtilLogger_1.SLogger.warn(`accept file 接收反馈错误: 响应结果无效`);
+                    return undefined;
+                }
+                const success = await result.data.promise;
+                if (!success)
+                    return undefined;
+                return { ...result, filepath: arg.acceptFilepath };
+            }
+        });
+        this._accept = acceptProc;
+        return this;
+    }
     /**自定的接收数据类型*/
     acceptRaw(proc) {
         this._accept = proc;
@@ -209,113 +231,99 @@ class UtilHttp {
     }
     //#endregion
     //#region 发送数据类型
-    /**预设的发送数据类型 */
-    send(t) {
-        const map = {
-            'json': this.sendJson(),
-            'query': this.sendQuery(),
-            'formData': this.sendFormData(),
-            'form': this.sendForm(),
-            'file': this.sendFile(),
-            'none': this.sendNone(),
-        };
-        return map[t];
-    }
     /**发送json
      * 请求参数为 (token:JToken)
      */
     sendJson() {
-        const proc = {
-            proc: (opt, token) => {
-                const { method } = opt;
-                const isPost = (method == "POST");
-                const data = JSON.stringify(token);
-                this._data.headers ??= {};
-                this._data.headers['Content-Length'] = Buffer.byteLength(data);
-                const procReq = (req) => {
+        const sendProc = (opt, arg) => {
+            const { method } = opt;
+            const isPost = (method == "POST");
+            const data = JSON.stringify(arg.json);
+            this._data.headers ??= {};
+            this._data.headers['Content-Length'] = Buffer.byteLength(data);
+            return {
+                proc: req => {
                     if (isPost)
                         req.write(data);
                     req.end();
-                };
-                return procReq;
-            }
+                }
+            };
         };
-        this._send = proc;
+        this._send = sendProc;
         this._data.headers ??= {};
         this._data.headers['Content-Type'] = 'application/json';
         return this;
     }
-    /**利用 appendQuery 直接将数据附加在path上发送请求
-     * 请求参数为 (form:QueryRequestData)
-     */
+    /**利用 appendQuery 直接将表单附加在path上发送请求 */
     sendQuery() {
-        const proc = {
-            proc: (opt, form) => {
-                opt.path = UtilHttp.buildQuery(opt.path ?? '', form);
-                const procReq = (req) => void req.end();
-                return procReq;
-            }
+        const sendProc = (opt, arg) => {
+            opt.path = UtilHttp.buildQuery(opt.path ?? '', arg.query);
+            return {
+                proc: req => void req.end()
+            };
         };
-        this._send = proc;
+        this._send = sendProc;
         return this;
     }
-    /**发送表单数据
-     * 请求参数为 (formData: FormData)
-     */
+    /**发送form-data包提供的表单数据  */
     sendFormData() {
-        const proc = {
-            proc: (opt, formData) => {
-                opt.headers = formData.getHeaders();
-                const procReq = (req) => {
-                    formData.pipe(req);
-                };
-                return procReq;
-            },
+        const sendProc = (opt, arg) => {
+            const { method } = opt;
+            const isPost = (method == "POST");
+            opt.headers = arg.formdata.getHeaders();
+            return {
+                proc: (req) => {
+                    if (isPost)
+                        arg.formdata.pipe(req);
+                    else
+                        req.end();
+                }
+            };
         };
-        this._send = proc;
+        this._send = sendProc;
         this._data.headers ??= {};
         this._data.headers['Content-Type'] = 'multipart/form-data';
         return this;
     }
-    /**发送表单
-     * 请求参数为 (form:QueryRequestData)
-     */
+    /**发送表单 */
     sendForm() {
-        const proc = {
-            proc: (opt, form) => {
-                const { method } = opt;
-                const isPost = (method == "POST");
-                const data = querystring_1.default.stringify(form);
-                this._data.headers ??= {};
-                this._data.headers['Content-Length'] = Buffer.byteLength(data);
-                const procReq = (req) => {
+        const snedProc = (opt, arg) => {
+            const { method } = opt;
+            const isPost = (method == "POST");
+            const data = querystring_1.default.stringify(arg.form);
+            this._data.headers ??= {};
+            this._data.headers['Content-Length'] = Buffer.byteLength(data);
+            return {
+                proc: req => {
                     if (isPost)
                         req.write(data);
                     req.end();
-                };
-                return procReq;
-            }
+                }
+            };
         };
-        this._send = proc;
+        this._send = snedProc;
         this._data.headers ??= {};
         this._data.headers['Content-Type'] = 'application/x-www-form-urlencoded';
         return this;
     }
-    /**发送文件
-     * 请求参数为 (filepath:string, filename?: string)
-     */
+    /**发送文件 */
     sendFile() {
-        const proc = {
-            proc: (opt, filepath, filename) => {
-                const formData = new form_data_1.default();
-                filename = filename ?? pathe_1.default.basename(filepath);
-                formData.append(filename, fs_1.default.createReadStream(filepath));
-                opt.headers = formData.getHeaders();
-                const procReq = (req) => {
-                    formData.pipe(req);
-                };
-                return procReq;
-            },
+        const proc = (opt, arg) => {
+            const { method } = opt;
+            const isPost = (method == "POST");
+            let { filepath, filename } = arg;
+            const formData = new form_data_1.default();
+            filename = filename ?? pathe_1.default.basename(filepath);
+            formData.append(filename, fs_1.default.createReadStream(filepath));
+            opt.headers = formData.getHeaders();
+            return {
+                proc: req => {
+                    if (isPost)
+                        formData.pipe(req);
+                    else
+                        req.end();
+                }
+            };
         };
         this._send = proc;
         this._data.headers ??= {};
@@ -335,11 +343,15 @@ class UtilHttp {
     /**发送请求
      * @param datas  - 数据对象
      */
-    async once(...datas) {
-        const fullopt = this._data;
-        const proc = await this._send.proc(fullopt, ...datas);
-        const { reduce, init, parse } = this._accept;
-        const res = await UtilHttp.request(fullopt, proc, reduce, init);
+    async once(arg) {
+        const fullopt = { ...this._data, ...arg.option ?? {} };
+        const sendProc = typeof this._send === 'function'
+            ? await this._send(fullopt, arg)
+            : this._send;
+        const { parse, ...acceptProc } = typeof this._accept === 'function'
+            ? await this._accept(arg)
+            : this._accept;
+        const res = await UtilHttp.request(fullopt, sendProc, acceptProc);
         return parse(res);
     }
     /**重复发送网络请求
@@ -347,20 +359,21 @@ class UtilHttp {
      * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
      * @param datas   - 数据对象
      */
-    async retry(opt, ...datas) {
-        let { retries, verify } = opt;
+    async retry(arg) {
+        let { retries, verify } = arg;
         retries ??= {};
         retries.tryDelay = retries.tryDelay ?? 1000;
-        const procFn = async () => this.once(...datas);
+        const procFn = async () => this.once(arg);
         return UtilFunctions_1.UtilFunc.retryPromise(procFn, verify, retries);
     }
     /**发送网络请求
-     * @param option  - 网络请求选项
-     * @param proc    - 请求处理函数 需调用req.end()
-     * @param reduce  - 数据处理函数
-     * @param init    - 初始数据
+     * @param option     - 网络请求选项
+     * @param reqProc    - 请求处理函数 需调用req.end()
+     * @param acceptProc - 响应处理数据
      */
-    static async request(option, proc, reduce, init) {
+    static async request(option, sendProc, acceptProc) {
+        const { reduce: reqReduce, init: reqInit } = acceptProc;
+        const { proc: reqProc } = sendProc;
         const { protocol, timeout, ...baseReqOpt } = option;
         const plusTimeout = (timeout ?? 0) + 1000;
         const hasTimeLimit = (timeout ? timeout >= 10_000 : false);
@@ -379,7 +392,7 @@ class UtilHttp {
                 clearTimeout(finallyTimeout);
                 resolve(t);
             };
-            const resFunc = (res) => {
+            const resFunc = async (res) => {
                 try {
                     //请求超时
                     if (hasTimeLimit) {
@@ -387,16 +400,30 @@ class UtilHttp {
                             UtilLogger_1.SLogger.warn(`${flagName} http.response 触发 ${timeout} ms 超时, 继续挂起等待`);
                         });
                     }
-                    let mergedata = init;
+                    let mergedata;
+                    try {
+                        mergedata = await reqInit(res);
+                    }
+                    catch (err) {
+                        UtilLogger_1.SLogger.error(`${flagName} init函数错误:`, err);
+                        finallyResolve(undefined);
+                        return;
+                    }
                     res.setEncoding(option.responseEncode ?? 'utf8');
-                    res.on('data', chunk => {
-                        dataPromise = reduceQueue
-                            .enqueue(async () => mergedata = await reduce(mergedata, chunk))
-                            .catch(err => {
-                            UtilLogger_1.SLogger.error(`${flagName} reduce函数错误:`, err, `chunk:${chunk}\nmergedata:`, mergedata);
-                            finallyResolve(undefined);
+                    if (reqReduce) {
+                        res.on('data', chunk => {
+                            dataPromise = reduceQueue
+                                .enqueue(async () => {
+                                try {
+                                    mergedata = await reqReduce(mergedata, chunk);
+                                }
+                                catch (err) {
+                                    UtilLogger_1.SLogger.error(`${flagName} reduce函数错误:`, err, `chunk:${chunk}\nmergedata:`, mergedata);
+                                    finallyResolve(undefined);
+                                }
+                            });
                         });
-                    });
+                    }
                     res.on('error', err => {
                         UtilLogger_1.SLogger.warn(`${flagName} 接收反馈错误:`, err);
                         finallyResolve(undefined);
@@ -431,7 +458,7 @@ class UtilHttp {
                 finallyResolve(undefined);
             });
             try {
-                await proc(req);
+                await reqProc(req);
             }
             catch (err) {
                 UtilLogger_1.SLogger.error(`${flagName} proc函数错误:`, err);
@@ -456,24 +483,30 @@ if (false)
         const tool = UtilHttp
             .url('https://httpbin.org/post')
             .post()
-            .finalize({ timeout: 10000 });
+            .option({ timeout: 20000 });
         //json
         const sj = await tool.clone()
             .sendJson()
             .acceptJson()
-            .once({ test: 1 });
+            .once({
+            json: { test: 1 },
+        });
         console.log(sj);
         //form
         const sf = await tool.clone()
             .sendForm()
             .acceptJson()
-            .once({ test: 1 });
+            .once({
+            form: { test: 1 }
+        });
         console.log(sf);
         //query
         const sq = await tool.clone()
             .sendQuery()
             .acceptJson()
-            .once({ test: 1 });
+            .once({
+            query: { test: 1 }
+        });
         console.log(sq);
         const filepath = pathe_1.default.join(__dirname, '..', 'input.wav');
         //formData
@@ -487,6 +520,8 @@ if (false)
         const sfile = await tool.clone()
             .sendFile()
             .acceptJson()
-            .once(filepath);
+            .once({
+            filepath: filepath
+        });
         console.log(sfile);
     })());

package/package.json

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