resultar 2.0.0 → 3.0.0-alpha.1

package/dist/result-async-CdlVdXgX.js

@@ -1,698 +0,0 @@
-//#region src/error.ts
-const defaultErrorConfig = { withStackTrace: false };
-const createResultarError = (message, result, config = defaultErrorConfig) => {
-	const data = result.isOk() ? {
-		type: "Ok",
-		value: result.value
-	} : {
-		type: "Err",
-		value: result.error
-	};
-	const maybeStack = config.withStackTrace ? (/* @__PURE__ */ new Error()).stack : void 0;
-	const error = {
-		name: "ResultarError",
-		data,
-		message
-	};
-	return maybeStack === void 0 ? error : Object.assign(error, { stack: maybeStack });
-};
-//#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/tagged-match.ts
-const isTaggedValue = (value) => typeof value === "object" && value !== null && "_tag" in value;
-const hasTag = (value, tag) => isTaggedValue(value) && value._tag === tag;
-const callTaggedHandler = (value, handlers) => {
-	if (!isTaggedValue(value)) return { matched: false };
-	const handler = handlers[value._tag];
-	if (handler === void 0) return { matched: false };
-	return {
-		matched: true,
-		value: handler(value)
-	};
-};
-const callErrorHandler = (error, handlers) => {
-	if (handlers.Error === void 0) return { matched: false };
-	return {
-		matched: true,
-		value: handlers.Error(error)
-	};
-};
-//#endregion
-//#region src/result.ts
-/**
-* 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 {
-	value;
-	constructor(value) {
-		this.value = value;
-	}
-	isOk() {
-		this;
-		return true;
-	}
-	isErr() {
-		this;
-		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;
-	}
-	toDisposable(f) {
-		return new DisposableResult(this, f);
-	}
-	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 {
-	error;
-	constructor(error) {
-		this.error = error;
-	}
-	isOk() {
-		this;
-		return false;
-	}
-	isErr() {
-		this;
-		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(this.error, tag)) return f(this.error);
-		return err(this.error);
-	}
-	catchTags(handlers) {
-		const error = this.error;
-		const handled = callTaggedHandler(error, handlers);
-		if (handled.matched) return handled.value;
-		return err(error);
-	}
-	asyncAndThen(_f) {
-		return errAsync(this.error);
-	}
-	asyncMap(_f) {
-		return errAsync(this.error);
-	}
-	unwrapOr(defaultValue) {
-		this;
-		return defaultValue;
-	}
-	match(_fnOk, fnErr) {
-		return fnErr(this.error);
-	}
-	matchTags(_fnOk, handlers) {
-		const error = this.error;
-		const tagged = callTaggedHandler(error, handlers);
-		if (tagged.matched) return tagged.value;
-		const errorHandler = callErrorHandler(error, handlers);
-		if (errorHandler.matched) return errorHandler.value;
-		throw error;
-	}
-	matchTagsPartial(_fnOk, handlers, fallback) {
-		const error = this.error;
-		const tagged = callTaggedHandler(error, handlers);
-		if (tagged.matched) return tagged.value;
-		const errorHandler = callErrorHandler(error, handlers);
-		if (errorHandler.matched) return errorHandler.value;
-		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;
-	}
-	toDisposable(f) {
-		return new DisposableResult(this, f);
-	}
-	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 {
-	disposed = false;
-	finalizer;
-	result;
-	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]() {
-		if (this.disposed) return;
-		this.disposed = true;
-		try {
-			this.finalizer(this.result.isOk() ? this.result.value : void 0, this.result.isErr() ? this.result.error : void 0);
-		} catch {}
-	}
-};
-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
-var DisposableResultAsync = class {
-	innerPromise;
-	finalizer;
-	disposed = false;
-	constructor(res, finalizer) {
-		this.innerPromise = res;
-		this.finalizer = finalizer;
-	}
-	then(successCallback, failureCallback) {
-		return this.innerPromise.then(successCallback, failureCallback);
-	}
-	async [Symbol.asyncDispose]() {
-		if (this.disposed) return;
-		this.disposed = true;
-		const result = await this.innerPromise;
-		try {
-			await this.finalizer(result.isOk() ? result.value : void 0, result.isErr() ? result.error : void 0);
-		} catch {}
-	}
-};
-/**
-* 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;
-			const handled = callTaggedHandler(error, handlers);
-			if (handled.matched) {
-				const next = handled.value;
-				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;
-			const tagged = callTaggedHandler(error, handlers);
-			if (tagged.matched) return tagged.value;
-			const errorHandler = callErrorHandler(error, handlers);
-			if (errorHandler.matched) return errorHandler.value;
-			throw error;
-		});
-	}
-	async matchTagsPartial(ok, handlers, fallback) {
-		return this.innerPromise.then((res) => {
-			if (res.isOk()) return ok(res.value);
-			const error = res.error;
-			const tagged = callTaggedHandler(error, handlers);
-			if (tagged.matched) return tagged.value;
-			const errorHandler = callErrorHandler(error, handlers);
-			if (errorHandler.matched) return errorHandler.value;
-			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);
-		}));
-	}
-	toAsyncDisposable(f) {
-		return new DisposableResultAsync(this.innerPromise, f);
-	}
-	async *[Symbol.asyncIterator]() {
-		const result = await this.innerPromise;
-		if (result.isOk()) return result.value;
-		yield err(result.error);
-		return void 0;
-	}
-};
-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
-export { unit as _, fromSafePromise as a, tryCatchAsync as c, Result as d, err as f, tryCatch as g, safeTry as h, fromPromise as i, unitAsync as l, ok as m, ResultAsync as n, fromThrowableAsync as o, fromThrowable as p, errAsync as r, okAsync as s, DisposableResultAsync as t, DisposableResult as u };
-
-//# sourceMappingURL=result-async-CdlVdXgX.js.map