@zwa73/utils 1.0.294 → 1.0.295

package/dist/UtilFunctions.d.ts

@@ -57,6 +57,6 @@ declare class _UtilFunc {
      */
     static resolveDataStore<T>(source: ParseableDataStore<T>): DataStore<T>;
 }
-export declare const UtilFunc: import("@zwa73/modular-mixer").ComposedClass<typeof _UtilFunc, typeof JsFunc, "__jsUtils", "prototype" | "preset" | "assignOption" | "genUUID" | "getTime" | "initField" | "initObject" | "afterward" | "sleep" | "getNeverResolvedPromise" | "retryPromise" | "timelimitPromise" | "mapEntries" | "eachField" | "stringifyJToken" | "sortJToken" | "constrainType" | "constrainLiteral" | "assertType" | "deepClone" | "isSafeNumber" | "dedent" | "throwError" | "getStack" | "getFuncLoc" | "cachePool" | "memoize" | "asyncize" | "lazyFunction" | "iocify" | "splitToChunk" | "mergeFromChunk" | "structEqual" | "concurrent" | "dynamicImport" | "createInjectable" | "createAsyncProxy" | "checkSharpSchema" | "unwarpReadonly" | "outcome" | "extractOutcome" | "success" | "failed" | "match" | "isStatus" | "eitherize" | "parseSrtTime" | "formatSrtTime" | "parseSrt" | "createSrt" | "ivk" | "range" | "s2l" | "l2s">;
+export declare const UtilFunc: import("@zwa73/modular-mixer").ComposedClass<typeof _UtilFunc, typeof JsFunc, "__jsUtils", "prototype" | "preset" | "assignOption" | "genUUID" | "getTime" | "initField" | "initObject" | "afterward" | "sleep" | "getNeverResolvedPromise" | "retryPromise" | "timelimitPromise" | "mapEntries" | "eachField" | "stringifyJToken" | "sortJToken" | "constrainType" | "constrainLiteral" | "assertType" | "deepClone" | "isSafeNumber" | "dedent" | "throwError" | "getStack" | "getFuncLoc" | "cachePool" | "memoize" | "asyncize" | "lazyFunction" | "iocify" | "splitToChunk" | "mergeFromChunk" | "structEqual" | "concurrent" | "dynamicImport" | "createInjectable" | "createAsyncProxy" | "checkSharpSchema" | "unwarpReadonly" | "wrapILogger" | "outcome" | "extractOutcome" | "success" | "failed" | "match" | "isStatus" | "eitherize" | "parseSrtTime" | "formatSrtTime" | "parseSrt" | "createSrt" | "ivk" | "range" | "s2l" | "l2s">;
 export type UtilFunc = typeof UtilFunc;
 export {};

package/dist/UtilHttp.d.ts

@@ -1,93 +1,82 @@
-import http from 'http';
 import type { LogLevel, PromiseRetries } from "@zwa73/js-utils";
 import { PromiseQueue } from "@zwa73/js-utils";
-import FormData from "form-data";
+import type { Dispatcher } from "undici";
 import type { AnyString, JToken, MPromise, PartialOption, StatusVerifyFn } from "./UtilInterfaces";
-/**网络请求返回值 */
+/** 网络请求返回值 */
 export type RequestResult<T> = {
-    /**响应头 */
-    headers: http.IncomingHttpHeaders;
-    /**响应状态码 */
+    /** 响应头 */
+    headers: Record<string, string | string[] | undefined>;
+    /** 响应状态码 */
     statusCode?: number;
-    /**响应数据 */
+    /** 响应数据 */
     data: T;
 };
 /**网络请求选项 */
 export type RequestOption = {
-    /**请求的log等级 默认http 不影响警告 */
+    /** 请求的log等级 默认http 不影响警告 */
     logLevel?: LogLevel;
-    /**请求协议 */
+    /** 请求协议 */
     protocol: 'http:' | 'https:';
-    /**超时时间/毫秒  最小为10_000 默认无限 */
+    /** 超时时间/毫秒  最小为10_000 默认无限 传入signal时无效 */
     timeout?: number;
-    /**请求域名 */
+    /** 请求域名 */
     hostname: string;
-    /**请求路径 */
+    /** 请求路径 */
     path?: string;
-    /**请求方式 post 为 */
-    method: 'POST' | 'GET';
-    /**端口 */
+    /** 请求方式 */
+    method: 'POST' | 'GET' | AnyString;
+    /** 端口 */
     port?: number;
     /**请求头 */
-    headers?: {
+    headers?: Record<string, string> & {
         /**内容类型 */
         'Content-Type'?: 'application/json' | 'multipart/form-data' | AnyString;
         /**内容长度 一般无需填写 应为buffer长度而非字符串长度 */
         'Content-Length'?: number;
     };
     /**响应buffer的编码 默认utf8 */
-    responseEncode?: BufferEncoding;
-} & http.RequestOptions;
+    /** 自定义网络调度器 (如 undici 的 ProxyAgent / MockAgent) */
+    dispatcher?: Dispatcher;
+    /** 外部传入的取消信号，如果传入，内部将不再自动根据 timeout 创建 AbortController */
+    signal?: AbortSignal;
+};
 /**getquery请求所允许的数据 */
 export type QueryRequestData = NodeJS.Dict<string | number | boolean | readonly string[] | readonly number[] | readonly boolean[] | null>;
-/**请求处理函数 需调用req.end() */
-export type RequestProcFn = (req: http.ClientRequest) => MPromise<void>;
-/**结果处理函数 */
-export type RequestParseFn<D, R> = (result: RequestResult<D> | undefined, opt: RequestOption) => MPromise<R>;
-/**数据处理函数 */
-export type RequestReduceFn<T> = (acc: T, data: string) => MPromise<T>;
-/**数据初始化函数 */
-export type RequestInitFn<T> = (res: http.IncomingMessage) => MPromise<T>;
-/**accept处理数据
- * @template D - 接受时转换的数据类型
- * @template R - 完成处理的数据类型
+/** accept处理配置 */
+type AcceptProcCtor<R, T extends {}> = AcceptProcData<R> | ((arg: T) => MPromise<AcceptProcData<R>>);
+/** 接受处理数据
+ * @template 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>;
-    parse: RequestParseFn<D, R>;
+type AcceptProcData<R> = {
+    parseResponse: (response: Response, opt: RequestOption) => MPromise<R>;
 };
-/**send处理数据 */
+/** send处理配置 */
 type SendProcCtor<T extends {}> = SendProcData | ((opt: RequestOption, arg: T) => MPromise<SendProcData>);
+/** fetch发送处理数据配置 */
 type SendProcData = {
-    proc: RequestProcFn;
+    body?: BodyInit;
+    headers?: Record<string, string>;
 };
 declare const SendNoneProc: SendProcCtor<{}>;
-declare const AcceptStringProc: AcceptProcCtor<string, RequestResult<string> | undefined, {}>;
-declare const AcceptNoneProc: AcceptProcCtor<undefined, RequestResult<undefined> | undefined, {}>;
-/**send处理的参数 */
+declare const AcceptStringProc: AcceptProcCtor<RequestResult<string> | undefined, {}>;
+declare const AcceptNoneProc: AcceptProcCtor<RequestResult<undefined> | undefined, {}>;
 type SendParams<S extends SendProcCtor<any>> = S extends SendProcCtor<infer P> ? P : never;
-/**send处理的参数 */
-type AcceptParams<A extends AcceptProcCtor<any, any, any>> = A extends AcceptProcCtor<any, any, infer P> ? P : never;
+type AcceptParams<A extends AcceptProcCtor<any, any>> = A extends AcceptProcCtor<any, infer P> ? P : never;
 type HasConflict<A, B> = keyof A & keyof B extends never ? false : true;
 type ConflictCheck<A, B, C> = HasConflict<A, B> extends true ? A & B & C & Error & "❌ A 与 B 有字段冲突" : HasConflict<A, C> extends true ? A & B & C & Error & "❌ A 与 C 有字段冲突" : HasConflict<B, C> extends true ? A & B & C & Error & "❌ B 与 C 有字段冲突" : A & B & C;
-/**accept处理的结果 */
-type ParseResult<P extends AcceptProcCtor<any, any, any>> = P extends AcceptProcCtor<any, infer T, any> ? Awaited<T> : never;
+type ParseResult<P extends AcceptProcCtor<any, any>> = P extends AcceptProcCtor<infer T, any> ? Awaited<T> : never;
 /**http请求工具 */
-export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<RequestOption, 'protocol'>>, S extends SendProcCtor<any>, A extends AcceptProcCtor<any, any, any>> {
+export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<RequestOption, 'protocol'>>, S extends SendProcCtor<any>, A extends AcceptProcCtor<any, any>> {
     private _data;
     private _send;
     private _accept;
     private constructor();
-    /**设为https请求 */
     static https(): UtilHttp<{
         readonly protocol: "https:";
-    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<string> | undefined, {}>>;
-    /**设为http请求 */
+    }, SendProcCtor<{}>, AcceptProcCtor<RequestResult<string> | undefined, {}>>;
     static http(): UtilHttp<{
         readonly protocol: "http:";
-    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<string> | undefined, {}>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<RequestResult<string> | undefined, {}>>;
     /**从url创建 */
     static url(urlStr: `${'http:' | 'https:'}//${string}`): UtilHttp<{
         protocol: "http:" | "https:";
@@ -95,7 +84,7 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
         hostname: string;
         path: string;
         port: number | undefined;
-    }, SendProcCtor<{}>, AcceptProcCtor<string, RequestResult<string> | undefined, {}>>;
+    }, SendProcCtor<{}>, AcceptProcCtor<RequestResult<string> | undefined, {}>>;
     /**设为get方式的请求 */
     get(): UtilHttp<D & {
         method: "GET";
@@ -110,8 +99,8 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
      */
     option<OPT extends Partial<RequestOption>>(option: OPT): UtilHttp<D & OPT, S, A>;
     /**补充header */
-    header<HAD extends http.OutgoingHttpHeaders>(headers: HAD): UtilHttp<D & {
-        headers: HAD;
+    header(headers: Record<string, string>): UtilHttp<D & {
+        headers: typeof headers;
     }, S, A>;
     /**添加一段query */
     query(data: QueryRequestData): this;
@@ -123,9 +112,8 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
             "Content-Type": "application/json";
         };
     }, (opt: RequestOption, arg: {
-        /**发送的json */
         json: JToken;
-    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }) => MPromise<SendProcData>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**收发皆为json的post预设 */
     postJson(): UtilHttp<D & {
         method: "POST";
@@ -134,20 +122,18 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
             'Content-Type': "application/json";
         };
     }, (opt: RequestOption, arg: {
-        /**发送的json */
         json: JToken;
-    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }) => MPromise<SendProcData>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的get预设 */
     getJson(): UtilHttp<D & {
         method: "GET";
-    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的get预设 */
     queryJson(): UtilHttp<D & {
         method: "GET";
     }, (opt: RequestOption, arg: {
-        /**附加的查询表单数据 */
         query: QueryRequestData;
-    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }) => MPromise<SendProcData>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**收发皆为json的https-post预设 */
     static httpsPostJson(): UtilHttp<{
         readonly protocol: "https:";
@@ -158,9 +144,8 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
             'Content-Type': "application/json";
         };
     }, (opt: RequestOption, arg: {
-        /**发送的json */
         json: JToken;
-    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }) => MPromise<SendProcData>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**收发皆为json的http-post预设 */
     static httpPostJson(): UtilHttp<{
         readonly protocol: "http:";
@@ -171,56 +156,49 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
             'Content-Type': "application/json";
         };
     }, (opt: RequestOption, arg: {
-        /**发送的json */
         json: JToken;
-    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }) => MPromise<SendProcData>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的https-get预设 */
     static httpsGetJson(): UtilHttp<{
         readonly protocol: "https:";
     } & {
         method: "GET";
-    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的https-get预设 */
     static httpsQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
     }, (opt: RequestOption, arg: {
-        /**附加的查询表单数据 */
         query: QueryRequestData;
-    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }) => MPromise<SendProcData>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**无查询参数获取json的http-get预设 */
     static httpGetJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
-    }, SendProcCtor<{}>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }, SendProcCtor<{}>, AcceptProcData<RequestResult<JToken> | undefined>>;
     /**有查询参数获取json的http-get预设 */
     static httpQueryJson(): UtilHttp<{
         readonly protocol: "http:";
     } & {
         method: "GET";
     }, (opt: RequestOption, arg: {
-        /**附加的查询表单数据 */
         query: QueryRequestData;
-    }) => MPromise<SendProcData>, AcceptProcData<string, RequestResult<JToken> | undefined>>;
-    acceptJson(): UtilHttp<D, S, AcceptProcData<string, RequestResult<JToken> | undefined>>;
+    }) => MPromise<SendProcData>, AcceptProcData<RequestResult<JToken> | undefined>>;
+    acceptJson(): UtilHttp<D, S, AcceptProcData<RequestResult<JToken> | undefined>>;
     acceptString(): UtilHttp<D, S, typeof AcceptStringProc>;
     acceptNone(): UtilHttp<D, S, typeof AcceptNoneProc>;
+    /** 接收并保存为文件 */
     acceptFile(): UtilHttp<D, S, (arg: {
         acceptFilepath: string;
-    }) => MPromise<AcceptProcData<{
-        promise: Promise<boolean>;
-    }, {
-        /**响应头 */
-        headers: http.IncomingHttpHeaders;
-        /**响应状态码 */
-        statusCode?: number;
-        /**保存文件路径 */
+    }) => MPromise<AcceptProcData<RequestResult<{
         filepath: string;
-    } | undefined>>>;
+    }> | undefined>>>;
+    /** 流式接收数据 (如 AI SSE 对话) 返回 AsyncGenerator */
+    acceptStream(): UtilHttp<D, S, AcceptProcData<RequestResult<AsyncGenerator<Uint8Array, void, unknown>> | undefined>>;
     /**自定的接收数据类型*/
-    acceptRaw<AD, AR, AT extends {}>(proc: AcceptProcCtor<AD, AR, AT>): UtilHttp<D, S, typeof proc>;
+    acceptRaw<AR, AT extends {}>(proc: AcceptProcCtor<AR, AT>): UtilHttp<D, S, typeof proc>;
     /**发送json
      * 请求参数为 (token:JToken)
      */
@@ -229,12 +207,10 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
             "Content-Type": "application/json";
         };
     }, (opt: RequestOption, arg: {
-        /**发送的json */
         json: JToken;
     }) => MPromise<SendProcData>, A>;
     /**利用 appendQuery 直接将表单附加在path上发送请求 */
     sendQuery(): UtilHttp<D, (opt: RequestOption, arg: {
-        /**附加的查询表单数据 */
         query: QueryRequestData;
     }) => MPromise<SendProcData>, A>;
     /**发送表单 */
@@ -243,19 +219,15 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
             "Content-Type": "application/x-www-form-urlencoded";
         };
     }, (opt: RequestOption, arg: {
-        /**表单 */
         form: QueryRequestData;
     }) => MPromise<SendProcData>, A>;
     /**发送form-data包提供的表单数据  */
     sendFormData(): UtilHttp<D, (opt: RequestOption, arg: {
-        /**form-data包提供的FormData表单数据 */
-        formdata: FormData;
+        formdata: globalThis.FormData;
     }) => MPromise<SendProcData>, A>;
     /**发送文件 */
     sendFile(): UtilHttp<D, (opt: RequestOption, arg: {
-        /**文件路径 */
         filepath: string;
-        /**文件名 */
         filename?: string;
     }) => MPromise<SendProcData>, A>;
     sendNone(): UtilHttp<D, typeof SendNoneProc, A>;
@@ -289,7 +261,7 @@ export declare class UtilHttp<D extends Partial<RequestOption> & Required<Pick<R
      * @param reqProc    - 请求处理函数 需调用req.end()
      * @param acceptProc - 响应处理数据
      */
-    static request<T>(option: RequestOption, sendProc: SendProcData, acceptProc: Omit<AcceptProcData<T, unknown>, 'parse'>): Promise<RequestResult<T> | undefined>;
+    static request<T>(option: RequestOption, sendProc: SendProcData, acceptProc: AcceptProcData<T>): Promise<T | undefined>;
     /**构建query */
     static buildQuery(base: string, data: QueryRequestData): string;
 }

package/dist/UtilHttp.js

@@ -5,12 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UtilHttp = void 0;
 const fs_1 = __importDefault(require("fs"));
-const http_1 = __importDefault(require("http"));
-const https_1 = __importDefault(require("https"));
 const querystring_1 = __importDefault(require("querystring"));
+const stream_1 = require("stream");
+const promises_1 = require("stream/promises");
 const url_1 = require("url");
 const js_utils_1 = require("@zwa73/js-utils");
-const form_data_1 = __importDefault(require("form-data"));
 const pathe_1 = __importDefault(require("pathe"));
 const UtilFunctions_1 = require("./UtilFunctions");
 const UtilLogger_1 = require("./UtilLogger");
@@ -18,28 +17,33 @@ const RequestDefOption = {
     logLevel: 'http',
     timeout: 0,
 };
-const SendNoneProc = {
-    proc: req => void req.end()
-};
+const SendNoneProc = {};
 const AcceptStringProc = {
-    init: () => '',
-    reduce: (acc, dat) => acc + dat,
-    parse: result => {
-        if (result == undefined) {
-            UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 响应结果无效`);
+    parseResponse: async (response, opt) => {
+        try {
+            const text = await response.text();
+            return {
+                headers: Object.fromEntries(response.headers.entries()),
+                statusCode: response.status,
+                data: text
+            };
+        }
+        catch (err) {
+            UtilLogger_1.SLogger.warn(`accept string 接收反馈错误:`, err);
             return undefined;
         }
-        return result;
     }
 };
 const AcceptNoneProc = {
-    init: () => undefined,
-    parse: result => {
-        if (result == undefined) {
-            UtilLogger_1.SLogger.warn(`accept none 接收反馈错误: 响应结果无效`);
-            return undefined;
-        }
-        return result;
+    parseResponse: async (response) => {
+        // 即使不处理返回值，也建议消费掉 body 释放内存
+        if (response.body)
+            await response.arrayBuffer();
+        return {
+            headers: Object.fromEntries(response.headers.entries()),
+            statusCode: response.status,
+            data: undefined
+        };
     }
 };
 /**http请求工具 */
@@ -53,11 +57,9 @@ class UtilHttp {
         this._accept = _accept;
     }
     //#region 流式创建
-    /**设为https请求 */
     static https() {
         return new UtilHttp({ protocol: 'https:' }, SendNoneProc, AcceptStringProc);
     }
-    /**设为http请求 */
     static http() {
         return new UtilHttp({ protocol: 'http:' }, SendNoneProc, AcceptStringProc);
     }
@@ -111,69 +113,47 @@ class UtilHttp {
     //#endregion
     //#region 快速预设
     /**收发皆为json的预设 */
-    json() {
-        return this.sendJson().acceptJson();
-    }
+    json() { return this.sendJson().acceptJson(); }
     /**收发皆为json的post预设 */
-    postJson() {
-        return this.post().json();
-    }
+    postJson() { return this.post().json(); }
     /**无查询参数获取json的get预设 */
-    getJson() {
-        return this.get().sendNone().acceptJson();
-    }
+    getJson() { return this.get().sendNone().acceptJson(); }
     /**有查询参数获取json的get预设 */
-    queryJson() {
-        return this.get().sendQuery().acceptJson();
-    }
+    queryJson() { return this.get().sendQuery().acceptJson(); }
     /**收发皆为json的https-post预设 */
-    static httpsPostJson() {
-        return UtilHttp.https().postJson();
-    }
+    static httpsPostJson() { return UtilHttp.https().postJson(); }
     /**收发皆为json的http-post预设 */
-    static httpPostJson() {
-        return UtilHttp.http().postJson();
-    }
+    static httpPostJson() { return UtilHttp.http().postJson(); }
     /**无查询参数获取json的https-get预设 */
-    static httpsGetJson() {
-        return UtilHttp.https().getJson();
-    }
+    static httpsGetJson() { return UtilHttp.https().getJson(); }
     /**有查询参数获取json的https-get预设 */
-    static httpsQueryJson() {
-        return UtilHttp.http().queryJson();
-    }
+    static httpsQueryJson() { return UtilHttp.http().queryJson(); }
     /**无查询参数获取json的http-get预设 */
-    static httpGetJson() {
-        return UtilHttp.http().getJson();
-    }
+    static httpGetJson() { return UtilHttp.http().getJson(); }
     /**有查询参数获取json的http-get预设 */
-    static httpQueryJson() {
-        return UtilHttp.http().queryJson();
-    }
+    static httpQueryJson() { return UtilHttp.http().queryJson(); }
     //#endregion
     //#region 接收数据类型
     acceptJson() {
         const acceptProc = {
-            init: () => '',
-            reduce: (acc, curr) => acc + curr,
-            parse: (result, opt) => {
-                if (result == undefined) {
-                    UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 响应结果无效`);
-                    return undefined;
-                }
-                const { data, ...rest } = result;
-                if (data.trim() == "") {
-                    UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 原始字符串为空`, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
-                    return { ...result, raw: "", data: null };
+            parseResponse: async (response, opt) => {
+                const text = await response.text();
+                const rest = {
+                    headers: Object.fromEntries(response.headers.entries()),
+                    statusCode: response.status
+                };
+                if (text.trim() == "") {
+                    UtilLogger_1.SLogger.warn(`accept json 接收反馈错误: 原始字符串为空`);
+                    return { ...rest, raw: "", data: null };
                 }
                 try {
-                    const obj = JSON.parse(data.trim());
-                    UtilLogger_1.SLogger.log(opt.logLevel ?? 'none', `accept json 接受信息 data:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }), `result:`, UtilFunctions_1.UtilFunc.stringifyJToken(rest, { compress: true, space: 2 }));
+                    const obj = JSON.parse(text.trim());
+                    UtilLogger_1.SLogger.log(opt.logLevel ?? 'none', `accept json 接受信息 data:`, UtilFunctions_1.UtilFunc.stringifyJToken(obj, { compress: true, space: 2 }));
                     return { ...rest, data: obj };
                 }
                 catch (err) {
-                    UtilLogger_1.SLogger.warn(`accept json 接收反馈错误:`, err, UtilFunctions_1.UtilFunc.stringifyJToken(result, { compress: true, space: 2 }));
-                    return { ...result, raw: data, data: null };
+                    UtilLogger_1.SLogger.warn(`accept json 解析错误:`, err, text);
+                    return { ...rest, raw: text, data: null };
                 }
             }
         };
@@ -188,36 +168,61 @@ class UtilHttp {
         this._accept = AcceptNoneProc;
         return this;
     }
+    /** 接收并保存为文件 */
     acceptFile() {
         const acceptProc = (arg) => ({
-            init: res => {
-                const fileStream = fs_1.default.createWriteStream(arg.acceptFilepath);
-                const fileWritePromise = new Promise((resolve) => {
-                    fileStream.on('error', err => {
-                        UtilLogger_1.SLogger.warn(`accept file 文件流写入错误:`, err);
-                        resolve(false); // 标记写入已结束, 但失败
-                    });
-                    fileStream.on('finish', () => {
-                        resolve(true); // 标记写入成功
-                    });
-                });
-                res.pipe(fileStream);
-                return { promise: fileWritePromise };
-            },
-            parse: async (result) => {
-                if (result == undefined) {
-                    UtilLogger_1.SLogger.warn(`accept file 接收反馈错误: 响应结果无效`);
+            parseResponse: async (response) => {
+                if (!response.body) {
+                    UtilLogger_1.SLogger.warn(`accept file 接收反馈错误: 响应结果无 body`);
                     return undefined;
                 }
-                const success = await result.data.promise;
-                if (!success)
+                try {
+                    const fileStream = fs_1.default.createWriteStream(arg.acceptFilepath);
+                    // Node 20 特性：将 Web ReadableStream 转换为 Node Stream
+                    const readable = stream_1.Readable.fromWeb(response.body);
+                    readable.pipe(fileStream);
+                    // 等待流写入完成
+                    await (0, promises_1.finished)(fileStream);
+                    return {
+                        headers: Object.fromEntries(response.headers.entries()),
+                        statusCode: response.status,
+                        data: { filepath: arg.acceptFilepath }
+                    };
+                }
+                catch (err) {
+                    UtilLogger_1.SLogger.warn(`accept file 文件流写入错误:`, err);
                     return undefined;
-                return { ...result, filepath: arg.acceptFilepath };
+                }
             }
         });
         this._accept = acceptProc;
         return this;
     }
+    /** 流式接收数据 (如 AI SSE 对话) 返回 AsyncGenerator */
+    acceptStream() {
+        const acceptProc = {
+            parseResponse: async (response) => {
+                if (response.body == null) {
+                    UtilLogger_1.SLogger.warn(`accept stream 接收反馈错误: 响应结果无 body`);
+                    return undefined;
+                }
+                const notnullBody = response.body;
+                // Node 20 允许直接异步迭代 Web Stream
+                const generator = async function* () {
+                    for await (const chunk of notnullBody) {
+                        yield chunk;
+                    }
+                }();
+                return {
+                    headers: Object.fromEntries(response.headers.entries()),
+                    statusCode: response.status,
+                    data: generator
+                };
+            }
+        };
+        this._accept = acceptProc;
+        return this;
+    }
     /**自定的接收数据类型*/
     acceptRaw(proc) {
         this._accept = proc;
@@ -229,23 +234,10 @@ class UtilHttp {
      * 请求参数为 (token:JToken)
      */
     sendJson() {
-        const sendProc = (opt, arg) => {
-            const { method } = opt;
-            const isPost = (method == "POST");
-            const data = JSON.stringify(arg.json);
-            this._data.headers ??= {};
-            this._data.headers['Content-Length'] = Buffer.byteLength(data);
-            return {
-                proc: async (req) => {
-                    if (isPost) {
-                        const flushed = req.write(data);
-                        if (!flushed)
-                            await new Promise((resolve) => req.once('drain', resolve));
-                    }
-                    req.end();
-                }
-            };
-        };
+        const sendProc = (opt, arg) => ({
+            body: JSON.stringify(arg.json),
+            headers: { 'Content-Type': 'application/json' }
+        });
         this._send = sendProc;
         this._data.headers ??= {};
         this._data.headers['Content-Type'] = 'application/json';
@@ -255,33 +247,21 @@ class UtilHttp {
     sendQuery() {
         const sendProc = (opt, arg) => {
             opt.path = UtilHttp.buildQuery(opt.path ?? '', arg.query);
-            return {
-                proc: req => void req.end()
-            };
+            return {};
         };
         this._send = sendProc;
         return this;
     }
     /**发送表单 */
     sendForm() {
-        const snedProc = (opt, arg) => {
-            const { method } = opt;
-            const isPost = (method == "POST");
+        const sendProc = (opt, arg) => {
             const data = querystring_1.default.stringify(arg.form);
-            this._data.headers ??= {};
-            this._data.headers['Content-Length'] = Buffer.byteLength(data);
             return {
-                proc: async (req) => {
-                    if (isPost) {
-                        const flushed = req.write(data);
-                        if (!flushed)
-                            await new Promise((resolve) => req.once('drain', resolve));
-                    }
-                    req.end();
-                }
+                body: data,
+                headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
             };
         };
-        this._send = snedProc;
+        this._send = sendProc;
         this._data.headers ??= {};
         this._data.headers['Content-Type'] = 'application/x-www-form-urlencoded';
         return this;
@@ -289,19 +269,9 @@ class UtilHttp {
     /**发送form-data包提供的表单数据  */
     sendFormData() {
         const sendProc = (opt, arg) => {
-            const { method } = opt;
-            const isPost = (method == "POST");
-            opt.headers = {
-                ...arg.formdata.getHeaders(),
-                ...opt.headers,
-            };
             return {
-                proc: (req) => {
-                    if (isPost)
-                        arg.formdata.pipe(req);
-                    else
-                        req.end();
-                }
+                body: arg.formdata
+                // 注意：绝对不要在这里手动设置 Content-Type，fetch 会自动设置并附带正确的 boundary
             };
         };
         this._send = sendProc;
@@ -309,25 +279,14 @@ class UtilHttp {
     }
     /**发送文件 */
     sendFile() {
-        const proc = (opt, arg) => {
-            const { method } = opt;
-            const isPost = (method == "POST");
+        const proc = async (opt, arg) => {
             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(),
-                ...opt.headers
-            };
-            return {
-                proc: req => {
-                    if (isPost)
-                        formData.pipe(req);
-                    else
-                        req.end();
-                }
-            };
+            const formData = new globalThis.FormData();
+            // Node 19.8+ 支持 openAsBlob，零内存拷贝读取文件为 Blob 格式
+            const fileBlob = await fs_1.default.openAsBlob(filepath);
+            formData.append(filename, fileBlob, filename);
+            return { body: formData };
         };
         this._send = proc;
         return this;
@@ -347,14 +306,10 @@ class UtilHttp {
      */
     async once(arg) {
         const fullopt = UtilFunctions_1.UtilFunc.assignOption(RequestDefOption, { ...this._data, ...arg.option ?? {} });
-        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 sendProc = typeof this._send === 'function' ? await this._send(fullopt, arg) : this._send;
+        const acceptProc = typeof this._accept === 'function' ? await this._accept(arg) : this._accept;
         const res = await UtilHttp.request(fullopt, sendProc, acceptProc);
-        return parse(res, fullopt);
+        return res;
     }
     /**重复发送网络请求
      * @param verify  - 有效性验证函数
@@ -376,106 +331,65 @@ class UtilHttp {
      * @param acceptProc - 响应处理数据
      */
     static async request(option, sendProc, acceptProc) {
-        const { reduce: reqReduce, init: reqInit } = acceptProc;
-        const { proc: reqProc } = sendProc;
-        //拆分扩展部分
-        const { protocol, logLevel, timeout, ...baseReqOpt } = UtilFunctions_1.UtilFunc.assignOption(RequestDefOption, option);
-        const plusTimeout = timeout + 1000;
-        const hasTimeLimit = timeout >= 10_000;
-        const flagName = `UtilHttp.request ${protocol}${baseReqOpt.method} ${UtilFunctions_1.UtilFunc.genUUID()}`;
-        const reduceQueue = new js_utils_1.PromiseQueue();
-        let dataPromise = null;
-        return new Promise(async (resolve, rejecte) => {
-            const finallyTimeout = hasTimeLimit
-                ? setTimeout(() => {
-                    UtilLogger_1.SLogger.warn(`${flagName} finallyTimeout 超时 ${timeout} ms, 终止请求`);
-                    req.destroy();
-                    resolve(undefined);
-                }, plusTimeout)
-                : undefined;
-            const finallyResolve = (t) => {
-                clearTimeout(finallyTimeout);
-                resolve(t);
-            };
-            const resFunc = async (res) => {
-                try {
-                    //请求超时
-                    if (hasTimeLimit) {
-                        res.setTimeout(timeout, () => {
-                            UtilLogger_1.SLogger.warn(`${flagName} http.response 触发 ${timeout} ms 超时, 继续挂起等待`);
-                        });
-                    }
-                    let mergedata;
-                    try {
-                        mergedata = await reqInit(res);
-                    }
-                    catch (err) {
-                        UtilLogger_1.SLogger.error(`${flagName} init函数错误:`, err);
-                        finallyResolve(undefined);
-                        return;
-                    }
-                    res.setEncoding(option.responseEncode ?? 'utf8');
-                    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);
-                    });
-                    res.on('end', async () => {
-                        await dataPromise;
-                        finallyResolve({
-                            headers: res.headers,
-                            statusCode: res.statusCode,
-                            data: mergedata,
-                        });
-                    });
-                }
-                catch (err) {
-                    UtilLogger_1.SLogger.warn(`${flagName} 未知错误:`, err);
-                    finallyResolve(undefined);
-                    return;
-                }
-            };
-            //路由 http/https
-            const req = protocol == "https:"
-                ? https_1.default.request(baseReqOpt, resFunc)
-                : http_1.default.request(baseReqOpt, resFunc);
-            //请求超时
-            if (hasTimeLimit) {
-                req.setTimeout(timeout, () => {
-                    UtilLogger_1.SLogger.warn(`${flagName} http.request 触发 ${timeout} ms 超时, 继续挂起等待`);
-                });
+        const { protocol, hostname, port, path: reqPath, method, timeout, headers: baseHeaders, signal, dispatcher } = option;
+        const { body, headers: extraHeaders } = sendProc;
+        const portStr = port ? `:${port}` : '';
+        const url = `${protocol}//${hostname}${portStr}${reqPath ?? ''}`;
+        const flagName = `UtilHttp.fetch ${method} ${url}`;
+        // === 信号与超时逻辑 ===
+        let finalSignal = signal;
+        const hasTimeLimit = timeout && timeout >= 10_000;
+        let timeoutId;
+        // 如果外部没有传 signal，并且设置了合法的 timeout，我们才自己建一个 controller
+        if (finalSignal == null && hasTimeLimit) {
+            const controller = new AbortController();
+            finalSignal = controller.signal;
+            timeoutId = setTimeout(() => {
+                UtilLogger_1.SLogger.warn(`${flagName} 触发 ${timeout} ms 超时, 取消请求`);
+                controller.abort();
+            }, timeout);
+        }
+        // 将可能含有 number 的 Header 对象标准化为 fetch 接受的 Record<string, string>
+        const fetchHeaders = Object.fromEntries(Object
+            .entries({ ...baseHeaders, ...extraHeaders })
+            .map(([k, v]) => {
+            if (v == undefined)
+                return undefined;
+            if (typeof v != 'string')
+                return [k, String(v)];
+            return [k, v];
+        }).filter(v => v != undefined));
+        // 构建 fetch 的初始配置
+        const fetchOptions = {
+            method, body, dispatcher,
+            headers: fetchHeaders,
+            signal: finalSignal,
+        };
+        try {
+            const response = await fetch(url, fetchOptions);
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            // 将 response 移交给具体的 Accept 策略解析 (JSON / 文本 / 写入流等)
+            return await acceptProc.parseResponse(response, option);
+        }
+        catch (err) {
+            if (UtilFunctions_1.UtilFunc.checkSharpSchema(err, { name: 'string' }) && err.name === 'AbortError') {
+                UtilLogger_1.SLogger.warn(`${flagName} 请求被终止 (超时)`);
             }
-            req.on('error', err => {
+            else {
                 UtilLogger_1.SLogger.warn(`${flagName} 发送请求错误:`, err);
-                finallyResolve(undefined);
-            });
-            try {
-                await reqProc(req);
-            }
-            catch (err) {
-                UtilLogger_1.SLogger.error(`${flagName} proc函数错误:`, err);
-                finallyResolve(undefined);
             }
-        });
+            return undefined;
+        }
+        finally {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+        }
     }
     /**构建query */
     static buildQuery(base, data) {
         const queryString = querystring_1.default.stringify(data);
         if (queryString) {
-            // 检查当前路径是否已经包含问号
             const separator = base.includes('?') ? '&' : '?';
             base += separator + queryString;
         }
@@ -501,25 +415,19 @@ if (false)
         const sj = await tool.clone()
             .sendJson()
             .acceptJson()
-            .once({
-            json: { test: 1 },
-        });
+            .once({ json: { test: 1 }, });
         console.log(sj);
         //form
         const sf = await tool.clone()
             .sendForm()
             .acceptJson()
-            .once({
-            form: { test: 1 }
-        });
+            .once({ form: { test: 1 } });
         console.log(sf);
         //query
         const sq = await tool.clone()
             .sendQuery()
             .acceptJson()
-            .once({
-            query: { test: 1 }
-        });
+            .once({ query: { test: 1 } });
         console.log(sq);
         const filepath = pathe_1.default.join(__dirname, '..', 'input.wav');
         //formData
@@ -533,8 +441,29 @@ if (false)
         const sfile = await tool.clone()
             .sendFile()
             .acceptJson()
-            .once({
-            filepath: filepath
-        });
+            .once({ filepath: filepath });
         console.log(sfile);
     })());
+if (false)
+    void (async () => {
+        console.log("=== 测试代理功能 ===");
+        // 基础测试工具
+        const tool = UtilHttp.url('https://httpbin.org/ip').getJson().option({ timeout: 10000 });
+        // 1. 测试直连 IP
+        console.log("正在测试直连...");
+        const directRes = await tool.clone().once({});
+        console.log("【直连 IP 结果】:", directRes?.data);
+        // 2. 测试代理 IP
+        // 请将下面的地址换成你本地实际的代理软件端口（比如 Clash 默认通常是 7890，v2ray 是 10809）
+        //const proxyUrl = 'http://127.0.0.1:7890'; 
+        //console.log(`\n正在测试代理 (${proxyUrl})...`);
+        //const proxyRes = await tool.clone()
+        //    .option({ proxy: proxyUrl })
+        //    .once({});
+        //
+        //if (proxyRes?.data) {
+        //    console.log("【代理 IP 结果】:", proxyRes.data);
+        //} else {
+        //    console.log("【代理请求失败】: 请检查代理软件是否运行，以及端口是否正确。");
+        //}
+    })();

package/dist/UtilInterfaces.d.ts

@@ -1,2 +1,2 @@
-export type { JToken, JValue, JArray, JObject, IJData, AnyFunc, Keyable, DeepReadonly, DeepWritable, PartialOption, ProperSubset, ProperSubsetCheck, IncludeCheck, UnionCheck, Literal, LiteralCheck, AllExtends, AssignObject, Writeable, Requireify, Inverted, FixedLengthTuple, Increment, RangeTuple, AnyString, UnionToIntersection, ExclusiveRecord, ExclusiveJObject, PromiseStatus, StatusVerifyFn, Await, FuncPropNames, ExtendThen, RequiredOnly, WithPrefix, Outcome, Either, Matchable, MatchableFlag, ExtractOutcome, ExtractMatchable, NeedInit, PRecord, MPromise, SPromise, SMPromise, NotPromise, AnyRecord, ReturnTypeOrNever, CmtTuple, Flasy, SrtSegment, ILogger, LogLevel, Asyncize, SharpSchema, ExpandSharpSchema, Preset, PresetOption, PresetFinal, NotFunc, MFunc, MReturnType, IoCDepTable, IoCDepCtorRtn, IoCDepCtor, StaticClass } from "@zwa73/js-utils";
+export type { JToken, JValue, JArray, JObject, IJData, AnyFunc, Keyable, DeepReadonly, DeepWritable, PartialOption, ProperSubset, ProperSubsetCheck, IncludeCheck, UnionCheck, Literal, LiteralCheck, AllExtends, AssignObject, Writeable, Requireify, Inverted, FixedLengthTuple, Increment, RangeTuple, AnyString, UnionToIntersection, ExclusiveRecord, ExclusiveJObject, PromiseStatus, StatusVerifyFn, Await, FuncPropNames, ExtendThen, RequiredOnly, WithPrefix, Outcome, Either, Matchable, MatchableFlag, ExtractOutcome, ExtractMatchable, NeedInit, PRecord, MPromise, SPromise, SMPromise, NotPromise, AnyRecord, ReturnTypeOrNever, CmtTuple, Flasy, SrtSegment, ILogger, LogLevel, ILoggerFull, Asyncize, SharpSchema, ExpandSharpSchema, Preset, PresetOption, PresetFinal, NotFunc, MFunc, MReturnType, IoCDepTable, IoCDepCtorRtn, IoCDepCtor, StaticClass } from "@zwa73/js-utils";
 export type { StringifyOpt, PromiseRetries, PromiseRetryResult } from "@zwa73/js-utils";

package/dist/UtilLogger.d.ts

@@ -1,3 +1,4 @@
+import type { ILogger, ILoggerFull } from '@zwa73/js-utils';
 import type { LogLevel } from './UtilInterfaces';
 /**hrtime所产生的的记录 */
 export type HRTimeLog = {
@@ -11,12 +12,12 @@ export declare class SLogger {
      * @param name - logger的名称 默认default
      * @returns 获取的logger
      */
-    static getLogger(name?: string): SLogger;
+    static getLogger(name?: string): ILoggerFull;
     /**创建Logger
-     * @param opt - 创建参数
-     * @returns 创建完成的logger
+     * @param opt - ILogger 实例或创建参数
+     * @returns ILogger
      */
-    static createLogger(opt?: {
+    static createLogger(opt?: ILogger | {
         /**logger的名称 默认default */
         name?: string;
         /**输出到控制台的最低等级 默认info */
@@ -25,7 +26,7 @@ export declare class SLogger {
         outFloder?: string;
         /**输出到文件的最低等级 默认info */
         fileLevel?: LogLevel;
-    }): SLogger;
+    }): ILogger;
     private constructor();
     private _logger;
     /**记录Logger的表 */
@@ -96,52 +97,52 @@ export declare class SLogger {
      * @param messages - log消息
      * @returns 自身
      */
-    static log(level: LogLevel, ...messages: any[]): SLogger;
+    static log(level: LogLevel, ...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条fatal等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static fatal(...messages: any[]): SLogger;
+    static fatal(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条error等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static error(...messages: any[]): SLogger;
+    static error(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条warn等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static warn(...messages: any[]): SLogger;
+    static warn(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条info等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static info(...messages: any[]): SLogger;
+    static info(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条http等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static http(...messages: any[]): SLogger;
+    static http(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条verbose等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static verbose(...messages: any[]): SLogger;
+    static verbose(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条debug等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static debug(...messages: any[]): SLogger;
+    static debug(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 产生一条silly等级的log 返回自身
      * @param messages - log消息
      * @returns 自身
      */
-    static silly(...messages: any[]): SLogger;
+    static silly(...messages: any[]): ILoggerFull;
     /**让名称为default的logger 记录当前时间戳并存入表
      * @param flag - 记录的命名
      * @returns 记录的时间
      */
-    static time(flag: string): HRTimeLog;
+    static time(flag: string): void;
     /**让名称为default的logger 根据之前记录的时间戳计算经过的时间 并输出log
      * @param flag  - 记录的命名
      * @param level - log等级

package/dist/UtilLogger.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SLogger = void 0;
 const util_1 = require("util");
+const js_utils_1 = require("@zwa73/js-utils");
 const pathe_1 = __importDefault(require("pathe"));
 const winston = __importStar(require("winston"));
 const winston_daily_rotate_file_1 = __importDefault(require("winston-daily-rotate-file"));
@@ -59,11 +60,32 @@ class SLogger {
         return SLogger.loggerTable[name] ?? SLogger.createLogger({ name });
     }
     /**创建Logger
-     * @param opt - 创建参数
-     * @returns 创建完成的logger
+     * @param opt - ILogger 实例或创建参数
+     * @returns ILogger
      */
     static createLogger(opt) {
-        const { name = "default", consoleLevel = "info", outFloder, fileLevel = "info" } = opt ?? {};
+        const tryDestory = (ilogger) => {
+            if (ilogger != null && ilogger._logger?.transports) {
+                const slogger = ilogger;
+                slogger._logger.transports.forEach(tp => {
+                    if (tp.close != null)
+                        tp.close();
+                });
+            }
+        };
+        // —— 情况一：传入的是 ILogger 实例 ——
+        if (opt && 'log' in opt && typeof opt.log === 'function') {
+            const externalLogger = opt;
+            const key = "default";
+            const wrapper = js_utils_1.JsFunc.wrapILogger(externalLogger);
+            // 析构旧的
+            tryDestory(SLogger.loggerTable[key]);
+            // 直接存入 table
+            SLogger.loggerTable[key] = wrapper;
+            return wrapper;
+        }
+        // —— 情况二：使用内置 winston ——（原有逻辑）
+        const { name = "default", consoleLevel = "info", outFloder, fileLevel = "info" } = (opt ?? {});
         const transports = [];
         if (outFloder != null) {
             const fileFormat = winston.format.combine(winston.format.timestamp({ format: 'HH:mm:ss' }), winston.format.printf((info) => {
@@ -112,10 +134,13 @@ class SLogger {
         out._logger = logger;
         if (SLogger.loggerTable[name] != null) {
             let old = SLogger.loggerTable[name];
-            old._logger.transports.forEach(tp => {
-                if (tp.close != null)
-                    tp.close();
-            });
+            // 只有 SLogger 实例有 _logger.transports
+            if (old._logger?.transports) {
+                old._logger.transports.forEach((tp) => {
+                    if (tp.close != null)
+                        tp.close();
+                });
+            }
         }
         SLogger.loggerTable[name] = out;
         return out;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zwa73/utils",
-	"version": "1.0.294",
+	"version": "1.0.295",
 	"description": "my utils",
 	"main": "dist/index.js",
 	"scripts": {
@@ -18,7 +18,6 @@
 	"dependencies": {
 		"@zwa73/js-utils": "*",
 		"@zwa73/modular-mixer": "^1.0.8",
-		"form-data": "^4.0.2",
 		"glob": "^13.0.0",
 		"html-entities": "^2.3.3",
 		"pathe": "^1.1.2",
@@ -62,6 +61,7 @@
 		"tiktoken": "^1.0.7",
 		"tsc-alias": "^1.8.8",
 		"typescript": "^5.3.3",
+		"undici": "^6.24.1",
 		"yaml": "^2.8.1"
 	},
 	"files": [