resultar 3.5.1 → 3.6.0

package/dist/index.js

@@ -192,6 +192,10 @@ var ResultNamespace = class {
 		return value instanceof Ok || value instanceof Err;
 	}
 	/**
+	* Alias for the top-level `safeTry` generator workflow.
+	*/
+	static gen = safeTry;
+	/**
 	* 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`.
@@ -302,6 +306,7 @@ var ResultNamespace = class {
 		return forEachResult(items, f, options);
 	}
 };
+/** Static helpers for creating, combining, and iterating over Result values. */
 const Result = ResultNamespace;
 var ResultVariant = class extends Pipeable {
 	filterOrElse(predicate, onFalse) {
@@ -992,11 +997,7 @@ const runConcurrentResultAsyncItems = (options) => Promise.try(async () => {
 		};
 		const schedule = () => {
 			if (settled) return;
-			if (state.stopScheduling) {
-				finishIfDone();
-				return;
-			}
-			while (!state.iteratorDone && state.activeCount < concurrency) {
+			while (!state.stopScheduling && !state.iteratorDone && state.activeCount < concurrency) {
 				const next = readNext();
 				if (next === void 0) return;
 				if (next.done === true) {
@@ -1019,7 +1020,6 @@ const runConcurrentResultAsyncItems = (options) => Promise.try(async () => {
 					if (settled) return;
 					state.activeCount -= 1;
 					schedule();
-					finishIfDone();
 				});
 			} catch (error) {
 				rejectOnce(error);
@@ -1436,6 +1436,7 @@ const callAsyncSideEffect = async (effect) => {
 		await effect();
 	} catch {}
 };
+/** Async-disposable wrapper that finalizes a `ResultAsync` exactly once. */
 var DisposableResultAsync = class {
 	innerPromise;
 	finalizer;
@@ -2026,4 +2027,282 @@ const runPromise = (result) => result.unwrapOrThrow();
 /** Compatibility alias. Prefer `tryResultAsync` in new code. */
 const tryCatchAsync = tryResultAsync;
 //#endregion
-export { AbortError, DisposableResult, DisposableResultAsync, Result, ResultAsync, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+//#region src/result-task.ts
+const success = (value) => ({
+	_tag: "Success",
+	value
+});
+const failure = (cause) => ({
+	_tag: "Failure",
+	cause
+});
+const failed = (error) => failure({
+	_tag: "Fail",
+	error
+});
+const died = (defect) => failure({
+	_tag: "Die",
+	defect
+});
+const throwDefect = (defect) => {
+	throw defect;
+};
+const isRecord = (value) => typeof value === "object" && value !== null;
+const createMissingServiceError = (identifier) => {
+	const error = /* @__PURE__ */ new Error(`Missing ResultTask service: ${identifier}`);
+	error.name = "MissingServiceError";
+	return error;
+};
+const isResultTaskYield = (value) => isRecord(value) && value["_tag"] === "ResultTask" && value["task"] instanceof ResultTask;
+const isServiceYield = (value) => isRecord(value) && value["_tag"] === "Service" && value["tag"] instanceof ServiceTagValue;
+const lookupService = (tag, context) => {
+	if (context.services.has(tag.key)) return context.services.get(tag.key);
+	return context.namedServices.get(tag.identifier);
+};
+const executeTaskSafely = async (task, executeTask) => {
+	try {
+		return await executeTask(task);
+	} catch (error) {
+		return { error };
+	}
+};
+const closeGenerator = async (iterator, exit, runtime) => {
+	try {
+		let step = iterator.return(void 0);
+		let finalExit = exit;
+		while (step.done === false) if (isResultTaskYield(step.value)) {
+			const outcome = await executeTaskSafely(step.value.task, runtime.executeTask);
+			if ("error" in outcome) {
+				finalExit = died(outcome.error);
+				step = iterator.return(void 0);
+			} else if (outcome._tag === "Failure") {
+				finalExit = outcome;
+				step = iterator.return(void 0);
+			} else step = iterator.next(outcome);
+		} else if (isServiceYield(step.value)) {
+			const service = lookupService(step.value.tag, runtime.context);
+			if (service === void 0) {
+				finalExit = died(createMissingServiceError(step.value.tag.identifier));
+				step = iterator.return(void 0);
+			} else step = iterator.next(service);
+		} else {
+			finalExit = died(/* @__PURE__ */ new TypeError("ResultTask.gen yielded an unsupported value"));
+			step = iterator.return(void 0);
+		}
+		return finalExit;
+	} catch (error) {
+		return died(error);
+	}
+};
+const withServices = (context, services) => ({
+	namedServices: context.namedServices,
+	services,
+	signal: context.signal
+});
+const withNamedServices = (context, namedServices) => ({
+	namedServices,
+	services: context.services,
+	signal: context.signal
+});
+var ServiceTagValue = class {
+	_tag = "ServiceTag";
+	identifier;
+	key;
+	constructor(identifier) {
+		this.identifier = identifier;
+		this.key = Symbol(identifier);
+	}
+	*[Symbol.iterator]() {
+		return yield {
+			_tag: "Service",
+			tag: this
+		};
+	}
+};
+/**
+* A lazy, composable workflow that can succeed with `A` or fail with `E`.
+*
+* Constructing a `ResultTask` never runs its work. Use `runResult`, `runExit`, or `runPromise` at an
+* explicit application boundary to execute it.
+*/
+var ResultTask = class ResultTask extends Pipeable {
+	execute;
+	constructor(execute) {
+		super();
+		this.execute = execute;
+	}
+	/** Creates a task that succeeds with `value` when it is executed. */
+	static succeed(value) {
+		return new ResultTask(() => Promise.resolve(success(value)));
+	}
+	/** Creates a task that fails with `error` when it is executed. */
+	static fail(error) {
+		return new ResultTask(() => Promise.resolve(failed(error)));
+	}
+	/** Lifts an already computed Result into a lazy task. */
+	static fromResult(result) {
+		return new ResultTask(() => Promise.resolve(result.isOk() ? success(result.value) : failed(result.error)));
+	}
+	/** Creates a task for synchronous work. Thrown values are defects, not typed failures. */
+	static sync(evaluate) {
+		return new ResultTask(() => Promise.resolve(success(evaluate())));
+	}
+	/** Creates a task that maps synchronous throws into the typed error channel. */
+	static try(options) {
+		return new ResultTask(() => {
+			try {
+				return Promise.resolve(success(options.try()));
+			} catch (error) {
+				return Promise.resolve(failed(options.catch(error)));
+			}
+		});
+	}
+	/** Creates a lazy task that maps synchronous throws and promise rejections into `E`. */
+	static tryPromise(options) {
+		return new ResultTask(async (context) => {
+			try {
+				return success(await options.try(context.signal));
+			} catch (error) {
+				return failed(options.catch(error));
+			}
+		});
+	}
+	/** Creates a service tag that can be requested with `yield*` inside `ResultTask.gen`. */
+	static service(identifier) {
+		return new ServiceTagValue(identifier);
+	}
+	/** Builds a task from a generator and short-circuits on the first failed task. */
+	static gen(body) {
+		return new ResultTask(async (context) => {
+			try {
+				const iterator = body();
+				const executeTask = (task) => task.execute(context);
+				let step = iterator.next();
+				while (step.done === false) if (isResultTaskYield(step.value)) {
+					const outcome = await executeTaskSafely(step.value.task, executeTask);
+					if ("error" in outcome) return await closeGenerator(iterator, died(outcome.error), {
+						context,
+						executeTask
+					});
+					if (outcome._tag === "Failure") return await closeGenerator(iterator, outcome, {
+						context,
+						executeTask
+					});
+					step = iterator.next(outcome);
+				} else if (isServiceYield(step.value)) {
+					const service = lookupService(step.value.tag, context);
+					if (service === void 0) return await closeGenerator(iterator, died(createMissingServiceError(step.value.tag.identifier)), {
+						context,
+						executeTask
+					});
+					step = iterator.next(service);
+				} else return await closeGenerator(iterator, died(/* @__PURE__ */ new TypeError("ResultTask.gen yielded an unsupported value")), {
+					context,
+					executeTask
+				});
+				return success(step.value);
+			} catch (error) {
+				return died(error);
+			}
+		});
+	}
+	/** Maps the success value without executing the task. */
+	map(f) {
+		return new ResultTask(async (context) => {
+			const exit = await this.execute(context);
+			if (exit._tag === "Failure") return exit;
+			return success(f(exit.value));
+		});
+	}
+	/** Chains another task from the success value without executing either task immediately. */
+	flatMap(f) {
+		return new ResultTask(async (context) => {
+			const exit = await this.execute(context);
+			if (exit._tag === "Failure") return exit;
+			return f(exit.value).execute(context);
+		});
+	}
+	/** Alias for `flatMap`, matching the existing Resultar vocabulary. */
+	andThen(f) {
+		return this.flatMap(f);
+	}
+	/** Recovers from a typed failure without recovering from a runtime defect. */
+	catchAll(f) {
+		return new ResultTask(async (context) => {
+			const exit = await this.execute(context);
+			if (exit._tag === "Success") return exit;
+			if (exit.cause._tag === "Die") return exit;
+			return f(exit.cause.error).execute(context);
+		});
+	}
+	/** Enables `yield* task` inside `ResultTask.gen` workflows. */
+	*[Symbol.iterator]() {
+		const exit = yield {
+			_tag: "ResultTask",
+			task: this
+		};
+		if (exit._tag === "Success") return exit.value;
+		return throwDefect(/* @__PURE__ */ new Error("ResultTask generator received a failed task result"));
+	}
+	/** Provides one required service and removes it from the task's requirements. */
+	static provideService(task, tag, service) {
+		return new ResultTask(async (context) => {
+			const services = new Map([...context.services, [tag.key, service]]);
+			return task.execute(withServices(context, services));
+		});
+	}
+	/** Provides all requirements using an object keyed by service identifier. */
+	static provideServices(task, services) {
+		return new ResultTask(async (context) => {
+			const namedServices = new Map(context.namedServices);
+			for (const [identifier, service] of Object.entries(services)) namedServices.set(identifier, service);
+			return task.execute(withNamedServices(context, namedServices));
+		});
+	}
+	/** Maps the success value using the canonical functional form. */
+	static map(task, f) {
+		return task.map(f);
+	}
+	/** Chains a task using the canonical functional form. */
+	static flatMap(task, f) {
+		return task.flatMap(f);
+	}
+	/** Recovers from a typed failure using the canonical functional form. */
+	static catchAll(task, f) {
+		return task.catchAll(f);
+	}
+	static async runExitInternal(task, options) {
+		const signal = options?.signal ?? new AbortController().signal;
+		const suppliedServices = options !== void 0 && "services" in options ? options.services : void 0;
+		const context = {
+			namedServices: new Map(Object.entries(suppliedServices ?? {})),
+			services: /* @__PURE__ */ new Map(),
+			signal
+		};
+		try {
+			return await task.execute(context);
+		} catch (error) {
+			return died(error);
+		}
+	}
+	static async runResultInternal(task, options) {
+		const exit = await ResultTask.runExitInternal(task, options);
+		if (exit._tag === "Success") return ok(exit.value);
+		if (exit.cause._tag === "Fail") return err(exit.cause.error);
+		return throwDefect(exit.cause.defect);
+	}
+	/** Runs a task and preserves success, typed failure, and runtime defects in an `Exit`. */
+	static runExit(task, ...args) {
+		return ResultTask.runExitInternal(task, args[0]);
+	}
+	/** Runs a task and returns a Result, rejecting only when a runtime defect occurs. */
+	static runResult(task, ...args) {
+		return ResultTask.runResultInternal(task, args[0]);
+	}
+	/** Runs a task and returns the success value, rejecting on typed failures or defects. */
+	static async runPromise(task, ...args) {
+		return (await ResultTask.runResultInternal(task, args[0])).unwrapOrThrow();
+	}
+};
+//#endregion
+export { AbortError, DisposableResult, DisposableResultAsync, Result, ResultAsync, ResultTask, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromCallback, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, runPromise, runSync, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "resultar",
-  "version": "3.5.1",
+  "version": "3.6.0",
   "description": "Result pattern for TypeScript",
   "keywords": [
     "error-handling",
@@ -41,16 +41,16 @@
     }
   },
   "devDependencies": {
-    "@stryker-mutator/core": "9.6.1",
-    "@stryker-mutator/vitest-runner": "9.6.1",
-    "@types/node": "26.1.0",
-    "@vitest/coverage-v8": "4.1.10",
-    "@vitest/ui": "4.1.10",
-    "fallow": "3.5.0",
-    "tsx": "4.23.0",
+    "@stryker-mutator/core": "10.0.0",
+    "@stryker-mutator/vitest-runner": "10.0.0",
+    "@types/node": "26.4.0",
+    "@vitest/coverage-v8": "4.1.11",
+    "@vitest/ui": "4.1.11",
+    "fallow": "3.20.0",
+    "tsx": "4.23.13",
     "typescript": "7.0.2",
-    "vite-plus": "0.2.4",
-    "vitest": "4.1.10"
+    "vite-plus": "0.3.0",
+    "vitest": "4.1.11"
   },
   "peerDependencies": {
     "typescript": ">=7.0.0"