@zwa73/utils 1.0.232 → 1.0.233

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,47 @@ 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>;
+/**数据初始化函数 */
+export type RequestInitFn<T> = (res: http.IncomingMessage) => 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;
+/**accept处理数据
+ * @template D - 接受时转换的数据类型
+ * @template R - 完成处理的数据类型
+*/
+type AcceptProcCtor<D, R, T> = (arg: T) => MPromise<AcceptProc<D, R>>;
+type AcceptProc<D, R> = {
+    init: RequestInitFn<D>;
     reduce: RequestReduceFn<D>;
-    parse: (result: RequestResult<D> | undefined) => MPromise<T>;
+    parse: RequestParseFn<D, R>;
 };
 /**send处理数据 */
-type SendProc<T extends any[]> = {
-    proc: (opt: RequestOption, ...args: T) => MPromise<RequestProcFn>;
+type SendProcCtor<T extends {}> = (opt: RequestOption, arg: T) => MPromise<SendProc>;
+type SendProc = {
+    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, 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 +86,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 +98,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 +112,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 +127,10 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             "Content-Type": "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{
+        /**发送的json */
+        json: JToken;
+    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**收发皆为json的post预设 */
     postJson(): UtilHttp<D & {
         method: "POST";
@@ -128,15 +138,21 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{
+        /**发送的json */
+        json: JToken;
+    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**无查询参数获取json的get预设 */
     getJson(): UtilHttp<D & {
         method: "GET";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**有查询参数获取json的get预设 */
     queryJson(): UtilHttp<D & {
         method: "GET";
-    }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**收发皆为json的https-post预设 */
     static httpsPostJson(): UtilHttp<{
         readonly protocol: "https:";
@@ -146,7 +162,10 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{
+        /**发送的json */
+        json: JToken;
+    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**收发皆为json的http-post预设 */
     static httpPostJson(): UtilHttp<{
         readonly protocol: "http:";
@@ -156,66 +175,104 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{
+        /**发送的json */
+        json: JToken;
+    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**无查询参数获取json的https-get预设 */
     static httpsGetJson(): UtilHttp<{
         readonly protocol: "https:";
     } & {
         method: "GET";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**有查询参数获取json的https-get预设 */
     static httpsQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**无查询参数获取json的http-get预设 */
     static httpGetJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     /**有查询参数获取json的http-get预设 */
     static httpQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }>, AcceptProcCtor<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>>;
+        readonly json: UtilHttp<D, S, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+        readonly string: UtilHttp<D, S, AcceptProcCtor<string, RequestResult<string> | undefined, {}>>;
+        readonly none: UtilHttp<D, S, AcceptProcCtor<undefined, undefined, {}>>;
     }[T];
-    acceptJson(): UtilHttp<D, S, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    acceptJson(): UtilHttp<D, S, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
     acceptString(): UtilHttp<D, S, typeof AcceptStringProc>;
     acceptNone(): UtilHttp<D, S, typeof AcceptNoneProc>;
+    acceptFile(): UtilHttp<D, S, AcceptProcCtor<{
+        promise: Promise<boolean>;
+    }, {
+        /**响应头 */
+        headers: http.IncomingHttpHeaders;
+        /**响应状态码 */
+        statusCode?: number;
+        /**保存文件路径 */
+        filepath: string;
+    } | undefined, {
+        acceptFilepath: string;
+    }>>;
     /**自定的接收数据类型*/
-    acceptRaw<AD, AT>(proc: AcceptProc<AD, AT>): UtilHttp<D, S, typeof proc>;
+    acceptRaw<AD, AR, AT>(proc: AcceptProcCtor<AD, AR, 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>;
+        }, SendProcCtor<{
+            /**发送的json */
+            json: JToken;
+        }>, A>;
+        readonly query: UtilHttp<D, SendProcCtor<{
+            /**附加的查询表单数据 */
+            query: QueryRequestData;
+        }>, A>;
         readonly formData: UtilHttp<D & {
             headers: {
                 "Content-Type": "multipart/form-data";
             };
-        }, SendProc<[FormData]>, A>;
+        }, SendProcCtor<{
+            /**form-data包提供的FormData表单数据 */
+            formdata: FormData;
+        }>, A>;
         readonly form: UtilHttp<D & {
             headers: {
                 "Content-Type": "application/x-www-form-urlencoded";
             };
-        }, SendProc<[QueryRequestData]>, A>;
+        }, SendProcCtor<{
+            /**表单 */
+            form: QueryRequestData;
+        }>, A>;
         readonly file: UtilHttp<D & {
             headers: {
                 "Content-Type": "multipart/form-data";
             };
-        }, SendProc<[string, (string | undefined)?]>, A>;
-        readonly none: UtilHttp<D, SendProc<[]>, A>;
+        }, SendProcCtor<{
+            /**文件路径 */
+            filepath: string;
+            /**文件名 */
+            filename?: string;
+        }>, A>;
+        readonly none: UtilHttp<D, SendProcCtor<{}>, A>;
     }[T];
     /**发送json
      * 请求参数为 (token:JToken)
@@ -224,58 +281,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)
-     */
+    }, SendProcCtor<{
+        /**发送的json */
+        json: JToken;
+    }>, A>;
+    /**利用 appendQuery 直接将数据附加在path上发送请求 */
+    sendQuery(): UtilHttp<D, SendProcCtor<{
+        /**附加的查询表单数据 */
+        query: QueryRequestData;
+    }>, A>;
+    /**发送表单数据  */
     sendFormData(): UtilHttp<D & {
         headers: {
             "Content-Type": "multipart/form-data";
         };
-    }, SendProc<[FormData]>, A>;
-    /**发送表单
-     * 请求参数为 (form:QueryRequestData)
-     */
+    }, SendProcCtor<{
+        /**form-data包提供的FormData表单数据 */
+        formdata: FormData;
+    }>, A>;
+    /**发送表单 */
     sendForm(): UtilHttp<D & {
         headers: {
             "Content-Type": "application/x-www-form-urlencoded";
         };
-    }, SendProc<[QueryRequestData]>, A>;
-    /**发送文件
-     * 请求参数为 (filepath:string, filename?: string)
-     */
+    }, SendProcCtor<{
+        /**表单 */
+        form: QueryRequestData;
+    }>, A>;
+    /**发送文件 */
     sendFile(): UtilHttp<D & {
         headers: {
             "Content-Type": "multipart/form-data";
         };
-    }, SendProc<[string, (string | undefined)?]>, A>;
+    }, SendProcCtor<{
+        /**文件路径 */
+        filepath: string;
+        /**文件名 */
+        filename?: string;
+    }>, 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: SendProc, acceptProc: Omit<AcceptProc<T, unknown>, 'parse'>): Promise<RequestResult<T> | undefined>;
     /**构建query */
     static buildQuery(base: string, data: QueryRequestData): string;
 }

package/dist/UtilHttp.js

@@ -18,19 +18,19 @@ 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()
-};
-const AcceptStringProc = {
-    init: '',
+const SendNoneProc = () => ({
+    proc: req => void req.end()
+});
+const AcceptStringProc = () => ({
+    init: () => '',
     reduce: (acc, dat) => acc + dat,
     parse: (result) => result
-};
-const AcceptNoneProc = {
-    init: undefined,
+});
+const AcceptNoneProc = () => ({
+    init: () => undefined,
     reduce: () => undefined,
     parse: () => undefined
-};
+});
 /**http请求工具 */
 class UtilHttp {
     _data;
@@ -80,14 +80,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 = {
@@ -167,10 +159,10 @@ class UtilHttp {
         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 接收反馈错误: 响应结果无效`);
                     return undefined;
@@ -190,8 +182,8 @@ class UtilHttp {
                     return { ...result, raw: data, data: null };
                 }
             }
-        };
-        this._accept = proc;
+        });
+        this._accept = acceptProc;
         return this;
     }
     acceptString() {
@@ -202,6 +194,35 @@ 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(`file accept 文件流写入错误:`, err);
+                        resolve(false); // 标记写入已结束, 但失败
+                    });
+                    fileStream.on('finish', () => {
+                        resolve(true); // 标记写入成功
+                    });
+                });
+                res.pipe(fileStream);
+                return { promise: fileWritePromise };
+            },
+            reduce: acc => acc,
+            parse: async (result) => {
+                if (result == undefined)
+                    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;
@@ -225,97 +246,85 @@ class UtilHttp {
      * 请求参数为 (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)
-     */
+    /**发送表单数据  */
     sendFormData() {
-        const proc = {
-            proc: (opt, formData) => {
-                opt.headers = formData.getHeaders();
-                const procReq = (req) => {
-                    formData.pipe(req);
-                };
-                return procReq;
-            },
+        const sendProc = (opt, arg) => {
+            opt.headers = arg.formdata.getHeaders();
+            return {
+                proc: (req) => {
+                    arg.formdata.pipe(req);
+                }
+            };
         };
-        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) => {
+        const proc = (opt, arg) => {
+            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) => {
                     formData.pipe(req);
-                };
-                return procReq;
-            },
+                }
+            };
         };
         this._send = proc;
         this._data.headers ??= {};
@@ -335,11 +344,11 @@ 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 = await this._send(fullopt, arg);
+        const { parse, ...acceptProc } = await this._accept(arg);
+        const res = await UtilHttp.request(fullopt, sendProc, acceptProc);
         return parse(res);
     }
     /**重复发送网络请求
@@ -347,20 +356,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 +389,7 @@ class UtilHttp {
                 clearTimeout(finallyTimeout);
                 resolve(t);
             };
-            const resFunc = (res) => {
+            const resFunc = async (res) => {
                 try {
                     //请求超时
                     if (hasTimeLimit) {
@@ -387,14 +397,26 @@ 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);
+                            .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 => {
@@ -431,7 +453,7 @@ class UtilHttp {
                 finallyResolve(undefined);
             });
             try {
-                await proc(req);
+                await reqProc(req);
             }
             catch (err) {
                 UtilLogger_1.SLogger.error(`${flagName} proc函数错误:`, err);
@@ -456,24 +478,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 +515,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.233",
 	"description": "my utils",
 	"main": "dist/index.js",
 	"scripts": {