@anjianshi/utils 3.0.7 → 3.1.0

package/index.d.ts

@@ -1,4 +1,3 @@
 export * from './lang/index.js';
 export * from './url.js';
-export * from './safe-request.js';
 export * from './logging/index.js';

package/index.js

@@ -1,4 +1,3 @@
 export * from './lang/index.js';
 export * from './url.js';
-export * from './safe-request.js';
 export * from './logging/index.js';

package/lang/result.d.ts

@@ -32,16 +32,23 @@ declare function failed(message: string, code?: string | number): Failed;
 declare function failed<T>(message: string, code: string | number | undefined, data: T): Failed<T>;
 export { failed };
 /**
- * 若传入值为 success，格式化其 data；否则原样返回错误
- * 支持传入会返回 Result 的 Promise
+ * 若传入值为 Success，格式化其 data；否则原样返回错误。
+ *
  */
 declare function formatSuccess<T1, T2, FT = void>(value: Result<T1, FT>, formatter: (value: T1) => T2): Result<T2, FT>;
 declare function formatSuccess<T1, T2, FT = void>(value: Promise<Result<T1, FT>>, formatter: (value: T1) => T2): Promise<Result<T2, FT>>;
 export { formatSuccess };
+/**
+ * 若传入值为 Failed，格式化其内容；否则原样返回。
+ * 支持传入会返回 Result 的 Promise。
+ */
+declare function formatFailed<T, FT>(value: Result<T>, formatter: (result: Failed) => Failed<FT>): Result<T, FT>;
+declare function formatFailed<T, FT>(value: Promise<Result<T>>, formatter: (result: Failed) => Failed<FT>): Promise<Result<T, FT>>;
+export { formatFailed };
 /**
  * 把可能抛出异常的 Promise 转换为返回 Result 的 Promise。
  * 其中返回的 Failed 对象的 data 是 catch 捕获到的错误对象。
  *
  * 通过此函数可避免写一长串嵌套的 try catch 语句。
  */
-export declare function handleException<T>(promise: Promise<T>): Promise<Result<T>>;
+export declare function exceptionToFailed<T>(promise: Promise<T>): Promise<Result<T>>;

package/lang/result.js

@@ -25,13 +25,19 @@ function formatSuccess(value, formatter) {
     return value.success ? success(formatter(value.data)) : value;
 }
 export { formatSuccess };
+function formatFailed(value, formatter) {
+    if ('then' in value)
+        return value.then(finalValue => formatFailed(finalValue, formatter));
+    return value.success ? value : formatter(value);
+}
+export { formatFailed };
 /**
  * 把可能抛出异常的 Promise 转换为返回 Result 的 Promise。
  * 其中返回的 Failed 对象的 data 是 catch 捕获到的错误对象。
  *
  * 通过此函数可避免写一长串嵌套的 try catch 语句。
  */
-export async function handleException(promise) {
+export async function exceptionToFailed(promise) {
     return promise.then(data => success(data), (error) => {
         let message;
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjianshi/utils",
-  "version": "3.0.7",
+  "version": "3.1.0",
   "description": "Common JavaScript Utils",
   "homepage": "https://github.com/anjianshi/js-packages/utils",
   "bugs": {
@@ -31,12 +31,12 @@
     "redis": "^5.5.6",
     "typescript": "^5.8.3",
     "vconsole": "^3.15.1",
-    "@anjianshi/presets-prettier": "3.0.5",
     "@anjianshi/presets-eslint-node": "6.0.0",
+    "@anjianshi/presets-eslint-typescript": "6.0.0",
+    "@anjianshi/presets-eslint-base": "6.0.0",
     "@anjianshi/presets-eslint-react": "6.0.0",
     "@anjianshi/presets-typescript": "3.2.5",
-    "@anjianshi/presets-eslint-base": "6.0.0",
-    "@anjianshi/presets-eslint-typescript": "6.0.0"
+    "@anjianshi/presets-prettier": "3.0.5"
   },
   "peerDependencies": {
     "@emotion/react": "^11.14.0",

package/request/client.d.ts

@@ -0,0 +1,35 @@
+import { type Result, type Failed } from '../lang/result.js';
+import { type Logger } from '../logging/index.js';
+import { type RequestError } from './error.js';
+import type { Options, PredefinedOptions, FormattedOptions } from './options.js';
+/** 此基类不可直接使用，因其未对错误格式进行具体约定 */
+export declare abstract class BaseRequestClient<FailedT> {
+    readonly logger: Logger;
+    readonly prefefinedOptions: PredefinedOptions;
+    constructor(options?: PredefinedOptions & {
+        loggerName?: string;
+    });
+    /** 生成一个快捷方式函数，调用它相当于调用 client.request() */
+    asFunction(): <T>(inputUrl: string, inputOptions?: Options) => Promise<Result<T, FailedT>>;
+    request<T>(inputUrl: string, inputOptions?: Options): Promise<Result<T, FailedT>>;
+    formatOptions(input: Options): Promise<FormattedOptions>;
+    /** 请求发起前调用此方法补充 Headers 内容 */
+    protected getHeaders(options: FormattedOptions, inputOptions: Options): Record<string, string> | undefined | Promise<Record<string, string> | undefined>;
+    /**
+     * 解析响应内容
+     * - 若 options.binary 为 true，返回二进制结果
+     * - 若 response Content-Type 为 'text/' 开头，返回文本结果
+     * - 尝试解析 JSON，若成功，返回 JSON 结果；
+     * - 若 JSON 解析失败：
+     *   - 若 response Content-Type 为 'application/json' 开头，返回解析失败信息
+     *   - 其他情况，返回纯文本结果
+     */
+    protected parseResponse(options: FormattedOptions, response: Response): Promise<Result<unknown, FailedT>>;
+    protected handleError(error: RequestError): Failed<FailedT>;
+    /** 生成符合 FailedT 约定的失败结果 */
+    protected abstract makeFailedResult(error: RequestError): Failed<FailedT>;
+}
+/** 默认的 RequestClient 实现。出现错误时，会把错误对象原样放入错误信息中。 */
+export declare class RequestClient extends BaseRequestClient<RequestError> {
+    protected makeFailedResult(error: RequestError): Failed<RequestError>;
+}

package/request/client.js

@@ -0,0 +1,154 @@
+/**
+ * 实现一个功能完善、异常处理逻辑全面的请求发起器。
+ * 可通过继承子类来扩展其功能。
+ */
+import pick from 'lodash/pick.js';
+import { success, failed, formatFailed, exceptionToFailed, } from '../lang/result.js';
+import { getLogger } from '../logging/index.js';
+import { combineUrl } from '../url.js';
+import { SendRequestFailed, RequestAborted, RequestTimedOut, NonSuccessStatus, ParseResponseBodyFailed, } from './error.js';
+/** 此基类不可直接使用，因其未对错误格式进行具体约定 */
+export class BaseRequestClient {
+    logger;
+    prefefinedOptions;
+    constructor(options = {}) {
+        this.logger = getLogger(options.loggerName ?? 'request');
+        this.prefefinedOptions = options;
+    }
+    /** 生成一个快捷方式函数，调用它相当于调用 client.request() */
+    asFunction() {
+        return async (inputUrl, inputOptions) => this.request(inputUrl, inputOptions);
+    }
+    // -------------------------------
+    // 发起请求
+    // -------------------------------
+    async request(inputUrl, inputOptions) {
+        const options = await this.formatOptions({
+            url: inputUrl,
+            ...(inputOptions ?? {}),
+        });
+        const { url, method, headers, body, timeout, signal: manualSignal } = options;
+        const timeoutSignal = timeout ? AbortSignal.timeout(timeout) : undefined;
+        const signal = manualSignal || timeoutSignal
+            ? AbortSignal.any([manualSignal, timeoutSignal].filter(Boolean))
+            : undefined;
+        // 发起请求
+        let response;
+        try {
+            response = await fetch(url, { method, headers, body, signal });
+        }
+        catch (error) {
+            // 失败情形“手动取消”
+            if (manualSignal && manualSignal.aborted && manualSignal.reason === error) {
+                const reason = error instanceof DOMException && error.name === 'AbortError' ? null : error;
+                return this.handleError(new RequestAborted(reason, options));
+            }
+            // 失败情形“请求超时”
+            if (error instanceof DOMException && error.name === 'TimeoutError') {
+                return this.handleError(new RequestTimedOut(options));
+            }
+            // 失败情形“请求发起失败”
+            return this.handleError(new SendRequestFailed(error, options));
+        }
+        // 失败情形“失败状态码”
+        if (!response.status.toString().startsWith('2')) {
+            // 此时服务端仍可能输出一些内容，试着解析出来
+            const responseDataRes = await this.parseResponse(options, response);
+            const responseData = responseDataRes.success ? responseDataRes.data : undefined;
+            return this.handleError(new NonSuccessStatus(response, responseData, options));
+        }
+        // 解析响应内容
+        const result = await this.parseResponse(options, response);
+        return result;
+    }
+    // -------------------------------
+    // 请求预处理
+    // -------------------------------
+    async formatOptions(input) {
+        const predefined = this.prefefinedOptions;
+        const { urlPrefix = predefined.urlPrefix ?? '', url: rawUrl, query = {}, method = predefined.method ?? 'GET', headers: rawHeaders = {}, body: rawBody = null, data, timeout = predefined.timeout ?? 0, binary = false, signal, } = input;
+        const headers = {
+            ...(predefined.headers ?? {}),
+            ...rawHeaders,
+        };
+        let body = rawBody;
+        if (data !== undefined) {
+            if (method === 'GET') {
+                Object.assign(query, data);
+            }
+            else {
+                body = data instanceof FormData ? data : JSON.stringify(data);
+                headers['Content-Type'] = 'application/json; charset=utf-8';
+            }
+        }
+        const url = combineUrl(urlPrefix + (rawUrl ?? ''), query);
+        const options = {
+            method,
+            url,
+            headers,
+            body,
+            timeout,
+            binary,
+            signal,
+        };
+        Object.assign(options.headers, await this.getHeaders(options, input));
+        return options;
+    }
+    /** 请求发起前调用此方法补充 Headers 内容 */
+    getHeaders(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    options, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    inputOptions) {
+        return undefined;
+    }
+    // -------------------------------
+    // 请求结果、错误处理
+    // -------------------------------
+    /**
+     * 解析响应内容
+     * - 若 options.binary 为 true，返回二进制结果
+     * - 若 response Content-Type 为 'text/' 开头，返回文本结果
+     * - 尝试解析 JSON，若成功，返回 JSON 结果；
+     * - 若 JSON 解析失败：
+     *   - 若 response Content-Type 为 'application/json' 开头，返回解析失败信息
+     *   - 其他情况，返回纯文本结果
+     */
+    async parseResponse(options, response) {
+        const contentType = (response.headers.get('Content-Type') ?? '').toLowerCase().trim();
+        if (options.binary) {
+            const blobResult = await exceptionToFailed(response.blob());
+            return formatFailed(blobResult, result => this.handleError(new ParseResponseBodyFailed(result.data, response, options, 'Parse Blob Body Failed')));
+        }
+        const textResult = await exceptionToFailed(response.text());
+        if (contentType.startsWith('text/') || !textResult.success) {
+            return formatFailed(textResult, result => this.handleError(new ParseResponseBodyFailed(result.data, response, options, 'Parse Text Body Failed')));
+        }
+        let jsonParseError;
+        try {
+            return success(JSON.parse(textResult.data));
+        }
+        catch (error) {
+            jsonParseError = error;
+        }
+        if (contentType.startsWith('application/json')) {
+            return this.handleError(new ParseResponseBodyFailed(jsonParseError, response, options, 'Parse JSON Body Failed'));
+        }
+        return textResult;
+    }
+    handleError(error) {
+        const info = pick(error.options, ['url', 'method']);
+        for (const key of ['originalError', 'status', 'response', 'responseData']) {
+            if (key in error)
+                Object.assign(info, pick(error, [key]));
+        }
+        this.logger.error(error.message, error);
+        return this.makeFailedResult(error);
+    }
+}
+/** 默认的 RequestClient 实现。出现错误时，会把错误对象原样放入错误信息中。 */
+export class RequestClient extends BaseRequestClient {
+    makeFailedResult(error) {
+        return failed(error.message, undefined, error);
+    }
+}

package/request/error.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 定义请求失败类型。
+ *
+ * 有两类失败情形不在处理范围内：
+ * 1. client 或子类自身代码报错，例如 formatOptions() 方法意外报错
+ * 2. 请求本身成功，但相应内容表达了业务上的失败，例如登录接口返回密码错误。
+ * 如有需要，可继承子类来处理这些失败情形。
+ */
+import { type FormattedOptions } from './options.js';
+export declare class RequestError extends Error {
+    readonly options: FormattedOptions;
+    constructor(message: string, options: FormattedOptions);
+}
+/** 手动取消 */
+export declare class RequestAborted extends RequestError {
+    /** 取消原因，即调用 abortController.abort() 时传入的值，若未传值则为 null */
+    readonly reason: unknown;
+    constructor(reason: unknown, options: FormattedOptions);
+}
+/** 请求超时 */
+export declare class RequestTimedOut extends RequestError {
+    constructor(options: FormattedOptions);
+}
+/** 请求发起失败（如网络异常） */
+export declare class SendRequestFailed extends RequestError {
+    readonly originalError: unknown;
+    constructor(originalError: unknown, options: FormattedOptions);
+}
+/** 失败状态码（服务端响应了代表失败的状态码，如 500） */
+export declare class NonSuccessStatus extends RequestError {
+    readonly response: Response;
+    readonly responseData: unknown;
+    readonly status: number;
+    constructor(response: Response, responseData: unknown, options: FormattedOptions);
+}
+/** 响应体解析失败 */
+export declare class ParseResponseBodyFailed extends RequestError {
+    readonly originalError: unknown;
+    readonly response: Response;
+    readonly status: number;
+    constructor(originalError: unknown, response: Response, options: FormattedOptions, message?: string);
+}

package/request/error.js

@@ -0,0 +1,54 @@
+export class RequestError extends Error {
+    options;
+    constructor(message, options) {
+        super(message);
+        this.options = options;
+    }
+}
+/** 手动取消 */
+export class RequestAborted extends RequestError {
+    /** 取消原因，即调用 abortController.abort() 时传入的值，若未传值则为 null */
+    reason;
+    constructor(reason, options) {
+        super('Request Aborted', options);
+        this.reason = reason;
+    }
+}
+/** 请求超时 */
+export class RequestTimedOut extends RequestError {
+    constructor(options) {
+        super('Request TimedOut', options);
+    }
+}
+/** 请求发起失败（如网络异常） */
+export class SendRequestFailed extends RequestError {
+    originalError;
+    constructor(originalError, options) {
+        super('Send Request Failed', options);
+        this.originalError = originalError;
+    }
+}
+/** 失败状态码（服务端响应了代表失败的状态码，如 500） */
+export class NonSuccessStatus extends RequestError {
+    response;
+    responseData;
+    status;
+    constructor(response, responseData, options) {
+        super('Non-Success Status', options);
+        this.response = response;
+        this.responseData = responseData;
+        this.status = response.status;
+    }
+}
+/** 响应体解析失败 */
+export class ParseResponseBodyFailed extends RequestError {
+    originalError;
+    response;
+    status;
+    constructor(originalError, response, options, message) {
+        super(message ?? 'Parse Response Body Failed', options);
+        this.originalError = originalError;
+        this.response = response;
+        this.status = response.status;
+    }
+}

package/request/index.d.ts

@@ -0,0 +1,5 @@
+export type * from './options.js';
+export * from './error.js';
+export * as errors from './error.js';
+export * from './client.js';
+export * from './instance.js';

package/request/index.js

@@ -0,0 +1,4 @@
+export * from './error.js';
+export * as errors from './error.js';
+export * from './client.js';
+export * from './instance.js';

package/request/instance.d.ts

@@ -0,0 +1,4 @@
+import { RequestClient } from './client.js';
+/** 提供一个即取即用的 RequestClient 实例及其函数版本 */
+export declare const client: RequestClient;
+export declare const request: <T>(inputUrl: string, inputOptions?: import("./options.js").Options) => Promise<import("../index.js").Result<T, import("./error.js").RequestError>>;

package/request/instance.js

@@ -0,0 +1,4 @@
+import { RequestClient } from './client.js';
+/** 提供一个即取即用的 RequestClient 实例及其函数版本 */
+export const client = new RequestClient();
+export const request = client.asFunction();

package/request/options.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 请求参数
+ */
+export interface Options {
+    urlPrefix?: string;
+    url?: string;
+    query?: Record<string, string | number | undefined>;
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string | FormData | null;
+    /**
+     * 向后端传递的数据。对于 GET 请求，会合并到 query 中；对于 POST 请求，会作为 POST body，代替 body 参数
+     * 注意：为了支持传入 interface 类型的值，Record 只能定义成 Record<string, any>
+     */
+    data?: FormData | Record<string, any>;
+    /** 是否把响应内容作为二进制处理（结果是 blob） */
+    binary?: boolean;
+    /** 超时时间，不指定或设为 0 代表不限 */
+    timeout?: number;
+    /** 可通过此信号手动终止请求 */
+    signal?: AbortSignal;
+}
+/** 可预指定的请求参数 */
+export type PredefinedOptions = Pick<Options, 'urlPrefix' | 'method' | 'headers' | 'timeout'>;
+/** 经过整理的请求参数（client 内部使用） */
+export type FormattedOptions = Required<Pick<Options, 'url' | 'method' | 'headers' | 'body' | 'timeout' | 'binary'>> & Pick<Options, 'signal'>;

package/request/options.js

@@ -0,0 +1 @@
+export {};

package/safe-request.d.ts

@@ -1,53 +0,0 @@
-import { type Result } from './lang/result.js';
-import { type Logger } from './logging/index.js';
-export type { Options as RequestOptions, FormattedOptions as RequestFormattedOptions };
-interface Options {
-    urlPrefix?: string;
-    url?: string;
-    query?: Record<string, string | number | undefined>;
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string | FormData | null;
-    /**
-     * 向后端传递的数据。对于 GET 请求，会合并到 query 中；对于 POST 请求，会作为 POST body，代替 body 参数
-     * 注意：为了支持传入 interface 类型的值，Record 只能定义成 Record<string, any>
-     */
-    data?: FormData | Record<string, any>;
-    /** 超时时间，不指定或设为 0 代表不限 */
-    timeout?: number;
-}
-type FormattedOptions = Required<Pick<Options, 'url' | 'method' | 'headers' | 'body' | 'timeout'>>;
-type PredefinedOptions = Pick<Options, 'urlPrefix' | 'method' | 'headers' | 'timeout'>;
-/**
- * 建立一个请求发起器，并可预设部分选项。
- * 可以继承此类来自定义默认的错误处理逻辑。
- *
- * 请求失败时的 Failed 对象，其 code 为 HTTP status，没有 status 时为 0
- * data 为解析出的响应内容，没有或解析失败则为 undefined
- */
-export declare class SafeRequestClient {
-    readonly logger: Logger;
-    readonly prefefinedOptions: PredefinedOptions;
-    constructor(options?: PredefinedOptions & {
-        loggerName?: string;
-    });
-    /** 生成一个快捷方式函数，调用它相当于调用 client.request() */
-    asFunction(): <T>(inputUrl: string, inputOptions?: Options) => Promise<Result<T>>;
-    request<T>(inputUrl: string, inputOptions?: Options): Promise<Result<T>>;
-    formatOptions(input: Options): Promise<FormattedOptions>;
-    /** 请求发起前调用此方法补充 Headers 内容 */
-    protected getHeaders(options: FormattedOptions, inputOptions: Options): Record<string, string> | undefined | Promise<Record<string, string> | undefined>;
-    protected parseResponse<T>(options: FormattedOptions, response: Response): Promise<Result<T>>;
-    /** 若请求未成功发起，会触发此回调来生成失败信息 */
-    protected onRequestError(error: Error, url: string): import("./lang/result.js").Failed<undefined>;
-    /** 请求成功发起，但服务端返回失败状态（如 500），会触发此回调来生成失败信息 */
-    protected onResponseError(url: string, response: Response, responseData: unknown): Promise<import("./lang/result.js").Failed<unknown>>;
-    /** 服务端返回内容解析失败时，会触发此回调来生成失败信息 */
-    protected onParseFailed(error: Error, response: Response, url: string): import("./lang/result.js").Failed<undefined>;
-    /** 处理超时 */
-    protected onTimeout(url: string): import("./lang/result.js").Failed<undefined>;
-}
-/**
- * 模块自带一个可直接调用发起请求的函数，跳过初始化实例
- */
-export declare const safeRequest: <T>(inputUrl: string, inputOptions?: Options) => Promise<Result<T>>;

package/safe-request.js

@@ -1,140 +0,0 @@
-import { sleep } from './lang/async.js';
-import { failed, handleException } from './lang/result.js';
-import { getLogger } from './logging/index.js';
-import { combineUrl } from './url.js';
-/**
- * 建立一个请求发起器，并可预设部分选项。
- * 可以继承此类来自定义默认的错误处理逻辑。
- *
- * 请求失败时的 Failed 对象，其 code 为 HTTP status，没有 status 时为 0
- * data 为解析出的响应内容，没有或解析失败则为 undefined
- */
-export class SafeRequestClient {
-    logger;
-    prefefinedOptions;
-    constructor(options = {}) {
-        this.logger = getLogger(options.loggerName ?? 'request');
-        this.prefefinedOptions = options;
-    }
-    /** 生成一个快捷方式函数，调用它相当于调用 client.request() */
-    asFunction() {
-        return async (inputUrl, inputOptions) => this.request(inputUrl, inputOptions);
-    }
-    async request(inputUrl, inputOptions) {
-        const options = await this.formatOptions({
-            url: inputUrl,
-            ...(inputOptions ?? {}),
-        });
-        const { url, method, headers, body, timeout } = options;
-        try {
-            // 发起请求
-            const request = fetch(url, { method, headers, body });
-            let response;
-            try {
-                response = await (typeof timeout === 'number'
-                    ? Promise.race([request, sleep(timeout)])
-                    : request);
-            }
-            catch (error) {
-                // 处理“请求发起失败”
-                return this.onRequestError(error, url);
-            }
-            // 处理超时
-            if (response === undefined) {
-                return this.onTimeout(url);
-            }
-            // 处理“服务端返回失败状态”
-            if (!response.status.toString().startsWith('2')) {
-                // 此时服务端仍可能输出一些内容，试着解析出来
-                const responseDataRes = await this.parseResponse(options, response);
-                const responseData = responseDataRes.success ? responseDataRes.data : undefined;
-                return await this.onResponseError(url, response, responseData);
-            }
-            // 解析响应内容
-            return await this.parseResponse(options, response);
-        }
-        catch (error) {
-            this.logger.error('Unexpected error', error);
-            return failed('Request handle failed.');
-        }
-    }
-    async formatOptions(input) {
-        const predefined = this.prefefinedOptions;
-        const { urlPrefix = predefined.urlPrefix ?? '', url: rawUrl, query = {}, method = predefined.method ?? 'GET', headers: rawHeaders = {}, body: rawBody = null, data, timeout = predefined.timeout ?? 0, } = input;
-        const headers = {
-            ...(predefined.headers ?? {}),
-            ...rawHeaders,
-        };
-        let body = rawBody;
-        if (data !== undefined) {
-            if (method === 'GET') {
-                Object.assign(query, data);
-            }
-            else {
-                body = data instanceof FormData ? data : JSON.stringify(data);
-                headers['Content-Type'] = 'application/json; charset=utf-8';
-            }
-        }
-        const url = combineUrl(urlPrefix + (rawUrl ?? ''), query);
-        const options = {
-            method,
-            url,
-            headers,
-            body,
-            timeout,
-        };
-        Object.assign(options.headers, await this.getHeaders(options, input));
-        return options;
-    }
-    /** 请求发起前调用此方法补充 Headers 内容 */
-    getHeaders(
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    options, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    inputOptions) {
-        return undefined;
-    }
-    async parseResponse(options, response) {
-        let result;
-        result = await handleException(response.json());
-        if (result.success)
-            return result;
-        const contentType = (response.headers.get('Content-Type') ?? '').toLowerCase().trim();
-        if (contentType.startsWith('text/') || contentType === '') {
-            result = (await handleException(response.text()));
-            if (result.success)
-                return result;
-        }
-        result = (await handleException(response.blob()));
-        return result;
-    }
-    /** 若请求未成功发起，会触发此回调来生成失败信息 */
-    onRequestError(error, url) {
-        this.logger.error('Request Failed', { url, error });
-        return failed('Request Failed', 0, undefined);
-    }
-    /** 请求成功发起，但服务端返回失败状态（如 500），会触发此回调来生成失败信息 */
-    // eslint-disable-next-line @typescript-eslint/require-await
-    async onResponseError(url, response, responseData) {
-        this.logger.error('Response Error Status', {
-            url,
-            status: response.status,
-            data: responseData,
-        });
-        return failed(`Response Error Status - ${response.status}`, response.status, responseData);
-    }
-    /** 服务端返回内容解析失败时，会触发此回调来生成失败信息 */
-    onParseFailed(error, response, url) {
-        this.logger.error('Response Parse Failed', { url, response, error });
-        return failed('Response Parse Failed', response.status, undefined);
-    }
-    /** 处理超时 */
-    onTimeout(url) {
-        this.logger.warn('Request Timeout', url);
-        return failed('Request Timeout', 0, undefined);
-    }
-}
-/**
- * 模块自带一个可直接调用发起请求的函数，跳过初始化实例
- */
-export const safeRequest = new SafeRequestClient().asFunction();