@zwa73/utils 1.0.233 → 1.0.235

package/dist/UtilHttp.d.ts

@@ -2,6 +2,7 @@ import { AnyString, JToken, MPromise, PartialOption, StatusVerifyFn } from "./Ut
 import http from 'http';
 import { PromiseRetries } from "./UtilFunctions";
 import FormData from "form-data";
+import { PromiseQueue } from "@zwa73/js-utils";
 /**网络请求返回值 */
 export type RequestResult<T> = {
     /**响应头 */
@@ -13,6 +14,10 @@ export type RequestResult<T> = {
 };
 /**网络请求选项 */
 export type RequestOption = {
+    /**请求之间的间隔, 单位毫秒 默认 1
+     * 如果用promise并发请求可能会导致req.write提前中断, 为避免此问题需要设置请求间隔
+     */
+    interval?: number;
     /**请求协议 */
     protocol: 'http:' | 'https:';
     /**超时时间/毫秒  最小为10_000 默认无限 */
@@ -45,30 +50,24 @@ export type RequestParseFn<D, R> = (result: RequestResult<D> | undefined) => MPr
 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处理数据
  * @template D - 接受时转换的数据类型
  * @template R - 完成处理的数据类型
 */
-type AcceptProcCtor<D, R, T> = (arg: T) => MPromise<AcceptProc<D, R>>;
-type AcceptProc<D, 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>;
+    reduce?: RequestReduceFn<D>;
     parse: RequestParseFn<D, R>;
 };
 /**send处理数据 */
-type SendProcCtor<T extends {}> = (opt: RequestOption, arg: T) => MPromise<SendProc>;
-type SendProc = {
+type SendProcCtor<T extends {}> = SendProcData | ((opt: RequestOption, arg: T) => MPromise<SendProcData>);
+type SendProcData = {
     proc: RequestProcFn;
 };
 declare const SendNoneProc: SendProcCtor<{}>;
 declare const AcceptStringProc: AcceptProcCtor<string, RequestResult<string> | undefined, {}>;
-declare const AcceptNoneProc: AcceptProcCtor<undefined, undefined, {}>;
+declare const AcceptNoneProc: AcceptProcCtor<undefined, RequestResult<undefined> | undefined, {}>;
 /**send处理的参数 */
 type SendParams<S extends SendProcCtor<any>> = S extends SendProcCtor<infer P> ? P : never;
 /**send处理的参数 */
@@ -127,10 +126,10 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             "Content-Type": "application/json";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**发送的json */
         json: JToken;
-    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的post预设 */
     postJson(): UtilHttp<D & {
         method: "POST";
@@ -138,21 +137,21 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**发送的json */
         json: JToken;
-    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的get预设 */
     getJson(): UtilHttp<D & {
         method: "GET";
-    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的get预设 */
     queryJson(): UtilHttp<D & {
         method: "GET";
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**附加的查询表单数据 */
         query: QueryRequestData;
-    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的https-post预设 */
     static httpsPostJson(): UtilHttp<{
         readonly protocol: "https:";
@@ -162,10 +161,10 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**发送的json */
         json: JToken;
-    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的http-post预设 */
     static httpPostJson(): UtilHttp<{
         readonly protocol: "http:";
@@ -175,50 +174,46 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             'Content-Type': "application/json";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**发送的json */
         json: JToken;
-    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的https-get预设 */
     static httpsGetJson(): UtilHttp<{
         readonly protocol: "https:";
     } & {
         method: "GET";
-    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的https-get预设 */
     static httpsQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**附加的查询表单数据 */
         query: QueryRequestData;
-    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的http-get预设 */
     static httpGetJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的http-get预设 */
     static httpQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**附加的查询表单数据 */
         query: QueryRequestData;
-    }>, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
-    /**预设的接收数据类型*/
-    accept<T extends AcceptType>(t: T): {
-        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, AcceptProcCtor<string, RequestResult<JToken> | undefined, {}>>;
+    }) => 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, AcceptProcCtor<{
+    acceptFile(): UtilHttp<D, S, (arg: {
+        acceptFilepath: string;
+    }) => MPromise<AcceptProcData<{
         promise: Promise<boolean>;
     }, {
         /**响应头 */
@@ -227,53 +222,9 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         statusCode?: number;
         /**保存文件路径 */
         filepath: string;
-    } | undefined, {
-        acceptFilepath: string;
-    }>>;
+    } | undefined>>>;
     /**自定的接收数据类型*/
-    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";
-            };
-        }, SendProcCtor<{
-            /**发送的json */
-            json: JToken;
-        }>, A>;
-        readonly query: UtilHttp<D, SendProcCtor<{
-            /**附加的查询表单数据 */
-            query: QueryRequestData;
-        }>, A>;
-        readonly formData: UtilHttp<D & {
-            headers: {
-                "Content-Type": "multipart/form-data";
-            };
-        }, SendProcCtor<{
-            /**form-data包提供的FormData表单数据 */
-            formdata: FormData;
-        }>, A>;
-        readonly form: UtilHttp<D & {
-            headers: {
-                "Content-Type": "application/x-www-form-urlencoded";
-            };
-        }, SendProcCtor<{
-            /**表单 */
-            form: QueryRequestData;
-        }>, A>;
-        readonly file: UtilHttp<D & {
-            headers: {
-                "Content-Type": "multipart/form-data";
-            };
-        }, SendProcCtor<{
-            /**文件路径 */
-            filepath: string;
-            /**文件名 */
-            filename?: string;
-        }>, A>;
-        readonly none: UtilHttp<D, SendProcCtor<{}>, A>;
-    }[T];
+    acceptRaw<AD, AR, AT extends {}>(proc: AcceptProcCtor<AD, AR, AT>): UtilHttp<D, S, typeof proc>;
     /**发送json
      * 请求参数为 (token:JToken)
      */
@@ -281,44 +232,44 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         headers: {
             "Content-Type": "application/json";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**发送的json */
         json: JToken;
-    }>, A>;
-    /**利用 appendQuery 直接将数据附加在path上发送请求 */
-    sendQuery(): UtilHttp<D, SendProcCtor<{
+    }) => MPromise<SendProcData>, A>;
+    /**利用 appendQuery 直接将表单附加在path上发送请求 */
+    sendQuery(): UtilHttp<D, (opt: RequestOption, arg: {
         /**附加的查询表单数据 */
         query: QueryRequestData;
-    }>, A>;
-    /**发送表单数据  */
+    }) => MPromise<SendProcData>, A>;
+    /**发送form-data包提供的表单数据  */
     sendFormData(): UtilHttp<D & {
         headers: {
             "Content-Type": "multipart/form-data";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**form-data包提供的FormData表单数据 */
         formdata: FormData;
-    }>, A>;
+    }) => MPromise<SendProcData>, A>;
     /**发送表单 */
     sendForm(): UtilHttp<D & {
         headers: {
             "Content-Type": "application/x-www-form-urlencoded";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**表单 */
         form: QueryRequestData;
-    }>, A>;
+    }) => MPromise<SendProcData>, A>;
     /**发送文件 */
     sendFile(): UtilHttp<D & {
         headers: {
             "Content-Type": "multipart/form-data";
         };
-    }, SendProcCtor<{
+    }, (opt: RequestOption, arg: {
         /**文件路径 */
         filepath: string;
         /**文件名 */
         filename?: string;
-    }>, A>;
+    }) => MPromise<SendProcData>, A>;
     sendNone(): UtilHttp<D, typeof SendNoneProc, A>;
     /**自定的发送数据类型 */
     sendRaw<T extends any[]>(proc: SendProcCtor<T>): UtilHttp<D, typeof proc, A>;
@@ -343,12 +294,14 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
     } : {
         option: OPT;
     })>): Promise<import("@zwa73/js-utils").PromiseRetryResult<ParseResult<A>>>;
+    /**控制请求间隔的队列 */
+    static requestQueue: PromiseQueue;
     /**发送网络请求
      * @param option     - 网络请求选项
      * @param reqProc    - 请求处理函数 需调用req.end()
      * @param acceptProc - 响应处理数据
      */
-    static request<T>(option: RequestOption, sendProc: SendProc, acceptProc: Omit<AcceptProc<T, unknown>, 'parse'>): 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,21 +16,30 @@ 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 = () => ({
+const SendNoneProc = {
     proc: req => void req.end()
-});
-const AcceptStringProc = () => ({
+};
+const AcceptStringProc = {
     init: () => '',
     reduce: (acc, dat) => acc + dat,
-    parse: (result) => result
-});
-const AcceptNoneProc = () => ({
+    parse: result => {
+        if (result == undefined) {
+            UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 响应结果无效`);
+            return undefined;
+        }
+        return result;
+    }
+};
+const AcceptNoneProc = {
     init: () => undefined,
-    reduce: () => undefined,
-    parse: () => undefined
-});
+    parse: result => {
+        if (result == undefined) {
+            UtilLogger_1.SLogger.warn(`accept none 接收反馈错误: 响应结果无效`);
+            return undefined;
+        }
+        return result;
+    }
+};
 /**http请求工具 */
 class UtilHttp {
     _data;
@@ -149,40 +158,31 @@ class UtilHttp {
     }
     //#endregion
     //#region 接收数据类型
-    /**预设的接收数据类型*/
-    accept(t) {
-        const map = {
-            'json': this.acceptJson(),
-            'string': this.acceptString(),
-            'none': this.acceptNone(),
-        };
-        return map[t];
-    }
     acceptJson() {
-        const acceptProc = () => ({
+        const acceptProc = {
             init: () => '',
             reduce: (acc, curr) => acc + curr,
             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 = acceptProc;
         return this;
     }
@@ -200,7 +200,7 @@ class UtilHttp {
                 const fileStream = fs_1.default.createWriteStream(arg.acceptFilepath);
                 const fileWritePromise = new Promise((resolve) => {
                     fileStream.on('error', err => {
-                        UtilLogger_1.SLogger.warn(`file accept 文件流写入错误:`, err);
+                        UtilLogger_1.SLogger.warn(`accept file 文件流写入错误:`, err);
                         resolve(false); // 标记写入已结束, 但失败
                     });
                     fileStream.on('finish', () => {
@@ -210,10 +210,11 @@ class UtilHttp {
                 res.pipe(fileStream);
                 return { promise: fileWritePromise };
             },
-            reduce: acc => acc,
             parse: async (result) => {
-                if (result == undefined)
+                if (result == undefined) {
+                    UtilLogger_1.SLogger.warn(`accept file 接收反馈错误: 响应结果无效`);
                     return undefined;
+                }
                 const success = await result.data.promise;
                 if (!success)
                     return undefined;
@@ -230,18 +231,6 @@ 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)
      */
@@ -253,7 +242,7 @@ class UtilHttp {
             this._data.headers ??= {};
             this._data.headers['Content-Length'] = Buffer.byteLength(data);
             return {
-                proc: (req) => {
+                proc: req => {
                     if (isPost)
                         req.write(data);
                     req.end();
@@ -265,24 +254,29 @@ class UtilHttp {
         this._data.headers['Content-Type'] = 'application/json';
         return this;
     }
-    /**利用 appendQuery 直接将数据附加在path上发送请求 */
+    /**利用 appendQuery 直接将表单附加在path上发送请求 */
     sendQuery() {
         const sendProc = (opt, arg) => {
             opt.path = UtilHttp.buildQuery(opt.path ?? '', arg.query);
             return {
-                proc: (req) => void req.end()
+                proc: req => void req.end()
             };
         };
         this._send = sendProc;
         return this;
     }
-    /**发送表单数据  */
+    /**发送form-data包提供的表单数据  */
     sendFormData() {
         const sendProc = (opt, arg) => {
+            const { method } = opt;
+            const isPost = (method == "POST");
             opt.headers = arg.formdata.getHeaders();
             return {
                 proc: (req) => {
-                    arg.formdata.pipe(req);
+                    if (isPost)
+                        arg.formdata.pipe(req);
+                    else
+                        req.end();
                 }
             };
         };
@@ -300,7 +294,7 @@ class UtilHttp {
             this._data.headers ??= {};
             this._data.headers['Content-Length'] = Buffer.byteLength(data);
             return {
-                proc: (req) => {
+                proc: req => {
                     if (isPost)
                         req.write(data);
                     req.end();
@@ -315,14 +309,19 @@ class UtilHttp {
     /**发送文件 */
     sendFile() {
         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) => {
-                    formData.pipe(req);
+                proc: req => {
+                    if (isPost)
+                        formData.pipe(req);
+                    else
+                        req.end();
                 }
             };
         };
@@ -346,8 +345,12 @@ class UtilHttp {
      */
     async once(arg) {
         const fullopt = { ...this._data, ...arg.option ?? {} };
-        const sendProc = await this._send(fullopt, arg);
-        const { parse, ...acceptProc } = await this._accept(arg);
+        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);
     }
@@ -363,6 +366,8 @@ class UtilHttp {
         const procFn = async () => this.once(arg);
         return UtilFunctions_1.UtilFunc.retryPromise(procFn, verify, retries);
     }
+    /**控制请求间隔的队列 */
+    static requestQueue = new js_utils_1.PromiseQueue();
     /**发送网络请求
      * @param option     - 网络请求选项
      * @param reqProc    - 请求处理函数 需调用req.end()
@@ -371,12 +376,15 @@ class UtilHttp {
     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);
+        const { protocol, timeout = 0, interval = 1, ...baseReqOpt } = option;
+        const plusTimeout = timeout + 1000;
+        const hasTimeLimit = timeout >= 10_000;
         const flagName = `UtilCom.request ${protocol}${baseReqOpt.method} ${UtilFunctions_1.UtilFunc.genUUID()}`;
         const reduceQueue = new js_utils_1.PromiseQueue();
         let dataPromise = null;
+        //等待间隔
+        if (UtilHttp.requestQueue.length > 0)
+            await UtilHttp.requestQueue.enqueue(async () => UtilFunctions_1.UtilFunc.sleep(interval));
         return new Promise(async (resolve, rejecte) => {
             const finallyTimeout = hasTimeLimit
                 ? setTimeout(() => {
@@ -407,18 +415,20 @@ class UtilHttp {
                         return;
                     }
                     res.setEncoding(option.responseEncode ?? 'utf8');
-                    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);
-                            }
+                    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);

package/package.json

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