try-ok 0.1.2 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2025 Sangun Kang <sangun950@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -20,86 +20,77 @@ That's why I created `try-ok`—to fix these habits with a tiny, zero-dependency
 ## Installation
 
 ```bash
-npm install @sangun-kang/try-ok
+npm install 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:
+## Quick Start
 
 ```ts
-import { tryOk } from "@sangun-kang/try-ok";
+import { tryOk } from "try-ok";
 
 const result = await tryOk(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)
+  console.error(result.error);
   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:
+## API
+
+### `tryOk(promise)` — Async
+
+```ts
+const result = await tryOk(fetchUser());
+```
+
+### `tryOkSync(fn)` — Sync
+
+```ts
+const result = tryOkSync(() => JSON.parse(jsonString));
+```
 
-```tsx
-import { tryOk } from "@sangun-kang/try-ok";
+### `unwrap(result, fallback)`
 
-export default async function Page() {
-  const result = await tryOk(getData());
+```ts
+const user = unwrap(result, defaultUser);  // Returns data or fallback
+```
 
-  if (result.isError) {
-    return <div>Oops!</div>;
-  }
+### `ok(data)` / `err(error)` — Create Result directly
 
-  return <div>I'm so happy</div>;
+```ts
+function divide(a: number, b: number): Result<number, string> {
+  if (b === 0) return err("Division by zero");
+  return ok(a / b);
 }
 ```
 
------
+### `isOk(result)` / `isErr(result)` — Type Guards
 
-## Types
+```ts
+if (isOk(result)) { /* result.data available */ }
+if (isErr(result)) { /* result.error available */ }
+```
 
-The implementation is minimal. No magic.
+## Types
 
 ```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>;
+type Ok<T> = { isError: false; data: T };
+type Err<E> = { isError: true; error: E };
+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 tryOk<User, ApiError>(getUser());
 
 if (result.isError) {
-  // TypeScript knows this is ApiError
-  console.log(result.error.status);
+  console.log(result.error.status);  // TypeScript knows this is ApiError
 }
 ```
 
@@ -112,8 +103,8 @@ Still, try-ok 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. 😊
+this library might fit your style.
 
------
+---
 
 MIT

package/dist/try-ok.cjs

@@ -1 +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;
+'use strict';var o=r=>({isError:false,data:r}),e=r=>({isError:true,error:r}),s=r=>!r.isError,E=r=>r.isError,n=(r,t)=>r.isError?t:r.data;async function p(r){try{let t=await r;return o(t)}catch(t){return e(t)}}function T(r){try{let t=r();return o(t)}catch(t){return e(t)}}exports.err=e;exports.isErr=E;exports.isOk=s;exports.ok=o;exports.tryOk=p;exports.tryOkSync=T;exports.unwrap=n;

package/dist/try-ok.d.cts

@@ -7,7 +7,13 @@ type Err<E = unknown> = {
     error: E;
 };
 type Result<T, E = unknown> = Ok<T> | Err<E>;
+declare const ok: <T>(data: T) => Ok<T>;
+declare const err: <E>(error: E) => Err<E>;
+declare const isOk: <T, E>(r: Result<T, E>) => r is Ok<T>;
+declare const isErr: <T, E>(r: Result<T, E>) => r is Err<E>;
+declare const unwrap: <T, E, F = T>(result: Result<T, E>, fallback: F) => T | F;
 
 declare function tryOk<T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>>;
+declare function tryOkSync<T, E = unknown>(fn: () => T): Result<T, E>;
 
-export { type Err, type Ok, type Result, tryOk };
+export { type Err, type Ok, type Result, err, isErr, isOk, ok, tryOk, tryOkSync, unwrap };

package/dist/try-ok.d.ts

@@ -7,7 +7,13 @@ type Err<E = unknown> = {
     error: E;
 };
 type Result<T, E = unknown> = Ok<T> | Err<E>;
+declare const ok: <T>(data: T) => Ok<T>;
+declare const err: <E>(error: E) => Err<E>;
+declare const isOk: <T, E>(r: Result<T, E>) => r is Ok<T>;
+declare const isErr: <T, E>(r: Result<T, E>) => r is Err<E>;
+declare const unwrap: <T, E, F = T>(result: Result<T, E>, fallback: F) => T | F;
 
 declare function tryOk<T, E = unknown>(promise: Promise<T>): Promise<Result<T, E>>;
+declare function tryOkSync<T, E = unknown>(fn: () => T): Result<T, E>;
 
-export { type Err, type Ok, type Result, tryOk };
+export { type Err, type Ok, type Result, err, isErr, isOk, ok, tryOk, tryOkSync, unwrap };

package/dist/try-ok.js

@@ -1 +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};
+var o=r=>({isError:false,data:r}),e=r=>({isError:true,error:r}),s=r=>!r.isError,E=r=>r.isError,n=(r,t)=>r.isError?t:r.data;async function p(r){try{let t=await r;return o(t)}catch(t){return e(t)}}function T(r){try{let t=r();return o(t)}catch(t){return e(t)}}export{e as err,E as isErr,s as isOk,o as ok,p as tryOk,T as tryOkSync,n as unwrap};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "try-ok",
-  "version": "0.1.2",
-  "description": "Type-safe error handling for async operations using Result pattern",
+  "version": "0.2.0",
+  "description": "Type-safe error handling for async and sync operations using Result pattern",
   "type": "module",
   "main": "./dist/try-ok.cjs",
   "module": "./dist/try-ok.js",
@@ -10,7 +10,8 @@
     ".": {
       "types": "./dist/try-ok.d.ts",
       "import": "./dist/try-ok.js",
-      "require": "./dist/try-ok.cjs"
+      "require": "./dist/try-ok.cjs",
+      "default": "./dist/try-ok.js"
     }
   },
   "files": ["dist"],
@@ -43,6 +44,7 @@
     "result",
     "type-safe",
     "async",
+    "sync",
     "promise"
   ]
 }