@zwa73/utils 1.0.194 → 1.0.196

package/dist/UtilClass.d.ts

@@ -1,4 +1,4 @@
-import { Keyable, Literal } from "./UtilInterfaces";
+import { Keyable, Literal, MPromise } from "./UtilInterfaces";
 import Handlebars from 'handlebars';
 /**函数管道器 */
 export declare class Piper<Arg, Result = Arg> {
@@ -18,7 +18,7 @@ export declare class Piper<Arg, Result = Arg> {
     /**直接调用 */
     invoke(arg: Arg): Result;
 }
-type StreamOperation<T, U> = (item: T) => Promise<U> | U;
+type StreamOperation<T, U> = (item: T) => MPromise<U>;
 /**并行流 */
 export declare class Stream<T> implements Iterable<T> {
     /**并发数*/
@@ -27,8 +27,11 @@ export declare class Stream<T> implements Iterable<T> {
     /**加工函数列表*/
     private _operation;
     private constructor();
-    /**从arraylike创建流 */
-    static from<T>(args: Parameters<typeof Array.from<T>>[0], concurrent?: number): Stream<T>;
+    /**从arraylike创建流
+     * @param args - arraylike
+     * @param concurrent - 并发数 默认 1
+     */
+    static from<T>(args: ArrayLike<T>, concurrent?: number): Stream<T>;
     /**从数组创建流 */
     static of<T>(...args: T[]): Stream<T>;
     /**设置并发数 */

package/dist/UtilClass.js

@@ -49,7 +49,10 @@ class Stream {
             this._list = new Array(...base);
         this._concurrent = concurrent;
     }
-    /**从arraylike创建流 */
+    /**从arraylike创建流
+     * @param args - arraylike
+     * @param concurrent - 并发数 默认 1
+     */
     static from(args, concurrent = 1) {
         return new Stream(Array.from(args), concurrent);
     }
@@ -200,6 +203,7 @@ class Stream {
     }
 }
 exports.Stream = Stream;
+//#endregion
 /**文本模板渲染器
  * @template T - 上下文对象的类型，默认为记录类型
  */

package/dist/UtilCom.d.ts

@@ -1,6 +1,6 @@
-import { AnyString, JObject, ReqVerifyFn } from "./UtilInterfaces";
+import { AnyString, JToken, MPromise, PartialOption, StatusVerifyFn } from "./UtilInterfaces";
 import http from 'http';
-import { RepeatPromiseOpt, RepeatPromiseResult } from "./UtilFunctions";
+import { RepeatPromiseOpt } from "./UtilFunctions";
 /**网络请求返回值 */
 export type ComResp<T> = {
     /**响应头 */
@@ -11,12 +11,11 @@ export type ComResp<T> = {
     data: T;
 };
 /**网络请求选项 */
-export type ComReqOpt = {
+export type ComRequestOption = {
     /**请求协议 */
-    protocol: 'http' | 'https';
+    protocol: 'http:' | 'https:';
     /**超时时间/毫秒  最小为10_000 默认无限 */
-    timeLimit?: number;
-} & {
+    timeout?: number;
     /**请求域名 */
     hostname: string;
     /**请求路径 */
@@ -35,125 +34,100 @@ export type ComReqOpt = {
 } & http.RequestOptions;
 /**get请求所允许的数据 */
 export type GetReqData = NodeJS.Dict<string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>;
-/**网络工具 */
-export declare namespace UtilCom {
+/**请求处理函数 需调用req.end() */
+export type ProcReqFn = ((req: http.ClientRequest) => MPromise<void>);
+/**数据处理函数 */
+export type ReduceDataFn<T> = (acc: T, data: string) => MPromise<T>;
+declare const AcceptTypeList: readonly ["json"];
+/**可用的接受类型 */
+type AcceptType = typeof AcceptTypeList[number];
+declare const SendTypeList: readonly ["json", "none"];
+/**可用的发送类型 */
+type SendType = typeof SendTypeList[number];
+/**accept处理数据 */
+type AcceptProc<D, T> = {
+    init: D;
+    reduce: ReduceDataFn<D>;
+    parse: (result: ComResp<D> | undefined) => MPromise<T>;
+};
+/**send处理数据 */
+type SendProc<T extends any[]> = {
+    proc: (opt: ComRequestOption, ...args: T) => MPromise<ProcReqFn>;
+};
+/**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>> {
+    private _data;
+    private _send;
+    private _accept;
+    private constructor();
+    /**设为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;
+    }>;
+    /**设为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;
+    }>;
+    /**设为get方式的请求 */
+    get(): UtilCom<D & {
+        readonly method: "GET";
+    }, S, A>;
+    /**设为Post方式的请求 */
+    post(): UtilCom<D & {
+        readonly method: "POST";
+    }, S, A>;
+    /**补充参数 */
+    option<OPT extends Partial<ComRequestOption>>(opt: OPT): UtilCom<D & OPT, S, A>;
+    /**接收数据类型*/
+    accept<T extends AcceptType>(t: T): {
+        readonly json: UtilCom<D, S, AcceptProc<string, JToken>>;
+        readonly log: UtilCom<D, S, AcceptProc<string, string>>;
+    }[T];
+    acceptJson(): UtilCom<D, S, AcceptProc<string, JToken>>;
+    acceptLog(): UtilCom<D, S, AcceptProc<string, string>>;
+    /**发送数据类型*/
+    send<T extends SendType>(t: T): {
+        readonly json: UtilCom<D, SendProc<[JsonType<D>]>, A>;
+        readonly none: UtilCom<D, SendProc<[]>, A>;
+    }[T];
+    sendJson(): UtilCom<D, SendProc<[JsonType<D>]>, A>;
+    sendNone(): UtilCom<D, SendProc<[]>, A>;
+    /**发送请求
+     * @param option       - 网络请求选项
+     * @param datas     - 数据对象
+     */
+    once(option: PartialOption<ComRequestOption, D>, ...datas: SendParams<S>): Promise<any>;
+    /**重复发送网络请求
+     * @param option       - 网络请求选项
+     * @param verifyFn  - 有效性验证函数
+     * @param repeatOpt - 重试选项 默认 延迟: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   - 初始数据
      */
-    function comReq<T>(comReqOpt: ComReqOpt, procReq: ((req: http.ClientRequest) => void | Promise<void>), reduceData: (acc: T, data: string) => T, initData: T): Promise<ComResp<T> | undefined>;
-    /**发送一个 https POST 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData     - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**发送一个 http POST 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData 	  - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**发送一个 https GET 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData     - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**发送一个 http GET 请求并接受数据
-     * @async
-     * @param comReqOpt   - 请求参数
-     * @param reqData 	  - 数据对象
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData): Promise<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>;
-    /**重复一个 https POST请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsRepeatPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
-    /**重复一个 http POST请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpRepeatPost(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: JObject, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
-    /**重复一个 https GET 请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpsRepeatGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
-    /**重复一个 http GET 请求并接受数据
-     * @async
-     * @param comReqOpt - 网络请求选项
-     * @param reqData   - 数据对象
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @returns 结果 undefined 为未能成功接收
-     */
-    function httpRepeatGet(comReqOpt: Omit<ComReqOpt, 'protocol' | 'method'>, reqData?: GetReqData, verifyFn?: ReqVerifyFn<JObject | undefined>, repeatOpt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<{
-        data: JObject;
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-    } | undefined>>;
+    static comReq<T>(comReqOpt: ComRequestOption, procReq: ProcReqFn, reduceData: ReduceDataFn<T>, initData: T): Promise<ComResp<T> | undefined>;
 }
+export {};