feat: adds sync function support

Author: thedanchez

package.json

@@ -40,7 +40,7 @@
     "lint:fix": "eslint . --fix",
     "pkg:changeset": "changeset",
     "pkg:version": "changeset version",
-    "pkg:publish": "changeset publish",
+    "pkg:publish": "bun run build && changeset publish",
     "serve": "vite preview",
     "start": "vite",
     "test": "vitest run",

src/__tests__/tryCatch.test.ts

@@ -3,6 +3,42 @@ import { describe, expect, it } from "vitest";
 import { tryCatch } from "../index";
 
 describe("UTIL FUNCTION: tryCatch", () => {
+  // Sync values
+  it("handles sync functions that return values", async () => {
+    const [err, data] = await tryCatch(() => JSON.parse('{"a":1}'));
+    expect(err).toBeNull();
+    expect(data).toEqual({ a: 1 });
+  });
+
+  it("handles sync function that throws", async () => {
+    const [err, data] = await tryCatch(() => JSON.parse("{ a: 1 }")); // invalid JSON (unquoted key)
+    expect(err).toBeInstanceOf(SyntaxError);
+    expect(err?.message).toContain(
+      "Expected property name or '}' in JSON at position 2",
+    );
+    expect(data).toBeNull();
+  });
+
+  it("handles sync functions that throw errors", async () => {
+    const [err, data] = await tryCatch(() => {
+      throw new RangeError("Out of bounds");
+    });
+    expect(err).toBeInstanceOf(RangeError);
+    expect(err?.message).toBe("Out of bounds");
+    expect(data).toBeNull();
+  });
+
+  it("handles sync functions that throw non-Error values", async () => {
+    const [err, data] = await tryCatch(() => {
+      throw "sync oops";
+    });
+    expect(err).toBeInstanceOf(Error);
+    expect(err?.message).toBe("sync oops");
+    expect(data).toBeNull();
+  });
+
+  // Async values
+
   it("handles resolved promises correctly", async () => {
     const [err, data] = await tryCatch(Promise.resolve(42));
     expect(err).toBeNull();

src/index.ts

@@ -2,17 +2,41 @@ type Success<T> = [error: null, data: T];
 type Failure<E extends Error = Error> = [error: E, data: null];
 type Result<T, E extends Error = Error> = Success<T> | Failure<E>;
 
+type SyncFn<T> = () => T;
+type AsyncFn<T> = () => Promise<T>;
+
+/**
+ * Acceptable input types for `tryCatch`:
+ * - A synchronous function that might throw
+ * - An async function (returns a promise)
+ * - A promise (e.g. from `fetch()`)
+ */
+type TryCatchInput<T> = SyncFn<T> | AsyncFn<T> | Promise<T>;
+
 /**
- * Wraps a promise or async function and returns a tuple [error, data].
- * Catches both synchronous and asynchronous errors.
+ * Wraps a potentially throwing function or a promise and returns a tuple `[error, data]`.
+ * Catches both sync and async errors, and wraps non-Error throws into an `Error` object.
+ *
+ * ## Examples
+ *
+ * ```ts
+ * // ✅ Synchronous function that may throw
+ * const [err, data] = await tryCatch(() => JSON.parse("{ \"a\": 1 }"));
+ *
+ * // ✅ Async function
+ * const [err, data] = await tryCatch(() => fetch("/api/data").then(r => r.json()));
+ *
+ * // ✅ Direct promise
+ * const [err, data] = await tryCatch(fetch("/api/data"));
+ * ```
  */
 export async function tryCatch<T, E extends Error = Error>(
-  promiseOrFn: Promise<T> | (() => Promise<T>),
+  input: TryCatchInput<T>,
 ): Promise<Result<T, E>> {
   try {
-    const data = typeof promiseOrFn === "function" ? await promiseOrFn() : await promiseOrFn;
+    const result = typeof input === "function" ? await input() : await input;
 
-    return [null, data];
+    return [null, result];
   } catch (e) {
     const error = e instanceof Error ? e : new Error(String(e), { cause: e });
     return [error as E, null];