@zwa73/utils 1.0.218 → 1.0.220

package/dist/UtilClass.d.ts

@@ -1 +1 @@
-export { Piper, Stream, Hbs, BridgeInterface, Bridge, SmartCache, DListMiddleNode, DLinkedList, PromoseQueueOption, PromiseQueue } from "@zwa73/js-utils";
+export { BridgeInterface, Bridge, Hbs, DListMiddleNode, DListHeadNode, DListTailNode, DListNode, DListMaybeNode, DLinkedList, Piper, PromoseQueueOption, PromiseQueue, SmartCache, Stream } from "@zwa73/js-utils";

package/dist/UtilClass.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PromiseQueue = exports.DLinkedList = exports.SmartCache = exports.Bridge = exports.Hbs = exports.Stream = exports.Piper = void 0;
+exports.Stream = exports.SmartCache = exports.PromiseQueue = exports.Piper = exports.DLinkedList = exports.Hbs = exports.Bridge = void 0;
 //#region UtilClass转导
 var js_utils_1 = require("@zwa73/js-utils");
-Object.defineProperty(exports, "Piper", { enumerable: true, get: function () { return js_utils_1.Piper; } });
-Object.defineProperty(exports, "Stream", { enumerable: true, get: function () { return js_utils_1.Stream; } });
-Object.defineProperty(exports, "Hbs", { enumerable: true, get: function () { return js_utils_1.Hbs; } });
 Object.defineProperty(exports, "Bridge", { enumerable: true, get: function () { return js_utils_1.Bridge; } });
-Object.defineProperty(exports, "SmartCache", { enumerable: true, get: function () { return js_utils_1.SmartCache; } });
+Object.defineProperty(exports, "Hbs", { enumerable: true, get: function () { return js_utils_1.Hbs; } });
 Object.defineProperty(exports, "DLinkedList", { enumerable: true, get: function () { return js_utils_1.DLinkedList; } });
+Object.defineProperty(exports, "Piper", { enumerable: true, get: function () { return js_utils_1.Piper; } });
 Object.defineProperty(exports, "PromiseQueue", { enumerable: true, get: function () { return js_utils_1.PromiseQueue; } });
+Object.defineProperty(exports, "SmartCache", { enumerable: true, get: function () { return js_utils_1.SmartCache; } });
+Object.defineProperty(exports, "Stream", { enumerable: true, get: function () { return js_utils_1.Stream; } });
 //#endregion

package/dist/UtilFileTools.js

@@ -279,23 +279,27 @@ var UtilFT;
      * @returns 文件名路径数组
      */
     async function fileSearchRegex(dir, traitRegex, opt) {
-        const recursive = opt?.recursive ?? true;
-        const outArray = [];
-        const subFiles = await fs.promises.readdir(dir, { withFileTypes: true });
+        const fixopt = Object.assign({ recursive: true }, opt);
         //如果使用 g 会导致 RegExp.lastIndex 更改, 将会导致匹配错误
         const regex = new RegExp(traitRegex);
-        await Promise.all(subFiles.map(async (subFile) => {
-            const subFilePath = pathe_1.default.join(dir, subFile.name);
-            //判断是否是文件夹，递归调用
-            if (subFile.isDirectory()) {
-                if (recursive)
-                    outArray.push(...await UtilFT.fileSearchRegex(pathe_1.default.join(subFilePath, pathe_1.default.sep), traitRegex));
-                return;
-            }
-            if (regex.test(subFilePath))
-                outArray.push(subFilePath);
-        }));
-        return outArray.map((filePath) => pathe_1.default.normalize(filePath));
+        const recursive = async (curPath) => {
+            const subDir = pathe_1.default.join(dir, curPath);
+            const subFiles = await fs.promises.readdir(subDir, { withFileTypes: true });
+            const matchFiles = await Promise.all(subFiles.map(async (subFile) => {
+                const subFilePath = pathe_1.default.join(subDir, subFile.name);
+                const nextPath = pathe_1.default.join(curPath, subFile.name);
+                //判断是否是文件夹，递归调用
+                if (subFile.isDirectory() && fixopt.recursive)
+                    return recursive(nextPath);
+                if (regex.test(nextPath))
+                    return [subFilePath];
+                return [undefined];
+            }));
+            return matchFiles.flat()
+                .filter(v => v != undefined)
+                .map(fp => pathe_1.default.normalize(fp));
+        };
+        return recursive('');
     }
     UtilFT.fileSearchRegex = fileSearchRegex;
     /**搜索路径符合正则表达式的文件 同步版本
@@ -306,23 +310,27 @@ var UtilFT;
      * @returns 文件名路径数组
      */
     function fileSearchRegexSync(dir, traitRegex, opt) {
-        const recursive = opt?.recursive ?? true;
-        const outArray = [];
-        const subFiles = fs.readdirSync(dir, { withFileTypes: true });
+        const fixopt = Object.assign({ recursive: true }, opt);
         //如果使用 g 会导致 RegExp.lastIndex 更改, 将会导致匹配错误
         const regex = new RegExp(traitRegex);
-        for (const subFile of subFiles) {
-            const subFilePath = pathe_1.default.join(dir, subFile.name);
-            //判断是否是文件夹，递归调用
-            if (subFile.isDirectory()) {
-                if (recursive)
-                    outArray.push(...fileSearchRegexSync(pathe_1.default.join(subFilePath, pathe_1.default.sep), traitRegex));
-                continue;
-            }
-            if (regex.test(subFilePath))
-                outArray.push(subFilePath);
-        }
-        return outArray.map((filePath) => pathe_1.default.normalize(filePath));
+        const recursive = (curPath) => {
+            const subDir = pathe_1.default.join(dir, curPath);
+            const subFiles = fs.readdirSync(subDir, { withFileTypes: true });
+            const matchFiles = subFiles.map(subFile => {
+                const subFilePath = pathe_1.default.join(subDir, subFile.name);
+                const nextPath = pathe_1.default.join(curPath, subFile.name);
+                //判断是否是文件夹，递归调用
+                if (subFile.isDirectory() && fixopt.recursive)
+                    return recursive(nextPath);
+                if (regex.test(nextPath))
+                    return [subFilePath];
+                return [undefined];
+            });
+            return matchFiles.flat()
+                .filter(v => v != undefined)
+                .map(fp => pathe_1.default.normalize(fp));
+        };
+        return recursive('');
     }
     UtilFT.fileSearchRegexSync = fileSearchRegexSync;
     /**搜索符合Glob匹配的文件

package/dist/{UtilCom.d.ts → 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 { RequiredOnly } from "@zwa73/js-utils";
 /**网络请求返回值 */
 export type RequestResult<T> = {
     /**响应头 */
@@ -64,48 +65,64 @@ declare const AcceptNoneProc: AcceptProc<undefined, undefined>;
 type SendParams<P extends SendProc<any>> = P extends SendProc<infer T> ? T : never;
 /**accept处理的结果 */
 type ParseResult<P extends AcceptProc<any, any>> = P extends AcceptProc<any, infer T> ? Awaited<T> : never;
-/**网络请求工具 */
-export declare class UtilCom<D extends Partial<RequestOption> & Required<Pick<RequestOption, 'protocol'>>, S extends SendProc<any>, A extends AcceptProc<any, any>> {
+/**http请求工具 */
+export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<RequestOption, 'protocol'>>, S extends SendProc<any>, A extends AcceptProc<any, any>> {
     private _data;
     private _send;
     private _accept;
     private constructor();
     /**设为https请求 */
-    static https(): UtilCom<{
+    static https(): UtilHttp<{
         readonly protocol: "https:";
     }, SendProc<[]>, AcceptProc<string, RequestResult<string> | undefined>>;
     /**设为http请求 */
-    static http(): UtilCom<{
+    static http(): UtilHttp<{
         readonly protocol: "http:";
     }, SendProc<[]>, AcceptProc<string, RequestResult<string> | undefined>>;
+    /**从url创建 */
+    static url(urlStr: `${'http:' | 'https:'}//${string}`): UtilHttp<{
+        protocol: "http:" | "https:";
+    } & {
+        hostname: string;
+        path: string;
+        port: number | undefined;
+    }, SendProc<[]>, AcceptProc<string, RequestResult<string> | undefined>>;
     /**设为get方式的请求 */
-    get(): UtilCom<D & {
+    get(): UtilHttp<D & {
         method: "GET";
     }, S, A>;
     /**设为Post方式的请求 */
-    post(): UtilCom<D & {
+    post(): UtilHttp<D & {
         method: "POST";
     }, S, A>;
     /**补充参数
+     * 不会检查必要参数完整性
      * 将会替换对应字段, 修改headers请用header函数
      */
-    option<OPT extends Partial<RequestOption>>(option: OPT): UtilCom<D & OPT, S, A>;
+    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): UtilCom<D & {
+    header<HAD extends http.OutgoingHttpHeaders>(headers: HAD): UtilHttp<D & {
         headers: HAD;
     }, S, A>;
     /**设置agent */
     proxyAgent(url: string): this;
     /**添加一段query */
     query(data: QueryRequestData): this;
+    /**克隆 */
+    clone(): UtilHttp<D, S, A>;
     /**收发皆为json的预设 */
-    json(): UtilCom<D & {
+    json(): UtilHttp<D & {
         headers: {
             "Content-Type": "application/json";
         };
     }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的post预设 */
-    postJson(): UtilCom<D & {
+    postJson(): UtilHttp<D & {
         method: "POST";
     } & {
         headers: {
@@ -113,15 +130,15 @@ export declare class UtilCom<D extends Partial<RequestOption> & Required<Pick<Re
         };
     }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的get预设 */
-    getJson(): UtilCom<D & {
+    getJson(): UtilHttp<D & {
         method: "GET";
     }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的get预设 */
-    queryJson(): UtilCom<D & {
+    queryJson(): UtilHttp<D & {
         method: "GET";
     }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的https-post预设 */
-    static httpsPostJson(): UtilCom<{
+    static httpsPostJson(): UtilHttp<{
         readonly protocol: "https:";
     } & {
         method: "POST";
@@ -131,7 +148,7 @@ export declare class UtilCom<D extends Partial<RequestOption> & Required<Pick<Re
         };
     }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**收发皆为json的http-post预设 */
-    static httpPostJson(): UtilCom<{
+    static httpPostJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "POST";
@@ -141,87 +158,117 @@ export declare class UtilCom<D extends Partial<RequestOption> & Required<Pick<Re
         };
     }, SendProc<[JToken]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的https-get预设 */
-    static httpsGetJson(): UtilCom<{
+    static httpsGetJson(): UtilHttp<{
         readonly protocol: "https:";
     } & {
         method: "GET";
     }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的https-get预设 */
-    static httpsQueryJson(): UtilCom<{
+    static httpsQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
     }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的http-get预设 */
-    static httpGetJson(): UtilCom<{
+    static httpGetJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
     }, SendProc<[]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的http-get预设 */
-    static httpQueryJson(): UtilCom<{
+    static httpQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
     }, SendProc<[QueryRequestData]>, AcceptProc<string, RequestResult<JToken> | undefined>>;
     /**预设的接收数据类型*/
     accept<T extends AcceptType>(t: T): {
-        readonly json: UtilCom<D, S, AcceptProc<string, RequestResult<JToken> | undefined>>;
-        readonly string: UtilCom<D, S, AcceptProc<string, RequestResult<string> | undefined>>;
-        readonly none: UtilCom<D, S, AcceptProc<undefined, undefined>>;
+        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(): UtilCom<D, S, AcceptProc<string, RequestResult<JToken> | undefined>>;
-    acceptString(): UtilCom<D, S, typeof AcceptStringProc>;
-    acceptNone(): UtilCom<D, S, typeof AcceptNoneProc>;
+    acceptJson(): UtilHttp<D, S, AcceptProc<string, RequestResult<JToken> | undefined>>;
+    acceptString(): UtilHttp<D, S, typeof AcceptStringProc>;
+    acceptNone(): UtilHttp<D, S, typeof AcceptNoneProc>;
     /**自定的接收数据类型*/
-    acceptRaw<AD, AT>(proc: AcceptProc<AD, AT>): UtilCom<D, S, typeof proc>;
-    /**预设的发送数据类型*/
+    acceptRaw<AD, AT>(proc: AcceptProc<AD, AT>): UtilHttp<D, S, typeof proc>;
+    /**预设的发送数据类型 */
     send<T extends SendType>(t: T): {
-        readonly json: UtilCom<D & {
+        readonly json: UtilHttp<D & {
             headers: {
                 "Content-Type": "application/json";
             };
         }, SendProc<[JToken]>, A>;
-        readonly query: UtilCom<D, SendProc<[QueryRequestData]>, A>;
-        readonly formData: UtilCom<D & {
+        readonly query: UtilHttp<D, SendProc<[QueryRequestData]>, A>;
+        readonly formData: UtilHttp<D & {
             headers: {
                 "Content-Type": "multipart/form-data";
             };
         }, SendProc<[FormData]>, A>;
-        readonly none: UtilCom<D, SendProc<[]>, 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];
-    /**利用 req.write 发送一段json */
-    sendJson(): UtilCom<D & {
+    /**发送json
+     * 请求参数为 (token:JToken)
+     */
+    sendJson(): UtilHttp<D & {
         headers: {
             "Content-Type": "application/json";
         };
     }, SendProc<[JToken]>, A>;
-    /**利用 appendQuery 直接将数据附加在path上发送请求 */
-    sendQuery(): UtilCom<D, SendProc<[QueryRequestData]>, A>;
-    sendFormData(): UtilCom<D & {
+    /**利用 appendQuery 直接将数据附加在path上发送请求
+     * 请求参数为 (form:QueryRequestData)
+     */
+    sendQuery(): UtilHttp<D, SendProc<[QueryRequestData]>, A>;
+    /**发送表单数据
+     * 请求参数为 (formData: FormData)
+     */
+    sendFormData(): UtilHttp<D & {
         headers: {
             "Content-Type": "multipart/form-data";
         };
     }, SendProc<[FormData]>, A>;
-    sendNone(): UtilCom<D, typeof SendNoneProc, A>;
-    /**自定的发送数据类型*/
-    sendRaw<T extends any[]>(proc: SendProc<T>): UtilCom<D, typeof proc, A>;
+    /**发送表单
+     * 请求参数为 (form:QueryRequestData)
+     */
+    sendForm(): UtilHttp<D & {
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded";
+        };
+    }, SendProc<[QueryRequestData]>, A>;
+    /**发送文件
+     * 请求参数为 (filepath:string, filename?: string)
+     */
+    sendFile(): UtilHttp<D & {
+        headers: {
+            "Content-Type": "multipart/form-data";
+        };
+    }, SendProc<[string, (string | undefined)?]>, A>;
+    sendNone(): UtilHttp<D, typeof SendNoneProc, A>;
+    /**自定的发送数据类型 */
+    sendRaw<T extends any[]>(proc: SendProc<T>): UtilHttp<D, typeof proc, A>;
     /**发送请求
-     * @param option - 网络请求选项
      * @param datas  - 数据对象
      */
-    once(option: PartialOption<RequestOption, D>, ...datas: SendParams<S>): Promise<ParseResult<A>>;
+    once(...datas: {} extends RequiredOnly<PartialOption<RequestOption, D>> ? SendParams<S> : [Error & "RequestOption不完整, 请使用 finalize 完成必要项"]): Promise<ParseResult<A>>;
     /**重复发送网络请求
-     * @param option  - 网络请求选项
      * @param verify  - 有效性验证函数
      * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
      * @param datas   - 数据对象
      */
     retry(opt: {
-        option: PartialOption<RequestOption, D>;
         verify?: StatusVerifyFn<ParseResult<A>>;
         retries?: PromiseRetries;
-    }, ...datas: SendParams<S>): Promise<import("@zwa73/js-utils").PromiseRetryResult<ParseResult<A>>>;
+    }, ...datas: {} extends RequiredOnly<PartialOption<RequestOption, D>> ? SendParams<S> : [Error & "RequestOption不完整, 请使用 finalize 完成必要项"]): Promise<import("@zwa73/js-utils").PromiseRetryResult<ParseResult<A>>>;
     /**发送网络请求
      * @param option  - 网络请求选项
      * @param proc    - 请求处理函数 需调用req.end()

package/dist/{UtilCom.js → UtilHttp.js}

@@ -3,15 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UtilCom = void 0;
+exports.UtilHttp = void 0;
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
+const url_1 = require("url");
 const UtilLogger_1 = require("./UtilLogger");
 const UtilFunctions_1 = require("./UtilFunctions");
 const querystring_1 = __importDefault(require("querystring"));
+const form_data_1 = __importDefault(require("form-data"));
 const http_proxy_agent_1 = __importDefault(require("http-proxy-agent"));
 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 = {
@@ -27,8 +31,8 @@ const AcceptNoneProc = {
     reduce: () => undefined,
     parse: () => undefined
 };
-/**网络请求工具 */
-class UtilCom {
+/**http请求工具 */
+class UtilHttp {
     _data;
     _send;
     _accept;
@@ -40,11 +44,23 @@ class UtilCom {
     //#region 流式创建
     /**设为https请求 */
     static https() {
-        return new UtilCom({ protocol: 'https:' }, SendNoneProc, AcceptStringProc);
+        return new UtilHttp({ protocol: 'https:' }, SendNoneProc, AcceptStringProc);
     }
     /**设为http请求 */
     static http() {
-        return new UtilCom({ protocol: 'http:' }, SendNoneProc, AcceptStringProc);
+        return new UtilHttp({ protocol: 'http:' }, SendNoneProc, AcceptStringProc);
+    }
+    /**从url创建 */
+    static url(urlStr) {
+        const { protocol, hostname, port, pathname } = new url_1.URL(urlStr);
+        if (!['http:', 'https:'].includes(protocol))
+            UtilFunctions_1.UtilFunc.throwError(`url协议错误: ${urlStr}`);
+        const req = new UtilHttp({ protocol: protocol }, SendNoneProc, AcceptStringProc);
+        return req.option({
+            hostname,
+            path: pathname,
+            port: port ? parseInt(port) : undefined,
+        });
     }
     /**设为get方式的请求 */
     get() {
@@ -57,12 +73,21 @@ class UtilCom {
         return this;
     }
     /**补充参数
+     * 不会检查必要参数完整性
      * 将会替换对应字段, 修改headers请用header函数
      */
     option(option) {
         this._data = { ...this._data, ...option };
         return this;
     }
+    /**完成参数
+     * 会检查必要参数完整性
+     * 将会替换对应字段, 修改headers请用header函数
+     */
+    finalize(option) {
+        this._data = { ...this._data, ...option };
+        return this;
+    }
     /**补充header */
     header(headers) {
         this._data.headers = {
@@ -81,9 +106,13 @@ class UtilCom {
     }
     /**添加一段query */
     query(data) {
-        this._data.path = UtilCom.buildQuery(this._data.path ?? '', data);
+        this._data.path = UtilHttp.buildQuery(this._data.path ?? '', data);
         return this;
     }
+    /**克隆 */
+    clone() {
+        return new UtilHttp({ ...this._data }, this._send, this._accept);
+    }
     //#endregion
     //#region 快速预设
     /**收发皆为json的预设 */
@@ -104,27 +133,27 @@ class UtilCom {
     }
     /**收发皆为json的https-post预设 */
     static httpsPostJson() {
-        return UtilCom.https().postJson();
+        return UtilHttp.https().postJson();
     }
     /**收发皆为json的http-post预设 */
     static httpPostJson() {
-        return UtilCom.http().postJson();
+        return UtilHttp.http().postJson();
     }
     /**无查询参数获取json的https-get预设 */
     static httpsGetJson() {
-        return UtilCom.https().getJson();
+        return UtilHttp.https().getJson();
     }
     /**有查询参数获取json的https-get预设 */
     static httpsQueryJson() {
-        return UtilCom.http().queryJson();
+        return UtilHttp.http().queryJson();
     }
     /**无查询参数获取json的http-get预设 */
     static httpGetJson() {
-        return UtilCom.http().getJson();
+        return UtilHttp.http().getJson();
     }
     /**有查询参数获取json的http-get预设 */
     static httpQueryJson() {
-        return UtilCom.http().queryJson();
+        return UtilHttp.http().queryJson();
     }
     //#endregion
     //#region 接收数据类型
@@ -180,27 +209,32 @@ class UtilCom {
     }
     //#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];
     }
-    /**利用 req.write 发送一段json */
+    /**发送json
+     * 请求参数为 (token:JToken)
+     */
     sendJson() {
         const proc = {
-            proc: (opt, reqData) => {
+            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(JSON.stringify(reqData));
+                this._data.headers['Content-Length'] = Buffer.byteLength(data);
                 const procReq = (req) => {
                     if (isPost)
-                        req.write(JSON.stringify(reqData));
+                        req.write(data);
                     req.end();
                 };
                 return procReq;
@@ -211,11 +245,13 @@ class UtilCom {
         this._data.headers['Content-Type'] = 'application/json';
         return this;
     }
-    /**利用 appendQuery 直接将数据附加在path上发送请求 */
+    /**利用 appendQuery 直接将数据附加在path上发送请求
+     * 请求参数为 (form:QueryRequestData)
+     */
     sendQuery() {
         const proc = {
-            proc: (opt, reqData) => {
-                opt.path = UtilCom.buildQuery(opt.path ?? '', reqData);
+            proc: (opt, form) => {
+                opt.path = UtilHttp.buildQuery(opt.path ?? '', form);
                 const procReq = (req) => void req.end();
                 return procReq;
             }
@@ -223,15 +259,62 @@ class UtilCom {
         this._send = proc;
         return this;
     }
+    /**发送表单数据
+     * 请求参数为 (formData: FormData)
+     */
     sendFormData() {
         const proc = {
             proc: (opt, formData) => {
                 opt.headers = formData.getHeaders();
                 const procReq = (req) => {
                     formData.pipe(req);
+                };
+                return procReq;
+            },
+        };
+        this._send = proc;
+        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) => {
+                    if (isPost)
+                        req.write(data);
                     req.end();
                 };
                 return procReq;
+            }
+        };
+        this._send = proc;
+        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;
             },
         };
         this._send = proc;
@@ -243,34 +326,32 @@ class UtilCom {
         this._send = SendNoneProc;
         return this;
     }
-    /**自定的发送数据类型*/
+    /**自定的发送数据类型 */
     sendRaw(proc) {
         this._send = proc;
         return this;
     }
     //#endregion
     /**发送请求
-     * @param option - 网络请求选项
      * @param datas  - 数据对象
      */
-    async once(option, ...datas) {
-        const fullopt = Object.assign({}, this._data, option);
+    async once(...datas) {
+        const fullopt = this._data;
         const proc = await this._send.proc(fullopt, ...datas);
         const { reduce, init, parse } = this._accept;
-        const res = await UtilCom.request(fullopt, proc, reduce, init);
+        const res = await UtilHttp.request(fullopt, proc, reduce, init);
         return parse(res);
     }
     /**重复发送网络请求
-     * @param option  - 网络请求选项
      * @param verify  - 有效性验证函数
      * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
      * @param datas   - 数据对象
      */
     async retry(opt, ...datas) {
-        let { option, retries, verify } = opt;
+        let { retries, verify } = opt;
         retries ??= {};
         retries.tryDelay = retries.tryDelay ?? 1000;
-        const procFn = async () => this.once(option, ...datas);
+        const procFn = async () => this.once(...datas);
         return UtilFunctions_1.UtilFunc.retryPromise(procFn, verify, retries);
     }
     /**发送网络请求
@@ -359,14 +440,43 @@ class UtilCom {
         return base;
     }
 }
-exports.UtilCom = UtilCom;
+exports.UtilHttp = UtilHttp;
 if (false)
     void ((async () => {
-        const t = await UtilCom.https().postJson()
-            .once({
-            hostname: 'httpbin.org',
-            path: '/post',
-            timeout: 10000
-        }, { test: 1 });
-        console.log(t);
+        const tool = UtilHttp
+            .url('https://httpbin.org/post')
+            .post()
+            .finalize({ timeout: 10000 });
+        //json
+        const sj = await tool.clone()
+            .sendJson()
+            .acceptJson()
+            .once({ test: 1 });
+        console.log(sj);
+        //form
+        const sf = await tool.clone()
+            .sendForm()
+            .acceptJson()
+            .once({ test: 1 });
+        console.log(sf);
+        //query
+        const sq = await tool.clone()
+            .sendQuery()
+            .acceptJson()
+            .once({ test: 1 });
+        console.log(sq);
+        const filepath = pathe_1.default.join(__dirname, '..', 'input.wav');
+        //formData
+        //const form = new FormData();
+        //form.append('name', 'input.wav');
+        //form.append('file', fs.createReadStream(path.join(__dirname,'..','input.wav')));
+        //const sfd = await tool.clone()
+        //    .sendFormData()
+        //    .acceptJson()
+        //    .once(form);
+        const sfile = await tool.clone()
+            .sendFile()
+            .acceptJson()
+            .once(filepath);
+        console.log(sfile);
     })());

package/dist/index.d.ts

@@ -2,7 +2,7 @@ export * from './UtilFunctions';
 export * from './UtilInterfaces';
 export * from './UtilSymbol';
 export * from './UtilClass';
-export * from './UtilCom';
+export * from './UtilHttp';
 export * from './UtilCodecs';
 export * from './UtilDecorators';
 export * from './UtilFileTools';

package/dist/index.js

@@ -35,7 +35,7 @@ __exportStar(require("./UtilFunctions"), exports);
 __exportStar(require("./UtilInterfaces"), exports);
 __exportStar(require("./UtilSymbol"), exports);
 __exportStar(require("./UtilClass"), exports);
-__exportStar(require("./UtilCom"), exports);
+__exportStar(require("./UtilHttp"), exports);
 __exportStar(require("./UtilCodecs"), exports);
 __exportStar(require("./UtilDecorators"), exports);
 __exportStar(require("./UtilFileTools"), exports);

package/package.json

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