@shkumbinhsn/try-catch 0.0.3 → 0.0.6

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+declare const errorSymbol: unique symbol;
+export type Throws<T extends Error> = {
+    [errorSymbol]?: T;
+};
+type ExtractErrors<T> = T extends Throws<infer E> ? E : never;
+type StripThrows<T> = T extends infer R & Throws<Error> ? R : T;
+type DataError<T> = [StripThrows<T>, null] | [null, Error | ExtractErrors<T>];
+type TryCatchReturn<T> = T extends Promise<infer R> ? Promise<DataError<R>> : DataError<T>;
+/**
+ * Executes a function within a try-catch block and returns a tuple [data, error].
+ *
+ * @param fn - The function to execute. Can be synchronous or return a Promise.
+ * @returns A tuple where:
+ *   - For success: [data, null] where data is the function's return value
+ *   - For failure: [null, error] where error is the caught exception
+ *
+ * @example
+ * // Synchronous usage
+ * const [data, error] = tryCatch(() => riskyFunction());
+ *
+ * @example
+ * // Asynchronous usage
+ * const [data, error] = await tryCatch(() => asyncRiskyFunction());
+ */
+export declare function tryCatch<T>(fn: () => T): TryCatchReturn<T>;
+interface TcBuilder<T> {
+    mightThrow<E extends Error>(): T & Throws<E>;
+}
+/**
+ * Brands a return value with potential error types for tryCatch inference.
+ * Uses a fluent API for declaring errors.
+ *
+ * @param value - The value to return
+ * @returns A builder with mightThrow() to declare error types
+ *
+ * @example
+ * function fetchUser() {
+ *   const user = getUser();
+ *   return tc(user).mightThrow<APIError | NetworkError>();
+ * }
+ */
+export declare function tc<T>(value: T): TcBuilder<T>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,WAAW,eAAW,CAAC;AAI7B,MAAM,MAAM,MAAM,CAAC,CAAC,SAAS,KAAK,IAAI;IACpC,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;CACnB,CAAC;AAEF,KAAK,aAAa,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;AAE9D,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEhE,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAE9E,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAC/C,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GACrB,SAAS,CAAC,CAAC,CAAC,CAAC;AAEjB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAc1D;AAED,UAAU,SAAS,CAAC,CAAC;IACnB,UAAU,CAAC,CAAC,SAAS,KAAK,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;CAC9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAM5C"}

package/dist/index.js

@@ -0,0 +1,54 @@
+const errorSymbol = Symbol();
+/**
+ * Executes a function within a try-catch block and returns a tuple [data, error].
+ *
+ * @param fn - The function to execute. Can be synchronous or return a Promise.
+ * @returns A tuple where:
+ *   - For success: [data, null] where data is the function's return value
+ *   - For failure: [null, error] where error is the caught exception
+ *
+ * @example
+ * // Synchronous usage
+ * const [data, error] = tryCatch(() => riskyFunction());
+ *
+ * @example
+ * // Asynchronous usage
+ * const [data, error] = await tryCatch(() => asyncRiskyFunction());
+ */
+export function tryCatch(fn) {
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            return new Promise((resolve) => {
+                result
+                    .then((data) => resolve([data, null]))
+                    .catch((error) => resolve([null, error]));
+            });
+        }
+        return [result, null];
+    }
+    catch (e) {
+        return [null, e];
+    }
+}
+/**
+ * Brands a return value with potential error types for tryCatch inference.
+ * Uses a fluent API for declaring errors.
+ *
+ * @param value - The value to return
+ * @returns A builder with mightThrow() to declare error types
+ *
+ * @example
+ * function fetchUser() {
+ *   const user = getUser();
+ *   return tc(user).mightThrow<APIError | NetworkError>();
+ * }
+ */
+export function tc(value) {
+    return {
+        mightThrow() {
+            return value;
+        },
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC;AAkB7B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,QAAQ,CAAI,EAAW;IACrC,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,EAAE,EAAE,CAAC;QACpB,IAAI,MAAM,YAAY,OAAO,EAAE,CAAC;YAC9B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;gBAC7B,MAAM;qBACH,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;qBACrC,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;YAC9C,CAAC,CAAsB,CAAC;QAC1B,CAAC;QACD,OAAO,CAAC,MAAM,EAAE,IAAI,CAAsB,CAAC;IAC7C,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,IAAI,EAAE,CAAC,CAAsB,CAAC;IACxC,CAAC;AACH,CAAC;AAMD;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,EAAE,CAAI,KAAQ;IAC5B,OAAO;QACL,UAAU;YACR,OAAO,KAAsB,CAAC;QAChC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@shkumbinhsn/try-catch",
-  "version": "0.0.3",
-  "description": "A utility package for handling try-catch blocks in TypeScript.",
-  "main": "./lib/try-catch.js",
-  "module": "./lib/try-catch.js",
-  "types": "./lib/try-catch.d.ts",
+  "version": "0.0.6",
+  "description": "A utility package for handling try-catch blocks in TypeScript with full type inference.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./lib/try-catch.d.ts",
-      "import": "./lib/try-catch.js",
-      "require": "./lib/try-catch.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
     }
   },
   "files": [
-    "lib"
+    "dist"
   ],
   "engines": {
     "node": ">=16"
@@ -22,11 +22,10 @@
     "access": "public"
   },
   "scripts": {
-    "test": "tsc -p tsconfig.json"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/shkumbinhasani/ts-try-catch.git"
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "typescript",
@@ -40,7 +39,12 @@
   ],
   "author": "Shkumbin Hasani",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shkumbinhasani/ts-try-catch.git",
+    "directory": "packages/try-catch"
+  },
   "devDependencies": {
-    "typescript": "^5.0.0"
+    "vitest": "^1.2.0"
   }
 }

package/README.md

@@ -1,152 +0,0 @@
-![cowboy trying to catch a horse](https://i.imgur.com/TzMOUUL.jpeg)
-[![npm version](https://img.shields.io/npm/v/@shkumbinhsn/try-catch.svg)](https://www.npmjs.com/package/@shkumbinhsn/try-catch)
-[![npm downloads](https://img.shields.io/npm/dm/@shkumbinhsn/try-catch.svg)](https://www.npmjs.com/package/@shkumbinhsn/try-catch)
-# Type-Safe Try-Catch Pattern for TypeScript
-
-A lightweight TypeScript utility that provides type-safe error handling through a functional approach. This library allows you to explicitly define error types while maintaining full TypeScript inference and zero runtime overhead.
-
-## Installation
-
-```bash
-npm install @shkumbinhsn/try-catch
-```
-
-## Key Features
-
-- **🔒 Type Safety**: Explicitly declare what errors your functions can throw
-- **🎯 Zero Runtime Overhead**: Types are compile-time only using TypeScript's structural typing
-- **🔄 Async/Sync Support**: Works seamlessly with both synchronous and asynchronous functions
-- **📦 Lightweight**: Minimal footprint with no dependencies
-- **🧠 Smart Inference**: Falls back to standard TypeScript inference when no error types are specified
-- **🛡️ Tuple-based**: Returns `[data, error]` tuples for explicit error handling
-
-## Why Use This Pattern?
-
-Traditional try-catch blocks in TypeScript don't provide type information about what errors might be thrown. This library solves that by:
-
-1. Making error types explicit in function signatures
-2. Forcing explicit error handling through tuple destructuring
-3. Providing better IntelliSense and type checking
-4. Maintaining compatibility with existing code
-
----
-
-## Example Code
-
-### Defining a Function with Error Handling
-
-```typescript
-import { tryCatch, type Throws } from "@shkumbinhsn/try-catch";
-
-class CustomError extends Error {}
-
-function iMightFail(): string & Throws<CustomError> {
-  const random = Math.random();
-  if (random > 0.2) {
-    return "success";
-  } else if (random > 0.5) {
-    throw new CustomError("Something went wrong");
-  }
-  throw new Error("Generic error");
-}
-
-const [data, error] = tryCatch(() => iMightFail());
-
-if (error) {
-  console.log("Operation failed:", error.message);
-  // TypeScript knows: error is Error | CustomError
-} else {
-  console.log("Operation succeeded:", data);
-  // TypeScript knows: data is string
-}
-```
-
-### Async Functions with Errors
-
-```typescript
-async function fetchUserData(id: string): Promise<User & Throws<ValidationError | NetworkError>> {
-  if (!id) {
-    throw new ValidationError("User ID is required");
-  }
-  
-  const response = await fetch(`/api/users/${id}`);
-  if (!response.ok) {
-    throw new NetworkError("Failed to fetch user data");
-  }
-  
-  return response.json();
-}
-
-const [userData, error] = await tryCatch(() => fetchUserData("123"));
-
-if (error) {
-  if (error instanceof ValidationError) {
-    console.log("Validation error:", error.message);
-  } else if (error instanceof NetworkError) {
-    console.log("Network error:", error.message);
-  } else {
-    console.log("Unexpected error:", error.message);
-  }
-} else {
-  console.log("User data:", userData);
-  // TypeScript knows: userData is User
-}
-```
-
-### Without Explicit Error Types
-
-When you don't specify error types, the library falls back to standard TypeScript inference:
-
-```typescript
-function regularFunction() {
-  return "success";
-}
-
-const [data, error] = tryCatch(regularFunction);
-
-if (error) {
-  console.log("Operation failed:", error.message);
-  // TypeScript knows: error is Error
-} else {
-  console.log("Operation succeeded:", data);
-  // TypeScript knows: data is string
-}
-```
-
-## API Reference
-
-### `tryCatch<T>(fn: () => T): TryCatchReturn<T>`
-
-Executes a function within a try-catch block and returns a result tuple.
-
-**Parameters:**
-- `fn`: Function to execute (can be sync or async)
-
-**Returns:**
-- `[data, null]` on success
-- `[null, error]` on failure
-
-### `Throws<T extends Error>`
-
-Type utility for declaring error types in function signatures.
-
-**Usage:**
-```typescript
-function myFunction(): ReturnType & Throws<MyError> {
-  // function implementation
-}
-```
-
-## Limitations
-
-- **Duplicate Definitions**: Error types must be declared in both the throw statement and return type
-- **Runtime Validation**: No runtime enforcement of declared error types
-- **Learning Curve**: Requires understanding of TypeScript's structural typing
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit issues and pull requests.
-
-## License
-
-MIT

package/lib/try-catch.d.ts

@@ -1,19 +0,0 @@
-const errorSymbol = Symbol();
-
-type ErrorSymbol = typeof errorSymbol;
-
-export type Throws<T extends Error> = {
-  [errorSymbol]?: T
-};
-
-type ExtractErrors<T> = T extends Throws<infer E> ? E : never;
-
-type StripThrows<T> = T extends infer R & Throws<Error> ? R : T;
-
-type DataError<T> = [StripThrows<T>, null] | [null, Error | ExtractErrors<T>];
-
-type TryCatchReturn<T> = T extends Promise<infer R>
-  ? Promise<DataError<R>>
-  : DataError<T>;
-
-export declare function tryCatch<T>(fn: () => T): TryCatchReturn<T>;

package/lib/try-catch.js

@@ -1,29 +0,0 @@
-/**
- * Executes a function within a try-catch block and returns a tuple [data, error].
- * 
- * @param {Function} fn - The function to execute. Can be synchronous or return a Promise.
- * @returns {Array|Promise<Array>} A tuple where:
- *   - For success: [data, null] where data is the function's return value
- *   - For failure: [null, error] where error is the caught exception
- * 
- * @example
- * // Synchronous usage
- * const [data, error] = tryCatch(() => riskyFunction());
- * 
- * @example  
- * // Asynchronous usage
- * const [data, error] = await tryCatch(() => asyncRiskyFunction());
- */
-export function tryCatch(fn) {
-    try {
-        const result = fn();
-        if(result instanceof Promise) {
-            return new Promise((resolve) => {
-                result.then((data) => resolve([data, null])).catch((error) => resolve([null, error]))
-            })
-        }
-        return [result, null];
-    } catch (e) {
-        return [null, e]
-    }
-}