try-ok 0.1.0

package/README.md

@@ -0,0 +1,119 @@
+# try-ok
+
+**Predictable, type-safe error handling for TypeScript.**
+Stop throwing. Start returning.
+
+## Motivation (Why I built this)
+
+In my projects, I noticed that `try-catch` was creating more problems than it solved.
+
+As our codebase grew, we faced the same issues repeatedly:
+
+  * Inside `catch(e)`, the error is always `unknown`, so TypeScript can't help us.
+  * `throw` breaks the control flow, making logic hard to follow.
+  * It's easy to forget error handling when it's hidden in a `catch` block.
+
+I wanted a way to write safer code without introducing a heavy framework. I needed something simple that treats errors as **values**, just like in Go or Rust.
+
+That's why I created `try-ok`—to fix these habits with a tiny, zero-dependency tool.
+
+## Installation
+
+```bash
+npm install @sangun-kang/try-ok
+```
+
+## How to use
+
+### The Problem (`try-catch`)
+
+Using `try-catch` often leads to nested code and loose typing:
+
+```ts
+try {
+  const data = await fetch("/api/user").then(r => r.json());
+  // ...logic
+} catch (error) {
+  // ❌ What is 'error'? We don't know.
+  // ❌ strict typing is lost here.
+  console.error(error);
+}
+```
+
+### The Solution (`try-ok`)
+
+With `try-ok`, you handle errors explicitly as return values:
+
+```ts
+import { tryResult } from "@sangun-kang/try-ok";
+
+const result = await tryResult(fetch("/api/user").then(r => r.json()));
+
+// 1. Handle Error First (Type Guard)
+if (result.isError) {
+  console.error(result.error); // Typed as unknown (or your custom type)
+  return;
+}
+
+// 2. Safe to proceed
+// 'result.data' is now guaranteed to be valid
+console.log(result.data);
+```
+
+`try-ok` works well inside React components, especially when calling an existing async function:
+
+```tsx
+import { tryResult } from "@sangun-kang/try-ok";
+
+export default async function Page() {
+  const result = await tryResult(getData());
+
+  if (result.isError) {
+    return <div>Oops!</div>;
+  }
+
+  return <div>I'm so happy</div>;
+}
+```
+
+-----
+
+## Types
+
+The implementation is minimal. No magic.
+
+```ts
+export type Ok<T> = { isError: false; data: T };
+export type Err<E> = { isError: true; error: E };
+export type Result<T, E = unknown> = Ok<T> | Err<E>;
+```
+
+## Custom Error Types
+
+You can strictly type your errors if needed:
+
+```ts
+type ApiError = { status: number; message: string };
+
+const result = await tryResult<User, ApiError>(getUser());
+
+if (result.isError) {
+  // TypeScript knows this is ApiError
+  console.log(result.error.status);
+}
+```
+
+## Why another library?
+
+I actually found a lot of similar OSS!
+Seems like developers everywhere have had the same idea haha.
+
+Still, try-result has a slightly different goal:
+it focuses on stronger type safety and explicit error handling using a clean Result pattern.
+
+If you prefer predictable control flow and safer TypeScript,
+this library might fit your style. 😊
+
+-----
+
+MIT

package/dist/try-ok.cjs

@@ -0,0 +1 @@
+'use strict';var o=r=>({isError:false,data:r}),e=r=>({isError:true,error:r});async function s(r){try{let t=await r;return o(t)}catch(t){return e(t)}}exports.tryOk=s;

package/dist/try-ok.d.cts

@@ -0,0 +1,13 @@
+type Ok<T> = {
+    isError: false;
+    data: T;
+};
+type Err<E = unknown> = {
+    isError: true;
+    error: E;
+};
+type Result<T, E = unknown> = Ok<T> | Err<E>;
+
+declare function tryOk<T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>>;
+
+export { type Err, type Ok, type Result, tryOk };

package/dist/try-ok.d.ts

@@ -0,0 +1,13 @@
+type Ok<T> = {
+    isError: false;
+    data: T;
+};
+type Err<E = unknown> = {
+    isError: true;
+    error: E;
+};
+type Result<T, E = unknown> = Ok<T> | Err<E>;
+
+declare function tryOk<T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>>;
+
+export { type Err, type Ok, type Result, tryOk };

package/dist/try-ok.js

@@ -0,0 +1 @@
+var o=r=>({isError:false,data:r}),e=r=>({isError:true,error:r});async function s(r){try{let t=await r;return o(t)}catch(t){return e(t)}}export{s as tryOk};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "try-ok",
+  "version": "0.1.0",
+  "description": "Type-safe error handling for async operations using Result pattern",
+  "type": "module",
+  "main": "./dist/try-ok.cjs",
+  "module": "./dist/try-ok.js",
+  "types": "./dist/try-ok.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/try-ok.d.ts",
+      "import": "./dist/try-ok.js",
+      "require": "./dist/try-ok.cjs"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.2",
+    "tsup": "^8.0.0",
+    "vitest": "^1.0.0"
+  },
+  "author": {
+    "name": "Sangun Kang",
+    "email": "sangun950@gmail.com"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=14.16"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sangun-kang/try-ok.git"
+  },
+  "keywords": [
+    "typescript",
+    "error-handling",
+    "result",
+    "type-safe",
+    "async",
+    "promise"
+  ]
+}