@anjianshi/utils 2.9.1 → 3.0.1

package/env-node/index.d.ts

@@ -3,4 +3,3 @@
  */
 export * from './fs.js';
 export * from './crypto-random.js';
-export * from './safe-request.js';

package/env-node/index.js

@@ -3,4 +3,3 @@
  */
 export * from './fs.js';
 export * from './crypto-random.js';
-export * from './safe-request.js';

package/env-react/hooks.d.ts

@@ -2,3 +2,22 @@
  * 生成一个 state 以及与其值同步的 ref
  */
 export declare function useStateWithRef<T>(initialValue: T | (() => T)): readonly [T, import("react").Dispatch<import("react").SetStateAction<T>>, import("react").RefObject<T>];
+/**
+ * 在 useEffect() 中执行异步操作。
+ * 因是异步运行，对清理机制的处理有所变化。
+ *
+ * 原本 useEffect() 中，通过返回一个函数来设置清理条件，在异步操作中不适用。
+ * 此外，同步内容是一定会在执行完只后才有可能触发清理的，但异步内容有可能在运行完之前，依赖就已经变化，触发了清理。
+ *
+ * 这里通过一个 context 对象来应对异步的情况。
+ * context.cancelled 值代表此次运行是否已被取消（清理），异步操作执行过程中如果发现此值变为 true，则可停止执行了。
+ * context.onCancelled(() => {}) 可注册一个回调，此次执行被清理时触发。多次调用仅保留最后一次的回调。
+ *
+ * 注意：需要配置 ESLint react-hooks/exhaustive-deps 规则以保证 deps 参与依赖检查
+ * 详见 https://react.dev/reference/eslint-plugin-react-hooks/lints/exhaustive-deps
+ */
+export declare function useAsyncEffect(callback: (context: AsyncEffectContext) => Promise<void>, deps?: unknown[]): void;
+export interface AsyncEffectContext {
+    cancelled: boolean;
+    onCancel: (callback: () => void) => void;
+}

package/env-react/hooks.js

@@ -14,3 +14,34 @@ export function useStateWithRef(initialValue) {
     }, []);
     return [state, setStateWithRef, ref];
 }
+/**
+ * 在 useEffect() 中执行异步操作。
+ * 因是异步运行，对清理机制的处理有所变化。
+ *
+ * 原本 useEffect() 中，通过返回一个函数来设置清理条件，在异步操作中不适用。
+ * 此外，同步内容是一定会在执行完只后才有可能触发清理的，但异步内容有可能在运行完之前，依赖就已经变化，触发了清理。
+ *
+ * 这里通过一个 context 对象来应对异步的情况。
+ * context.cancelled 值代表此次运行是否已被取消（清理），异步操作执行过程中如果发现此值变为 true，则可停止执行了。
+ * context.onCancelled(() => {}) 可注册一个回调，此次执行被清理时触发。多次调用仅保留最后一次的回调。
+ *
+ * 注意：需要配置 ESLint react-hooks/exhaustive-deps 规则以保证 deps 参与依赖检查
+ * 详见 https://react.dev/reference/eslint-plugin-react-hooks/lints/exhaustive-deps
+ */
+export function useAsyncEffect(callback, deps = []) {
+    useEffect(() => {
+        let onCancel = null;
+        const context = {
+            cancelled: false,
+            onCancel(callback) {
+                onCancel = callback;
+            },
+        };
+        void callback(context);
+        return () => {
+            context.cancelled = true;
+            if (onCancel)
+                onCancel();
+        };
+    }, deps); // eslint-disable-line ts-react-hooks/exhaustive-deps
+}

package/env-service/prisma/extensions/with-transaction.d.ts

@@ -1,9 +1,9 @@
 import { type ITXClientDenyList } from '@prisma/client/runtime/library.js';
-import type { MaySuccess, Failed } from '../../../index.js';
+import type { Result, Failed } from '../../../index.js';
 export declare const withTransaction: (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {}, {}, {
     $withTransaction: typeof $withTransaction;
 }>>;
 export type GetPrismaClientInTransaction<PrismaClient> = Omit<PrismaClient, ITXClientDenyList>;
 export type WithTransactionMethod = typeof $withTransaction;
-declare function $withTransaction<That extends object, R extends MaySuccess<unknown, unknown>>(this: That, callback: (dbInTransaction: GetPrismaClientInTransaction<That>) => Promise<R>): Promise<Failed<any> | R>;
+declare function $withTransaction<That extends object, R extends Result<unknown, unknown>>(this: That, callback: (dbInTransaction: GetPrismaClientInTransaction<That>) => Promise<R>): Promise<Failed<any> | R>;
 export {};

package/env-service/prisma/extensions/with-transaction.js

@@ -1,11 +1,11 @@
 /**
  * 在事务中执行回调。与 $transaction 有几点不同：
- * 1. 回调必须返回 MaySuccess 值
+ * 1. 回调必须返回 Result 值
  * 2. 回调返回 Failed 值或抛出异常都会触发回滚。
  *    如果是返回 Failed，会作为此方法的返回值；如果是抛出异常，则异常会继续向上传递，直到被捕获或触发请求失败。
  * 3. 如果已经处于事务中，会沿用上层事务，且回调返回 Failed 或抛出异常会触发上层事务的回滚。
  *
- * const result: MaySuccess = await db.$withTransaction(
+ * const result: Result = await db.$withTransaction(
  *   async (dbInTransaction) => {
  *     // do something
  *     return success()
@@ -26,7 +26,7 @@ class FailedInTransaction extends Error {
         this.failed = failed;
     }
 }
-// 注意：此函数的返回值为 `R | Failed<any>`，例如实际可能为 `MaySuccess<xxx, xxx> | Failed<any>`，这是有意为之的，`Failed<any>` 并不多余。
+// 注意：此函数的返回值为 `R | Failed<any>`，例如实际可能为 `Result<xxx, xxx> | Failed<any>`，这是有意为之的，`Failed<any>` 并不多余。
 // 因为有时 callback() 只会返回 success 结果，此时 R=Success<xxx>，但是 $withTransaction 整体的返回值仍有可能有 Failed<any>，所以不能用 R 作为整体返回值。
 async function $withTransaction(callback) {
     const executeCallback = async (dbInTransaction) => {

package/index.d.ts

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

package/index.js

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

package/lang/async.d.ts

@@ -5,7 +5,7 @@
  * 返回一个指定毫秒后 resolve 的 Promise
  * 若指定了 resolveValue，则 Promise 最终会解析出此值
  */
-declare function sleep(ms: number): Promise<void>;
+declare function sleep(ms: number): Promise<undefined>;
 declare function sleep<T>(ms: number, resolveValue: T): Promise<T>;
 export { sleep };
 /**

package/lang/index.d.ts

@@ -1,5 +1,5 @@
 export * from './types.js';
-export * from './may-success.js';
+export * from './result.js';
 export * from './string.js';
 export * from './object.js';
 export * from './time.js';

package/lang/index.js

@@ -1,5 +1,5 @@
 export * from './types.js';
-export * from './may-success.js';
+export * from './result.js';
 export * from './string.js';
 export * from './object.js';
 export * from './time.js';

package/lang/{may-success.d.ts → result.d.ts}

@@ -1,5 +1,5 @@
 /**
- * MaySuccess：代表一种“可能失败”的操作结果，可以作为函数返回值，也可以作为接口响应值。
+ * Result：代表一种“可能失败”的操作结果，可以作为函数返回值，也可以作为接口响应值。
  * 它的灵感来自 Scala 的 Option 类型。
  *
  * 原本，在 JavaScript 里一个可能失败的操作有两种表示失败的方式：
@@ -7,7 +7,7 @@
  * 2. 抛出异常
  * 返回空值的方式无法附带失败信息；而抛出异常会导致层层嵌套的 try catch 语句，且其实性能不好。
  *
- * MaySuccess 就是为了解决这两个痛点：
+ * Result 就是为了解决这两个痛点：
  * 1. 它的 Failed 类型可以携带失败信息。
  * 2. 无需 try catch，只需简单的 result.success 判断
  */
@@ -16,13 +16,13 @@ export interface Success<T = void> {
     success: true;
     data: T;
 }
-export interface Failed<T = void> {
+export interface Failed<T = unknown> {
     success: false;
     message: string;
     code?: string | number;
     data: T;
 }
-export type MaySuccess<T = void, FT = void> = Success<T> | Failed<FT>;
+export type Result<T = void, FailedT = unknown> = Success<T> | Failed<FailedT>;
 /** 生成 Success 数据 */
 declare function success(): Success;
 declare function success<T>(data: T): Success<T>;
@@ -33,8 +33,15 @@ declare function failed<T>(message: string, code: string | number | undefined, d
 export { failed };
 /**
  * 若传入值为 success，格式化其 data；否则原样返回错误
- * 支持传入会返回 MaySuccess 的 Promise
+ * 支持传入会返回 Result 的 Promise
  */
-declare function formatSuccess<T1, T2, FT = void>(value: MaySuccess<T1, FT>, formatter: (value: T1) => T2): MaySuccess<T2, FT>;
-declare function formatSuccess<T1, T2, FT = void>(value: Promise<MaySuccess<T1, FT>>, formatter: (value: T1) => T2): Promise<MaySuccess<T2, FT>>;
+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 };
+/**
+ * 把可能抛出异常的 Promise 转换为返回 Result 的 Promise。
+ * 其中返回的 Failed 对象的 data 是 catch 捕获到的错误对象。
+ *
+ * 通过此函数可避免写一长串嵌套的 try catch 语句。
+ */
+export declare function handleException<T>(promise: Promise<T>): Promise<Result<T>>;

package/lang/{may-success.js → result.js}

@@ -1,5 +1,5 @@
 /**
- * MaySuccess：代表一种“可能失败”的操作结果，可以作为函数返回值，也可以作为接口响应值。
+ * Result：代表一种“可能失败”的操作结果，可以作为函数返回值，也可以作为接口响应值。
  * 它的灵感来自 Scala 的 Option 类型。
  *
  * 原本，在 JavaScript 里一个可能失败的操作有两种表示失败的方式：
@@ -7,7 +7,7 @@
  * 2. 抛出异常
  * 返回空值的方式无法附带失败信息；而抛出异常会导致层层嵌套的 try catch 语句，且其实性能不好。
  *
- * MaySuccess 就是为了解决这两个痛点：
+ * Result 就是为了解决这两个痛点：
  * 1. 它的 Failed 类型可以携带失败信息。
  * 2. 无需 try catch，只需简单的 result.success 判断
  */
@@ -25,3 +25,21 @@ function formatSuccess(value, formatter) {
     return value.success ? success(formatter(value.data)) : value;
 }
 export { formatSuccess };
+/**
+ * 把可能抛出异常的 Promise 转换为返回 Result 的 Promise。
+ * 其中返回的 Failed 对象的 data 是 catch 捕获到的错误对象。
+ *
+ * 通过此函数可避免写一长串嵌套的 try catch 语句。
+ */
+export async function handleException(promise) {
+    return promise.then(data => success(data), (error) => {
+        let message;
+        try {
+            message = (error?.message ?? '') || String(error);
+        }
+        catch (e) {
+            message = 'Got Exception';
+        }
+        return failed(message, undefined, error);
+    });
+}

package/lang/string.d.ts

@@ -10,7 +10,7 @@ export declare function numericCompare(a: string, b: string): number;
  * 1. 默认设置 radix 为 10，无需再手动指定
  * 2. 支持指定 fallback，当解析出来的数字是 NaN 时返回这个值
  */
-export declare function safeParseInt(value: string | number, fallback?: number, redix?: number): number;
+export declare function safeParseInt(value: string | number, fallback?: number, radix?: number): number;
 /**
  * 字符串解析成浮点数；若解析结果是 NaN，返回 fallback
  */

package/lang/string.js

@@ -45,9 +45,9 @@ export function numericCompare(a, b) {
  * 1. 默认设置 radix 为 10，无需再手动指定
  * 2. 支持指定 fallback，当解析出来的数字是 NaN 时返回这个值
  */
-export function safeParseInt(value, fallback, redix = 10) {
-    const raw = parseInt(String(value), redix);
-    return isFinite(raw) ? raw : (fallback ?? raw);
+export function safeParseInt(value, fallback, radix = 10) {
+    const raw = parseInt(String(value), radix);
+    return isFinite(raw) ? raw : fallback ?? raw;
 }
 /**
  * 字符串解析成浮点数；若解析结果是 NaN，返回 fallback

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anjianshi/utils",
-  "version": "2.9.1",
+  "version": "3.0.1",
   "description": "Common JavaScript Utils",
   "homepage": "https://github.com/anjianshi/js-packages/utils",
   "bugs": {
@@ -32,11 +32,11 @@
     "typescript": "^5.8.3",
     "vconsole": "^3.15.1",
     "@anjianshi/presets-eslint-base": "6.0.0",
-    "@anjianshi/presets-eslint-react": "6.0.0",
     "@anjianshi/presets-eslint-node": "6.0.0",
+    "@anjianshi/presets-eslint-react": "6.0.0",
     "@anjianshi/presets-eslint-typescript": "6.0.0",
-    "@anjianshi/presets-prettier": "3.0.4",
-    "@anjianshi/presets-typescript": "3.2.4"
+    "@anjianshi/presets-prettier": "3.0.5",
+    "@anjianshi/presets-typescript": "3.2.5"
   },
   "peerDependencies": {
     "@emotion/react": "^11.14.0",

package/safe-request.d.ts

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,140 @@
+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.arrayBuffer()));
+        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();

package/validators/base.d.ts

@@ -1,4 +1,4 @@
-import { type MaySuccess } from '../lang/index.js';
+import { type Result } from '../lang/index.js';
 /**
  * 支持传入进行验证的值类型
  */
@@ -22,7 +22,7 @@ export interface CommonOptions<Value = any> {
      * 指定后 required 选项将失去作用。
      */
     defaults?: Value;
-    custom?: (input: Value) => MaySuccess<Value>;
+    custom?: (input: Value) => Result<Value>;
     [key: string]: unknown;
 }
 /**
@@ -66,14 +66,14 @@ export type Validated<Value, InputOptions extends CommonOptions> = FullfiledOpti
  * 最终生成的 validator 函数类型
  */
 export interface Validator<Value, InputOptions extends CommonOptions> {
-    (input: AllowedInputValue): MaySuccess<Validated<Value, InputOptions>>;
-    (field: string, input: AllowedInputValue): MaySuccess<Validated<Value, InputOptions>>;
+    (input: AllowedInputValue): Result<Validated<Value, InputOptions>>;
+    (field: string, input: AllowedInputValue): Result<Validated<Value, InputOptions>>;
 }
 /**
  * 返回支持指定格式的 options、并按照传入的逻辑进行验证的 validator 的生成器。
  * 对 CommonOptions 相关内容的验证以自动包含在里面，只需要传入额外的验证逻辑即可。
  */
-export declare function getValidatorGenerator<Value, Options extends CommonOptions>(validate: (field: string, input: PrimitiveType | Validated<Value, Options>, options: Options) => MaySuccess<Value>): <const InputOptions extends Options>(inputOptions: InputOptions) => Validator<Value, InputOptions>;
+export declare function getValidatorGenerator<Value, Options extends CommonOptions>(validate: (field: string, input: PrimitiveType | Validated<Value, Options>, options: Options) => Result<Value>): <const InputOptions extends Options>(inputOptions: InputOptions) => Validator<Value, InputOptions>;
 /**
  * 返回只进行基本检查，不带定制的验证逻辑的 validator。
  * 同时也是定制 validator 最小化实现的例子。

package/env-node/safe-request.d.ts

@@ -1,26 +0,0 @@
-import { type MaySuccess, type Failed } from '../lang/may-success.js';
-interface BaseOptions {
-    url: string;
-    method?: 'GET' | 'POST';
-    headers?: Record<string, string>;
-    body?: string | null;
-    /** 若请求未成功发起，会触发此函数来生成失败信息 */
-    handleRequestError?: (error: Error) => Failed<unknown>;
-    /** 请求成功发起，但服务端返回失败结果（如 500），会触发此函数来生成失败信息 */
-    handleResponseError?: (response: Response) => Failed<unknown> | Promise<Failed<unknown>>;
-    /** 服务端返回内容解析失败时，会触发此函数来生成失败信息 */
-    handleParseFailed?: (error: Error, response: Response) => Failed<unknown>;
-}
-/**
- * 发起请求并妥善处理返回值，可用于与外部服务对接
- */
-declare function safeRequest<T>(options: BaseOptions & {
-    responseType?: 'json';
-}): Promise<MaySuccess<T, Error | string>>;
-declare function safeRequest(options: BaseOptions & {
-    responseType: 'binary';
-}): Promise<MaySuccess<Buffer, Error | string>>;
-declare function safeRequest(options: BaseOptions & {
-    responseType: 'text';
-}): Promise<MaySuccess<string, Error | string>>;
-export { safeRequest };

package/env-node/safe-request.js

@@ -1,40 +0,0 @@
-import { success, failed } from '../lang/may-success.js';
-function defaultHandleRequestError(error) {
-    return failed('Request Error', undefined, error);
-}
-async function defaultHandleResponseError(response) {
-    return failed(`Response Error:${response.status}`, undefined, await response.text());
-}
-function defaultHandleParseFailed(error) {
-    return failed('Response Parse Failed', undefined, error);
-}
-async function safeRequest(options) {
-    const { url, method = 'GET', headers = {}, body = null, responseType = 'json' } = options;
-    try {
-        const response = await fetch(url, {
-            method,
-            headers,
-            body,
-        });
-        try {
-            if (response.status !== 200 && (response.status !== 204 || responseType !== 'text')) {
-                return await (options.handleResponseError ?? defaultHandleResponseError)(response);
-            }
-            let responseBody;
-            if (responseType === 'json')
-                responseBody = await response.json();
-            else if (responseType === 'binary')
-                responseBody = Buffer.from(await response.arrayBuffer());
-            else
-                responseBody = await response.text();
-            return success(responseBody);
-        }
-        catch (e) {
-            return (options.handleParseFailed ?? defaultHandleParseFailed)(e, response);
-        }
-    }
-    catch (e) {
-        return (options.handleRequestError ?? defaultHandleRequestError)(e);
-    }
-}
-export { safeRequest };