resultar 3.2.0 → 3.3.0

package/dist/index.js

@@ -53,32 +53,28 @@ const createResultarError = (message, result, config = defaultErrorConfig) => {
 };
 //#endregion
 //#region src/tagged-match.ts
+const noTaggedHandlerMatch = Symbol("noTaggedHandlerMatch");
+const isTaggedHandlerMatch = (call) => call !== noTaggedHandlerMatch;
 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 };
+	if (!isTaggedValue(value)) return noTaggedHandlerMatch;
 	const handler = handlers[value._tag];
-	if (handler === void 0) return { matched: false };
-	return {
-		matched: true,
-		value: handler(value)
-	};
+	if (handler === void 0) return noTaggedHandlerMatch;
+	return { value: handler(value) };
 };
 const callErrorHandler = (error, handlers) => {
-	if (handlers.Error === void 0) return { matched: false };
-	return {
-		matched: true,
-		value: handlers.Error(error)
-	};
+	if (handlers.Error === void 0) return noTaggedHandlerMatch;
+	return { value: handlers.Error(error) };
 };
 const callTaggedOrErrorHandler = (error, handlers) => {
 	const tagged = callTaggedHandler(error, handlers);
-	if (tagged.matched) return tagged;
+	if (isTaggedHandlerMatch(tagged)) return tagged;
 	return callErrorHandler(error, handlers);
 };
 const matchTaggedOr = (error, handlers, fallback) => {
 	const handled = callTaggedOrErrorHandler(error, handlers);
-	return handled.matched ? handled.value : fallback(error);
+	return isTaggedHandlerMatch(handled) ? handled.value : fallback(error);
 };
 //#endregion
 //#region src/result.ts
@@ -113,38 +109,30 @@ const combineResultRecordWithAllErrors = (resultRecord) => {
 	if (errors.length > 0) return err(errors);
 	return ok(values);
 };
-const isIterable$1 = (value) => typeof value === "object" && value !== null && Symbol.iterator in value;
-const validateAllResultItems = (items, f) => {
-	return combineResultListWithAllErrors(Array.from(items, f));
-};
+const isIterable$1 = (value) => value !== null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.iterator] === "function";
 const createEmptyResultsCollectionError = () => {
 	const error = /* @__PURE__ */ new Error("Received an empty collection of results");
 	error.name = "IllegalArgumentException";
 	return error;
 };
-const firstSuccessOfResultCandidates = (candidates) => {
-	let latestError = void 0;
-	let hasCandidates = false;
-	for (const candidate of candidates) {
-		hasCandidates = true;
-		const result = candidate();
-		if (result.isOk()) return result;
-		latestError = result;
-	}
-	if (!hasCandidates || latestError === void 0) throw createEmptyResultsCollectionError();
-	return latestError;
-};
-const getReason$1 = (value) => typeof value === "object" && value !== null && "reason" in value ? value.reason : void 0;
+const getReason$1 = (value) => value.reason;
 const loopResult = (initial, options) => {
 	let state = initial;
+	if (options.discard === true) {
+		while (options.while(state)) {
+			const result = options.body(state);
+			if (result.isErr()) return err(result.error);
+			state = options.step(state);
+		}
+		return ok(void 0);
+	}
 	const values = [];
 	while (options.while(state)) {
 		const result = options.body(state);
 		if (result.isErr()) return err(result.error);
-		if (options.discard !== true) values.push(result.value);
+		values.push(result.value);
 		state = options.step(state);
 	}
-	if (options.discard === true) return ok(void 0);
 	return ok(values);
 };
 const iterateResult = (initial, options) => {
@@ -157,34 +145,25 @@ const iterateResult = (initial, options) => {
 	return ok(state);
 };
 const forEachResult = (items, f, options) => {
+	if (options?.discard === true) {
+		let index = 0;
+		for (const item of items) {
+			const result = f(item, index);
+			if (result.isErr()) return err(result.error);
+			index += 1;
+		}
+		return ok(void 0);
+	}
 	const values = [];
 	let index = 0;
 	for (const item of items) {
 		const result = f(item, index);
 		if (result.isErr()) return err(result.error);
-		if (options?.discard !== true) values.push(result.value);
+		values.push(result.value);
 		index += 1;
 	}
-	if (options?.discard === true) return ok(void 0);
 	return ok(values);
 };
-const resolveResultBooleanCondition = (condition) => typeof condition === "function" ? condition() : condition;
-const ifResult = (condition, options) => resolveResultBooleanCondition(condition) ? options.onTrue() : options.onFalse();
-const ifResultWithCondition = (condition, options) => {
-	if (condition.isErr()) return err(condition.error);
-	return ifResult(condition.value, options);
-};
-const whenResult = (condition, body) => {
-	if (resolveResultBooleanCondition(condition)) return body();
-	return ok(void 0);
-};
-const whenResultWithConditionByPredicate = (condition, body, predicate) => {
-	if (condition.isErr()) return err(condition.error);
-	return whenResult(predicate(condition.value), body);
-};
-const whenResultWithCondition = (condition, body) => whenResultWithConditionByPredicate(condition, body, (value) => value);
-const unlessResult = (condition, body) => whenResult(() => !resolveResultBooleanCondition(condition), body);
-const unlessResultWithCondition = (condition, body) => whenResultWithConditionByPredicate(condition, body, (value) => !value);
 const callSyncSideEffect = (effect) => {
 	try {
 		effect();
@@ -264,29 +243,43 @@ var ResultNamespace = class {
 	}
 	static validateAll(resultListOrItems, f) {
 		if (f === void 0) return combineResultListWithAllErrors(resultListOrItems);
-		return validateAllResultItems(resultListOrItems, f);
+		return combineResultListWithAllErrors(Array.from(resultListOrItems, f));
 	}
 	static zip(left, right) {
 		return combineResultList([left, right]);
 	}
 	static firstSuccessOf(candidates) {
-		return firstSuccessOfResultCandidates(candidates);
+		let latestError = void 0;
+		for (const candidate of candidates) {
+			const result = candidate();
+			if (result.isOk()) return result;
+			latestError = result;
+		}
+		if (latestError === void 0) throw createEmptyResultsCollectionError();
+		return latestError;
 	}
 	static if(condition, options) {
-		if (typeof condition === "boolean" || typeof condition === "function") return ifResult(condition, options);
-		return ifResultWithCondition(condition, options);
+		if (typeof condition === "boolean" || typeof condition === "function") return (typeof condition === "function" ? condition() : condition) ? options.onTrue() : options.onFalse();
+		if (condition.isErr()) return err(condition.error);
+		return condition.value ? options.onTrue() : options.onFalse();
 	}
 	static when(condition, body) {
-		return whenResult(condition, body);
+		if (typeof condition === "function" ? condition() : condition) return body();
+		return ok(void 0);
 	}
 	static whenResult(condition, body) {
-		return whenResultWithCondition(condition, body);
+		if (condition.isErr()) return err(condition.error);
+		if (condition.value) return body();
+		return ok(void 0);
 	}
 	static unless(condition, body) {
-		return unlessResult(condition, body);
+		if (typeof condition === "function" ? !condition() : !condition) return body();
+		return ok(void 0);
 	}
 	static unlessResult(condition, body) {
-		return unlessResultWithCondition(condition, body);
+		if (condition.isErr()) return err(condition.error);
+		if (!condition.value) return body();
+		return ok(void 0);
 	}
 	static loop(initial, options) {
 		return loopResult(initial, options);
@@ -454,7 +447,7 @@ var Err = class extends ResultVariant {
 	catchTags(handlers) {
 		const error = this.error;
 		const handled = callTaggedHandler(error, handlers);
-		if (handled.matched) return handled.value;
+		if (isTaggedHandlerMatch(handled)) return handled.value;
 		return err(error);
 	}
 	catchReason(errorTag, reasonTag, f) {
@@ -639,7 +632,7 @@ const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fro
 const combineResultAsyncRecordWithAllErrors = (asyncResultRecord) => {
 	return new ResultAsync(collectResultAsyncRecord(asyncResultRecord).then((resultRecord) => Result.combineWithAllErrors(resultRecord)));
 };
-const isIterable = (value) => typeof value === "object" && value !== null && Symbol.iterator in value;
+const isIterable = (value) => value !== null && (typeof value === "object" || typeof value === "function") && typeof value[Symbol.iterator] === "function";
 const createIllegalArgumentException = (message) => {
 	const error = new Error(message);
 	error.name = "IllegalArgumentException";
@@ -730,11 +723,6 @@ const runConcurrentResultAsyncItems = (options) => Promise.try(async () => {
 		schedule();
 	});
 });
-const createResultAsyncRetryContext = (attempt, times) => ({
-	attempt,
-	nextAttempt: attempt + 1,
-	retriesRemaining: Math.max(0, times - attempt)
-});
 const createResultAsyncRetryAbortError = (signal) => signal.reason === void 0 ? new AbortError("ResultAsync retry aborted") : new AbortError("ResultAsync retry aborted", { cause: signal.reason });
 const createResultAsyncResourceAbortError = (signal) => signal.reason === void 0 ? new AbortError("ResultAsync resource scope aborted") : new AbortError("ResultAsync resource scope aborted", { cause: signal.reason });
 const validateResultAsyncRetryTimes = (times) => {
@@ -755,23 +743,6 @@ const validateResultAsyncRetryStaticJittered = (jittered) => {
 const validateResultAsyncRetryStaticDelay = (delay) => {
 	if (typeof delay === "number") validateResultAsyncRetryDelayValue(delay);
 };
-const getResultAsyncRetryJitterRandom = () => {
-	const value = Math.random();
-	validateResultAsyncRetryJitterRandomValue(value);
-	return value;
-};
-const applyResultAsyncRetryJitter = (delayMs, jittered) => {
-	if (jittered === void 0 || jittered === 0 || delayMs === 0) return delayMs;
-	const random = getResultAsyncRetryJitterRandom();
-	const range = delayMs * jittered;
-	const min = Math.max(0, delayMs - range);
-	return min + (delayMs + range - min) * random;
-};
-const normalizeResultAsyncRetryDelay = (delay, jittered, context) => {
-	const delayMs = typeof delay === "function" ? delay(context) : delay ?? 0;
-	validateResultAsyncRetryDelayValue(delayMs);
-	return applyResultAsyncRetryJitter(delayMs, jittered);
-};
 const waitResultAsyncRetryDelay = async (delayMs, signal) => {
 	if (signal.aborted) return Result.err(createResultAsyncRetryAbortError(signal));
 	if (delayMs === 0) return Result.ok(void 0);
@@ -787,13 +758,6 @@ const waitResultAsyncRetryDelay = async (delayMs, signal) => {
 		signal.addEventListener("abort", abort, { once: true });
 	});
 };
-const callResultAsyncRetryOnRetry = async (options, error, context) => {
-	try {
-		await options.onRetry?.(error, context);
-	} catch {}
-};
-const shouldRetryResultAsyncError = async (options, error, context) => options.while?.(error, context) ?? true;
-const resolveResultAsyncRetryRecovery = async (recovered) => recovered instanceof ResultAsync ? recovered : recovered;
 const runResultAsyncRetryAttempts = async (task, options, recover) => {
 	validateResultAsyncRetryTimes(options.times);
 	validateResultAsyncRetryStaticDelay(options.delayMs);
@@ -804,10 +768,31 @@ const runResultAsyncRetryAttempts = async (task, options, recover) => {
 		if (signal.aborted) return Result.err(createResultAsyncRetryAbortError(signal));
 		const result = await task(attempt, signal);
 		if (result.isOk()) return Result.ok(result.value);
-		const context = createResultAsyncRetryContext(attempt, options.times);
-		if (!await shouldRetryResultAsyncError(options, result.error, context) || attempt >= options.times) return resolveResultAsyncRetryRecovery(recover(result.error, context));
-		await callResultAsyncRetryOnRetry(options, result.error, context);
-		const delayResult = await waitResultAsyncRetryDelay(normalizeResultAsyncRetryDelay(options.delayMs, options.jittered, context), signal);
+		const context = {
+			attempt,
+			nextAttempt: attempt + 1,
+			retriesRemaining: Math.max(0, options.times - attempt)
+		};
+		const shouldRetry = options.while;
+		if (!(shouldRetry === void 0 ? true : await shouldRetry(result.error, context)) || attempt >= options.times) {
+			const recovered = recover(result.error, context);
+			return recovered instanceof ResultAsync ? recovered : recovered;
+		}
+		const onRetry = options.onRetry;
+		if (onRetry !== void 0) try {
+			await onRetry(result.error, context);
+		} catch {}
+		let delayMs = typeof options.delayMs === "function" ? options.delayMs(context) : options.delayMs ?? 0;
+		validateResultAsyncRetryDelayValue(delayMs);
+		const jittered = options.jittered;
+		if (jittered !== void 0 && jittered !== 0 && delayMs !== 0) {
+			const random = Math.random();
+			validateResultAsyncRetryJitterRandomValue(random);
+			const range = delayMs * jittered;
+			const min = Math.max(0, delayMs - range);
+			delayMs = min + (delayMs + range - min) * random;
+		}
+		const delayResult = await waitResultAsyncRetryDelay(delayMs, signal);
 		if (delayResult.isErr()) return Result.err(delayResult.error);
 		attempt += 1;
 	}
@@ -865,18 +850,16 @@ const validateAllResultAsyncItems = (items, f, options) => {
 const firstSuccessOfAsyncCandidates = (candidates) => {
 	return new ResultAsync(Promise.try(async () => {
 		let latestError = void 0;
-		let hasCandidates = false;
 		for (const candidate of candidates) {
-			hasCandidates = true;
 			const result = await candidate();
 			if (result.isOk()) return result;
 			latestError = result;
 		}
-		if (!hasCandidates || latestError === void 0) throw createEmptyResultsCollectionError();
+		if (latestError === void 0) throw createEmptyResultsCollectionError();
 		return latestError;
 	}));
 };
-const getReason = (value) => typeof value === "object" && value !== null && "reason" in value ? value.reason : void 0;
+const getReason = (value) => value.reason;
 const createRaceAbortReason = () => new AbortError("ResultAsync race loser interrupted");
 const startRaceTask = (task, index) => {
 	const controller = new AbortController();
@@ -890,33 +873,26 @@ const startRaceTask = (task, index) => {
 		}))
 	};
 };
-const abortStartedRaceTask = (task, reason = createRaceAbortReason()) => {
-	if (!task.controller.signal.aborted) task.controller.abort(reason);
-};
 const createRaceHandle = (task) => ({
 	get signal() {
 		return task.controller.signal;
 	},
-	abort(reason) {
-		abortStartedRaceTask(task, reason);
+	abort(reason = createRaceAbortReason()) {
+		task.controller.abort(reason);
 	},
 	wait() {
 		return task.result;
 	}
 });
-const abortRaceLosers = (startedTasks, winnerIndex) => {
-	const winner = startedTasks[winnerIndex];
-	for (const loser of startedTasks) if (loser !== winner) abortStartedRaceTask(loser);
-};
-const abortPendingRaceLosers = (startedTasks, winnerIndex, completedIndexes) => {
-	const winner = startedTasks[winnerIndex];
-	for (const [index, loser] of startedTasks.entries()) if (loser !== winner && !completedIndexes.has(index)) abortStartedRaceTask(loser);
-};
 const observeRaceFirstTask = (task, context) => {
 	task.settled.then(({ index, result }) => {
 		if (context.state.settled) return;
 		context.state.settled = true;
-		abortRaceLosers(context.startedTasks, index);
+		const startedTasks = context.startedTasks;
+		for (let loserIndex = 0; loserIndex < startedTasks.length; loserIndex += 1) {
+			const loser = startedTasks[loserIndex];
+			if (loser === void 0) {} else if (loserIndex !== index) loser.controller.abort(createRaceAbortReason());
+		}
 		context.resolve(result);
 	});
 };
@@ -926,13 +902,17 @@ const observeRaceSuccessTask = (task, context) => {
 		context.state.completedIndexes.add(index);
 		if (result.isOk()) {
 			context.state.settled = true;
-			abortPendingRaceLosers(context.startedTasks, index, context.state.completedIndexes);
+			const startedTasks = context.startedTasks;
+			for (let loserIndex = 0; loserIndex < startedTasks.length; loserIndex += 1) {
+				const loser = startedTasks[loserIndex];
+				if (loser === void 0) {} else if (!context.state.completedIndexes.has(loserIndex)) loser.controller.abort(createRaceAbortReason());
+			}
 			context.resolve(result);
 			return;
 		}
 		context.state.completedCount += 1;
 		context.state.latestError = result;
-		if (context.state.completedCount === context.startedTasks.length && context.state.latestError !== void 0) {
+		if (context.state.completedCount === context.startedTasks.length) {
 			context.state.settled = true;
 			context.resolve(context.state.latestError);
 		}
@@ -947,13 +927,6 @@ const observeRaceResultAsyncTasks = (tasks, createContext, observeTask) => {
 		for (const task of startedTasks) observeTask(task, context);
 	}));
 };
-const raceFirstResultAsyncTasks = (tasks) => observeRaceResultAsyncTasks(tasks, (resolve, startedTasks) => ({
-	resolve,
-	startedTasks,
-	state: { settled: false }
-}), (task, context) => {
-	observeRaceFirstTask(task, context);
-});
 const raceResultAsyncTasks = (tasks) => observeRaceResultAsyncTasks(tasks, (resolve, startedTasks) => ({
 	resolve,
 	startedTasks,
@@ -963,20 +936,25 @@ const raceResultAsyncTasks = (tasks) => observeRaceResultAsyncTasks(tasks, (reso
 		latestError: void 0,
 		settled: false
 	}
-}), (task, context) => {
-	observeRaceSuccessTask(task, context);
-});
+}), observeRaceSuccessTask);
 const loopResultAsync = (initial, options) => {
 	return new ResultAsync(Promise.try(async () => {
 		let state = initial;
+		if (options.discard === true) {
+			while (options.while(state)) {
+				const result = await options.body(state);
+				if (result.isErr()) return Result.err(result.error);
+				state = options.step(state);
+			}
+			return Result.ok(void 0);
+		}
 		const values = [];
 		while (options.while(state)) {
 			const result = await options.body(state);
 			if (result.isErr()) return Result.err(result.error);
-			if (options.discard !== true) values.push(result.value);
+			values.push(result.value);
 			state = options.step(state);
 		}
-		if (options.discard === true) return Result.ok(void 0);
 		return Result.ok(values);
 	}));
 };
@@ -992,13 +970,32 @@ const iterateResultAsync = (initial, options) => {
 	}));
 };
 const forEachResultAsync = (items, f, options) => {
+	if (options?.discard === true) return new ResultAsync(runConcurrentResultAsyncItems({
+		concurrency: options.concurrency,
+		finish: (state) => {
+			if (state.activeCount > 0) return;
+			const firstError = sortIndexedResultAsyncErrors(state.errors)[0];
+			if (firstError !== void 0) return Result.err(firstError.error);
+			return Result.ok(void 0);
+		},
+		items,
+		onResult: (result, currentIndex, state) => {
+			if (result.isErr()) {
+				state.errors.push({
+					error: result.error,
+					index: currentIndex
+				});
+				state.stopScheduling = true;
+			}
+		},
+		run: f
+	}));
 	return new ResultAsync(runConcurrentResultAsyncItems({
 		concurrency: options?.concurrency,
 		finish: (state) => {
-			if (state.activeCount > 0 || !state.iteratorDone && !state.stopScheduling) return;
+			if (state.activeCount > 0) return;
 			const firstError = sortIndexedResultAsyncErrors(state.errors)[0];
 			if (firstError !== void 0) return Result.err(firstError.error);
-			if (options?.discard === true) return Result.ok(void 0);
 			return Result.ok(state.values);
 		},
 		items,
@@ -1011,7 +1008,7 @@ const forEachResultAsync = (items, f, options) => {
 				state.stopScheduling = true;
 				return;
 			}
-			if (options?.discard !== true) state.values[currentIndex] = result.value;
+			state.values[currentIndex] = result.value;
 		},
 		run: f
 	}));
@@ -1177,7 +1174,11 @@ var ResultAsync = class ResultAsync extends Pipeable {
 		return raceResultAsyncTasks(tasks);
 	}
 	static raceFirst(left, right) {
-		return raceFirstResultAsyncTasks([left, right]);
+		return observeRaceResultAsyncTasks([left, right], (resolve, startedTasks) => ({
+			resolve,
+			startedTasks,
+			state: { settled: false }
+		}), observeRaceFirstTask);
 	}
 	static raceWith(left, right, handlers) {
 		return new ResultAsync(new Promise((resolve) => {
@@ -1212,7 +1213,7 @@ var ResultAsync = class ResultAsync extends Pipeable {
 				}, options.timeoutMs);
 				signal.addEventListener("abort", () => {
 					clearTimeout(timeout);
-				}, { once: true });
+				});
 			}));
 		};
 		return ResultAsync.raceWith(task, timeoutTask, {
@@ -1222,7 +1223,6 @@ var ResultAsync = class ResultAsync extends Pipeable {
 			},
 			onRightDone: (result, taskHandle) => {
 				if (result.isErr()) taskHandle.abort(result.error);
-				else taskHandle.abort(createRaceAbortReason());
 				return result;
 			}
 		});
@@ -1342,7 +1342,7 @@ var ResultAsync = class ResultAsync extends Pipeable {
 			if (res.isOk()) return Result.ok(res.value);
 			const error = res.error;
 			const handled = callTaggedHandler(error, handlers);
-			if (handled.matched) {
+			if (isTaggedHandlerMatch(handled)) {
 				const next = handled.value;
 				return next instanceof ResultAsync ? next.innerPromise : next;
 			}
@@ -1533,10 +1533,7 @@ const stringifySymbolTemplateValue = (value) => {
 	return symbol.description ?? symbol.toString();
 };
 const stringifyFunctionTemplateValue = (value) => value.name;
-const stringifyObjectTemplateValue = (value) => {
-	if (value === null) return "null";
-	return JSON.stringify(value) ?? Object.prototype.toString.call(value);
-};
+const stringifyObjectTemplateValue = (value) => JSON.stringify(value) ?? Object.prototype.toString.call(value);
 const templateValueStringifiers = {
 	bigint: stringifyDirectTemplateValue,
 	boolean: stringifyDirectTemplateValue,
@@ -1546,7 +1543,7 @@ const templateValueStringifiers = {
 	string: stringifyDirectTemplateValue,
 	symbol: stringifySymbolTemplateValue
 };
-const stringifyTemplateValue = (value) => isRedacted(value) ? stringifyRedacted(value) : templateValueStringifiers[typeof value]?.(value) ?? "";
+const stringifyTemplateValue = (value) => isRedacted(value) ? stringifyRedacted(value) : templateValueStringifiers[typeof value](value);
 const compileMessageInterpolator = (template) => (values) => template.replaceAll(templateVariableMatcher, (variable, key) => {
 	const value = values?.[key];
 	return value === void 0 ? variable : stringifyTemplateValue(value);