@shirudo/result 1.0.0 → 1.1.0

package/dist/{result-DKKaNdOx.mjs → result-q9Na2bGa.mjs}

@@ -1,4 +1,4 @@
-import { d as ExpectOkError, f as InvalidResultStateError, m as MatchOnOkError, p as MatchErrHandlerNotResultError, u as ExpectErrError, v as UnwrapErrOnOkError, y as UnwrapOnErrError } from "./errors-2WOswg7r.mjs";
+import { ExpectErrError, ExpectOkError, InvalidResultStateError, MatchErrHandlerNotResultError, MatchOnOkError, MatchTagMissingHandlerError, UnwrapErrOnOkError, UnwrapOnErrError } from "./errors.mjs";
 
 //#region src/core/pipeable.ts
 var Pipeable = class {
@@ -48,8 +48,9 @@ function matchTag(result, key, handlers) {
 	if (result.isOk()) throw new MatchOnOkError("matchTag");
 	if (result.isErr()) {
 		const error = result.error;
-		const handler = handlers[error[key]];
-		if (typeof handler !== "function") throw new InvalidResultStateError("matchTag");
+		const tag = error[key];
+		const handler = Object.hasOwn(handlers, tag) ? handlers[tag] : void 0;
+		if (typeof handler !== "function") throw new MatchTagMissingHandlerError(tag);
 		return handler(error);
 	}
 	throw new InvalidResultStateError("matchTag");
@@ -99,18 +100,19 @@ var ErrorMatchBuilder = class ErrorMatchBuilder {
 var AsyncErrorMatchBuilder = class AsyncErrorMatchBuilder {
 	#error;
 	#matched;
-	#value;
-	constructor(error, matched = false, value) {
+	#handler;
+	#memo;
+	constructor(error, matched = false, handler) {
 		this.#error = error;
 		this.#matched = matched;
-		this.#value = value;
+		this.#handler = handler;
 		Object.freeze(this);
 	}
 	when(ctor, handler) {
 		if (this.#matched) return this;
 		if (this.#error instanceof ctor) {
-			const value = Promise.resolve().then(() => handler(this.#error));
-			return new AsyncErrorMatchBuilder(this.#error, true, value);
+			const run = () => handler(this.#error);
+			return new AsyncErrorMatchBuilder(this.#error, true, run);
 		}
 		return this;
 	}
@@ -118,27 +120,31 @@ var AsyncErrorMatchBuilder = class AsyncErrorMatchBuilder {
 		if (this.#matched) return this;
 		const error = this.#error;
 		if (guard(error)) {
-			const value = Promise.resolve().then(() => handler(error));
-			return new AsyncErrorMatchBuilder(this.#error, true, value);
+			const run = () => handler(error);
+			return new AsyncErrorMatchBuilder(this.#error, true, run);
 		}
 		return this;
 	}
 	whenTag(key, tag, handler) {
 		if (this.#matched) return this;
 		if (matchesTag(this.#error, key, tag)) {
-			const value = Promise.resolve().then(() => handler(this.#error));
-			return new AsyncErrorMatchBuilder(this.#error, true, value);
+			const run = () => handler(this.#error);
+			return new AsyncErrorMatchBuilder(this.#error, true, run);
 		}
 		return this;
 	}
 	async otherwise(handler) {
-		if (this.#matched) return await this.#value;
+		if (this.#matched) return await this.#invoke();
 		return await handler(this.#error);
 	}
 	async run() {
-		if (this.#matched) return await this.#value;
+		if (this.#matched) return await this.#invoke();
 		throw this.#error;
 	}
+	#invoke() {
+		this.#memo ??= Promise.resolve().then(this.#handler);
+		return this.#memo;
+	}
 };
 const expectResultReturn = (value, handlerName) => {
 	if (isResult(value)) return value;
@@ -199,50 +205,55 @@ var ErrMatchBuilder = class ErrMatchBuilder {
 };
 var AsyncErrMatchBuilder = class AsyncErrMatchBuilder {
 	#error;
-	#resolved;
-	constructor(error, resolved) {
+	#resolve;
+	#memo;
+	constructor(error, resolve) {
 		this.#error = error;
-		this.#resolved = resolved;
+		this.#resolve = resolve;
 		Object.freeze(this);
 	}
 	static fromResult(result) {
-		if (result.isOk()) return new AsyncErrMatchBuilder(void 0, Promise.resolve(result));
+		if (result.isOk()) return new AsyncErrMatchBuilder(void 0, () => result);
 		if (result.isErr()) return new AsyncErrMatchBuilder(result.error);
 		throw new InvalidResultStateError("AsyncErrMatchBuilder.fromResult");
 	}
 	when(ctor, handler) {
-		if (this.#resolved) return this;
+		if (this.#resolve) return this;
 		if (this.#error instanceof ctor) {
-			const resolved = Promise.resolve().then(() => handler(this.#error)).then((out) => expectResultReturn(out, "when"));
-			return new AsyncErrMatchBuilder(this.#error, resolved);
+			const resolve = async () => expectResultReturn(await handler(this.#error), "when");
+			return new AsyncErrMatchBuilder(this.#error, resolve);
 		}
 		return this;
 	}
 	whenGuard(guard, handler) {
-		if (this.#resolved) return this;
+		if (this.#resolve) return this;
 		const error = this.#error;
 		if (guard(error)) {
-			const resolved = Promise.resolve().then(() => handler(error)).then((out) => expectResultReturn(out, "whenGuard"));
-			return new AsyncErrMatchBuilder(this.#error, resolved);
+			const resolve = async () => expectResultReturn(await handler(error), "whenGuard");
+			return new AsyncErrMatchBuilder(this.#error, resolve);
 		}
 		return this;
 	}
 	whenTag(key, tag, handler) {
-		if (this.#resolved) return this;
+		if (this.#resolve) return this;
 		if (matchesTag(this.#error, key, tag)) {
-			const resolved = Promise.resolve().then(() => handler(this.#error)).then((out) => expectResultReturn(out, "whenTag"));
-			return new AsyncErrMatchBuilder(this.#error, resolved);
+			const resolve = async () => expectResultReturn(await handler(this.#error), "whenTag");
+			return new AsyncErrMatchBuilder(this.#error, resolve);
 		}
 		return this;
 	}
 	async otherwise(handler) {
-		if (this.#resolved) return await this.#resolved;
+		if (this.#resolve) return await this.#invoke();
 		return expectResultReturn(await handler(this.#error), "otherwise");
 	}
 	async run() {
-		if (this.#resolved) return await this.#resolved;
+		if (this.#resolve) return await this.#invoke();
 		throw this.#error;
 	}
+	#invoke() {
+		this.#memo ??= Promise.resolve().then(this.#resolve);
+		return this.#memo;
+	}
 };
 
 //#endregion
@@ -281,8 +292,8 @@ function zipImpl(left, right) {
 }
 function zip(...args) {
 	if (args.length === 1) {
-		const right$1 = args[0];
-		return (left$1) => zipImpl(left$1, right$1);
+		const right = args[0];
+		return (left) => zipImpl(left, right);
 	}
 	const [left, right] = args;
 	return zipImpl(left, right);
@@ -298,347 +309,16 @@ function combineImpl(left, right) {
 }
 function combine(...args) {
 	if (args.length === 1) {
-		const right$1 = args[0];
-		return (left$1) => combineImpl(left$1, right$1);
+		const right = args[0];
+		return (left) => combineImpl(left, right);
 	}
 	const [left, right] = args;
 	return combineImpl(left, right);
 }
 
-//#endregion
-//#region src/core/map.ts
-/**
-* Transforms the value (Ok case).
-* Corresponds to Rust `map`.
-*/
-function map(project) {
-	return (source) => {
-		if (source.isOk()) return ok(project(source.value));
-		if (source.isErr()) return source;
-		throw new InvalidResultStateError("map");
-	};
-}
-
-//#endregion
-//#region src/core/mapErr.ts
-/**
-* Transforms the error (Err case).
-* Corresponds to Rust `map_err`.
-*/
-function mapErr(project) {
-	return (source) => {
-		if (source.isErr()) return err(project(source.error));
-		if (source.isOk()) return source;
-		throw new InvalidResultStateError("mapErr");
-	};
-}
-
-//#endregion
-//#region src/core/mapBoth.ts
-/**
-* Transforms both the Ok value and the Err error.
-* Corresponds to FP `bimap` / `mapBoth`.
-*/
-function mapBoth(mapOk, mapErr$1) {
-	return (source) => {
-		if (source.isOk()) return ok(mapOk(source.value));
-		if (source.isErr()) return err(mapErr$1(source.error));
-		throw new InvalidResultStateError("mapBoth");
-	};
-}
-/**
-* Alias for `mapBoth`.
-*/
-const bimap = mapBoth;
-
-//#endregion
-//#region src/core/flatMap.ts
-/**
-* Chains another operation that returns a Result.
-* Corresponds to Rust `and_then` or JS `flatMap`.
-*/
-function flatMap(project) {
-	return (source) => {
-		if (source.isOk()) return project(source.value);
-		if (source.isErr()) return source;
-		throw new InvalidResultStateError("flatMap");
-	};
-}
-
-//#endregion
-//#region src/core/tap.ts
-/**
-* Executes a side effect (logging, debugging) without changing the Result.
-* Corresponds to Rust `inspect` / `inspect_err`.
-*/
-function tap(observer) {
-	return (source) => {
-		if (source.isOk()) {
-			if (observer.ok) observer.ok(source.value);
-			return source;
-		}
-		if (source.isErr()) {
-			if (observer.err) observer.err(source.error);
-			return source;
-		}
-		throw new InvalidResultStateError("tap");
-	};
-}
-
-//#endregion
-//#region src/core/filter.ts
-/**
-* Checks a condition. If false, the Result becomes Err.
-* Corresponds to Rust `filter` (partially).
-*/
-function filter(predicate, errorFn) {
-	return (source) => {
-		if (source.isOk()) {
-			if (predicate(source.value)) return source;
-			return err(errorFn());
-		}
-		if (source.isErr()) return source;
-		throw new InvalidResultStateError("filter");
-	};
-}
-
-//#endregion
-//#region src/core/match.ts
-/**
-* Resolves the Result. The end of the pipe.
-* Corresponds to Rust `match`.
-*/
-function match(handlers) {
-	return (source) => {
-		if (source.isOk()) return handlers.ok(source.value);
-		if (source.isErr()) return handlers.err(source.error);
-		throw new InvalidResultStateError("match");
-	};
-}
-
-//#endregion
-//#region src/core/recover.ts
-/**
-* Recover: converts Err to Ok(defaultValue).
-* Result is guaranteed to be Ok → Error type becomes `never`.
-*/
-function recover(defaultValue) {
-	return (source) => {
-		if (source.isOk()) return source;
-		if (source.isErr()) return ok(defaultValue);
-		throw new InvalidResultStateError("recover");
-	};
-}
-/**
-* Like `recover`, but calculates the default value based on the error.
-*/
-function recoverWith(fn) {
-	return (source) => {
-		if (source.isOk()) return source;
-		if (source.isErr()) return ok(fn(source.error));
-		throw new InvalidResultStateError("recoverWith");
-	};
-}
-
-//#endregion
-//#region src/core/swap.ts
-/**
-* Swaps Ok and Err.
-* Result<T, E> → Result<E, T>
-*/
-function swap(result) {
-	if (result.isOk()) return err(result.value);
-	if (result.isErr()) return ok(result.error);
-	throw new InvalidResultStateError("swap");
-}
-
-//#endregion
-//#region src/core/tryCatch.ts
-/**
-* Executes a function and catches exceptions.
-* Converts exceptions into Result<E>.
-* Corresponds to Rust `Result::from` for fallible operations.
-*/
-function tryCatch(fn, errorMapper) {
-	return (source) => {
-		if (source.isErr()) return source;
-		try {
-			return ok(fn());
-		} catch (error) {
-			return err(errorMapper ? errorMapper(error) : error);
-		}
-	};
-}
-
-//#endregion
-//#region src/core/tryMap.ts
-/**
-* Like `map`, but catches exceptions and converts them to Err.
-*/
-function tryMap(project, errorMapper) {
-	return (source) => {
-		if (source.isErr()) return source;
-		if (!source.isOk()) throw new InvalidResultStateError("tryMap");
-		try {
-			return ok(project(source.value));
-		} catch (error) {
-			return err(errorMapper ? errorMapper(error) : error);
-		}
-	};
-}
-
-//#endregion
-//#region src/core/collectFirstOk.ts
-/**
-* Parse a set of `Result`s, short-circuits when an input value is `Ok`.
-* If no `Ok` is found, returns an `Err` containing the collected error values.
-* Useful for "try multiple approaches until one works" patterns.
-*/
-function collectFirstOk(results) {
-	const errors = [];
-	for (const result of results) {
-		if (result.isOk()) return ok(result.value);
-		if (result.isErr()) {
-			errors.push(result.error);
-			continue;
-		}
-		throw new InvalidResultStateError("collectFirstOk");
-	}
-	return err(errors);
-}
-
-//#endregion
-//#region src/core/mapAsync.ts
-/**
-* Async version of map.
-*/
-function mapAsync(project) {
-	return async (source) => {
-		if (source.isOk()) return ok(await project(source.value));
-		if (source.isErr()) return source;
-		throw new InvalidResultStateError("mapAsync");
-	};
-}
-
-//#endregion
-//#region src/core/mapErrAsync.ts
-/**
-* Async version of mapErr.
-*/
-function mapErrAsync(project) {
-	return async (source) => {
-		if (source.isErr()) return err(await project(source.error));
-		if (source.isOk()) return source;
-		throw new InvalidResultStateError("mapErrAsync");
-	};
-}
-
-//#endregion
-//#region src/core/flatMapAsync.ts
-/**
-* Async version of flatMap.
-*/
-function flatMapAsync(project) {
-	return async (source) => {
-		if (source.isOk()) return await project(source.value);
-		if (source.isErr()) return source;
-		throw new InvalidResultStateError("flatMapAsync");
-	};
-}
-
-//#endregion
-//#region src/core/tapAsync.ts
-/**
-* Async version of tap.
-*/
-function tapAsync(observer) {
-	return async (source) => {
-		if (source.isOk()) {
-			if (observer.ok) await observer.ok(source.value);
-			return source;
-		}
-		if (source.isErr()) {
-			if (observer.err) await observer.err(source.error);
-			return source;
-		}
-		throw new InvalidResultStateError("tapAsync");
-	};
-}
-
-//#endregion
-//#region src/core/filterAsync.ts
-/**
-* Async version of filter.
-*/
-function filterAsync(predicate, errorFn) {
-	return async (source) => {
-		if (source.isOk()) {
-			if (await predicate(source.value)) return source;
-			return err(await errorFn());
-		}
-		if (source.isErr()) return source;
-		throw new InvalidResultStateError("filterAsync");
-	};
-}
-
-//#endregion
-//#region src/core/matchAsync.ts
-/**
-* Async version of match.
-*/
-function matchAsync(handlers) {
-	return async (source) => {
-		if (source.isOk()) return await handlers.ok(source.value);
-		if (source.isErr()) return await handlers.err(source.error);
-		throw new InvalidResultStateError("matchAsync");
-	};
-}
-
-//#endregion
-//#region src/core/tryCatchAsync.ts
-/**
-* Async version of tryCatch.
-*/
-function tryCatchAsync(fn, errorMapper) {
-	return async (source) => {
-		if (source.isErr()) return source;
-		try {
-			return ok(await fn());
-		} catch (error) {
-			return err(errorMapper ? errorMapper(error) : error);
-		}
-	};
-}
-
-//#endregion
-//#region src/core/tryMapAsync.ts
-/**
-* Async version of tryMap.
-*/
-function tryMapAsync(project, errorMapper) {
-	return async (source) => {
-		if (source.isErr()) return source;
-		if (!source.isOk()) throw new InvalidResultStateError("tryMapAsync");
-		try {
-			return ok(await project(source.value));
-		} catch (error) {
-			return err(errorMapper ? errorMapper(error) : error);
-		}
-	};
-}
-
 //#endregion
 //#region src/core/result.ts
 var ResultBase = class extends Pipeable {
-	constructor() {
-		super();
-		Object.defineProperty(this, RESULT_BRAND, {
-			value: true,
-			enumerable: false,
-			configurable: false,
-			writable: false
-		});
-	}
 	isOk() {
 		if (this._tag === "Ok") return true;
 		if (this._tag === "Err") return false;
@@ -676,12 +356,12 @@ var ResultBase = class extends Pipeable {
 	}
 	expect(message) {
 		if (this._tag === "Ok") return this.value;
-		if (this._tag === "Err") throw new ExpectOkError(message);
+		if (this._tag === "Err") throw new ExpectOkError(message, this.error);
 		throw new InvalidResultStateError("Result.expect");
 	}
 	expectErr(message) {
 		if (this._tag === "Err") return this.error;
-		if (this._tag === "Ok") throw new ExpectErrError(message);
+		if (this._tag === "Ok") throw new ExpectErrError(message, this.value);
 		throw new InvalidResultStateError("Result.expectErr");
 	}
 	toPromise() {
@@ -723,12 +403,17 @@ var ResultBase = class extends Pipeable {
 		throw new InvalidResultStateError("Result.matchErrorAsync");
 	}
 	/**
-	* Matches on the Err value via `.when(...)` chain.
+	* Matches on the **Err** value via a `.when(...)` chain.
 	*
-	* Note: for type safety reasons, `.match()` can only be called on a Result already narrowed to `Err`,
-	* e.g. inside `if (result.isErr()) { ... }`.
+	* Not the same as the `match({ ok, err })` pipe operator: that operator resolves
+	* **both** branches (Ok and Err) via callbacks, whereas this method is **Err-only**
+	* and returns an {@link ErrorMatchBuilder}.
 	*
-	* @deprecated Use `.matchError()` for clearer Err-only semantics.
+	* Note: for type-safety reasons, `.match()` can only be called on a Result already
+	* narrowed to `Err`, e.g. inside `if (result.isErr()) { ... }`.
+	*
+	* @deprecated Use `.matchError()` for clearer Err-only semantics. For Ok+Err handling,
+	* use the `match({ ok, err })` pipe operator instead.
 	*/
 	match() {
 		if (this._tag === "Err") return new ErrorMatchBuilder(this.error);
@@ -747,8 +432,32 @@ var ResultBase = class extends Pipeable {
 		return AsyncErrMatchBuilder.fromResult(this);
 	}
 	/**
+	* Serializes the Result into the discriminated shape
+	* `{ _tag: 'Ok', value }` / `{ _tag: 'Err', error }`.
+	*
+	* Unlike {@link serialize}, `Ok(undefined)` stays unambiguous, and the
+	* shape round-trips through `fromSerialized(...)`. It also matches what
+	* `JSON.stringify(result)` produces for a Result instance.
+	*/
+	toSerialized() {
+		if (this._tag === "Ok") return {
+			_tag: "Ok",
+			value: this.value
+		};
+		if (this._tag === "Err") return {
+			_tag: "Err",
+			error: this.error
+		};
+		throw new InvalidResultStateError("Result.toSerialized");
+	}
+	/**
 	* Serializes the Result into a simple object format.
 	* Preserves the original types.
+	*
+	* @deprecated Use {@link toSerialized} instead: with this format,
+	* `Ok(undefined)` is indistinguishable from a missing `data` field, and
+	* there is no way to rebuild a Result from it. `toSerialized()`
+	* round-trips via `fromSerialized(...)`.
 	*/
 	serialize() {
 		if (this._tag === "Ok") return {
@@ -778,6 +487,12 @@ var ResultBase = class extends Pipeable {
 		};
 	}
 };
+Object.defineProperty(ResultBase.prototype, RESULT_BRAND, {
+	value: true,
+	enumerable: false,
+	configurable: false,
+	writable: false
+});
 var Ok = class extends ResultBase {
 	_tag = "Ok";
 	value;
@@ -857,5 +572,5 @@ const Result = {
 };
 
 //#endregion
-export { flatMap as A, isResult as B, tryCatch as C, match as D, recoverWith as E, combine as F, zip as I, all as L, mapBoth as M, mapErr as N, filter as O, map as P, sequence as R, tryMap as S, recover as T, tapAsync as _, fromNullable as a, mapAsync as b, ok as c, tryAsync as d, tryFn as f, filterAsync as g, matchAsync as h, err as i, bimap as j, tap as k, okIf as l, tryCatchAsync as m, Ok as n, fromPromise as o, tryMapAsync as p, Result as r, fromThrowable as s, Err as t, okIfLazy as u, flatMapAsync as v, swap as w, collectFirstOk as x, mapErrAsync as y, matchTag as z };
-//# sourceMappingURL=result-DKKaNdOx.mjs.map
+export { matchTag as _, fromNullable as a, ok as c, tryAsync as d, tryFn as f, sequence as g, all as h, err as i, okIf as l, zip as m, Ok as n, fromPromise as o, combine as p, Result as r, fromThrowable as s, Err as t, okIfLazy as u, isResult as v };
+//# sourceMappingURL=result-q9Na2bGa.mjs.map