@zwa73/utils 1.0.198 → 1.0.200

package/dist/UtilCom.js

@@ -4,21 +4,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilCom = void 0;
-const https_1 = __importDefault(require("https"));
 const http_1 = __importDefault(require("http"));
+const https_1 = __importDefault(require("https"));
 const UtilLogger_1 = require("./UtilLogger");
 const UtilFunctions_1 = require("./UtilFunctions");
 const querystring_1 = __importDefault(require("querystring"));
 const UtilSymbol_1 = require("./UtilSymbol");
-const AcceptTypeList = ["json"];
-const SendTypeList = ["json", "none"];
-const defSend = {
-    proc: () => (req) => void req.end()
+const http_proxy_agent_1 = __importDefault(require("http-proxy-agent"));
+const https_proxy_agent_1 = __importDefault(require("https-proxy-agent"));
+const AcceptTypeList = ["json", "string"];
+const SendTypeList = ["json", "query", "formData", "none"];
+const SendNoneProc = {
+    proc: (opt) => (req) => void req.end()
 };
-const defAccept = {
+const AcceptStringProc = {
     init: '',
     reduce: (acc, dat) => acc + dat,
-    parse: (result) => void console.log(result)
+    parse: (result) => result
 };
 /**网络请求工具 */
 class UtilCom {
@@ -30,44 +32,102 @@ class UtilCom {
         this._send = _send;
         this._accept = _accept;
     }
-    //#region 快速流式创建
+    //#region 流式创建
     /**设为https请求 */
     static https() {
-        return new UtilCom({ protocol: 'https:' }, defSend, defAccept);
+        return new UtilCom({ protocol: 'https:' }, SendNoneProc, AcceptStringProc);
     }
     /**设为http请求 */
     static http() {
-        return new UtilCom({ protocol: 'http:' }, defSend, defAccept);
+        return new UtilCom({ protocol: 'http:' }, SendNoneProc, AcceptStringProc);
     }
     /**设为get方式的请求 */
     get() {
-        return new UtilCom({ ...this._data, method: 'GET' }, this._send, this._accept);
+        this._data.method = 'GET';
+        return this;
     }
     /**设为Post方式的请求 */
     post() {
-        return new UtilCom({ ...this._data, method: 'POST' }, this._send, this._accept);
+        this._data.method = 'POST';
+        return this;
+    }
+    /**补充参数
+     * 将会替换对应字段, 修改headers请用header函数
+     */
+    option(option) {
+        this._data = { ...this._data, ...option };
+        return this;
+    }
+    /**补充header */
+    header(headers) {
+        this._data.headers = {
+            ...this._data.headers,
+            ...headers,
+        };
+        return this;
     }
-    /**补充参数 */
-    option(opt) {
-        return new UtilCom({ ...this._data, ...opt }, this._send, this._accept);
+    /**设置agent */
+    proxyAgent(url) {
+        this._data.agent = UtilFunctions_1.UtilFunc.matchProc(this._data['protocol'], {
+            'http:': () => (0, http_proxy_agent_1.default)(url),
+            'https:': () => (0, https_proxy_agent_1.default)(url),
+        });
+        return this;
+    }
+    /**添加一段query */
+    query(data) {
+        this._data.path = UtilCom.buildQuery(this._data.path ?? '', data);
+        return this;
     }
     //#endregion
     //#region 快速预设
+    /**收发皆为json的预设 */
+    json() {
+        return this.sendJson().acceptJson();
+    }
     /**收发皆为json的post预设 */
     postJson() {
         return this.post().json();
     }
-    /**收发皆为json的预设 */
-    json() {
-        return this.sendJson().acceptJson();
+    /**无查询参数获取json的get预设 */
+    getJson() {
+        return this.get().sendNone().acceptJson();
+    }
+    /**有查询参数获取json的get预设 */
+    queryJson() {
+        return this.get().sendQuery().acceptJson();
+    }
+    /**收发皆为json的https-post预设 */
+    static httpsPostJson() {
+        return UtilCom.https().postJson();
+    }
+    /**收发皆为json的http-post预设 */
+    static httpPostJson() {
+        return UtilCom.http().postJson();
+    }
+    /**无查询参数获取json的https-get预设 */
+    static httpsGetJson() {
+        return UtilCom.https().getJson();
+    }
+    /**有查询参数获取json的https-get预设 */
+    static httpsQueryJson() {
+        return UtilCom.http().queryJson();
+    }
+    /**无查询参数获取json的http-get预设 */
+    static httpGetJson() {
+        return UtilCom.http().getJson();
+    }
+    /**有查询参数获取json的http-get预设 */
+    static httpQueryJson() {
+        return UtilCom.http().queryJson();
     }
     //#endregion
     //#region 接收数据类型
-    /**接收数据类型*/
+    /**预设的接收数据类型*/
     accept(t) {
         const map = {
             'json': this.acceptJson(),
-            'log': this.acceptLog(),
+            'string': this.acceptString(),
         };
         return map[t];
     }
@@ -80,65 +140,52 @@ class UtilCom {
                     return undefined;
                 const { data, ...rest } = result;
                 if (data.trim() == "") {
-                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`);
+                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误: 原始字符串为空`, 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 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }));
+                    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 }));
                     return { ...rest, data: obj };
                 }
                 catch (e) {
-                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误:${e}\n原始字符串:${data}`);
+                    UtilLogger_1.SLogger.warn(`json accept 接收反馈错误:${e}`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
                     return { ...result, raw: data, data: null };
                 }
             }
         };
-        return new UtilCom(this._data, this._send, proc);
+        this._accept = proc;
+        return this;
     }
-    acceptLog() {
-        const proc = {
-            init: '',
-            reduce: (acc, curr) => acc + curr,
-            parse: (result) => {
-                UtilLogger_1.SLogger.http(`log accept 接受信息:`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
-                if (result == undefined)
-                    return '';
-                const { data, ...rest } = result;
-                return data;
-            }
-        };
-        return new UtilCom(this._data, this._send, proc);
+    acceptString() {
+        this._accept = AcceptStringProc;
+        return this;
+    }
+    /**自定的接收数据类型*/
+    acceptRaw(proc) {
+        this._accept = proc;
+        return this;
     }
     //#endregion
     //#region 发送数据类型
-    /**发送数据类型*/
+    /**预设的发送数据类型*/
     send(t) {
         const map = {
             'json': this.sendJson(),
-            "none": this.sendNone(),
+            'query': this.sendQuery(),
+            'formData': this.sendFormData(),
+            'none': this.sendNone(),
         };
         return map[t];
     }
+    /**利用 req.write 发送一段json */
     sendJson() {
         const proc = {
             proc: (opt, reqData) => {
                 const { method } = opt;
                 const isPost = (method == "POST");
-                if (!isPost && reqData != undefined) {
-                    const queryString = querystring_1.default.stringify(reqData);
-                    if (queryString) {
-                        // 检查当前路径是否已经包含问号
-                        const separator = opt?.path?.includes('?') ? '&' : '?';
-                        opt.path += separator + queryString;
-                    }
-                }
-                if (isPost) {
-                    this._data.headers ??= {
-                        'Content-Type': 'application/json',
-                        'Content-Length': Buffer.from(JSON.stringify(reqData)).length,
-                    };
-                }
+                this._data.headers ??= {};
+                this._data.headers['Content-Length'] = Buffer.byteLength(JSON.stringify(reqData));
                 const procReq = (req) => {
                     if (isPost)
                         req.write(JSON.stringify(reqData));
@@ -147,52 +194,83 @@ class UtilCom {
                 return procReq;
             }
         };
-        return new UtilCom(this._data, proc, this._accept);
+        this._send = proc;
+        this._data.headers ??= {};
+        this._data.headers['Content-Type'] = 'application/json';
+        return this;
     }
-    sendNone() {
+    /**利用 appendQuery 直接将数据附加在path上发送请求 */
+    sendQuery() {
         const proc = {
-            proc: (opt) => {
+            proc: (opt, reqData) => {
+                opt.path = UtilCom.buildQuery(opt.path ?? '', reqData);
+                const procReq = (req) => void req.end();
+                return procReq;
+            }
+        };
+        this._send = proc;
+        return this;
+    }
+    sendFormData() {
+        const proc = {
+            proc: (opt, formData) => {
+                opt.headers = formData.getHeaders();
                 const procReq = (req) => {
+                    formData.pipe(req);
                     req.end();
                 };
                 return procReq;
-            }
+            },
         };
-        return new UtilCom(this._data, proc, this._accept);
+        this._send = proc;
+        this._data.headers ??= {};
+        this._data.headers['Content-Type'] = 'multipart/form-data';
+        return this;
+    }
+    sendNone() {
+        this._send = SendNoneProc;
+        return this;
+    }
+    /**自定的发送数据类型*/
+    sendRaw(proc) {
+        this._send = proc;
+        return this;
     }
     //#endregion
     /**发送请求
-     * @param option       - 网络请求选项
-     * @param datas     - 数据对象
+     * @param option - 网络请求选项
+     * @param datas  - 数据对象
      */
     async once(option, ...datas) {
         const fullopt = Object.assign({}, this._data, option);
-        const procReq = await this._send.proc(fullopt, ...datas);
+        const proc = await this._send.proc(fullopt, ...datas);
         const { reduce, init, parse } = this._accept;
-        const res = await UtilCom.comReq(fullopt, procReq, reduce, init);
+        const res = await UtilCom.request(fullopt, proc, reduce, init);
         return parse(res);
     }
     /**重复发送网络请求
-     * @param option       - 网络请求选项
-     * @param verifyFn  - 有效性验证函数
-     * @param repeatOpt - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
-     * @param datas     - 数据对象
+     * @param option  - 网络请求选项
+     * @param verify  - 有效性验证函数
+     * @param retries - 重试选项 默认 延迟:1000ms 间隔:180_000ms 重试:3次
+     * @param datas   - 数据对象
      */
-    async repeat(option, verifyFn, repeatOpt = {}, ...datas) {
-        repeatOpt.tryDelay = repeatOpt.tryDelay ?? 1000;
+    async retry(opt, ...datas) {
+        let { option, retries, verify } = opt;
+        retries ??= {};
+        retries.tryDelay = retries.tryDelay ?? 1000;
         const procFn = () => this.once(option, ...datas);
-        return UtilFunctions_1.UtilFunc.repeatPromise(procFn, verifyFn, repeatOpt);
+        return UtilFunctions_1.UtilFunc.retryPromise(procFn, verify, retries);
     }
-    /**网络请求
-     * @param comReqOpt  - 网络请求选项
-     * @param procReq    - 请求处理函数 需调用req.end()
-     * @param reduceData - 数据处理函数
-     * @param initData   - 初始数据
+    /**发送网络请求
+     * @param option  - 网络请求选项
+     * @param proc    - 请求处理函数 需调用req.end()
+     * @param reduce  - 数据处理函数
+     * @param init    - 初始数据
      */
-    static async comReq(comReqOpt, procReq, reduceData, initData) {
-        const { protocol, timeout, ...baseReqOpt } = comReqOpt;
+    static async request(option, proc, reduce, init) {
+        const { protocol, timeout, ...baseReqOpt } = option;
         const hasTimeLimit = (timeout ? timeout >= 10_000 : false);
-        const flagName = `UtilCom.comReq ${protocol}${baseReqOpt.method} ${UtilFunctions_1.UtilFunc.genUUID()}`;
+        const flagName = `UtilCom.request ${protocol}${baseReqOpt.method} ${UtilFunctions_1.UtilFunc.genUUID()}`;
         let dataPromise = null;
         return new Promise(async (resolve, rejecte) => {
             const resFunc = (res) => {
@@ -204,10 +282,10 @@ class UtilCom {
                             resolve(undefined);
                         });
                     }
-                    let mergedata = initData;
+                    let mergedata = init;
                     res.setEncoding('utf8');
                     res.on('data', chunk => {
-                        dataPromise = UtilFunctions_1.UtilFunc.queueProc(flagName, async () => mergedata = await reduceData(mergedata, chunk));
+                        dataPromise = UtilFunctions_1.UtilFunc.queueProc(flagName, async () => mergedata = await reduce(mergedata, chunk));
                     });
                     res.on('error', (e) => {
                         UtilLogger_1.SLogger.warn(`${flagName} 接收反馈错误:${e}`);
@@ -243,18 +321,32 @@ class UtilCom {
                 UtilLogger_1.SLogger.warn(`${flagName} 发送请求错误:${e}`);
                 resolve(undefined);
             });
-            await procReq(req);
+            await proc(req);
         });
     }
+    /**构建query */
+    static buildQuery(base, data) {
+        const queryString = querystring_1.default.stringify(data);
+        if (queryString) {
+            // 检查当前路径是否已经包含问号
+            const separator = base.includes('?') ? '&' : '?';
+            base += separator + queryString;
+        }
+        return base;
+    }
 }
 exports.UtilCom = UtilCom;
 if (false)
     ((async () => {
-        const t = await UtilCom.https().post().accept('json').send('json')
-            .repeat({
-            hostname: 'httpbin.org',
-            path: '/post',
-            timeout: 10000
-        }, () => UtilSymbol_1.Success, {}, { test: 1 });
+        const t = await UtilCom.https().postJson()
+            .retry({
+            option: {
+                hostname: 'httpbin.org',
+                path: '/post',
+                timeout: 10000
+            },
+            verify: () => UtilSymbol_1.Success,
+            retries: {}
+        }, { test: 1 });
         console.log(t);
     })());

package/dist/UtilFileTools.d.ts

@@ -115,7 +115,6 @@ export declare namespace UtilFT {
      */
     function loadJSONFile<T extends JToken>(filePath: string, opt: LoadJsonFileOpt<T>): Promise<T>;
     /**写入JSON文件
-     * void (string,Object)
      * @async
      * @param filePath - 文件路径
      * @param token    - 所要写入的JToken

package/dist/UtilFileTools.js

@@ -176,7 +176,6 @@ var UtilFT;
     }
     UtilFT.loadJSONFile = loadJSONFile;
     /**写入JSON文件
-     * void (string,Object)
      * @async
      * @param filePath - 文件路径
      * @param token    - 所要写入的JToken

package/dist/UtilFunctions.d.ts

@@ -20,7 +20,7 @@ type StringifyOpt = Partial<{
     space: string | number | null | undefined;
 }>;
 /**Promise重试选项 */
-export type RepeatPromiseOpt = Partial<{
+export type PromiseRetries = Partial<{
     /**重试次数 默认3*/
     count?: number;
     /**尝试间隔时间 超过此事件会重新创建新的Promise
@@ -29,11 +29,15 @@ export type RepeatPromiseOpt = Partial<{
     tryInterval?: number;
     /**尝试延迟 重新尝试时会先等待此毫秒数 毫秒 默认0*/
     tryDelay?: number;
+    /**是否使用指数回退 默认false 仅在tryDelay被设置时有效 */
+    expBackoff?: boolean;
+    /**指数回退上限值 默认无限*/
+    expBackoffMax?: number;
 }>;
 type SuccessOut<T> = Outcome<Success, T>;
 type TimeoutOut<T> = Outcome<Timeout, Promise<T>>;
 /**完成的重试请求 */
-export type RepeatPromiseResult<T> = {
+export type PromiseRetryResult<T> = {
     completed: T | undefined;
     /**还未完成的其他Promise 若是验证失败则会返回undefined */
     pending: Promise<T | undefined>[];
@@ -108,12 +112,12 @@ export declare class UtilFunc {
     static getNeverResolvedPromise<T>(): Promise<T>;
     /**重复尝试promise
      * @async
-     * @param procFn      - 发起函数
-     * @param verifyFn    - 验证函数
-     * @param opt         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
+     * @param proc      - 发起函数
+     * @param verify    - 验证函数
+     * @param retries         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
      * @returns 重复结果
      */
-    static repeatPromise<T>(procFn: () => Promise<T>, verifyFn?: StatusVerifyFn<T>, opt?: RepeatPromiseOpt): Promise<RepeatPromiseResult<T>>;
+    static retryPromise<T>(proc: () => Promise<T>, verify?: StatusVerifyFn<T>, retries?: PromiseRetries): Promise<PromiseRetryResult<T>>;
     /**创建一个限时的Promise
      * @param func      - 处理函数
      * @param timeLimit - 毫秒限时
@@ -292,7 +296,7 @@ export declare class UtilFunc {
      * @param func - 待转换函数
      * @returns 转换完成的函数
      */
-    static eitherize<T extends AnyFunc>(func: T): (...args: Parameters<T>) => Outcome<typeof Success, ReturnType<T>> | Outcome<typeof Failed, Error>;
+    static eitherize<T extends AnyFunc>(func: ReturnType<T> extends Promise<any> ? Error & "对异步函数请使用taskEitherize" : T): (...args: Parameters<T>) => Outcome<typeof Success, ReturnType<T>> | Outcome<typeof Failed, Error>;
     /**将传入的异步函数包装为显式处理错误的函数
      * @param func - 待转换函数
      * @returns 转换完成的函数

package/dist/UtilFunctions.js

@@ -168,35 +168,39 @@ class UtilFunc {
     }
     /**重复尝试promise
      * @async
-     * @param procFn      - 发起函数
-     * @param verifyFn    - 验证函数
-     * @param opt         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
+     * @param proc      - 发起函数
+     * @param verify    - 验证函数
+     * @param retries         - 重试参数 默认 延迟:0ms 间隔:180_000ms 重试:3次
      * @returns 重复结果
      */
-    static async repeatPromise(procFn, verifyFn, opt = {}) {
-        opt.count = opt.count ?? 3;
-        opt.tryInterval = opt.tryInterval ?? 180_000;
-        const { count, tryInterval } = opt;
+    static async retryPromise(proc, verify, retries = {}) {
+        retries.count = retries.count ?? 3;
+        retries.tryInterval = retries.tryInterval ?? 180_000;
+        const { count, tryInterval, tryDelay } = retries;
         /**是否含有超时时间 */
         const hasRepeatTime = (tryInterval >= 5000);
         //验证处理函数
-        if (verifyFn === undefined)
-            verifyFn = () => UtilSymbol_1.Success;
+        if (verify === undefined)
+            verify = () => UtilSymbol_1.Success;
         //进行中的请求
         const plist = [];
         //开始处理
         try {
             //根据最大重试次数限制进行循环
             for (let i = 0; i < count;) {
-                if (i > 0 && opt.tryDelay)
-                    await UtilFunc.sleep(opt.tryDelay);
-                UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 repeatPromise`);
+                if (i > 0 && tryDelay) {
+                    const delay = retries.expBackoff
+                        ? Math.min((Math.pow(2, i) - 1) * tryDelay, retries.expBackoffMax ?? Infinity)
+                        : tryDelay;
+                    await UtilFunc.sleep(delay);
+                }
+                UtilLogger_1.SLogger.info(`开始第 ${i + 1} 次 retryPromise`);
                 //如果 plist 中当前下标的任务还未创建 则 创建当前任务
                 if (plist.length < i + 1) {
                     plist.push(UtilFunc.timelimitPromise(async () => {
                         const index = i;
-                        const result = await procFn();
-                        const stat = await verifyFn(result);
+                        const result = await proc();
+                        const stat = await verify(result);
                         return { result, stat, index };
                     }, hasRepeatTime ? tryInterval : undefined));
                 }
@@ -209,7 +213,7 @@ class UtilFunc {
                         const res = await currObj.result;
                         rslove(UtilFunc.outcome(UtilSymbol_1.Success, res));
                     });
-                    UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 repeatPromise 超时 ${tryInterval} ms 开始重试`);
+                    UtilLogger_1.SLogger.warn(`第 ${i + 1} 次 retryPromise 超时 ${tryInterval} ms 开始重试`);
                     i++;
                     continue;
                 }
@@ -217,14 +221,14 @@ class UtilFunc {
                 const postresult = currObj.result;
                 const result = UtilFunc.matchProc(postresult.stat, {
                     [UtilSymbol_1.Success]() {
-                        UtilLogger_1.SLogger.info(`第 ${postresult.index + 1} 次 repeatPromise 成功`);
+                        UtilLogger_1.SLogger.info(`第 ${postresult.index + 1} 次 retryPromise 成功`);
                         //非当前
                         if (postresult.index != i)
                             UtilLogger_1.SLogger.info(`成功的 promise 非当前 promise 考虑增大重试时间\n当前index: ${i}\n当前重试时间: ${tryInterval}`);
                         return postresult.result;
                     },
                     [UtilSymbol_1.Terminated]() {
-                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 repeatPromise 终止 停止重试`);
+                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 retryPromise 终止 停止重试`);
                         return postresult.result;
                     },
                     [UtilSymbol_1.Failed]() {
@@ -232,12 +236,12 @@ class UtilFunc {
                         plist[postresult.index] = UtilFunc.getNeverResolvedPromise();
                         //是当前
                         if (postresult.index == i) {
-                            UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 repeatPromise 失败 开始重试`);
+                            UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 retryPromise 失败 开始重试`);
                             i++;
                             return UtilSymbol_1.None;
                         }
                         //非当前
-                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 repeatPromise 失败`);
+                        UtilLogger_1.SLogger.warn(`第 ${postresult.index + 1} 次 retryPromise 失败`);
                         return UtilSymbol_1.None;
                     },
                 });
@@ -264,7 +268,7 @@ class UtilFunc {
                     };
             }
             //全部失败或超时则返回 全pending
-            UtilLogger_1.SLogger.warn(`${count} 次 repeatPromise 尝试均失败`);
+            UtilLogger_1.SLogger.warn(`${count} 次 retryPromise 尝试均失败`);
             return {
                 completed: undefined,
                 pending: plist
@@ -286,7 +290,7 @@ class UtilFunc {
             };
         }
         catch (err) {
-            UtilLogger_1.SLogger.warn(`repeatPromise 发生意外错误`, err);
+            UtilLogger_1.SLogger.warn(`retryPromise 发生意外错误`, err);
             return { completed: undefined, pending: [] };
         }
     }
@@ -792,8 +796,8 @@ class UtilFunc {
 }
 exports.UtilFunc = UtilFunc;
 __decorate([
-    (0, UtilDecorators_1.LogTimeAsync)("repeatPromise ", true),
+    (0, UtilDecorators_1.LogTimeAsync)("retryPromise ", true),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Function, Function, Object]),
     __metadata("design:returntype", Promise)
-], UtilFunc, "repeatPromise", null);
+], UtilFunc, "retryPromise", null);

package/dist/UtilInterfaces.d.ts

@@ -124,7 +124,7 @@ export type RequiredOnly<T> = {
 export type WithPrefix<T, P extends string> = {
     [K in (keyof T) as K extends string ? `${P}${K}` : K]: T[K];
 };
-/**返回结果
+/**附带状态的返回结果用于状态返回值的封装
  * @template K - 类型键值
  * @template V - 值
  */
@@ -134,16 +134,16 @@ export type Outcome<K extends Keyable, V> = {
     /**值 */
     readonly result: V;
 };
-/**可成功或失败的结果
- * @template S - 成功时的结果
- * @template F - 失败时的结果
+/**可进行匹配的对象
+ * 如果是Outcome则自动处理status
  */
-export type Eithercome<S, F> = Outcome<Success, S> | Outcome<Failed, F>;
-/**可进行匹配的 outcome或symbol */
 export type Matchable<T extends Keyable> = T | Outcome<T, unknown>;
 /**可进行匹配的 outcome或symbol 中的状态类型 */
 export type MatchableFlag<T> = T extends infer O | Outcome<infer O, unknown> ? O : never;
-/**从联合 Outcome 中 根据 id 提取对应 Outcome */
+/**从联合 Outcome 中 根据 K 提取对应 Outcome
+ * @template T - 联合Outcome匹配的类型
+ * @template K - 所需的状态
+*/
 export type ExtractOutcome<T, K extends Keyable> = T extends Outcome<infer O, unknown> ? O extends Exclude<O, K> ? never : T : never;
 /**用于辅助解析智能补全的类型
  * 输出schema后替换为 ^.*$ 的 string 匹配

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.198",
+	"version": "1.0.200",
 	"description": "my utils",
 	"main": "index.js",
 	"scripts": {
@@ -18,6 +18,7 @@
 	"dependencies": {
 		"@deepkit/type": "^1.0.1-alpha.153",
 		"fluent-ffmpeg": "2.1.2",
+		"form-data": "^4.0.2",
 		"glob": "^10.4.1",
 		"handlebars": "^4.7.8",
 		"html-entities": "^2.3.3",

package/src/UtilCom.macro.ts

@@ -0,0 +1,28 @@
+import { regionMacro } from "@zwa73/dev-utils";
+import { dedent } from "./QuickExport";
+
+const sep1 = ["http","https"];
+const sep2 = ["get","post"];
+const AcceptTypeList = ["json","raw"]as const;
+const SendTypeList = ["json","query","formData","none","raw"] as const;
+const sep3 = SendTypeList;
+const up = (str:string)=>{
+    if (str.length === 0) return str; // 处理空字符串
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+if(false)
+regionMacro("UtilCom宏定义",()=>{
+    const result:string[] = [];
+    sep1.forEach(s1=>{
+        sep2.forEach(s2=>{
+            sep3.filter(s=>s!='raw').forEach(s3=>{
+                result.push(dedent`
+                    /** 宏 UtilCom.${s1}().${s2}().send('${s3}').acceptJson() */
+                    static ${s1}${up(s2)}${up(s3)}(){
+                        return UtilCom.${s1}().${s2}().send('${s3}' as const).acceptJson();
+                    }`.trim());
+            })
+        })
+    })
+    return result.reverse().join('\n');
+});