@shirudo/result 1.0.1 → 1.1.0

package/dist/{result-CY-KIivk.cjs → result-BBOGxvSH.cjs}

@@ -1,4 +1,4 @@
-const require_errors = require('./errors-D2EMzJQl.cjs');
+const require_errors = require('./errors.cjs');
 
 //#region src/core/pipeable.ts
 var Pipeable = class {
@@ -48,8 +48,9 @@ function matchTag(result, key, handlers) {
 	if (result.isOk()) throw new require_errors.MatchOnOkError("matchTag");
 	if (result.isErr()) {
 		const error = result.error;
-		const handler = handlers[error[key]];
-		if (typeof handler !== "function") throw new require_errors.InvalidResultStateError("matchTag");
+		const tag = error[key];
+		const handler = Object.hasOwn(handlers, tag) ? handlers[tag] : void 0;
+		if (typeof handler !== "function") throw new require_errors.MatchTagMissingHandlerError(tag);
 		return handler(error);
 	}
 	throw new require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.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 require_errors.ExpectOkError(message);
+		if (this._tag === "Err") throw new require_errors.ExpectOkError(message, this.error);
 		throw new require_errors.InvalidResultStateError("Result.expect");
 	}
 	expectErr(message) {
 		if (this._tag === "Err") return this.error;
-		if (this._tag === "Ok") throw new require_errors.ExpectErrError(message);
+		if (this._tag === "Ok") throw new require_errors.ExpectErrError(message, this.value);
 		throw new require_errors.InvalidResultStateError("Result.expectErr");
 	}
 	toPromise() {
@@ -723,12 +403,17 @@ var ResultBase = class extends Pipeable {
 		throw new require_errors.InvalidResultStateError("Result.matchErrorAsync");
 	}
 	/**
-	* Matches on the Err value via `.when(...)` chain.
+	* Matches on the **Err** value via a `.when(...)` chain.
+	*
+	* 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}.
 	*
-	* Note: for type safety reasons, `.match()` can only be called on a Result already narrowed to `Err`,
-	* e.g. inside `if (result.isErr()) { ... }`.
+	* 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.
+	* @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 require_errors.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;
@@ -881,18 +596,6 @@ Object.defineProperty(exports, 'all', {
     return all;
   }
 });
-Object.defineProperty(exports, 'bimap', {
-  enumerable: true,
-  get: function () {
-    return bimap;
-  }
-});
-Object.defineProperty(exports, 'collectFirstOk', {
-  enumerable: true,
-  get: function () {
-    return collectFirstOk;
-  }
-});
 Object.defineProperty(exports, 'combine', {
   enumerable: true,
   get: function () {
@@ -905,30 +608,6 @@ Object.defineProperty(exports, 'err', {
     return err;
   }
 });
-Object.defineProperty(exports, 'filter', {
-  enumerable: true,
-  get: function () {
-    return filter;
-  }
-});
-Object.defineProperty(exports, 'filterAsync', {
-  enumerable: true,
-  get: function () {
-    return filterAsync;
-  }
-});
-Object.defineProperty(exports, 'flatMap', {
-  enumerable: true,
-  get: function () {
-    return flatMap;
-  }
-});
-Object.defineProperty(exports, 'flatMapAsync', {
-  enumerable: true,
-  get: function () {
-    return flatMapAsync;
-  }
-});
 Object.defineProperty(exports, 'fromNullable', {
   enumerable: true,
   get: function () {
@@ -953,48 +632,6 @@ Object.defineProperty(exports, 'isResult', {
     return isResult;
   }
 });
-Object.defineProperty(exports, 'map', {
-  enumerable: true,
-  get: function () {
-    return map;
-  }
-});
-Object.defineProperty(exports, 'mapAsync', {
-  enumerable: true,
-  get: function () {
-    return mapAsync;
-  }
-});
-Object.defineProperty(exports, 'mapBoth', {
-  enumerable: true,
-  get: function () {
-    return mapBoth;
-  }
-});
-Object.defineProperty(exports, 'mapErr', {
-  enumerable: true,
-  get: function () {
-    return mapErr;
-  }
-});
-Object.defineProperty(exports, 'mapErrAsync', {
-  enumerable: true,
-  get: function () {
-    return mapErrAsync;
-  }
-});
-Object.defineProperty(exports, 'match', {
-  enumerable: true,
-  get: function () {
-    return match;
-  }
-});
-Object.defineProperty(exports, 'matchAsync', {
-  enumerable: true,
-  get: function () {
-    return matchAsync;
-  }
-});
 Object.defineProperty(exports, 'matchTag', {
   enumerable: true,
   get: function () {
@@ -1019,82 +656,28 @@ Object.defineProperty(exports, 'okIfLazy', {
     return okIfLazy;
   }
 });
-Object.defineProperty(exports, 'recover', {
-  enumerable: true,
-  get: function () {
-    return recover;
-  }
-});
-Object.defineProperty(exports, 'recoverWith', {
-  enumerable: true,
-  get: function () {
-    return recoverWith;
-  }
-});
 Object.defineProperty(exports, 'sequence', {
   enumerable: true,
   get: function () {
     return sequence;
   }
 });
-Object.defineProperty(exports, 'swap', {
-  enumerable: true,
-  get: function () {
-    return swap;
-  }
-});
-Object.defineProperty(exports, 'tap', {
-  enumerable: true,
-  get: function () {
-    return tap;
-  }
-});
-Object.defineProperty(exports, 'tapAsync', {
-  enumerable: true,
-  get: function () {
-    return tapAsync;
-  }
-});
 Object.defineProperty(exports, 'tryAsync', {
   enumerable: true,
   get: function () {
     return tryAsync;
   }
 });
-Object.defineProperty(exports, 'tryCatch', {
-  enumerable: true,
-  get: function () {
-    return tryCatch;
-  }
-});
-Object.defineProperty(exports, 'tryCatchAsync', {
-  enumerable: true,
-  get: function () {
-    return tryCatchAsync;
-  }
-});
 Object.defineProperty(exports, 'tryFn', {
   enumerable: true,
   get: function () {
     return tryFn;
   }
 });
-Object.defineProperty(exports, 'tryMap', {
-  enumerable: true,
-  get: function () {
-    return tryMap;
-  }
-});
-Object.defineProperty(exports, 'tryMapAsync', {
-  enumerable: true,
-  get: function () {
-    return tryMapAsync;
-  }
-});
 Object.defineProperty(exports, 'zip', {
   enumerable: true,
   get: function () {
     return zip;
   }
 });
-//# sourceMappingURL=result-CY-KIivk.cjs.map
+//# sourceMappingURL=result-BBOGxvSH.cjs.map