@yuyu0202/rustlikeresult 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026
+
+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

@@ -0,0 +1,53 @@
+# RustLikeResult
+
+Rust-like `Result<T, E>` for TypeScript, with sync/async helpers.
+
+## Install
+
+```bash
+npm install rustlikeresult
+```
+
+## Quick start
+
+```ts
+import { Ok, Err, Result } from "rustlikeresult";
+
+const success = Ok(123);
+const failure = Err(new Error("boom"));
+
+const fromSync = Result.from(() => JSON.parse('{"ok":true}'));
+const fromAsync = await Result.fromAsync(async () => {
+  return 42;
+});
+
+const value = success.unwrapOr(0);
+
+const text = failure.match({
+  ok: (v) => `value=${v}`,
+  err: (e) => `error=${e.message}`,
+});
+```
+
+## API
+
+- `Ok(value?)`: create a success result.
+- `Err(error)`: create a failure result.
+- `Result.from(fn)`: wrap a sync function and catch thrown errors.
+- `Result.fromAsync(fn)`: wrap an async function and catch rejected/thrown errors.
+- `result.unwrap()`: get value or throw stored error.
+- `result.unwrapOr(defaultValue)`: get value or fallback.
+- `result.isOk()` / `result.isErr()`: type guards.
+- `result.match({ ok, err })`: pattern-match style branching.
+
+## Development
+
+```bash
+npm run typecheck
+npm run build
+```
+
+## License
+
+MIT
+

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+import type { ResultAsync, Awaitable } from "./types/index";
+export declare function Ok<T>(): Result<void, never>;
+export declare function Ok<T>(value: T): Result<T, never>;
+export declare function Err<E = Error>(error: E): Result<never, E>;
+export declare class Result<T, E = Error> {
+    static Ok<T>(): Result<void, never>;
+    static Ok<T>(value: T): Result<T, never>;
+    static Err<E = Error>(error: E): Result<never, E>;
+    static fromAsync<T>(fn: () => Awaitable<T>): ResultAsync<T>;
+    static from<T>(fn: () => T): Result<T>;
+    readonly success: boolean;
+    readonly value?: T;
+    readonly error?: E;
+    private constructor();
+    unwrap(): T;
+    unwrapOr(defaultValue: T): T;
+    unwrapOrElse(defaultFn: () => T): T;
+    ok(): T | undefined;
+    err(): E | undefined;
+    isOk(): this is Result<T, E> & {
+        ok: true;
+        value: T;
+    };
+    isErr(): this is Result<T, E> & {
+        ok: false;
+        error: E;
+    };
+    match<U>(handlers: Readonly<{
+        ok: (v: T) => U;
+        err: (e: E) => U;
+    }>): U;
+    map<U>(fn: (v: T) => U): Result<U, E>;
+    mapErr<F>(fn: (e: E) => F): Result<T, F>;
+    andThen<U>(fn: (v: T) => Result<U, E>): Result<U, E>;
+}

package/dist/index.js

@@ -0,0 +1,87 @@
+export function Ok(value) {
+    if (arguments.length === 0) {
+        return Result.Ok();
+    }
+    else {
+        return Result.Ok(value);
+    }
+}
+export function Err(error) {
+    return Result.Err(error);
+}
+export class Result {
+    static Ok(value) {
+        if (arguments.length === 0) {
+            return new Result({ ok: true, value: undefined });
+        }
+        else {
+            return new Result({ ok: true, value: value });
+        }
+    }
+    static Err(error) {
+        return new Result({ ok: false, error });
+    }
+    static async fromAsync(fn) {
+        try {
+            return Result.Ok(await fn());
+        }
+        catch (e) {
+            return Result.Err(e instanceof Error ? e : new Error(String(e)));
+        }
+    }
+    static from(fn) {
+        try {
+            return Result.Ok(fn());
+        }
+        catch (e) {
+            return Result.Err(e instanceof Error ? e : new Error(String(e)));
+        }
+    }
+    constructor(payload) {
+        this.success = payload.ok;
+        if (payload.ok) {
+            this.value = payload.value;
+        }
+        else {
+            this.error = payload.error;
+        }
+    }
+    unwrap() {
+        if (this.success) {
+            return this.value;
+        }
+        throw this.error;
+    }
+    unwrapOr(defaultValue) {
+        return this.isOk() ? this.value : defaultValue;
+    }
+    unwrapOrElse(defaultFn) {
+        return this.isOk() ? this.value : defaultFn();
+    }
+    ok() {
+        return this.isOk() ? this.value : undefined;
+    }
+    err() {
+        return this.isOk() ? undefined : this.error;
+    }
+    isOk() {
+        return this.success;
+    }
+    isErr() {
+        return !this.success;
+    }
+    match(handlers) {
+        return this.isOk()
+            ? handlers.ok(this.value)
+            : handlers.err(this.error);
+    }
+    map(fn) {
+        return this.isOk() ? Result.Ok(fn(this.value)) : Result.Err(this.error);
+    }
+    mapErr(fn) {
+        return this.isErr() ? Result.Err(fn(this.error)) : Result.Ok(this.value);
+    }
+    andThen(fn) {
+        return this.isOk() ? fn(this.value) : Result.Err(this.error);
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from "../index";
+export type Awaitable<T> = T | Promise<T>;
+export type ResultPayload<T, E> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+export type ResultAsync<T, E = Error> = Promise<Result<T, E>>;
+export type AwaitableResult<T, E = Error> = Awaitable<Result<T, E>>;

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@yuyu0202/rustlikeresult",
+  "version": "1.0.0",
+  "description": "Rust-like Result type for TypeScript with sync/async helpers.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "result",
+    "rust",
+    "typescript",
+    "error-handling"
+  ],
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+    "typescript": "^5.5.3",
+    "rimraf": "^6.1.3"
+  },
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}