@mkvlrn/result 5.0.8 → 6.0.1

package/README.md

@@ -2,7 +2,7 @@
 
 Dead simple Result pattern for TypeScript.
 
-No `.map()`, no `.flatMap()`, no `.andThen()`, no `.orElse()`, no `.unwrap()`, no monadic gymnastics. Just a type, two functions, and TypeScript doing what TypeScript already does well.
+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)
 
@@ -10,9 +10,9 @@ No `.map()`, no `.flatMap()`, no `.andThen()`, no `.orElse()`, no `.unwrap()`, n
 
 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.
 
-This package does **one thing**: gives you a type-safe `Result<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.
+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.
 
-**The entire implementation is ~35 lines. Zero runtime dependencies. Four exports.**
+**The entire implementation is ~35 lines. Zero runtime dependencies. Two exports.**
 
 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.
 
@@ -24,61 +24,59 @@ pnpm add @mkvlrn/result
 
 ## API
 
-| Export              | What it does                                 |
-| ------------------- | -------------------------------------------- |
-| `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 |
 
 That's it. That's the whole thing.
 
 ## Usage
 
 ```typescript
-import { type Result, type AsyncResult, ok, err } from "@mkvlrn/result";
+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);
-}
 
-const result = divide(10, 2);
-if (result.isOk) {
-  console.log(result.value); // number - TypeScript knows
+  return ResultSync.ok(a / b);
 }
 
+const result = divide(10, 2);
 if (result.isError) {
   console.log(result.error.message); // Error - TypeScript knows
+} else {
+  console.log(result.value); // number - TypeScript knows
 }
 ```
 
-No `.unwrap()`. No `.expect()`. Just an `if` statement and the compiler handles the rest.
+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"));
   }
 }
 ```
 
-`AsyncResult<T, E>` is just `Promise<Result<T, E>>`. It's a type alias, not a class, not a wrapper, not a monad.
+`ResultAsync<T, E>` is just `Promise<ResultSync<T, E>>`. It's a type alias.
 
 ### Custom Error Types
 
@@ -93,17 +91,18 @@ class ValidationError extends Error {
   }
 }
 
-function validateEmail(email: string): Result<string, ValidationError> {
+function validateEmail(email: string): ResultSync<string, ValidationError> {
   if (!email.includes("@")) {
-    return err(new ValidationError(400, "bad-email"));
+    return ResultSync.err(new ValidationError(400, "bad-email"));
   }
-  return ok(email);
+
+  return ResultSync.ok(email);
 }
 
 const result = validateEmail("invalid-email");
 if (result.isError) {
   // TypeScript knows this is a ValidationError, not just Error
-  console.log(`${result.error.code}: ${result.error.message}`); // 400: bad-email
+  console.log(`${result.error.code}:${result.error.message}`); // 400: bad-email
 }
 ```
 

package/build/index.d.ts

@@ -1,16 +1,23 @@
 //#region src/index.d.ts
-type Result<T, E extends Error> = {
+type SyncResult<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>;
+declare const ok: <T>(value: T) => SyncResult<T, never>;
+declare const err: <E extends Error>(error: E) => SyncResult<never, E>;
+type ResultSync<T, E extends Error> = SyncResult<T, E>;
+declare const ResultSync: {
+  ok: typeof ok;
+  err: typeof err;
+};
+type ResultAsync<T, E extends Error> = Promise<SyncResult<T, E>>;
+declare const ResultAsync: {
+  ok: typeof ok;
+  err: typeof err;
+};
 //#endregion
-export { AsyncResult, Result, err, ok };
+export { ResultAsync, ResultSync };
 //# sourceMappingURL=index.d.ts.map

package/build/index.js

@@ -4,26 +4,48 @@
 * @param value The success value
 * @returns A Result object representing success
 */
-function ok(value) {
-	return {
-		isError: false,
-		isOk: true,
-		value
-	};
-}
+const ok = (value) => ({
+	isError: false,
+	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
-	};
-}
-
+const err = (error) => ({
+	isError: true,
+	error
+});
+const ResultSync = {
+	/**
+	* Creates a successful Result with the given value.
+	* @param value The success value
+	* @returns A Result object representing success
+	*/
+	ok,
+	/**
+	* Creates an error Result with the given error.
+	* @param error The error value
+	* @returns A Result object representing error
+	*/
+	err
+};
+const ResultAsync = {
+	/**
+	* Creates a successful Result with the given value.
+	* @param value The success value
+	* @returns A Result object representing success
+	*/
+	ok,
+	/**
+	* Creates an error Result with the given error.
+	* @param error The error value
+	* @returns A Result object representing error
+	*/
+	err
+};
 //#endregion
-export { err, ok };
+export { ResultAsync, ResultSync };
+
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["type SyncResult<T, E extends Error> =\n  | { readonly isError: false; readonly value: T }\n  | { readonly isError: true; readonly error: 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 */\nconst ok = <T>(value: T): SyncResult<T, never> => ({\n  isError: false,\n  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 */\nconst err = <E extends Error>(error: E): SyncResult<never, E> => ({\n  isError: true,\n  error,\n});\n\n/**\n * Result type to represent the synchronous outcome of an operation.\n * It can either be a success with a value or an error.\n *\n * It is also an object containing the ok and err functions to\n * make it easier to create Result objects.\n */\nexport type ResultSync<T, E extends Error> = SyncResult<T, E>;\n\nexport const ResultSync = {\n  /**\n   * Creates a successful Result with the given value.\n   * @param value The success value\n   * @returns A Result object representing success\n   */\n  ok,\n  /**\n   * Creates an error Result with the given error.\n   * @param error The error value\n   * @returns A Result object representing error\n   */\n  err,\n};\n\n/**\n * Async version of Result type that wraps a Result in a Promise.\n *\n * It is also an object containing the ok and err functions to\n * make it easier to create Result objects for async workflows.\n */\nexport type ResultAsync<T, E extends Error> = Promise<SyncResult<T, E>>;\n\nexport const ResultAsync = {\n  /**\n   * Creates a successful Result with the given value.\n   * @param value The success value\n   * @returns A Result object representing success\n   */\n  ok,\n  /**\n   * Creates an error Result with the given error.\n   * @param error The error value\n   * @returns A Result object representing error\n   */\n  err,\n};\n"],"mappings":";;;;;;AASA,MAAM,MAAS,WAAoC;CACjD,SAAS;CACT;AACF;;;;;;AAOA,MAAM,OAAwB,WAAoC;CAChE,SAAS;CACT;AACF;AAWA,MAAa,aAAa;;;;;;CAMxB;;;;;;CAMA;AACF;AAUA,MAAa,cAAc;;;;;;CAMzB;;;;;;CAMA;AACF"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mkvlrn/result",
   "description": "Simple Result type/pattern for TypeScript",
-  "version": "5.0.8",
+  "version": "6.0.1",
   "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,13 @@
     "default": "./build/index.js"
   },
   "devDependencies": {
-    "@types/node": "^25.3.3",
-    "lint-staged": "^16.3.2",
+    "@types/node": "^26.1.1",
     "tsc-files": "^1.1.4",
-    "tsdown": "0.20.3",
-    "typescript": "6.0.0-beta",
-    "vitest": "^4.0.18"
+    "tsdown": "0.22.14",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   },
   "scripts": {
-    "build": "tsdown",
-    "typecheck": "tsc --noEmit"
+    "build": "tsdown"
   }
 }