新增：AnyCLass类型，新增了tryCatch的错误部分捕获

Author: Ceale

README.md

@@ -48,6 +48,7 @@
     - Enum()
     - EnumKeys<>
     - `type` anyobject
+    - `type` AnyClass
 - Object.prototype
     - hasKeys()
     - inKeys()

bun.lock

@@ -1,39 +1,36 @@
 {
   "name": "@ceale/util",
-  "version": "1.17.0",
-  
+  "version": "1.18.0",
   "author": "Ceale",
   "description": "小工具集",
   "repository": {
     "url": "git+https://github.com/Ceale/ts-util.git"
   },
-
   "license": "Unlicense or CC0 or WTFPL",
-  "keywords": [ "util" ],
-
+  "keywords": ["util"],
   "type": "module",
   "module": "dist/esm/index.ts",
   "main": "dist/cjs/index.js",
   "types": "dist/types/index.d.ts",
   "files": ["dist"],
   "exports": {
     ".": {
+      "types": "./dist/types/index.d.ts",
       "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js",
-      "types": "./dist/types/index.d.ts"
+      "require": "./dist/cjs/index.js"
     },
     "./package.json": "./package.json"
   },
-
   "scripts": {
     "build": "bun run build:esm && bun run build:cjs && bun run build:ts",
-    "build:cjs": "bun build --outdir=dist/cjs/ --format=cjs --target=node --packages=external src/index.ts",
-    "build:esm": "bun build --outdir=dist/esm/ --format=esm --target=node --packages=external src/index.ts",
+    "build:esm": "esbuild --outdir=dist/esm/ --format=esm --target=esnext --bundle --packages=external src/index.ts",
+    "build:cjs": "esbuild --outdir=dist/cjs/ --format=cjs --target=esnext --bundle --packages=external src/index.ts",
     "build:ts": "tsc --project tsconfig.build.json"
   },
   "devDependencies": {
-    "typescript": "^5",
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "esbuild": "^0.27.0",
+    "typescript": "^5"
   },
   "dependencies": {
     "csstype": "^3.1.3"

package.json

@@ -1,5 +1,4 @@
-// 定义一个通用的类/构造函数类型
-type AnyClass = new (...args: any[]) => any
+import type { AnyClass } from "./type"
 
 declare global {
     interface Function {

src/class.ts

@@ -1,3 +1,5 @@
+import type { AnyClass } from "./type"
+
 type Success<T> = {
     data: T
     error: null
@@ -14,61 +16,61 @@ type Failure<E> = {
     error: E
 ]
 
-type Result<T, E extends unknown = Error> = Success<T> | Failure<E>
+type Result<T, E = any> = Success<T> | Failure<E>
 
 interface tryCatch {
-    <T>(arg: Promise<T>): Promise<Result<T>>
-    <V>(arg: (() => V)): Result<V>
+    // 捕获所有
+    <T>(func: (() => T)): Result<T>
+    <T>(asyncFunc: Promise<T>): Promise<Result<T>>
+    // 捕获指定
+    <T, E extends AnyClass>(func: (() => T), catchClass: E): Result<T, InstanceType<E>>
+    <T, E extends AnyClass>(func: Promise<T>, catchClass: E): Promise<Result<T, InstanceType<E>>>
 }
 
 /**
- * 尝试执行一个函数或Promise，返回一个包含执行结果或错误信息的复合对象
+ * 尝试执行一个函数或Promise，返回一个对象，其中包含执行结果或被捕获的错误
  * 
  * 该对象同时支持对象属性访问(.data/.error)和数组索引访问([0]/[1])两种方式
  * 
- * @param parameter 一个函数或者Promise对象
- * @returns 返回参数中，data和[0]是函数的返回值或是Promise的解析结果，error和[1]是错误对象。两者将有一为`null`
+ * @param func 一个函数或者Promise对象
+ * @param catchClass 要捕获的错误类型（含子类），如果不指定，则捕获所有错误；如指定，则为被捕获的错误将继续上抛
+ * @returns 返回一个如后方例的对象`{ data, error } & [ data, error ]`
  * 
  * @example
  * tryCatch(() => func(...))
  * // => [data, error] & {data, error}
  * // data: func的返回值，error：函数执行过程中发生的错误
  * 
+ * 
+ * @example
+ * tryCatch(() => func(...), TypeError)
+ * // => [data, error] & {data, error}
+ * // data: func的返回值，error：函数执行过程中，发生的TypeError或其子类错误
+ * 
  * @example
  * await tryCatch(asyncFunc(...))
  * // => [data, error] & {data, error}
- * // data: asyncFunc的返回值，error：asyncFunc执行过程中发生的错误
+ * // data: 异步函数asyncFunc的返回值，error：asyncFunc执行过程中发生的错误
  */
-export const tryCatch: tryCatch = (parameter: any): any => {
-    
-    // 处理 Promise
-    if (typeof parameter === "object") {
-        return (parameter as Promise<any>)
-            .then(data => Object.assign([ data, null ], { data, error: null }))
-            .catch(error => Object.assign([ null, error ], { data: null, error }))
-    }
+export const tryCatch: tryCatch = (func: Function | Promise<any>, catchClass?: any): any => {
 
     // 处理函数
-    if (typeof parameter === "function") {
+    if (typeof func === "function") {
         try {
-            const data = parameter()
+            const data = func()
             return Object.assign([ data, null ], { data, error: null })
         } catch (error) {
-            return Object.assign([ null, error ], { data: null, error })
+            if (!catchClass || error instanceof catchClass) return Object.assign([ null, error ], { data: null, error })
+            throw error
         }
-    }
-    
-    throw new TypeError("参数类型错误，应为 Promise 或函数")
-}
+    } else {
+        // 处理 Promise，兼容第三方Promise实现
+        return func
+            .then(data => Object.assign([ data, null ], { data, error: null }))
+            .catch(error => {
+                if (!catchClass || error instanceof catchClass) return Object.assign([ null, error ], { data: null, error })
+                throw error
+            })
 
-// import fs from "node:fs/promises"
-// (async () => {
-//     const a = await tryCatch(fs.stat("a.txt"))
-//     console.log(typeof a)
-// })()
-// console.log(a)
-// if (!a.error) {
-//     console.log(a.error)
-// } else {
-//     console.log(a.data)
-// }
+    }
+}

src/error.ts

@@ -1,3 +1,15 @@
+/**
+ * 一种介于 `any` 与 `object` 之间的类型
+ * - 与 `any` 类似，可以任意访问属性
+ * - 与 `object` 类似，排除了原始类型
+ */
+export type anyobject = Record<any, any>
+
+/**
+ * 表示任意的类或构造函数
+ */
+export type AnyClass = new (...args: any[]) => any
+
 /**
  * 就地断言一个变量为指定类型
  * @template Type 断言的类型，默认为`any`
@@ -14,13 +26,6 @@ export const assert = <Type = any>(variable: any): asserts variable is Type => v
  */
 export const expand = <Type>(variable: any): asserts variable is (typeof variable & Type) => variable
 
-/**
- * 一种介于 `any` 与 `object` 之间的类型
- * - 与 `any` 类似，可以任意访问属性
- * - 与 `object` 类似，排除了原始类型
- */
-export type anyobject = Record<any, any>
-
 /** 
  * 定义一个枚举类型。
  * 返回一个枚举对象，其中每个键名与值相同。
@@ -70,4 +75,5 @@ export const Enum = (keys: Record<string, string>) => ({
  * const 对吗 = defineEnum("对", "不对")
  * Enum<typeof 对吗> // "对" | "不对"
  */
-export type EnumKeys<E> = E[keyof E]
+export type EnumKeys<E> = E[keyof E]
+// 定义一个通用的类/构造函数类型

src/type.ts

@@ -0,0 +1,90 @@
+import { describe, expect, test } from "bun:test";
+import { tryCatch } from "src/error"
+
+// 定义一些自定义错误用于测试 catchClass
+class MyError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "MyError";
+    }
+}
+
+class OtherError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = "OtherError";
+    }
+}
+
+describe("tryCatch 同步函数测试", () => {
+    test("同步成功：应返回数据并支持数组/对象解构", () => {
+        const [data, error] = tryCatch(() => "hello");
+        const res = tryCatch(() => "hello");
+
+        expect(data).toBe("hello");
+        expect(error).toBeNull();
+        expect(res.data).toBe("hello");
+        expect(res.error).toBeNull();
+    });
+
+    test("同步失败（捕获所有）：应返回错误", () => {
+        const err = new Error("sync fail");
+        const [data, error] = tryCatch(() => {
+            throw err;
+        });
+
+        expect(data).toBeNull();
+        expect(error).toBe(err);
+    });
+
+    test("同步失败（指定错误类）：匹配时应捕获", () => {
+        const err = new MyError("known error");
+        const [data, error] = tryCatch(() => {
+            throw err;
+        }, MyError);
+
+        expect(data).toBeNull();
+        expect(error).toBe(err);
+    });
+
+    test("同步失败（指定错误类）：不匹配时应抛出错误", () => {
+        const err = new OtherError("unknown error");
+        expect(() => {
+            tryCatch(() => {
+                throw err;
+            }, MyError);
+        }).toThrow(OtherError);
+    });
+});
+
+describe("tryCatch Promise 测试", () => {
+    test("异步成功：应返回数据", async () => {
+        const promise = Promise.resolve("async hello");
+        const [data, error] = await tryCatch(promise);
+
+        expect(data).toBe("async hello");
+        expect(error).toBeNull();
+    });
+
+    test("异步失败（捕获所有）：应返回错误", async () => {
+        const err = new Error("async fail");
+        const [data, error] = await tryCatch(Promise.reject(err));
+
+        expect(data).toBeNull();
+        expect(error).toBe(err);
+    });
+
+    test("异步失败（指定错误类）：匹配时应捕获", async () => {
+        const err = new MyError("async known error");
+        const [data, error] = await tryCatch(Promise.reject(err), MyError);
+
+        expect(data).toBeNull();
+        expect(error).toBe(err);
+    });
+
+    test("异步失败（指定错误类）：不匹配时应 reject", async () => {
+        const err = new OtherError("async unknown error");
+        // Bun 的 expect 支持 rejects 断言
+        expect(tryCatch(Promise.reject(err), MyError)).rejects.toThrow(OtherError);
+    });
+});