docs: update README

Author: thedanchez

README.md

@@ -1,62 +1,70 @@
-<p>
-  <img width="100%" src="https://assets.solidjs.com/banner?type=Ecosystem&background=tiles&project=library-name" alt="solid-create-script">
-</p>
+# @dschz/try-catch
 
-# Template: SolidJS Library
+> A tiny utility to wrap promises or async functions and return a `[error, data]` tuple — no more `try/catch` boilerplate.
 
-Template for [SolidJS](https://www.solidjs.com/) library package. Bundling of the library is managed by [tsup](https://tsup.egoist.dev/).
+## ✨ Features
 
-Other things configured include:
+- ✅ Supports both async functions and raw promises
+- ✅ Catches both **sync and async** errors
+- ✅ Strongly typed result via `Result<T, E>`
+- ✅ Zero dependencies — just TypeScript
 
-- Bun (for dependency management and running scripts)
-- TypeScript
-- ESLint / Prettier
-- Solid Testing Library + Vitest (for testing)
-- Playground app using library
-- GitHub Actions (for all CI/CD)
+## 📆 Installation
 
-## Getting Started
+```bash
+npm install @dschz/try-catch
+pnpm install @dschz/try-catch
+yarn install @dschz/try-catch
+bun install @dschz/try-catch
+```
 
-Some pre-requisites before install dependencies:
+## 🚀 Usage
 
-- Install Node Version Manager (NVM)
-  ```bash
-  curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
-  ```
-- Install Bun
-  ```bash
-  curl -fsSL https://bun.sh/install | bash
-  ```
+```ts
+import { tryCatch } from "@dschz/try-catch";
 
-### Installing Dependencies
+const [err, data] = await tryCatch(fetch("/api/data"));
 
-```bash
-nvm use
-bun install
+if (err) {
+  console.error("Something went wrong:", err);
+} else {
+  console.log("Data:", data);
+}
 ```
 
-### Local Development Build
+You can also pass a function that returns a promise:
 
-```bash
-bun start
+```ts
+const [err, user] = await tryCatch(() => fetchUserById(123));
 ```
 
-### Linting & Formatting
+## 🧠 Types
 
-```bash
-bun run lint    # checks source for lint violations
-bun run format  # checks source for format violations
+```ts
+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>;
+```
+
+The return value is a tuple:
 
-bun run lint:fix    # fixes lint violations
-bun run format:fix  # fixes format violations
+```ts
+[error, data]; // One will always be null
 ```
 
-### Contributing
+## 🧪 Example with Custom Error Types
+
+```ts
+class MyError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "MyError";
+  }
+}
+
+const [err, data] = await tryCatch<MyType, MyError>(() => doSomething());
+```
 
-The only requirements when contributing are:
+## 📄 License
 
-- You keep a clean git history in your branch
-  - rebasing `main` instead of making merge commits.
-- Using proper commit message formats that adhere to [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/)
-  - Additionally, squashing (via rebase) commits that are not [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/)
-- CI checks pass before merging into `main`
+MIT © [@dschz](https://github.com/thedanchez)

package.json

@@ -37,7 +37,7 @@
     "lint:fix": "eslint . --fix",
     "pkg:changeset": "changeset",
     "pkg:version": "changeset version",
-    "pkg:release": "changeset publish",
+    "pkg:publish": "changeset publish",
     "serve": "vite preview",
     "start": "vite",
     "test": "vitest run",

src/__tests__/tryCatch.test.ts

@@ -9,35 +9,35 @@ describe("UTIL FUNCTION: tryCatch", () => {
     expect(data).toBe(42);
   });
 
-  it('handles rejected promises correctly', async () => {
-    const error = new Error('Oops!');
+  it("handles rejected promises correctly", async () => {
+    const error = new Error("Oops!");
     const [err, data] = await tryCatch(Promise.reject(error));
     expect(err).toBeInstanceOf(Error);
-    expect(err?.message).toBe('Oops!');
+    expect(err?.message).toBe("Oops!");
     expect(data).toBeNull();
   });
 
-  it('handles successful async functions', async () => {
-    const [err, data] = await tryCatch(async () => 'done');
+  it("handles successful async functions", async () => {
+    const [err, data] = await tryCatch(async () => "done");
     expect(err).toBeNull();
-    expect(data).toBe('done');
+    expect(data).toBe("done");
   });
 
-  it('handles async functions that throw', async () => {
+  it("handles async functions that throw", async () => {
     const [err, data] = await tryCatch(async () => {
-      throw new TypeError('Bad input');
+      throw new TypeError("Bad input");
     });
     expect(err).toBeInstanceOf(TypeError);
-    expect(err?.message).toBe('Bad input');
+    expect(err?.message).toBe("Bad input");
     expect(data).toBeNull();
   });
 
-  it('wraps non-Error throws into an Error', async () => {
+  it("wraps non-Error throws into an Error", async () => {
     const [err, data] = await tryCatch(async () => {
-      throw 'string error';
+      throw "string error";
     });
     expect(err).toBeInstanceOf(Error);
-    expect(err?.message).toBe('string error');
+    expect(err?.message).toBe("string error");
     expect(data).toBeNull();
   });
 });