@mkvlrn/result 5.0.7 → 6.0.0

package/README.md

@@ -1,102 +1,108 @@
 # @mkvlrn/result
 
-Type-safe Result pattern for TypeScript representing success or error. Anything to avoid try/catch hell.
+Dead simple Result pattern for TypeScript.
+
+No `.map()`, no `.flatMap()`, no `.andThen()`, no `.orElse()`, no `.unwrap()`, no monadic gymnastics. Just two types with two functions. Then TypeScript does its thing.
 
 [![npm](https://img.shields.io/npm/v/@mkvlrn/result)](https://www.npmjs.com/package/@mkvlrn/result)
 
-## Installation
+## Why this one?
 
-```bash
-pnpm add @mkvlrn/result
-```
+There are dozens of Result libraries for TypeScript. Nearly all of them bolt on method chaining, transformation pipelines, and functional programming utilities that turn a simple concept into an entire paradigm.
 
-## Usage
+This package does **one thing**: gives you a type-safe `ResultSync<T, E>` or `ResultAsync<T, E>` discriminated union with `ok()` and `err()` constructors. You use `if/else` to handle it. TypeScript narrows the type for you. That's the whole API.
 
-```typescript
-import { Result, AsyncResult, ok, err } from "@mkvlrn/result";
+**The entire implementation is ~35 lines. Zero runtime dependencies. Two exports.**
 
-// Success
-const success = ok(42);
+If you need `.map().flatMap().andThen().orElse().unwrapOr()` chains, use [neverthrow](https://github.com/supermacro/neverthrow) or [ts-results](https://github.com/vultix/ts-results). They're good libraries. This isn't that.
 
-// Error
-const failure = err(new Error("Something went wrong"));
+## Installation
 
-// Check result
-const result = ok(42);
-if (result.isError) {
-  console.log("Error:", result.error.message);
-} else {
-  console.log("Value:", result.value);
-}
+```bash
+pnpm add @mkvlrn/result
 ```
 
 ## API
 
-| Export              | Description                                  |
-| ------------------- | -------------------------------------------- |
-| `Result<T, E>`      | Union type representing success or failure   |
-| `AsyncResult<T, E>` | `Promise<Result<T, E>>` for async operations |
-| `ok(value)`         | Creates a success result                     |
-| `err(error)`        | Creates an error result                      |
+| Export              | What it does                                |
+| ------------------- | ------------------------------------------- |
+| `ResultSync<T, E>`  | Sync Result type and `{ ok, err }` helpers  |
+| `ResultAsync<T, E>` | Async Result type and `{ ok, err }` helpers |
 
-## Examples
+That's it. That's the whole thing.
 
-### Basic Function
+## Usage
+
+```typescript
+import { ResultSync, ResultAsync } from "@mkvlrn/result";
+```
+
+### Create results, check results
 
 ```typescript
-function divide(a: number, b: number): Result<number, Error> {
+function divide(a: number, b: number): ResultSync<number, Error> {
   if (b === 0) {
-    return err(new Error("Division by zero"));
+    return ResultSync.err(new Error("Division by zero"));
   }
-  return ok(a / b);
+
+  return ResultSync.ok(a / b);
 }
 
 const result = divide(10, 2);
-if (result.isOk) {
-  console.log(result.value); // 5
+if (result.isError) {
+  console.log(result.error.message); // Error - TypeScript knows
+} else {
+  console.log(result.value); // number - TypeScript knows
 }
 ```
 
+No `.unwrap()`, no `.expect()`, no other dozens of functions. You just use an `if` statement and the compiler handles the rest.
+
 ### Async Operations
 
 ```typescript
-async function fetchUser(id: number): AsyncResult<User, Error> {
+async function fetchUser(id: number): ResultAsync<User, Error> {
   try {
     const response = await fetch(`/api/users/${id}`);
     if (!response.ok) {
-      return err(new Error(`HTTP ${response.status}`));
+      return ResultAsync.err(new Error(`HTTP ${response.status}`));
     }
     const user = await response.json();
-    return ok(user);
+
+    return ResultAsync.ok(user);
   } catch (error) {
-    return err(error instanceof Error ? error : new Error("Unknown error"));
+    return ResultAsync.err(error instanceof Error ? error : new Error("Unknown error"));
   }
 }
 ```
 
+`ResultAsync<T, E>` is just `Promise<ResultSync<T, E>>`. It's a type alias.
+
 ### Custom Error Types
 
 ```typescript
 class ValidationError extends Error {
-  readonly customField: number;
+  readonly code: number;
 
-  constructor(customField: number, message: string) {
+  constructor(code: number, message: string) {
     super(message);
     this.name = "ValidationError";
-    this.customField = customField;
+    this.code = code;
   }
 }
 
-function validateEmail(email: string): Result<string, ValidationError> {
+function validateEmail(email: string): ResultSync<string, ValidationError> {
   if (!email.includes("@")) {
-    return err(new ValidationError(400, "custom"));
+    return ResultSync.err(new ValidationError(400, "bad-email"));
   }
-  return ok(email);
+
+  return ResultSync.ok(email);
 }
 
 const result = validateEmail("invalid-email");
 if (result.isError) {
-  console.log(`${result.error.customField}: ${result.error.message}`);
+  // TypeScript knows this is a ValidationError, not just Error
+  console.log(`${result.error.code}:${result.error.message}`); // 400: bad-email
 }
 ```
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mkvlrn/result",
   "description": "Simple Result type/pattern for TypeScript",
-  "version": "5.0.7",
+  "version": "6.0.0",
   "license": "MIT",
   "type": "module",
   "author": "Mike Valeriano <mkvlrn@gmail.com>",
@@ -9,6 +9,10 @@
     "type": "git",
     "url": "git@github.com:mkvlrn/tools"
   },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "keywords": [
     "node",
     "typescript",
@@ -25,15 +29,10 @@
     "default": "./build/index.js"
   },
   "devDependencies": {
-    "@types/node": "^25.2.3",
-    "lint-staged": "^16.2.7",
+    "@types/node": "^26.1.1",
     "tsc-files": "^1.1.4",
-    "tsdown": "0.20.3",
-    "typescript": "6.0.0-beta",
-    "vitest": "^4.0.18"
-  },
-  "scripts": {
-    "build": "tsdown",
-    "typecheck": "tsc --noEmit"
+    "tsdown": "0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   }
 }

package/build/index.d.ts

@@ -1,16 +0,0 @@
-//#region src/index.d.ts
-type Result<T, E extends Error> = {
-  readonly isError: false;
-  readonly isOk: true;
-  readonly value: T;
-} | {
-  readonly isError: true;
-  readonly isOk: false;
-  readonly error: E;
-};
-type AsyncResult<T, E extends Error> = Promise<Result<T, E>>;
-declare function ok<T>(value: T): Result<T, never>;
-declare function err<E extends Error>(error: E): Result<never, E>;
-//#endregion
-export { AsyncResult, Result, err, ok };
-//# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -1,29 +0,0 @@
-//#region src/index.ts
-/**
-* Creates a successful Result with the given value.
-* @param value The success value
-* @returns A Result object representing success
-*/
-function ok(value) {
-	return {
-		isError: false,
-		isOk: true,
-		value
-	};
-}
-/**
-* Creates an error Result with the given error.
-* @param error The error value
-* @returns A Result object representing error
-*/
-function err(error) {
-	return {
-		isError: true,
-		isOk: false,
-		error
-	};
-}
-
-//#endregion
-export { err, ok };
-//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * Result type to represent the outcome of an operation.\n * It can either be a success with a value or an error.\n * This is a generic type that can be used with any type of value and error (should extend Error).\n *\n * It is also an alias object containing the ok and error functions to\n * make it easier to create Result objects.\n */\nexport type Result<T, E extends Error> =\n  | { readonly isError: false; readonly isOk: true; readonly value: T }\n  | { readonly isError: true; readonly isOk: false; readonly error: E };\n\n/**\n * Async version of Result type that wraps a Result in a Promise.\n */\nexport type AsyncResult<T, E extends Error> = Promise<Result<T, E>>;\n\n/**\n * Creates a successful Result with the given value.\n * @param value The success value\n * @returns A Result object representing success\n */\nexport function ok<T>(value: T): Result<T, never> {\n  return { isError: false, isOk: true, value };\n}\n\n/**\n * Creates an error Result with the given error.\n * @param error The error value\n * @returns A Result object representing error\n */\nexport function err<E extends Error>(error: E): Result<never, E> {\n  return { isError: true, isOk: false, error };\n}\n"],"mappings":";;;;;;AAsBA,SAAgB,GAAM,OAA4B;AAChD,QAAO;EAAE,SAAS;EAAO,MAAM;EAAM;EAAO;;;;;;;AAQ9C,SAAgB,IAAqB,OAA4B;AAC/D,QAAO;EAAE,SAAS;EAAM,MAAM;EAAO;EAAO"}