resultar 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/index.js

@@ -1,719 +1,4 @@
-//#region src/error.ts
-const defaultErrorConfig = { withStackTrace: false };
-const createResultarError = (message, result, config = defaultErrorConfig) => {
-	return {
-		name: "ResultarError",
-		data: result.isOk() ? {
-			type: "Ok",
-			value: result.value
-		} : {
-			type: "Err",
-			value: result.error
-		},
-		message,
-		stack: config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0
-	};
-};
-//#endregion
-//#region src/utils.ts
-/**
-* Short circuits on the FIRST Err value that we find
-*/
-const combineResultList = (resultList) => {
-	const values = [];
-	for (const result of resultList) {
-		if (result.isErr()) return err(result.error);
-		values.push(result.value);
-	}
-	return ok(values);
-};
-const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
-/**
-* Give a list of all the errors we find
-*/
-const combineResultListWithAllErrors = (resultList) => {
-	let acc = ok([]);
-	for (const result of resultList) if (result.isErr() && acc.isErr()) acc.error.push(result.error);
-	else if (result.isErr() && acc.isOk()) acc = err([result.error]);
-	else if (result.isOk() && acc.isOk()) acc.value.push(result.value);
-	return acc;
-};
-const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
-//#endregion
-//#region src/result.ts
-const hasTag$1 = (value, tag) => typeof value === "object" && value !== null && "_tag" in value && value._tag === tag;
-/**
-* Runtime namespace for Result constructors and static helpers.
-*/
-var ResultNamespace = class {
-	static [Symbol.hasInstance](value) {
-		return value instanceof Ok || value instanceof Err;
-	}
-	/**
-	* Creates a `Result` by running a function that might throw.
-	* If the function throws, the error will be caught and returned as an `Err`.
-	* If the function succeeds, the value will be wrapped in an `Ok`.
-	*
-	* @param fn - The function to execute, which might throw an error
-	* @param errorFn - Optional function to transform the thrown error before wrapping in `Err`
-	* @returns A `Result` containing either the function's return value or the caught error
-	*/
-	static tryCatch(fn, errorFn) {
-		try {
-			return ok(fn());
-		} catch (error) {
-			if (errorFn) return err(errorFn(error));
-			return err(error);
-		}
-	}
-	/**
-	* Wraps a function with a try catch, creating a new function with the same
-	* arguments but returning `Ok` if successful, `Err` if the function throws
-	*
-	* @param fn function to wrap with ok on success or err on failure
-	* @param errorFn when an error is thrown, this will wrap the error result if provided
-	*/
-	static fromThrowable(fn, errorFn) {
-		return (...args) => {
-			try {
-				return ok(fn(...args));
-			} catch (error) {
-				if (errorFn) return err(errorFn(error));
-				return err(error);
-			}
-		};
-	}
-	static ok(value) {
-		return ok(value);
-	}
-	/**
-	* Creates a new `Result` instance representing a successful operation with an undefined value.
-	*
-	* @return {Result<undefined, E>} A new `Result` instance with an undefined value.
-	*/
-	static unit() {
-		return unit();
-	}
-	static err(error) {
-		return err(error);
-	}
-	static combine(resultList) {
-		return combineResultList(resultList);
-	}
-	static combineWithAllErrors(resultList) {
-		return combineResultListWithAllErrors(resultList);
-	}
-};
-const Result = ResultNamespace;
-var Ok = class {
-	constructor(value) {
-		this.value = value;
-	}
-	isOk() {
-		return true;
-	}
-	isErr() {
-		return false;
-	}
-	map(f) {
-		return ok(f(this.value));
-	}
-	filterOrElse(predicate, onFalse) {
-		if (predicate(this.value)) return ok(this.value);
-		return err(onFalse(this.value));
-	}
-	mapErr(_fn) {
-		return ok(this.value);
-	}
-	andThen(f) {
-		return f(this.value);
-	}
-	if(fCondition) {
-		return { true: (fTrue) => ({ false: (fFalse) => fCondition(this.value) ? fTrue(this.value) : fFalse(this.value) }) };
-	}
-	orElse(_f) {
-		return ok(this.value);
-	}
-	catchTag(_tag, _f) {
-		return ok(this.value);
-	}
-	catchTags(_handlers) {
-		return ok(this.value);
-	}
-	asyncAndThen(f) {
-		return f(this.value);
-	}
-	asyncMap(f) {
-		return ResultAsync.fromSafePromise(f(this.value));
-	}
-	unwrapOr(_defaultValue) {
-		return this.value;
-	}
-	match(fnOk, _fnErr) {
-		return fnOk(this.value);
-	}
-	matchTags(fnOk, _handlers) {
-		return fnOk(this.value);
-	}
-	matchTagsPartial(fnOk, _handlers, _fallback) {
-		return fnOk(this.value);
-	}
-	pipe(...fns) {
-		const first = fns[0];
-		if (!first) return this;
-		let input = first(this);
-		for (const fn of fns.slice(1)) input = fn(input);
-		return input;
-	}
-	log(fn) {
-		try {
-			fn(this.value, void 0);
-		} catch {}
-		return this;
-	}
-	tap(fn) {
-		try {
-			fn(this.value);
-		} catch {}
-		return this;
-	}
-	tapError(_fn) {
-		return this;
-	}
-	finally(f) {
-		const resultDisposable = new DisposableResult(this, f);
-		try {
-			return resultDisposable;
-		} finally {
-			try {
-				resultDisposable[Symbol.dispose]();
-			} catch {}
-		}
-	}
-	unwrapOrThrow() {
-		return this.value;
-	}
-	_unsafeUnwrap(_config) {
-		return this.value;
-	}
-	_unsafeUnwrapErr(config) {
-		throw createResultarError("Called `_unsafeUnwrapErr` on an Ok", this, config);
-	}
-	*[Symbol.iterator]() {
-		return this.value;
-	}
-	safeUnwrap() {
-		const { value } = this;
-		return (function* () {
-			return value;
-		})();
-	}
-};
-var Err = class {
-	constructor(error) {
-		this.error = error;
-	}
-	isOk() {
-		return false;
-	}
-	isErr() {
-		return true;
-	}
-	map(_f) {
-		return err(this.error);
-	}
-	filterOrElse(_predicate, _onFalse) {
-		return err(this.error);
-	}
-	mapErr(fn) {
-		return err(fn(this.error));
-	}
-	andThen(_f) {
-		return err(this.error);
-	}
-	if(_fCondition) {
-		return { true: (_fTrue) => ({ false: (_fFalse) => err(this.error) }) };
-	}
-	orElse(f) {
-		return f(this.error);
-	}
-	catchTag(tag, f) {
-		if (hasTag$1(this.error, tag)) return f(this.error);
-		return err(this.error);
-	}
-	catchTags(handlers) {
-		const error = this.error;
-		if (typeof error === "object" && error !== null && "_tag" in error) {
-			const handler = handlers[error._tag];
-			if (handler !== void 0) return handler(error);
-		}
-		return err(error);
-	}
-	asyncAndThen(_f) {
-		return errAsync(this.error);
-	}
-	asyncMap(_f) {
-		return errAsync(this.error);
-	}
-	unwrapOr(defaultValue) {
-		return defaultValue;
-	}
-	match(_fnOk, fnErr) {
-		return fnErr(this.error);
-	}
-	matchTags(_fnOk, handlers) {
-		const error = this.error;
-		if (typeof error === "object" && error !== null && "_tag" in error) {
-			const handler = handlers[error._tag];
-			if (handler !== void 0) return handler(error);
-		}
-		if (handlers.Error) return handlers.Error(error);
-		throw error;
-	}
-	matchTagsPartial(_fnOk, handlers, fallback) {
-		const error = this.error;
-		const errorHandler = handlers.Error;
-		if (typeof error === "object" && error !== null && "_tag" in error) {
-			const handler = handlers[error._tag];
-			if (handler !== void 0) return handler(error);
-		}
-		if (errorHandler) return errorHandler(error);
-		return fallback(error);
-	}
-	pipe(...fns) {
-		const first = fns[0];
-		if (!first) return this;
-		let input = first(this);
-		for (const fn of fns.slice(1)) input = fn(input);
-		return input;
-	}
-	log(fn) {
-		try {
-			fn(void 0, this.error);
-		} catch {}
-		return this;
-	}
-	tap(_fn) {
-		return this;
-	}
-	tapError(fn) {
-		try {
-			fn(this.error);
-		} catch {}
-		return this;
-	}
-	finally(f) {
-		const resultDisposable = new DisposableResult(this, f);
-		try {
-			return resultDisposable;
-		} finally {
-			try {
-				resultDisposable[Symbol.dispose]();
-			} catch {}
-		}
-	}
-	unwrapOrThrow() {
-		throw this.error;
-	}
-	_unsafeUnwrap(config) {
-		throw createResultarError("Called `_unsafeUnwrap` on an Err", this, config);
-	}
-	_unsafeUnwrapErr(_config) {
-		return this.error;
-	}
-	*[Symbol.iterator]() {
-		yield this;
-		return this;
-	}
-	safeUnwrap() {
-		const { error } = this;
-		return (function* () {
-			yield err(error);
-			throw new Error("Do not use this generator out of `safeTry`");
-		})();
-	}
-};
-/**
-* A `Disposable` is an object that has a `dispose` method that can be used to
-* clean up resources.
-*/
-var DisposableResult = class {
-	constructor(result, finalizer) {
-		this.result = result;
-		this.finalizer = finalizer;
-	}
-	get value() {
-		return this.result.isOk() ? this.result.value : void 0;
-	}
-	get error() {
-		return this.result.isErr() ? this.result.error : void 0;
-	}
-	_unsafeUnwrap(config) {
-		return this.result._unsafeUnwrap(config);
-	}
-	_unsafeUnwrapErr(config) {
-		return this.result._unsafeUnwrapErr(config);
-	}
-	isOk() {
-		return this.result.isOk();
-	}
-	isErr() {
-		return this.result.isErr();
-	}
-	unwrapOr(defaultValue) {
-		return this.result.unwrapOr(defaultValue);
-	}
-	[Symbol.dispose]() {
-		this.finalizer(this.result.isOk() ? this.result.value : void 0, this.result.isErr() ? this.result.error : void 0);
-	}
-};
-function safeTry(body) {
-	const n = body().next();
-	if (n instanceof Promise) return new ResultAsync(n.then((r) => r.value));
-	return n.value;
-}
-function ok(value) {
-	return new Ok(value);
-}
-function err(error) {
-	return new Err(error);
-}
-const fromThrowable = Result.fromThrowable;
-function unit() {
-	return ok(void 0);
-}
-const tryCatch = Result.tryCatch;
-//#endregion
-//#region src/result-async.ts
-const hasTag = (value, tag) => typeof value === "object" && value !== null && "_tag" in value && value._tag === tag;
-var DisposableResultAsync = class {
-	innerPromise;
-	constructor(res) {
-		this.innerPromise = res;
-	}
-	then(successCallback, failureCallback) {
-		return this.innerPromise.then(successCallback, failureCallback);
-	}
-};
-/**
-* Represents an asynchronous Result type that wraps a Promise of a Result<T, E>.
-* This class provides a way to handle asynchronous operations that may succeed with a value of type T
-* or fail with an error of type E.
-*
-* @template T - The type of the success value
-* @template E - The type of the error value
-*
-* @implements {PromiseLike<Result<T, E>>}
-*
-* @example
-* ```typescript
-* // Create a successful async result
-* const okAsync = ResultAsync.okAsync(42);
-*
-* // Create a failed async result
-* const errAsync = ResultAsync.errAsync(new Error("Something went wrong"));
-*
-* // Transform a Promise into a ResultAsync
-* const resultFromPromise = ResultAsync.fromPromise(
-*   fetch("https://api.example.com/data"),
-*   (error) => new Error(`API call failed: ${error}`)
-* );
-* ```
-*
-* @remarks
-* ResultAsync implements the PromiseLike interface, allowing it to be used with async/await syntax.
-* It provides various utility methods for transforming and combining results, similar to the Result type,
-* but operating in an asynchronous context.
-*
-* The class includes methods for:
-* - Creating ResultAsync instances (okAsync, errAsync, fromPromise)
-* - Transforming values (map, mapErr)
-* - Chaining operations (andThen, orElse)
-* - Error handling (tapError)
-* - Conditional branching (if)
-* - Combining multiple ResultAsync instances (combine, combineWithAllErrors)
-*/
-var ResultAsync = class ResultAsync {
-	static okAsync(value) {
-		return new ResultAsync(Promise.resolve(Result.ok(value)));
-	}
-	/**
-	* Returns a ResultAsync that is immediately resolved with a Result.ok(undefined) value.
-	*
-	* @return {ResultAsync<undefined, E>} A ResultAsync instance with undefined as the value type and E as the error type.
-	*/
-	static unitAsync() {
-		return new ResultAsync(Promise.resolve(Result.unit()));
-	}
-	static errAsync(error) {
-		return new ResultAsync(Promise.resolve(Result.err(error)));
-	}
-	static tryCatch(fn, errorFn) {
-		return new ResultAsync((typeof fn === "function" ? Promise.try(fn) : fn).then((value) => Result.ok(value)).catch((error) => {
-			if (errorFn) return Result.err(errorFn(error));
-			return Result.err(error);
-		}));
-	}
-	static fromSafePromise(promise) {
-		return new ResultAsync(promise.then((value) => Result.ok(value)));
-	}
-	static fromPromise(promise, errorFn) {
-		return new ResultAsync(promise.then((value) => Result.ok(value)).catch((error) => Result.err(errorFn(error))));
-	}
-	static combine(asyncResultList) {
-		return combineResultAsyncList(asyncResultList);
-	}
-	static combineWithAllErrors(asyncResultList) {
-		return combineResultAsyncListWithAllErrors(asyncResultList);
-	}
-	/**
-	* Wraps a async function with a try catch, creating a new function with the same
-	* arguments but returning `Ok` if successful, `Err` if the function throws
-	*
-	* @param fn function to wrap with ok on success or err on failure
-	* @param errorFn when an error is thrown, this will wrap the error result if provided
-	* @returns a new function that returns a `ResultAsync`
-	*/
-	static fromThrowable(fn, errorFn) {
-		return (...args) => new ResultAsync((async () => {
-			try {
-				const v = await fn(...args);
-				return Result.ok(v);
-			} catch (error) {
-				const e = errorFn ? errorFn(error) : error;
-				return Result.err(e);
-			}
-		})());
-	}
-	innerPromise;
-	constructor(res) {
-		this.innerPromise = res;
-	}
-	then(successCallback, failureCallback) {
-		return this.innerPromise.then(successCallback, failureCallback);
-	}
-	mapErr(f) {
-		return new ResultAsync(this.innerPromise.then(async (res) => {
-			if (res.isOk()) return Result.ok(res.value);
-			return Result.err(await f(res.error));
-		}));
-	}
-	map(f) {
-		return new ResultAsync(this.innerPromise.then(async (res) => {
-			if (res.isErr()) return Result.err(res.error);
-			return Result.ok(await f(res.value));
-		}));
-	}
-	filterOrElse(predicate, onFalse) {
-		return new ResultAsync(this.innerPromise.then(async (res) => {
-			if (res.isErr()) return Result.err(res.error);
-			if (await predicate(res.value)) return Result.ok(res.value);
-			return Result.err(await onFalse(res.value));
-		}));
-	}
-	andThen(f) {
-		return new ResultAsync(this.innerPromise.then((res) => {
-			if (res.isErr()) return Result.err(res.error);
-			const next = f(res.value);
-			return next instanceof ResultAsync ? next.innerPromise : next;
-		}));
-	}
-	if(fCondition) {
-		return { true: (fTrue) => ({ false: (fFalse) => new ResultAsync(this.innerPromise.then(async (res) => {
-			if (res.isOk()) return fCondition(res.value) ? fTrue(res.value) : fFalse(res.value);
-			return errAsync(res.error);
-		})) }) };
-	}
-	orElse(f) {
-		return new ResultAsync(this.innerPromise.then((res) => {
-			if (res.isErr()) {
-				const next = f(res.error);
-				return next instanceof ResultAsync ? next.innerPromise : next;
-			}
-			return Result.ok(res.value);
-		}));
-	}
-	catchTag(tag, f) {
-		return new ResultAsync(this.innerPromise.then((res) => {
-			if (res.isOk()) return Result.ok(res.value);
-			if (hasTag(res.error, tag)) {
-				const next = f(res.error);
-				return next instanceof ResultAsync ? next.innerPromise : next;
-			}
-			return Result.err(res.error);
-		}));
-	}
-	catchTags(handlers) {
-		return new ResultAsync(this.innerPromise.then((res) => {
-			if (res.isOk()) return Result.ok(res.value);
-			const error = res.error;
-			if (typeof error === "object" && error !== null && "_tag" in error) {
-				const handler = handlers[error._tag];
-				if (handler !== void 0) {
-					const next = handler(error);
-					return next instanceof ResultAsync ? next.innerPromise : next;
-				}
-			}
-			return Result.err(error);
-		}));
-	}
-	async match(ok, fnErr) {
-		return this.innerPromise.then((res) => res.match(ok, fnErr));
-	}
-	async matchTags(ok, handlers) {
-		return this.innerPromise.then((res) => {
-			if (res.isOk()) return ok(res.value);
-			const error = res.error;
-			if (typeof error === "object" && error !== null && "_tag" in error) {
-				const handler = handlers[error._tag];
-				if (handler !== void 0) return handler(error);
-			}
-			if (handlers.Error) return handlers.Error(error);
-			throw error;
-		});
-	}
-	async matchTagsPartial(ok, handlers, fallback) {
-		return this.innerPromise.then((res) => {
-			if (res.isOk()) return ok(res.value);
-			const error = res.error;
-			const errorHandler = handlers.Error;
-			if (typeof error === "object" && error !== null && "_tag" in error) {
-				const handler = handlers[error._tag];
-				if (handler !== void 0) return handler(error);
-			}
-			if (errorHandler) return errorHandler(error);
-			return fallback(error);
-		});
-	}
-	async unwrapOr(t) {
-		return this.innerPromise.then((res) => res.unwrapOr(t));
-	}
-	async unwrapOrThrow() {
-		return this.innerPromise.then((res) => res.unwrapOrThrow());
-	}
-	pipe(...fns) {
-		const first = fns[0];
-		if (!first) return this;
-		let input = first(this);
-		for (const fn of fns.slice(1)) input = fn(input);
-		return input;
-	}
-	/**
-	* Runs a side effect for either variant and preserves the original async result.
-	*
-	* For `Ok`, the callback receives `(value, undefined)`.
-	* For `Err`, the callback receives `(undefined, error)`.
-	* Callback errors and rejected callback promises are intentionally ignored.
-	*
-	* Use `map`, `mapErr`, `andThen`, or `orElse` when the callback should
-	* transform the result.
-	*/
-	log(f) {
-		return new ResultAsync(this.innerPromise.then(async (res) => {
-			if (res.isOk()) {
-				try {
-					await f(res.value);
-				} catch {}
-				return okAsync(res.value);
-			}
-			try {
-				await f(void 0, res.error);
-			} catch {}
-			return errAsync(res.error);
-		}));
-	}
-	/**
-	* Runs a side effect only for the `Ok` variant and preserves the original async result.
-	*
-	* Callback errors and rejected callback promises are intentionally ignored.
-	* Use `map` or `andThen` when the callback should transform the value.
-	*/
-	tap(f) {
-		return new ResultAsync(this.innerPromise.then(async (res) => {
-			if (res.isErr()) return errAsync(res.error);
-			try {
-				await f(res.value);
-			} catch {}
-			return okAsync(res.value);
-		}));
-	}
-	/**
-	* Runs a side effect only for the `Err` variant and preserves the original async result.
-	*
-	* Callback errors and rejected callback promises are intentionally ignored.
-	* Use `mapErr` or `orElse` when the callback should transform the error.
-	*/
-	tapError(f) {
-		return new ResultAsync(this.innerPromise.then(async (res) => {
-			if (res.isErr()) {
-				try {
-					await f(res.error);
-				} catch {}
-				return errAsync(res.error);
-			}
-			return okAsync(res.value);
-		}));
-	}
-	/**
-	* Runs a cleanup side effect with `(value, error)` after the inner promise
-	* settles to a `Result`, then preserves the original async result.
-	*
-	* Callback errors and rejected callback promises are intentionally ignored.
-	*/
-	finally(f) {
-		return new DisposableResultAsync(this.innerPromise.then(async (res) => {
-			try {
-				await f(res.isOk() ? res.value : void 0, res.isErr() ? res.error : void 0);
-			} catch {}
-			return res;
-		}));
-	}
-	async *[Symbol.asyncIterator]() {
-		const result = await this.innerPromise;
-		if (result.isOk()) return result.value;
-		yield err(result.error);
-		return void 0;
-	}
-	/**
-	* @deprecated will be removed in 2.0.0.
-	*
-	* You can use `safeTry` without this method.
-	* @example
-	* ```typescript
-	* safeTry(async function* () {
-	*   const okValue = yield* yourResult
-	* })
-	* ```
-	* Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-	*/
-	async *safeUnwrap() {
-		const result = await this.innerPromise;
-		if (result.isOk()) return result.value;
-		yield err(result.error);
-		throw new Error("Do not use this generator out of `safeTry`");
-	}
-};
-/**
-* @deprecated Use `safeTry` instead.
-* @see `safeTry`
-*
-* This will be removed in the next major version.
-*/
-function safeTryAsync(body) {
-	return new ResultAsync((async () => {
-		const n = await body().next();
-		if (n.value.isOk()) return okAsync(n.value.value);
-		return errAsync(n.value.error);
-	})());
-}
-const okAsync = ResultAsync.okAsync;
-const errAsync = ResultAsync.errAsync;
-const fromPromise = ResultAsync.fromPromise;
-const fromSafePromise = ResultAsync.fromSafePromise;
-const unitAsync = ResultAsync.unitAsync;
-const fromThrowableAsync = ResultAsync.fromThrowable;
-const tryCatchAsync = ResultAsync.tryCatch;
-//#endregion
+import { _ as unit, a as fromSafePromise, c as tryCatchAsync, d as Result, f as err, g as tryCatch, h as safeTry, i as fromPromise, l as unitAsync, m as ok, n as ResultAsync, o as fromThrowableAsync, p as fromThrowable, r as errAsync, s as okAsync, t as DisposableResultAsync, u as DisposableResult } from "./result-async-CdlVdXgX.js";
 //#region src/tagged-error.ts
 const defaultBaseError = Error;
 const defaultMessageTemplate = "$message";
@@ -814,7 +99,7 @@ function createTaggedError(options) {
 				messageTemplate: this.messageTemplate,
 				name: this.name
 			};
-			if (this.cause !== void 0) json.cause = serializeCause(this.cause);
+			if (this.cause !== void 0) json["cause"] = serializeCause(this.cause);
 			for (const [key, value] of Object.entries(this)) if (!(key in json) && key !== "cause" && key !== "stack") json[key] = value;
 			return json;
 		}
@@ -838,6 +123,6 @@ const matchErrorPartial = (error, handlers, fallback) => {
 	return fallback(error);
 };
 //#endregion
-export { Result, ResultAsync, createTaggedError, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, safeTryAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+export { DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryCatch, tryCatchAsync, unit, unitAsync };
 
 //# sourceMappingURL=index.js.map