galvorn 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 axelhamil
+
+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,155 @@
+# galvorn
+
+Rust's `Option` and `Result` for TypeScript. Fully typed, tested, zero dependencies.
+
+```bash
+pnpm add galvorn
+```
+
+## Why
+
+TypeScript lacks a standard way to represent optional values and fallible operations without `null`, `undefined`, or `try/catch`. Galvorn brings Rust's algebraic types to TypeScript with an idiomatic API and complete type safety.
+
+- **Option\<T\>** replaces `T | null | undefined`
+- **Result\<T, E\>** replaces `try/catch` and `{ data, error }` patterns
+- **match()** provides exhaustive pattern matching for both types
+- 100% test coverage, 112 tests, zero runtime dependencies
+
+## Usage
+
+### Option
+
+```typescript
+import { Some, None, Option } from 'galvorn';
+
+const name = Some('Alice');
+const empty = None<string>();
+
+// Transform
+const upper = name.map((n) => n.toUpperCase()); // Some("ALICE")
+
+// Chain
+const first = name.flatMap((n) => (n.length > 0 ? Some(n[0]) : None()));
+
+// Extract
+const value = empty.unwrapOr('default'); // "default"
+
+// Pattern match
+name.match({
+  Some: (n) => console.log(`Hello, ${n}`),
+  None: () => console.log('No name'),
+});
+
+// Convert from nullable
+const opt = Option.fromNullable(document.getElementById('app'));
+```
+
+#### Option API
+
+| Method | Description |
+|---|---|
+| `isSome()` | Returns `true` if the option contains a value |
+| `isNone()` | Returns `true` if the option is empty |
+| `unwrap()` | Returns the value or throws |
+| `expect(msg)` | Returns the value or throws with a custom message |
+| `unwrapOr(default)` | Returns the value or a default |
+| `unwrapOrElse(fn)` | Returns the value or computes a default |
+| `map(fn)` | Transforms the inner value |
+| `flatMap(fn)` | Transforms and flattens `Option<Option<U>>` |
+| `filter(predicate)` | Returns `None` if the predicate fails |
+| `and(other)` | Returns `other` if both are `Some`, otherwise `None` |
+| `or(other)` | Returns `self` if `Some`, otherwise `other` |
+| `orElse(fn)` | Returns `self` if `Some`, otherwise calls `fn` |
+| `xor(other)` | Returns `Some` if exactly one is `Some` |
+| `zip(other)` | Combines two `Some` values into a tuple |
+| `inspect(fn)` | Calls `fn` on the value without consuming it |
+| `match({ Some, None })` | Exhaustive pattern matching |
+| `toUndefined()` | Converts to `T \| undefined` |
+| `toNull()` | Converts to `T \| null` |
+| `Option.fromNullable(v)` | Creates `Some(v)` or `None` from a nullable value |
+
+### Result
+
+```typescript
+import { Ok, Fail, Result } from 'galvorn';
+
+const success = Ok(42);
+const failure = Fail('something went wrong');
+
+// Transform
+const doubled = success.map((n) => n * 2); // Ok(84)
+
+// Chain
+const parsed = Ok('42').flatMap((s) => {
+  const n = Number(s);
+  return Number.isNaN(n) ? Fail('not a number') : Ok(n);
+});
+
+// Extract
+const value = failure.unwrapOr(0); // 0
+
+// Pattern match
+parsed.match({
+  Ok: (n) => console.log(`Parsed: ${n}`),
+  Err: (e) => console.error(`Error: ${e}`),
+});
+
+// Catch exceptions
+const result = Result.fromThrowable(() => JSON.parse(input));
+
+// Combine multiple results
+const combined = Result.combine([Ok(1), Ok(2), Ok(3)]); // Ok([1, 2, 3])
+```
+
+#### Result API
+
+| Method | Description |
+|---|---|
+| `isOk()` | Returns `true` if the result is `Ok` |
+| `isErr()` | Returns `true` if the result is `Err` |
+| `unwrap()` | Returns the value or throws |
+| `unwrapErr()` | Returns the error or throws |
+| `expect(msg)` | Returns the value or throws with a custom message |
+| `expectErr(msg)` | Returns the error or throws with a custom message |
+| `unwrapOr(default)` | Returns the value or a default |
+| `unwrapOrElse(fn)` | Returns the value or computes from the error |
+| `map(fn)` | Transforms the `Ok` value |
+| `mapErr(fn)` | Transforms the `Err` value |
+| `mapOr(default, fn)` | Transforms `Ok` or returns a default |
+| `mapOrElse(errFn, okFn)` | Transforms both branches |
+| `flatMap(fn)` | Transforms and flattens `Result<Result<U, E>, E>` |
+| `and(other)` | Returns `other` if both are `Ok`, otherwise the first `Err` |
+| `or(other)` | Returns `self` if `Ok`, otherwise `other` |
+| `orElse(fn)` | Returns `self` if `Ok`, otherwise calls `fn` with the error |
+| `inspect(fn)` | Calls `fn` on the `Ok` value without consuming it |
+| `inspectErr(fn)` | Calls `fn` on the `Err` value without consuming it |
+| `match({ Ok, Err })` | Exhaustive pattern matching |
+| `Result.fromThrowable(fn)` | Wraps a throwing function into `Result<T, Error>` |
+| `Result.combine(results)` | Collects an array of results into `Result<T[], E>` |
+
+### Standalone match
+
+```typescript
+import { match, Some, Ok } from 'galvorn';
+
+// Works with both Option and Result
+const msg = match(Some(42), {
+  Some: (v) => `got ${v}`,
+  None: () => 'nothing',
+});
+
+const status = match(Ok(200), {
+  Ok: (code) => `status ${code}`,
+  Err: (e) => `failed: ${e}`,
+});
+```
+
+## Compatibility
+
+- Node.js >= 20
+- TypeScript >= 5.0
+- ESM only
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,331 @@
+//#region src/option.d.ts
+/**
+ * Represents an optional value: either `Some(value)` or `None`.
+ *
+ * Use {@link Some} and {@link None} factory functions to create instances.
+ *
+ * @typeParam T - The type of the contained value.
+ *
+ * @example
+ * ```ts
+ * const name = Some('Alice');
+ * const greeting = name.map(n => `Hello, ${n}`).unwrapOr('Hello, stranger');
+ * ```
+ */
+declare abstract class Option<T> {
+  /** Returns `true` if the option contains a value. */
+  abstract isSome(): boolean;
+  /** Returns `true` if the option is empty. */
+  abstract isNone(): boolean;
+  /**
+   * Returns the contained value.
+   * @throws If the option is `None`.
+   */
+  abstract unwrap(): T;
+  /**
+   * Returns the contained value.
+   * @param msg - Error message to throw if the option is `None`.
+   * @throws With `msg` if the option is `None`.
+   */
+  abstract expect(msg: string): T;
+  /**
+   * Returns the contained value, or `defaultValue` if `None`.
+   * @param defaultValue - Value to return if `None`.
+   */
+  abstract unwrapOr(defaultValue: T): T;
+  /**
+   * Returns the contained value, or computes it from `f` if `None`.
+   * @param f - Function to compute the default value.
+   */
+  abstract unwrapOrElse(f: () => T): T;
+  /**
+   * Transforms the contained value by applying `f`.
+   * Returns `None` if the option is `None`.
+   * @param f - Function to apply to the value.
+   */
+  abstract map<U>(f: (value: T) => U): Option<U>;
+  /**
+   * Transforms the contained value by applying `f`, which itself returns an `Option`.
+   * Flattens the result (avoids `Option<Option<U>>`).
+   * @param f - Function returning an `Option`.
+   */
+  abstract flatMap<U>(f: (value: T) => Option<U>): Option<U>;
+  /**
+   * Returns `None` if the option is `None` or the predicate returns `false`.
+   * @param predicate - Function to test the contained value.
+   */
+  abstract filter(predicate: (value: T) => boolean): Option<T>;
+  /**
+   * Returns `None` if this option is `None`, otherwise returns `optb`.
+   * @param optb - The other option.
+   */
+  abstract and<U>(optb: Option<U>): Option<U>;
+  /**
+   * Returns this option if it is `Some`, otherwise returns `optb`.
+   * @param optb - Fallback option.
+   */
+  abstract or(optb: Option<T>): Option<T>;
+  /**
+   * Returns this option if it is `Some`, otherwise calls `f` and returns the result.
+   * @param f - Function producing the fallback option.
+   */
+  abstract orElse(f: () => Option<T>): Option<T>;
+  /**
+   * Returns `Some` if exactly one of `this` and `optb` is `Some`, otherwise `None`.
+   * @param optb - The other option.
+   */
+  abstract xor(optb: Option<T>): Option<T>;
+  /**
+   * Zips this option with another. Returns `Some([a, b])` if both are `Some`, otherwise `None`.
+   * @param other - The other option to zip with.
+   */
+  abstract zip<U>(other: Option<U>): Option<[T, U]>;
+  /**
+   * Calls `f` with the contained value if `Some`, then returns `this` unchanged.
+   * Useful for side effects in a chain.
+   * @param f - Function to call with the value.
+   */
+  abstract inspect(f: (value: T) => void): Option<T>;
+  /**
+   * Exhaustive pattern matching on the option.
+   * @param patterns - Object with `Some` and `None` handlers.
+   *
+   * @example
+   * ```ts
+   * Some(42).match({
+   *   Some: v => `got ${v}`,
+   *   None: () => 'nothing',
+   * });
+   * ```
+   */
+  abstract match<U>(patterns: {
+    Some: (value: T) => U;
+    None: () => U;
+  }): U;
+  /** Converts to `T | undefined`. Returns `undefined` if `None`. */
+  abstract toUndefined(): T | undefined;
+  /** Converts to `T | null`. Returns `null` if `None`. */
+  abstract toNull(): T | null;
+  /**
+   * Creates an `Option` from a nullable value.
+   * Returns `Some(value)` if non-null/undefined, otherwise `None`.
+   * @param value - A possibly null or undefined value.
+   */
+  static fromNullable<T>(value: T | null | undefined): Option<T>;
+}
+/**
+ * Creates an `Option` containing a value.
+ * @param value - The value to wrap.
+ *
+ * @example
+ * ```ts
+ * const opt = Some(42);
+ * opt.unwrap(); // 42
+ * ```
+ */
+declare function Some<T>(value: T): Option<T>;
+/**
+ * Creates an empty `Option`.
+ *
+ * @example
+ * ```ts
+ * const opt = None<number>();
+ * opt.isNone(); // true
+ * ```
+ */
+declare function None<T>(): Option<T>;
+//# sourceMappingURL=option.d.ts.map
+//#endregion
+//#region src/result.d.ts
+/**
+ * Represents the outcome of a fallible operation: either `Ok(value)` or `Fail(error)`.
+ *
+ * Use {@link Ok} and {@link Fail} factory functions to create instances.
+ *
+ * @typeParam T - The type of the success value.
+ * @typeParam E - The type of the error value. Defaults to `string`.
+ *
+ * @example
+ * ```ts
+ * const parsed = Result.fromThrowable(() => JSON.parse(input));
+ * const value = parsed.unwrapOr({});
+ * ```
+ */
+declare abstract class Result<T, E = string> {
+  /** Returns `true` if the result is `Ok`. */
+  abstract isOk(): boolean;
+  /** Returns `true` if the result is `Err`. */
+  abstract isErr(): boolean;
+  /**
+   * Returns the success value.
+   * @throws If the result is `Err`.
+   */
+  abstract unwrap(): T;
+  /**
+   * Returns the error value.
+   * @throws If the result is `Ok`.
+   */
+  abstract unwrapErr(): E;
+  /**
+   * Returns the success value.
+   * @param msg - Error message to throw if the result is `Err`.
+   * @throws With `msg` if the result is `Err`.
+   */
+  abstract expect(msg: string): T;
+  /**
+   * Returns the error value.
+   * @param msg - Error message to throw if the result is `Ok`.
+   * @throws With `msg` if the result is `Ok`.
+   */
+  abstract expectErr(msg: string): E;
+  /**
+   * Returns the success value, or `defaultValue` if `Err`.
+   * @param defaultValue - Value to return if `Err`.
+   */
+  abstract unwrapOr(defaultValue: T): T;
+  /**
+   * Returns the success value, or computes it from the error using `f`.
+   * @param f - Function to compute the default from the error.
+   */
+  abstract unwrapOrElse(f: (error: E) => T): T;
+  /**
+   * Transforms the success value by applying `f`.
+   * Returns the original `Err` if the result is `Err`.
+   * @param f - Function to apply to the success value.
+   */
+  abstract map<U>(f: (value: T) => U): Result<U, E>;
+  /**
+   * Transforms the error value by applying `f`.
+   * Returns the original `Ok` if the result is `Ok`.
+   * @param f - Function to apply to the error value.
+   */
+  abstract mapErr<F>(f: (error: E) => F): Result<T, F>;
+  /**
+   * Applies `f` to the success value, or returns `defaultValue` if `Err`.
+   * @param defaultValue - Value to return if `Err`.
+   * @param f - Function to apply to the success value.
+   */
+  abstract mapOr<U>(defaultValue: U, f: (value: T) => U): U;
+  /**
+   * Applies `f` to the success value, or `defaultFn` to the error.
+   * @param defaultFn - Function to apply to the error.
+   * @param f - Function to apply to the success value.
+   */
+  abstract mapOrElse<U>(defaultFn: (error: E) => U, f: (value: T) => U): U;
+  /**
+   * Transforms the success value by applying `f`, which itself returns a `Result`.
+   * Flattens the result (avoids `Result<Result<U, E>, E>`).
+   * @param f - Function returning a `Result`.
+   */
+  abstract flatMap<U>(f: (value: T) => Result<U, E>): Result<U, E>;
+  /**
+   * Returns `Err` if this result is `Err`, otherwise returns `res`.
+   * @param res - The other result.
+   */
+  abstract and<U>(res: Result<U, E>): Result<U, E>;
+  /**
+   * Returns this result if it is `Ok`, otherwise returns `res`.
+   * @param res - Fallback result.
+   */
+  abstract or<F>(res: Result<T, F>): Result<T, F>;
+  /**
+   * Returns this result if it is `Ok`, otherwise calls `f` with the error and returns the result.
+   * @param f - Function producing the fallback result from the error.
+   */
+  abstract orElse<F>(f: (error: E) => Result<T, F>): Result<T, F>;
+  /**
+   * Calls `f` with the success value if `Ok`, then returns `this` unchanged.
+   * Useful for side effects in a chain.
+   * @param f - Function to call with the success value.
+   */
+  abstract inspect(f: (value: T) => void): Result<T, E>;
+  /**
+   * Calls `f` with the error value if `Err`, then returns `this` unchanged.
+   * Useful for side effects in a chain.
+   * @param f - Function to call with the error value.
+   */
+  abstract inspectErr(f: (error: E) => void): Result<T, E>;
+  /**
+   * Exhaustive pattern matching on the result.
+   * @param patterns - Object with `Ok` and `Err` handlers.
+   *
+   * @example
+   * ```ts
+   * Ok(42).match({
+   *   Ok: v => `got ${v}`,
+   *   Err: e => `error: ${e}`,
+   * });
+   * ```
+   */
+  abstract match<U>(patterns: {
+    Ok: (value: T) => U;
+    Err: (error: E) => U;
+  }): U;
+  /**
+   * Wraps a potentially throwing function into a `Result`.
+   * Returns `Ok(value)` on success, `Fail(error)` on exception.
+   * Non-`Error` exceptions are wrapped in `new Error(String(e))`.
+   * @param f - Function that may throw.
+   */
+  static fromThrowable<T>(f: () => T): Result<T, Error>;
+  /**
+   * Collects an array of results into a single result.
+   * Returns `Ok(values[])` if all succeed, or the first `Err` encountered.
+   * @param results - Array of results to combine.
+   *
+   * @example
+   * ```ts
+   * Result.combine([Ok(1), Ok(2), Ok(3)]); // Ok([1, 2, 3])
+   * Result.combine([Ok(1), Fail('no')]); // Fail('no')
+   * ```
+   */
+  static combine<E = string>(results: Result<unknown, E>[]): Result<unknown[], E>;
+}
+/**
+ * Creates a successful `Result` containing a value.
+ * @param value - The success value to wrap.
+ *
+ * @example
+ * ```ts
+ * const res = Ok(42);
+ * res.unwrap(); // 42
+ * ```
+ */
+declare function Ok<T, E = string>(value: T): Result<T, E>;
+/**
+ * Creates a failed `Result` containing an error.
+ * @param error - The error value to wrap.
+ *
+ * @example
+ * ```ts
+ * const res = Fail('not found');
+ * res.unwrapErr(); // 'not found'
+ * ```
+ */
+declare function Fail<T = never, E = string>(error: E): Result<T, E>;
+//# sourceMappingURL=result.d.ts.map
+//#endregion
+//#region src/match.d.ts
+/**
+ * Standalone pattern matching for `Option`.
+ * @param value - The `Option` to match on.
+ * @param patterns - Object with `Some` and `None` handlers.
+ */
+declare function match<T, U>(value: Option<T>, patterns: {
+  Some: (value: T) => U;
+  None: () => U;
+}): U;
+/**
+ * Standalone pattern matching for `Result`.
+ * @param value - The `Result` to match on.
+ * @param patterns - Object with `Ok` and `Err` handlers.
+ */
+declare function match<T, E, U>(value: Result<T, E>, patterns: {
+  Ok: (value: T) => U;
+  Err: (error: E) => U;
+}): U;
+//# sourceMappingURL=match.d.ts.map
+
+//#endregion
+export { Fail, None, Ok, Option, Result, Some, match };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/option.ts","../src/result.ts","../src/match.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,2 @@
+function e(e,t){return e.match(t)}var t=class{static fromNullable(e){return e==null?a():i(e)}},n=class extends t{constructor(e){super(),this.value=e}isSome(){return!0}isNone(){return!1}unwrap(){return this.value}expect(e){return this.value}unwrapOr(e){return this.value}unwrapOrElse(e){return this.value}map(e){return i(e(this.value))}flatMap(e){return e(this.value)}filter(e){return e(this.value)?this:a()}and(e){return e}or(e){return this}orElse(e){return this}xor(e){return e.isNone()?this:a()}zip(e){return e.isSome()?i([this.value,e.unwrap()]):a()}inspect(e){return e(this.value),this}match(e){return e.Some(this.value)}toUndefined(){return this.value}toNull(){return this.value}toString(){return`Some(${this.value})`}},r=class extends t{isSome(){return!1}isNone(){return!0}unwrap(){throw Error(`Called unwrap on a None value`)}expect(e){throw Error(e)}unwrapOr(e){return e}unwrapOrElse(e){return e()}map(e){return a()}flatMap(e){return a()}filter(e){return this}and(e){return a()}or(e){return e}orElse(e){return e()}xor(e){return e.isSome()?e:a()}zip(e){return a()}inspect(e){return this}match(e){return e.None()}toUndefined(){}toNull(){return null}toString(){return`None`}};function i(e){return new n(e)}function a(){return new r}var o=class{static fromThrowable(e){try{return l(e())}catch(e){return u(e instanceof Error?e:Error(String(e)))}}static combine(e){let t=[];for(let n of e){if(n.isErr())return u(n.unwrapErr());t.push(n.unwrap())}return l(t)}},s=class extends o{constructor(e){super(),this.value=e}isOk(){return!0}isErr(){return!1}unwrap(){return this.value}unwrapErr(){throw Error(`Called unwrapErr on an Ok value`)}expect(e){return this.value}expectErr(e){throw Error(e)}unwrapOr(e){return this.value}unwrapOrElse(e){return this.value}map(e){return l(e(this.value))}mapErr(e){return l(this.value)}mapOr(e,t){return t(this.value)}mapOrElse(e,t){return t(this.value)}flatMap(e){return e(this.value)}and(e){return e}or(e){return l(this.value)}orElse(e){return l(this.value)}inspect(e){return e(this.value),this}inspectErr(e){return this}match(e){return e.Ok(this.value)}toString(){return`Ok(${this.value})`}},c=class extends o{constructor(e){super(),this.error=e}isOk(){return!1}isErr(){return!0}unwrap(){throw Error(`Called unwrap on an Err value: ${this.error}`)}unwrapErr(){return this.error}expect(e){throw Error(e)}expectErr(e){return this.error}unwrapOr(e){return e}unwrapOrElse(e){return e(this.error)}map(e){return u(this.error)}mapErr(e){return u(e(this.error))}mapOr(e,t){return e}mapOrElse(e,t){return e(this.error)}flatMap(e){return u(this.error)}and(e){return u(this.error)}or(e){return e}orElse(e){return e(this.error)}inspect(e){return this}inspectErr(e){return e(this.error),this}match(e){return e.Err(this.error)}toString(){return`Err(${this.error})`}};function l(e){return new s(e)}function u(e){return new c(e)}export{u as Fail,a as None,l as Ok,t as Option,o as Result,i as Some,e as match};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/match.ts","../src/option.ts","../src/result.ts"],"sourcesContent":["import type { Option } from './option.js';\nimport type { Result } from './result.js';\n\n/**\n * Standalone pattern matching for `Option`.\n * @param value - The `Option` to match on.\n * @param patterns - Object with `Some` and `None` handlers.\n */\nexport function match<T, U>(\n  value: Option<T>,\n  patterns: { Some: (value: T) => U; None: () => U },\n): U;\n/**\n * Standalone pattern matching for `Result`.\n * @param value - The `Result` to match on.\n * @param patterns - Object with `Ok` and `Err` handlers.\n */\nexport function match<T, E, U>(\n  value: Result<T, E>,\n  patterns: { Ok: (value: T) => U; Err: (error: E) => U },\n): U;\nexport function match(\n  value: Option<unknown> | Result<unknown, unknown>,\n  patterns: unknown,\n): unknown {\n  return value.match(patterns as never);\n}\n","/**\n * Represents an optional value: either `Some(value)` or `None`.\n *\n * Use {@link Some} and {@link None} factory functions to create instances.\n *\n * @typeParam T - The type of the contained value.\n *\n * @example\n * ```ts\n * const name = Some('Alice');\n * const greeting = name.map(n => `Hello, ${n}`).unwrapOr('Hello, stranger');\n * ```\n */\nexport abstract class Option<T> {\n  /** Returns `true` if the option contains a value. */\n  abstract isSome(): boolean;\n\n  /** Returns `true` if the option is empty. */\n  abstract isNone(): boolean;\n\n  /**\n   * Returns the contained value.\n   * @throws If the option is `None`.\n   */\n  abstract unwrap(): T;\n\n  /**\n   * Returns the contained value.\n   * @param msg - Error message to throw if the option is `None`.\n   * @throws With `msg` if the option is `None`.\n   */\n  abstract expect(msg: string): T;\n\n  /**\n   * Returns the contained value, or `defaultValue` if `None`.\n   * @param defaultValue - Value to return if `None`.\n   */\n  abstract unwrapOr(defaultValue: T): T;\n\n  /**\n   * Returns the contained value, or computes it from `f` if `None`.\n   * @param f - Function to compute the default value.\n   */\n  abstract unwrapOrElse(f: () => T): T;\n\n  /**\n   * Transforms the contained value by applying `f`.\n   * Returns `None` if the option is `None`.\n   * @param f - Function to apply to the value.\n   */\n  abstract map<U>(f: (value: T) => U): Option<U>;\n\n  /**\n   * Transforms the contained value by applying `f`, which itself returns an `Option`.\n   * Flattens the result (avoids `Option<Option<U>>`).\n   * @param f - Function returning an `Option`.\n   */\n  abstract flatMap<U>(f: (value: T) => Option<U>): Option<U>;\n\n  /**\n   * Returns `None` if the option is `None` or the predicate returns `false`.\n   * @param predicate - Function to test the contained value.\n   */\n  abstract filter(predicate: (value: T) => boolean): Option<T>;\n\n  /**\n   * Returns `None` if this option is `None`, otherwise returns `optb`.\n   * @param optb - The other option.\n   */\n  abstract and<U>(optb: Option<U>): Option<U>;\n\n  /**\n   * Returns this option if it is `Some`, otherwise returns `optb`.\n   * @param optb - Fallback option.\n   */\n  abstract or(optb: Option<T>): Option<T>;\n\n  /**\n   * Returns this option if it is `Some`, otherwise calls `f` and returns the result.\n   * @param f - Function producing the fallback option.\n   */\n  abstract orElse(f: () => Option<T>): Option<T>;\n\n  /**\n   * Returns `Some` if exactly one of `this` and `optb` is `Some`, otherwise `None`.\n   * @param optb - The other option.\n   */\n  abstract xor(optb: Option<T>): Option<T>;\n\n  /**\n   * Zips this option with another. Returns `Some([a, b])` if both are `Some`, otherwise `None`.\n   * @param other - The other option to zip with.\n   */\n  abstract zip<U>(other: Option<U>): Option<[T, U]>;\n\n  /**\n   * Calls `f` with the contained value if `Some`, then returns `this` unchanged.\n   * Useful for side effects in a chain.\n   * @param f - Function to call with the value.\n   */\n  abstract inspect(f: (value: T) => void): Option<T>;\n\n  /**\n   * Exhaustive pattern matching on the option.\n   * @param patterns - Object with `Some` and `None` handlers.\n   *\n   * @example\n   * ```ts\n   * Some(42).match({\n   *   Some: v => `got ${v}`,\n   *   None: () => 'nothing',\n   * });\n   * ```\n   */\n  abstract match<U>(patterns: { Some: (value: T) => U; None: () => U }): U;\n\n  /** Converts to `T | undefined`. Returns `undefined` if `None`. */\n  abstract toUndefined(): T | undefined;\n\n  /** Converts to `T | null`. Returns `null` if `None`. */\n  abstract toNull(): T | null;\n\n  /**\n   * Creates an `Option` from a nullable value.\n   * Returns `Some(value)` if non-null/undefined, otherwise `None`.\n   * @param value - A possibly null or undefined value.\n   */\n  static fromNullable<T>(value: T | null | undefined): Option<T> {\n    return value != null ? Some(value) : None<T>();\n  }\n}\n\nclass SomeOption<T> extends Option<T> {\n  constructor(private readonly value: T) {\n    super();\n  }\n\n  isSome(): boolean {\n    return true;\n  }\n\n  isNone(): boolean {\n    return false;\n  }\n\n  unwrap(): T {\n    return this.value;\n  }\n\n  expect(_msg: string): T {\n    return this.value;\n  }\n\n  unwrapOr(_defaultValue: T): T {\n    return this.value;\n  }\n\n  unwrapOrElse(_f: () => T): T {\n    return this.value;\n  }\n\n  map<U>(f: (value: T) => U): Option<U> {\n    return Some(f(this.value));\n  }\n\n  flatMap<U>(f: (value: T) => Option<U>): Option<U> {\n    return f(this.value);\n  }\n\n  filter(predicate: (value: T) => boolean): Option<T> {\n    return predicate(this.value) ? this : None<T>();\n  }\n\n  and<U>(optb: Option<U>): Option<U> {\n    return optb;\n  }\n\n  or(_optb: Option<T>): Option<T> {\n    return this;\n  }\n\n  orElse(_f: () => Option<T>): Option<T> {\n    return this;\n  }\n\n  xor(optb: Option<T>): Option<T> {\n    return optb.isNone() ? this : None<T>();\n  }\n\n  zip<U>(other: Option<U>): Option<[T, U]> {\n    return other.isSome() ? Some<[T, U]>([this.value, other.unwrap()]) : None<[T, U]>();\n  }\n\n  inspect(f: (value: T) => void): Option<T> {\n    f(this.value);\n    return this;\n  }\n\n  match<U>(patterns: { Some: (value: T) => U; None: () => U }): U {\n    return patterns.Some(this.value);\n  }\n\n  toUndefined(): T | undefined {\n    return this.value;\n  }\n\n  toNull(): T | null {\n    return this.value;\n  }\n\n  toString(): string {\n    return `Some(${this.value})`;\n  }\n}\n\nclass NoneOption<T> extends Option<T> {\n  isSome(): boolean {\n    return false;\n  }\n\n  isNone(): boolean {\n    return true;\n  }\n\n  unwrap(): T {\n    throw new Error('Called unwrap on a None value');\n  }\n\n  expect(msg: string): T {\n    throw new Error(msg);\n  }\n\n  unwrapOr(defaultValue: T): T {\n    return defaultValue;\n  }\n\n  unwrapOrElse(f: () => T): T {\n    return f();\n  }\n\n  map<U>(_f: (value: T) => U): Option<U> {\n    return None<U>();\n  }\n\n  flatMap<U>(_f: (value: T) => Option<U>): Option<U> {\n    return None<U>();\n  }\n\n  filter(_predicate: (value: T) => boolean): Option<T> {\n    return this;\n  }\n\n  and<U>(_optb: Option<U>): Option<U> {\n    return None<U>();\n  }\n\n  or(optb: Option<T>): Option<T> {\n    return optb;\n  }\n\n  orElse(f: () => Option<T>): Option<T> {\n    return f();\n  }\n\n  xor(optb: Option<T>): Option<T> {\n    return optb.isSome() ? optb : None<T>();\n  }\n\n  zip<U>(_other: Option<U>): Option<[T, U]> {\n    return None<[T, U]>();\n  }\n\n  inspect(_f: (value: T) => void): Option<T> {\n    return this;\n  }\n\n  match<U>(patterns: { Some: (value: T) => U; None: () => U }): U {\n    return patterns.None();\n  }\n\n  toUndefined(): T | undefined {\n    return undefined;\n  }\n\n  toNull(): T | null {\n    return null;\n  }\n\n  toString(): string {\n    return 'None';\n  }\n}\n\n/**\n * Creates an `Option` containing a value.\n * @param value - The value to wrap.\n *\n * @example\n * ```ts\n * const opt = Some(42);\n * opt.unwrap(); // 42\n * ```\n */\nexport function Some<T>(value: T): Option<T> {\n  return new SomeOption(value);\n}\n\n/**\n * Creates an empty `Option`.\n *\n * @example\n * ```ts\n * const opt = None<number>();\n * opt.isNone(); // true\n * ```\n */\nexport function None<T>(): Option<T> {\n  return new NoneOption<T>();\n}\n","/**\n * Represents the outcome of a fallible operation: either `Ok(value)` or `Fail(error)`.\n *\n * Use {@link Ok} and {@link Fail} factory functions to create instances.\n *\n * @typeParam T - The type of the success value.\n * @typeParam E - The type of the error value. Defaults to `string`.\n *\n * @example\n * ```ts\n * const parsed = Result.fromThrowable(() => JSON.parse(input));\n * const value = parsed.unwrapOr({});\n * ```\n */\nexport abstract class Result<T, E = string> {\n  /** Returns `true` if the result is `Ok`. */\n  abstract isOk(): boolean;\n\n  /** Returns `true` if the result is `Err`. */\n  abstract isErr(): boolean;\n\n  /**\n   * Returns the success value.\n   * @throws If the result is `Err`.\n   */\n  abstract unwrap(): T;\n\n  /**\n   * Returns the error value.\n   * @throws If the result is `Ok`.\n   */\n  abstract unwrapErr(): E;\n\n  /**\n   * Returns the success value.\n   * @param msg - Error message to throw if the result is `Err`.\n   * @throws With `msg` if the result is `Err`.\n   */\n  abstract expect(msg: string): T;\n\n  /**\n   * Returns the error value.\n   * @param msg - Error message to throw if the result is `Ok`.\n   * @throws With `msg` if the result is `Ok`.\n   */\n  abstract expectErr(msg: string): E;\n\n  /**\n   * Returns the success value, or `defaultValue` if `Err`.\n   * @param defaultValue - Value to return if `Err`.\n   */\n  abstract unwrapOr(defaultValue: T): T;\n\n  /**\n   * Returns the success value, or computes it from the error using `f`.\n   * @param f - Function to compute the default from the error.\n   */\n  abstract unwrapOrElse(f: (error: E) => T): T;\n\n  /**\n   * Transforms the success value by applying `f`.\n   * Returns the original `Err` if the result is `Err`.\n   * @param f - Function to apply to the success value.\n   */\n  abstract map<U>(f: (value: T) => U): Result<U, E>;\n\n  /**\n   * Transforms the error value by applying `f`.\n   * Returns the original `Ok` if the result is `Ok`.\n   * @param f - Function to apply to the error value.\n   */\n  abstract mapErr<F>(f: (error: E) => F): Result<T, F>;\n\n  /**\n   * Applies `f` to the success value, or returns `defaultValue` if `Err`.\n   * @param defaultValue - Value to return if `Err`.\n   * @param f - Function to apply to the success value.\n   */\n  abstract mapOr<U>(defaultValue: U, f: (value: T) => U): U;\n\n  /**\n   * Applies `f` to the success value, or `defaultFn` to the error.\n   * @param defaultFn - Function to apply to the error.\n   * @param f - Function to apply to the success value.\n   */\n  abstract mapOrElse<U>(defaultFn: (error: E) => U, f: (value: T) => U): U;\n\n  /**\n   * Transforms the success value by applying `f`, which itself returns a `Result`.\n   * Flattens the result (avoids `Result<Result<U, E>, E>`).\n   * @param f - Function returning a `Result`.\n   */\n  abstract flatMap<U>(f: (value: T) => Result<U, E>): Result<U, E>;\n\n  /**\n   * Returns `Err` if this result is `Err`, otherwise returns `res`.\n   * @param res - The other result.\n   */\n  abstract and<U>(res: Result<U, E>): Result<U, E>;\n\n  /**\n   * Returns this result if it is `Ok`, otherwise returns `res`.\n   * @param res - Fallback result.\n   */\n  abstract or<F>(res: Result<T, F>): Result<T, F>;\n\n  /**\n   * Returns this result if it is `Ok`, otherwise calls `f` with the error and returns the result.\n   * @param f - Function producing the fallback result from the error.\n   */\n  abstract orElse<F>(f: (error: E) => Result<T, F>): Result<T, F>;\n\n  /**\n   * Calls `f` with the success value if `Ok`, then returns `this` unchanged.\n   * Useful for side effects in a chain.\n   * @param f - Function to call with the success value.\n   */\n  abstract inspect(f: (value: T) => void): Result<T, E>;\n\n  /**\n   * Calls `f` with the error value if `Err`, then returns `this` unchanged.\n   * Useful for side effects in a chain.\n   * @param f - Function to call with the error value.\n   */\n  abstract inspectErr(f: (error: E) => void): Result<T, E>;\n\n  /**\n   * Exhaustive pattern matching on the result.\n   * @param patterns - Object with `Ok` and `Err` handlers.\n   *\n   * @example\n   * ```ts\n   * Ok(42).match({\n   *   Ok: v => `got ${v}`,\n   *   Err: e => `error: ${e}`,\n   * });\n   * ```\n   */\n  abstract match<U>(patterns: { Ok: (value: T) => U; Err: (error: E) => U }): U;\n\n  /**\n   * Wraps a potentially throwing function into a `Result`.\n   * Returns `Ok(value)` on success, `Fail(error)` on exception.\n   * Non-`Error` exceptions are wrapped in `new Error(String(e))`.\n   * @param f - Function that may throw.\n   */\n  static fromThrowable<T>(f: () => T): Result<T, Error> {\n    try {\n      return Ok(f());\n    } catch (e) {\n      return Fail(e instanceof Error ? e : new Error(String(e)));\n    }\n  }\n\n  /**\n   * Collects an array of results into a single result.\n   * Returns `Ok(values[])` if all succeed, or the first `Err` encountered.\n   * @param results - Array of results to combine.\n   *\n   * @example\n   * ```ts\n   * Result.combine([Ok(1), Ok(2), Ok(3)]); // Ok([1, 2, 3])\n   * Result.combine([Ok(1), Fail('no')]); // Fail('no')\n   * ```\n   */\n  static combine<E = string>(results: Result<unknown, E>[]): Result<unknown[], E> {\n    const values: unknown[] = [];\n    for (const result of results) {\n      if (result.isErr()) return Fail(result.unwrapErr());\n      values.push(result.unwrap());\n    }\n    return Ok(values);\n  }\n}\n\nclass OkResult<T, E = string> extends Result<T, E> {\n  constructor(private readonly value: T) {\n    super();\n  }\n\n  isOk(): boolean {\n    return true;\n  }\n\n  isErr(): boolean {\n    return false;\n  }\n\n  unwrap(): T {\n    return this.value;\n  }\n\n  unwrapErr(): E {\n    throw new Error('Called unwrapErr on an Ok value');\n  }\n\n  expect(_msg: string): T {\n    return this.value;\n  }\n\n  expectErr(msg: string): E {\n    throw new Error(msg);\n  }\n\n  unwrapOr(_defaultValue: T): T {\n    return this.value;\n  }\n\n  unwrapOrElse(_f: (error: E) => T): T {\n    return this.value;\n  }\n\n  map<U>(f: (value: T) => U): Result<U, E> {\n    return Ok(f(this.value));\n  }\n\n  mapErr<F>(_f: (error: E) => F): Result<T, F> {\n    return Ok(this.value);\n  }\n\n  mapOr<U>(_defaultValue: U, f: (value: T) => U): U {\n    return f(this.value);\n  }\n\n  mapOrElse<U>(_defaultFn: (error: E) => U, f: (value: T) => U): U {\n    return f(this.value);\n  }\n\n  flatMap<U>(f: (value: T) => Result<U, E>): Result<U, E> {\n    return f(this.value);\n  }\n\n  and<U>(res: Result<U, E>): Result<U, E> {\n    return res;\n  }\n\n  or<F>(_res: Result<T, F>): Result<T, F> {\n    return Ok(this.value);\n  }\n\n  orElse<F>(_f: (error: E) => Result<T, F>): Result<T, F> {\n    return Ok(this.value);\n  }\n\n  inspect(f: (value: T) => void): Result<T, E> {\n    f(this.value);\n    return this;\n  }\n\n  inspectErr(_f: (error: E) => void): Result<T, E> {\n    return this;\n  }\n\n  match<U>(patterns: { Ok: (value: T) => U; Err: (error: E) => U }): U {\n    return patterns.Ok(this.value);\n  }\n\n  toString(): string {\n    return `Ok(${this.value})`;\n  }\n}\n\nclass ErrResult<T, E = string> extends Result<T, E> {\n  constructor(private readonly error: E) {\n    super();\n  }\n\n  isOk(): boolean {\n    return false;\n  }\n\n  isErr(): boolean {\n    return true;\n  }\n\n  unwrap(): T {\n    throw new Error(`Called unwrap on an Err value: ${this.error}`);\n  }\n\n  unwrapErr(): E {\n    return this.error;\n  }\n\n  expect(msg: string): T {\n    throw new Error(msg);\n  }\n\n  expectErr(_msg: string): E {\n    return this.error;\n  }\n\n  unwrapOr(defaultValue: T): T {\n    return defaultValue;\n  }\n\n  unwrapOrElse(f: (error: E) => T): T {\n    return f(this.error);\n  }\n\n  map<U>(_f: (value: T) => U): Result<U, E> {\n    return Fail(this.error);\n  }\n\n  mapErr<F>(f: (error: E) => F): Result<T, F> {\n    return Fail(f(this.error));\n  }\n\n  mapOr<U>(defaultValue: U, _f: (value: T) => U): U {\n    return defaultValue;\n  }\n\n  mapOrElse<U>(defaultFn: (error: E) => U, _f: (value: T) => U): U {\n    return defaultFn(this.error);\n  }\n\n  flatMap<U>(_f: (value: T) => Result<U, E>): Result<U, E> {\n    return Fail(this.error);\n  }\n\n  and<U>(_res: Result<U, E>): Result<U, E> {\n    return Fail(this.error);\n  }\n\n  or<F>(res: Result<T, F>): Result<T, F> {\n    return res;\n  }\n\n  orElse<F>(f: (error: E) => Result<T, F>): Result<T, F> {\n    return f(this.error);\n  }\n\n  inspect(_f: (value: T) => void): Result<T, E> {\n    return this;\n  }\n\n  inspectErr(f: (error: E) => void): Result<T, E> {\n    f(this.error);\n    return this;\n  }\n\n  match<U>(patterns: { Ok: (value: T) => U; Err: (error: E) => U }): U {\n    return patterns.Err(this.error);\n  }\n\n  toString(): string {\n    return `Err(${this.error})`;\n  }\n}\n\n/**\n * Creates a successful `Result` containing a value.\n * @param value - The success value to wrap.\n *\n * @example\n * ```ts\n * const res = Ok(42);\n * res.unwrap(); // 42\n * ```\n */\nexport function Ok<T, E = string>(value: T): Result<T, E> {\n  return new OkResult(value);\n}\n\n/**\n * Creates a failed `Result` containing an error.\n * @param error - The error value to wrap.\n *\n * @example\n * ```ts\n * const res = Fail('not found');\n * res.unwrapErr(); // 'not found'\n * ```\n */\nexport function Fail<T = never, E = string>(error: E): Result<T, E> {\n  return new ErrResult(error);\n}\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "galvorn",
+  "version": "1.0.1",
+  "description": "Rust's Option and Result for TypeScript. Fully typed, tested, zero dependencies.",
+  "type": "module",
+  "license": "MIT",
+  "author": "axelhamil",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/axelhamil/galvorn.git"
+  },
+  "bugs": {
+    "url": "https://github.com/axelhamil/galvorn/issues"
+  },
+  "homepage": "https://github.com/axelhamil/galvorn#readme",
+  "packageManager": "pnpm@10.26.0",
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "lint:fix": "biome check --fix ."
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.14",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.6",
+    "@vitest/coverage-v8": "^3.2.1",
+    "publint": "^0.3.17",
+    "semantic-release": "^25.0.3",
+    "tsdown": "^0.12.5",
+    "typescript": "^5.8.3",
+    "vitest": "^3.2.1"
+  }
+}