better-effect 0.10.0 → 0.11.0

package/dist/effect-2ZcGZI8A.mjs

@@ -0,0 +1,513 @@
+import { t as isPromiseLike } from "./runtime-CDcCF5cb.mjs";
+import { t as Scope } from "./scope-GGnmTQck.mjs";
+import { Err, Result, matchError, matchErrorPartial } from "better-result";
+//#region src/effect/combinators.ts
+const asResult = (value) => {
+	return value;
+};
+const mapResult = (result, fn) => {
+	return Result.map(result, fn);
+};
+const mapErrorResult = (result, fn) => {
+	return Result.mapError(result, fn);
+};
+const andThenResult = (result, next) => {
+	const resultNext = next;
+	return Result.andThen(result, resultNext);
+};
+const andThenAsyncResult = (result, next) => {
+	const resultNext = (value) => {
+		return Promise.resolve(next(value));
+	};
+	return Result.andThenAsync(result, resultNext);
+};
+function map$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return map$1(effect, callback);
+		};
+	}
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return mapResult(result, fn);
+	});
+	return mapResult(first, fn);
+}
+function mapError$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return mapError$1(effect, callback);
+		};
+	}
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return mapErrorResult(result, fn);
+	});
+	return mapErrorResult(first, fn);
+}
+function andThen$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return andThen$1(effect, callback);
+		};
+	}
+	return andThenResult(first, second);
+}
+function andThenAsync(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => {
+			return andThenAsync(effect, callback);
+		};
+	}
+	const next = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => {
+		return andThenAsyncResult(result, next);
+	});
+	return andThenAsyncResult(first, next);
+}
+const tapResult = (result, fn) => Result.tap(result, fn);
+const tapErrorResult = (result, fn) => Result.tapError(result, fn);
+const tapBothResult = (result, handlers) => Result.tapBoth(result, handlers);
+const tapAsyncResult = (result, fn) => Result.tapAsync(result, (value) => Promise.resolve(fn(value)));
+const tapErrorAsyncResult = (result, fn) => Result.tapErrorAsync(result, (error) => Promise.resolve(fn(error)));
+const tapBothAsyncResult = (result, handlers) => Result.tapBothAsync(result, {
+	ok: (value) => Promise.resolve(handlers.ok(value)),
+	err: (error) => Promise.resolve(handlers.err(error))
+});
+const asTaggedResult = (result) => {
+	return result;
+};
+const matchErrorResult = (result, handlers) => {
+	return Result.mapError(result, (error) => matchError(error, handlers));
+};
+const matchErrorPartialResult = (result, handlers) => {
+	return Result.mapError(result, (error) => matchErrorPartial(error, handlers));
+};
+const recoverResult = (result, fn) => Result.tryRecover(result, fn);
+const recoverAsyncResult = (result, fn) => Result.tryRecoverAsync(result, (error) => Promise.resolve(fn(error)));
+const flattenResult = (result) => Result.flatten(result);
+const matchResult = (result, handlers) => Result.match(result, handlers);
+const allResult = (results) => Result.all(results);
+function tap$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tap$1(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tap requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapResult(asResult(result), fn));
+	return tapResult(asResult(first), fn);
+}
+function tapError$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tapError$1(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tapError requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapErrorResult(asResult(result), fn));
+	return tapErrorResult(asResult(first), fn);
+}
+function tapBoth(first, second) {
+	if (second === void 0) return (effect) => tapBoth(effect, first);
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapBothResult(result, second));
+	return tapBothResult(asResult(first), second);
+}
+function tapAsync(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tapAsync(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tapAsync requires a callback");
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapAsyncResult(asResult(result), second));
+	return tapAsyncResult(asResult(first), second);
+}
+function tapErrorAsync(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => tapErrorAsync(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.tapErrorAsync requires a callback");
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapErrorAsyncResult(asResult(result), second));
+	return tapErrorAsyncResult(asResult(first), second);
+}
+function tapBothAsync(first, second) {
+	if (second === void 0) return (effect) => tapBothAsync(effect, first);
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => tapBothAsyncResult(result, second));
+	return tapBothAsyncResult(asResult(first), second);
+}
+function matchError$1(first, second) {
+	if (second === void 0) throw new TypeError("Effect.matchError requires handlers");
+	const handlers = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => matchErrorResult(asTaggedResult(asResult(result)), handlers));
+	return matchErrorResult(asTaggedResult(asResult(first)), handlers);
+}
+function matchErrorPartial$1(first, second) {
+	if (second === void 0) throw new TypeError("Effect.matchErrorPartial requires handlers");
+	const handlers = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => matchErrorPartialResult(asTaggedResult(asResult(result)), handlers));
+	return matchErrorPartialResult(asTaggedResult(asResult(first)), handlers);
+}
+function recover$1(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => recover$1(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.recover requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => recoverResult(asResult(result), fn));
+	return recoverResult(asResult(first), fn);
+}
+function recoverAsync(first, second) {
+	if (first instanceof Function && second === void 0) {
+		const callback = first;
+		return (effect) => recoverAsync(effect, callback);
+	}
+	if (second === void 0) throw new TypeError("Effect.recoverAsync requires a callback");
+	const fn = second;
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => recoverAsyncResult(asResult(result), fn));
+	return recoverAsyncResult(asResult(first), fn);
+}
+/** Remove one nested Result/Effect layer. */
+function flatten(effect) {
+	return flattenResult(asResult(effect));
+}
+function as(first, second) {
+	if (arguments.length < 2) return (effect) => as(effect, first);
+	return mapResult(asResult(first), () => second);
+}
+/** Replace a successful value with void. */
+function asVoid(effect) {
+	return mapResult(asResult(effect), () => void 0);
+}
+function match(first, second) {
+	if (isPromiseLike(first)) return Promise.resolve(first).then((result) => match(asResult(result), second));
+	return matchResult(asResult(first), second);
+}
+/** Collect already-created Effects in input order. */
+function all(results) {
+	return allResult(results);
+}
+/** Combine two already-created Effects in input order. */
+function zip(left, right) {
+	return Result.all([left, right]);
+}
+//#endregion
+//#region src/effect/program-combinators.ts
+const asProgram = (program) => program;
+const isAsyncEffect = (effect) => isPromiseLike(effect);
+const mapRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.map(result, fn));
+	return Result.map(effect, fn);
+};
+const mapErrorRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.mapError(result, fn));
+	return Result.mapError(effect, fn);
+};
+const tapRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.tap(result, fn));
+	return Result.tap(effect, fn);
+};
+const tapErrorRuntime = (effect, fn) => {
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.tapError(result, fn));
+	return Result.tapError(effect, fn);
+};
+const invoke = (output) => output instanceof Function ? output() : output;
+const andThenRuntime = (effect, next) => {
+	const continueWith = (value) => Promise.resolve(invoke(next(value)));
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.andThenAsync(result, continueWith));
+	return Result.andThenAsync(effect, continueWith);
+};
+const recoverRuntime = (effect, recover) => {
+	const continueWith = (error) => Promise.resolve(invoke(recover(error)));
+	if (isAsyncEffect(effect)) return Promise.resolve(effect).then((result) => Result.tryRecoverAsync(result, continueWith));
+	return Result.tryRecoverAsync(effect, continueWith);
+};
+const mapProgram = (program, fn) => asProgram(() => mapRuntime(program(), fn));
+const mapErrorProgram = (program, fn) => asProgram(() => mapErrorRuntime(program(), fn));
+const tapProgram = (program, fn) => asProgram(() => tapRuntime(program(), fn));
+const tapErrorProgram = (program, fn) => asProgram(() => tapErrorRuntime(program(), fn));
+function map(first, second) {
+	if (second === void 0) return (program) => {
+		return mapProgram(program, first);
+	};
+	return mapProgram(first, second);
+}
+function mapError(first, second) {
+	if (second === void 0) return (program) => {
+		return mapErrorProgram(program, first);
+	};
+	return mapErrorProgram(first, second);
+}
+function andThen(first, second) {
+	if (second === void 0) return (program) => () => andThenRuntime(program(), first);
+	return () => andThenRuntime(first(), second);
+}
+function tap(first, second) {
+	if (second === void 0) return (program) => {
+		return tapProgram(program, first);
+	};
+	return tapProgram(first, second);
+}
+function tapError(first, second) {
+	if (second === void 0) return (program) => {
+		return tapErrorProgram(program, first);
+	};
+	return tapErrorProgram(first, second);
+}
+function recover(first, second) {
+	if (second === void 0) return (program) => () => recoverRuntime(program(), first);
+	return () => recoverRuntime(first(), second);
+}
+//#endregion
+//#region src/effect/program-scheduler.ts
+/** Validate the shared bounded-concurrency option before a Program is run. */
+const validateProgramConcurrency = (concurrency) => {
+	if (concurrency !== void 0 && (!Number.isFinite(concurrency) || !Number.isInteger(concurrency) || concurrency <= 0)) throw new RangeError("Program.all concurrency must be a positive integer");
+};
+const runWorker = async (length, task, stopOnResultError, state) => {
+	while (!state.stopScheduling) {
+		const index = state.nextIndex++;
+		if (index >= length) return;
+		try {
+			const result = await task(index);
+			state.results[index] = result;
+			if (result instanceof Err) state.stopScheduling ||= stopOnResultError;
+		} catch (cause) {
+			state.defects[index] = { cause };
+			state.stopScheduling = true;
+		}
+	}
+};
+/** Run claimed Programs with a shared FIFO worker pool and no cancellation. */
+const runProgramCollection = async (length, task, options) => {
+	const state = {
+		nextIndex: 0,
+		stopScheduling: false,
+		results: Array.from({ length }),
+		defects: Array.from({ length })
+	};
+	const workerCount = Math.min(options.concurrency ?? length, length);
+	const workers = Array.from({ length: workerCount }, () => runWorker(length, task, options.stopOnResultError, state));
+	await Promise.all(workers);
+	return state;
+};
+/** Select the first defect by input index, independent of settlement order. */
+const firstProgramDefect = (defects) => {
+	for (const defect of defects) if (defect !== void 0) return defect;
+};
+/** Select the first short-circuiting failure by input index. */
+const firstProgramFailure = (results, defects) => {
+	const length = Math.max(results.length, defects.length);
+	for (let index = 0; index < length; index++) {
+		const defect = defects[index];
+		if (defect !== void 0) return {
+			kind: "defect",
+			cause: defect.cause
+		};
+		const result = results[index];
+		if (result instanceof Err) return {
+			kind: "result",
+			result
+		};
+	}
+};
+//#endregion
+//#region src/effect/effect.ts
+const runResultGenerator = Result.gen;
+function gen(body) {
+	return runResultGenerator(body);
+}
+function fn(body) {
+	const program = () => runResultGenerator(body);
+	return program;
+}
+const runShortCircuitingCollection = async (length, task, concurrency) => {
+	const outcome = await runProgramCollection(length, task, {
+		concurrency,
+		stopOnResultError: true
+	});
+	const failure = firstProgramFailure(outcome.results, outcome.defects);
+	if (failure?.kind === "defect") throw failure.cause;
+	if (failure?.kind === "result") return failure.result;
+	return Result.all(outcome.results);
+};
+const runAllResultsCollection = async (length, task, concurrency) => {
+	const outcome = await runProgramCollection(length, task, {
+		concurrency,
+		stopOnResultError: false
+	});
+	const defect = firstProgramDefect(outcome.defects);
+	if (defect !== void 0) throw defect.cause;
+	return Result.ok(outcome.results);
+};
+/** Build a lazy Program collection with optional bounded concurrency. */
+function programAll(programs, options = {}) {
+	const concurrency = options.concurrency;
+	validateProgramConcurrency(concurrency);
+	const program = () => runShortCircuitingCollection(programs.length, (index) => programs[index](), concurrency);
+	return program;
+}
+/** Build a lazy Program collection from an input array and Program factory. */
+function programForEach(items, makeProgram, options = {}) {
+	const concurrency = options.concurrency;
+	validateProgramConcurrency(concurrency);
+	const program = () => runShortCircuitingCollection(items.length, (index) => makeProgram(items[index], index)(), concurrency);
+	return program;
+}
+/** Build a lazy Program collection that retains every child Result. */
+function programAllResults(programs, options = {}) {
+	const concurrency = options.concurrency;
+	validateProgramConcurrency(concurrency);
+	const program = () => runAllResultsCollection(programs.length, (index) => programs[index](), concurrency);
+	return program;
+}
+/** Value-level namespace for lazy Program combinators. */
+const Program = {
+	all: programAll,
+	forEach: programForEach,
+	allResults: programAllResults,
+	map,
+	mapError,
+	andThen,
+	tap,
+	tapError,
+	recover
+};
+/**
+* Acquire a resource in the current Scope and register its release callback.
+*
+* Acquisition failures are represented in the Effect Result error channel;
+* release failures remain owned by Scope cleanup. The release callback
+* receives the final outcome chosen by the enclosing execution boundary.
+*
+* @example
+* ```ts
+* const connection = yield* Effect.acquireRelease(
+*   () => pool.connect(),
+*   (connection, outcome) => connection.close(outcome)
+* )
+* ```
+*/
+function acquireRelease(acquire, release) {
+	const scope = Scope.current();
+	return Result.await(Result.tryPromise(() => scope.acquire(acquire, release)));
+}
+var AcquireReleaseResultFailure = class {
+	result;
+	constructor(result) {
+		this.result = result;
+	}
+};
+/**
+* Acquire a Result-valued resource and register only successful acquisitions.
+*
+* Typed acquisition failures remain unchanged in the Effect error channel;
+* unexpected acquisition and registration failures are normalized by
+* `better-result`. Release failures remain Scope cleanup failures.
+*/
+function acquireReleaseResult(acquire, release) {
+	const scope = Scope.current();
+	const registered = Result.tryPromise(async () => {
+		try {
+			const resource = await scope.acquire(async () => {
+				const result = await acquire();
+				if (Result.isError(result)) throw new AcquireReleaseResultFailure(result);
+				return result.value;
+			}, release);
+			return Result.ok(resource);
+		} catch (cause) {
+			if (cause instanceof AcquireReleaseResultFailure) return cause.result;
+			throw cause;
+		}
+	});
+	return Result.await(registered.then((result) => result.andThen((acquired) => acquired)));
+}
+/**
+* Lazily acquire and register a disposable resource in the current Scope.
+*
+* Disposal is delegated to `Scope.add`, including protocol preference,
+* validation, race-safe registration, and cleanup error handling.
+*/
+function acquireDisposable(acquire) {
+	const scope = Scope.current();
+	return Result.await(Result.tryPromise(async () => scope.add(await acquire())));
+}
+/**
+* Register an already-acquired disposable resource in the current Scope.
+*
+* The resource is not acquired by this helper. Registration failures are
+* represented in the Effect Result error channel; disposal failures remain
+* owned by Scope cleanup.
+*
+* @example
+* ```ts
+* const file = yield* Effect.add(await openFile('notes.txt'))
+* ```
+*/
+function add(resource) {
+	const scope = Scope.current();
+	return Result.await(Result.tryPromise(() => scope.add(resource)));
+}
+const Effect = {
+	/** Compose a generator-based Effect program. */
+	gen,
+	/** Build a lazy Program from a generator. */
+	fn,
+	/** Acquire and register a resource in the current Scope. */
+	acquireRelease,
+	/** Acquire a Result-valued resource and register successful acquisitions. */
+	acquireReleaseResult,
+	/** Acquire and register a disposable resource in the current Scope. */
+	acquireDisposable,
+	/** Register an already-acquired disposable in the current Scope. */
+	add,
+	/** Map a successful Effect result. */
+	map: map$1,
+	/** Map an Effect error. */
+	mapError: mapError$1,
+	/** Chain a synchronous Effect result. */
+	andThen: andThen$1,
+	/** Chain an asynchronous Effect result. */
+	andThenAsync,
+	/** Observe successful values without changing the Result. */
+	tap: tap$1,
+	/** Observe successful values asynchronously without changing the Result. */
+	tapAsync,
+	/** Observe error values without changing the Result. */
+	tapError: tapError$1,
+	/** Observe error values asynchronously without changing the Result. */
+	tapErrorAsync,
+	/** Observe the active Result branch without changing the Result. */
+	tapBoth,
+	/** Observe the active Result branch asynchronously without changing the Result. */
+	tapBothAsync,
+	/** Match every tagged error variant and map it to a new error value. */
+	matchError: matchError$1,
+	/** Match selected tagged errors and retain unhandled variants. */
+	matchErrorPartial: matchErrorPartial$1,
+	/** Recover an error with another Effect. */
+	recover: recover$1,
+	/** Recover an error asynchronously with another Effect. */
+	recoverAsync,
+	/** Remove one nested Effect layer. */
+	flatten,
+	/** Replace a successful value. */
+	as,
+	/** Replace a successful value with void. */
+	asVoid,
+	/** Match either Result branch. */
+	match,
+	/** Collect Effects in input order. */
+	all,
+	/** Zip two Effects in input order. */
+	zip
+};
+//#endregion
+export { Program as n, Effect as t };
+
+//# sourceMappingURL=effect-2ZcGZI8A.mjs.map