@zwa73/utils 1.0.198 → 1.0.200

package/dist/UtilCom.d.ts

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