resultfier 1.0.0

package/bun.lock

@@ -0,0 +1,30 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "resultfier",
+      "devDependencies": {
+        "@types/bun": "latest",
+        "typescript": "^5.9.2",
+      },
+      "peerDependencies": {
+        "typescript": "^5.9.2",
+      },
+    },
+  },
+  "packages": {
+    "@types/bun": ["@types/bun@1.2.21", "", { "dependencies": { "bun-types": "1.2.21" } }, "sha512-NiDnvEqmbfQ6dmZ3EeUO577s4P5bf4HCTXtI6trMc6f6RzirY5IrF3aIookuSpyslFzrnvv2lmEWv5HyC1X79A=="],
+
+    "@types/node": ["@types/node@24.3.1", "", { "dependencies": { "undici-types": "~7.10.0" } }, "sha512-3vXmQDXy+woz+gnrTvuvNrPzekOi+Ds0ReMxw0LzBiK3a+1k0kQn9f2NWk+lgD4rJehFUmYy2gMhJ2ZI+7YP9g=="],
+
+    "@types/react": ["@types/react@19.1.12", "", { "dependencies": { "csstype": "^3.0.2" } }, "sha512-cMoR+FoAf/Jyq6+Df2/Z41jISvGZZ2eTlnsaJRptmZ76Caldwy1odD4xTr/gNV9VLj0AWgg/nmkevIyUfIIq5w=="],
+
+    "bun-types": ["bun-types@1.2.21", "", { "dependencies": { "@types/node": "*" }, "peerDependencies": { "@types/react": "^19" } }, "sha512-sa2Tj77Ijc/NTLS0/Odjq/qngmEPZfbfnOERi0KRUYhT9R8M4VBioWVmMWE5GrYbKMc+5lVybXygLdibHaqVqw=="],
+
+    "csstype": ["csstype@3.1.3", "", {}, "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw=="],
+
+    "typescript": ["typescript@5.9.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
+
+    "undici-types": ["undici-types@7.10.0", "", {}, "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="],
+  }
+}

package/lib/core/err.ts

@@ -0,0 +1,93 @@
+import { type Result, ResultBase } from "./result";
+
+/**
+ * Represents an error result containing an error value.
+ */
+export class Err<E> extends ResultBase<never, E> {
+  readonly _tag = "err" as const;
+  readonly isOk = false;
+  readonly isErr = true;
+
+  constructor(readonly error: E) {
+    super();
+  }
+
+  /**
+   * Maps the value type, but since this is `Err`, it's a no-op.
+   */
+  map<U>(_fn: (value: never) => U): Err<E> {
+    return this;
+  }
+
+  /**
+   * Maps the contained error using the provided function.
+   * Since this is `Err`, the function is always applied.
+   */
+  mapErr<F>(fn: (error: E) => F): Err<F> {
+    return new Err(fn(this.error));
+  }
+
+  /**
+   * Throws an error since this is `Err`, not `Ok`.
+   */
+  unwrap(): never {
+    throw new Error(`Called unwrap() on an Err value: ${this.error}`);
+  }
+
+  /**
+   * Returns the contained error.
+   */
+  unwrapErr(): E {
+    return this.error;
+  }
+
+  /**
+   * Returns the provided default value since this is `Err`.
+   */
+  unwrapOr<T>(defaultValue: T): T {
+    return defaultValue;
+  }
+
+  /**
+   * Computes and returns the fallback value using the provided function.
+   */
+  unwrapOrElse<T>(fn: (error: E) => T): T {
+    return fn(this.error);
+  }
+
+  /**
+   * Returns this `Err` unchanged since there's no value to chain.
+   */
+  andThen<U>(_fn: (value: never) => Result<U, E>): Err<E> {
+    return this;
+  }
+
+  /**
+   * Always returns false since this is `Err`, not `Ok`.
+   */
+  contains(_value: never): boolean {
+    return false;
+  }
+
+  /**
+   * Checks if the contained error matches the provided error.
+   */
+  containsErr(error: E): boolean {
+    return this.error === error;
+  }
+}
+
+/**
+ * Creates a new `Err` result with the given error.
+ */
+export function err<E>(error: E): Err<E> {
+  return new Err(error);
+}
+
+/**
+ * Type guard to check if a result is `Err`.
+ * @deprecated use `.isErr` instead
+ */
+export function isErr<T, E>(result: Result<T, E>): result is Err<E> {
+  return result.isErr;
+}

package/lib/core/index.ts

@@ -0,0 +1,3 @@
+export { err, isErr, Err } from "./err";
+export { ok, isOk, Ok } from "./ok";
+export type { Result, AsyncResult } from "./result";

package/lib/core/ok.ts

@@ -0,0 +1,93 @@
+import { type Result, ResultBase } from "./result";
+
+/**
+ * Represents a successful result containing a value.
+ */
+export class Ok<T> extends ResultBase<T, never> {
+  readonly _tag = "ok" as const;
+  readonly isOk = true;
+  readonly isErr = false;
+
+  constructor(readonly value: T) {
+    super();
+  }
+
+  /**
+   * Maps the contained value using the provided function.
+   * Since this is `Ok`, the function is always applied.
+   */
+  map<U>(fn: (value: T) => U): Ok<U> {
+    return new Ok(fn(this.value));
+  }
+
+  /**
+   * Maps the error type, but since this is `Ok`, it's a no-op.
+   */
+  mapErr<F>(_fn: (error: never) => F): Ok<T> {
+    return this;
+  }
+
+  /**
+   * Returns the contained value.
+   */
+  unwrap(): T {
+    return this.value;
+  }
+
+  /**
+   * Throws an error since this is Ok, not Err.
+   */
+  unwrapErr(): never {
+    throw new Error(`Called unwrapErr() on an Ok value: ${this.value}`);
+  }
+
+  /**
+   * Returns the contained value, ignoring the default.
+   */
+  unwrapOr(_defaultValue: T): T {
+    return this.value;
+  }
+
+  /**
+   * Returns the contained value, ignoring the fallback function.
+   */
+  unwrapOrElse(_fn: (error: never) => T): T {
+    return this.value;
+  }
+
+  /**
+   * Applies the function to the contained value and returns the result.
+   */
+  andThen<U>(fn: (value: T) => Result<U, never>): Result<U, never> {
+    return fn(this.value);
+  }
+
+  /**
+   * Checks if the contained value matches the provided value.
+   */
+  contains(value: T): boolean {
+    return this.value === value;
+  }
+
+  /**
+   * Always returns false since this is `Ok`, not `Err`.
+   */
+   override containsErr(_error: never): false {
+    return false;
+  }
+}
+
+/**
+ * Creates a new `Ok` result with the given value.
+ */
+export function ok<T>(value: T): Ok<T> {
+  return new Ok(value);
+}
+
+/**
+ * Type guard to check if a result is `Ok`.
+ * @deprecated use `.isOk` instead
+ */
+export function isOk<T, E>(result: Result<T, E>): result is Ok<T> {
+  return result.isOk;
+}

package/lib/core/result.ts

@@ -0,0 +1,78 @@
+import type { Err } from "./err";
+import type { Ok } from "./ok";
+
+/**
+ * Represents a Result type that can either be a success (`Ok`) or an error (`Err`).
+ * This is an abstract base class that provides common functionality for both variants.
+ */
+export abstract class ResultBase<T, E> {
+  /**
+   * Type guard to check if the result is an `Ok` variant.
+   */
+  abstract readonly isOk: boolean;
+
+  /**
+   * Type guard to check if the result is an `Err` variant.
+   */
+  abstract readonly isErr: boolean;
+
+  /**
+   * Maps a `Result<T, E>` to `Result<U, E>` by applying a function to a contained `Ok` value,
+   * leaving an `Err` value untouched.
+   */
+  abstract map<U>(fn: (value: T) => U): Result<U, E>;
+
+  /**
+   * Maps a `Result<T, E>` to `Result<T, F>` by applying a function to a contained `Err` value,
+   * leaving an `Ok` value untouched.
+   */
+  abstract mapErr<F>(fn: (error: E) => F): Result<T, F>;
+
+  /**
+   * Returns the contained `Ok` value, consuming the self value.
+   * Throws an error if the result is `Err`.
+   */
+  abstract unwrap(): T;
+
+  /**
+   * Returns the contained `Err` value, consuming the self value.
+   * Throws an error if the result is Ok.
+   */
+  abstract unwrapErr(): E;
+
+  /**
+   * Returns the contained `Ok` value or a provided default.
+   */
+  abstract unwrapOr(defaultValue: T): T;
+
+  /**
+   * Returns the contained `Ok` value or computes it from a closure.
+   */
+  abstract unwrapOrElse(fn: (error: E) => T): T;
+
+  /**
+   * Calls the provided function with the contained value and returns the result.
+   * If the result is `Err`, the function is not called and the `Err` is returned.
+   */
+  abstract andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
+
+  /**
+   * Returns true if the result is `Ok` and the value inside of it matches a predicate.
+   */
+  abstract contains(value: T): boolean;
+
+  /**
+   * Returns true if the result is `Err` and the error inside of it matches a predicate.
+   */
+  abstract containsErr(error: E): boolean;
+}
+
+/**
+ * Type alias for a `Result` that can be either `Ok<T>` or `Err<E>`.
+ */
+export type Result<T, E> = Ok<T> | Err<E>;
+
+/**
+ * Type alias for an async `Result` (Promise-wrapped `Result`).
+ */
+export type AsyncResult<T, E> = Promise<Result<T, E>>;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "resultfier",
+  "version": "1.0.0",
+  "description": "A TypeScript implementation of Rust-like Result type for better error handling",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "bun run build"
+  },
+  "author": "Vitor Koch <vitorgabrielkoch@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vitorkoch/resultfier.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vitorkoch/resultfier/issues"
+  },
+  "homepage": "https://github.com/vitorkoch/resultfier#readme",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.9.2"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+  "compilerOptions": {
+    // Output configuration for npm publishing
+    "outDir": "./out",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "rootDir": "lib/",
+    
+    // Module system
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+
+    // Type checking
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    // Additional checks
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+
+    // Library
+    "lib": ["ES2020"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "out"]
+}