@oscarpalmer/atoms 0.158.0 → 0.159.0

package/dist/atoms.full.js

@@ -3275,6 +3275,105 @@ function roundNumber(callback, value, decimals) {
 function sum(array, key) {
 	return getAggregated("sum", array, key);
 }
+async function asyncMatchResult(result, first, error) {
+	let value;
+	if (typeof result === "function") value = await result();
+	else if (result instanceof Promise) value = await result;
+	else value = result;
+	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
+	const hasObj = typeof first === "object" && first !== null;
+	const okHandler = hasObj ? first.ok : first;
+	const errorHandler = hasObj ? first.error : error;
+	if (isOk(value)) return okHandler(value.value);
+	return errorHandler(value.error, value.original);
+}
+function matchResult(result, first, error) {
+	const value = typeof result === "function" ? result() : result;
+	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
+	const hasObj = typeof first === "object" && first !== null;
+	const okHandler = hasObj ? first.ok : first;
+	const errorHandler = hasObj ? first.error : error;
+	if (isOk(value)) return okHandler(value.value);
+	return errorHandler(value.error, value.original);
+}
+matchResult.async = asyncMatchResult;
+const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
+function error(value, original) {
+	return getError(value, original);
+}
+function getError(value, original) {
+	const errorResult = {
+		error: value,
+		ok: false
+	};
+	if (original instanceof Error) errorResult.original = original;
+	return errorResult;
+}
+/**
+* Creates an ok result
+* @param value Value
+* @returns Ok result
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/**
+* Converts a result to a promise
+*
+* Resolves if ok, rejects for error
+* @param result Result to convert
+* @returns Promised result
+*/
+async function toPromise(result) {
+	const actual = typeof result === "function" ? result() : result;
+	if (!isResult(actual)) return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
+	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
+}
+function unwrap(value, defaultValue) {
+	return isOk(value) ? value.value : defaultValue;
+}
+const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
+function attemptAsyncFlow(...fns) {
+	let Flow;
+	return (...args) => attempt.async(() => {
+		Flow ??= flow.async(...fns);
+		return Flow(...args.map((value) => {
+			if (isError(value)) throw value.error;
+			return isOk(value) ? value.value : value;
+		}));
+	});
+}
+function attemptFlow(...fns) {
+	let Flow;
+	return (...args) => attempt(() => {
+		Flow ??= flow(...fns);
+		return Flow(...args.map((value) => {
+			if (isError(value)) throw value.error;
+			return isOk(value) ? value.value : value;
+		}));
+	});
+}
+attemptFlow.async = attemptAsyncFlow;
+async function attemptAsyncPipe(initial, first, ...seconds) {
+	return attempt.async(() => {
+		if (isError(initial)) throw initial.error;
+		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		if (first == null) return value;
+		return pipe.async(value, ...[first, ...seconds]);
+	});
+}
+function attemptPipe(initial, first, ...seconds) {
+	return attempt(() => {
+		if (isError(initial)) throw initial.error;
+		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		if (first == null) return value;
+		return pipe(value, ...[first, ...seconds]);
+	});
+}
+attemptPipe.async = attemptAsyncPipe;
 var CancelablePromise = class extends Promise {
 	#rejector;
 	constructor(executor) {
@@ -3311,6 +3410,60 @@ const PROMISE_STRATEGY_ALL = new Set(["complete", "first"]);
 const PROMISE_STRATEGY_DEFAULT = "complete";
 const PROMISE_TYPE_FULFILLED = "fulfilled";
 const PROMISE_TYPE_REJECTED = "rejected";
+/**
+* Create a cancelable promise
+* @param executor Executor function for the promise
+* @returns Cancelable promise
+*/
+function cancelable(executor) {
+	return new CancelablePromise(executor);
+}
+function handleResult(status, parameters) {
+	const { abort, complete, data, handlers, index, signal, value } = parameters;
+	if (signal?.aborted ?? false) return;
+	if (!complete && status === "rejected") {
+		settlePromise(abort, handlers.reject, value, signal);
+		return;
+	}
+	data.result[index] = !complete ? value : status === "fulfilled" ? {
+		status,
+		value
+	} : {
+		status,
+		reason: value
+	};
+	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
+}
+function settlePromise(aborter, settler, value, signal) {
+	signal?.removeEventListener(PROMISE_EVENT_NAME, aborter);
+	settler(value);
+}
+async function toResult(value) {
+	const actual = typeof value === "function" ? value() : value;
+	if (!(actual instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
+	return actual.then((result) => ok(result)).catch((reason) => error(reason));
+}
+async function asyncAttempt(value, err) {
+	try {
+		let result = typeof value === "function" ? value() : await value;
+		if (result instanceof Promise) result = await result;
+		return ok(result);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+function attempt(callback, err) {
+	try {
+		return ok(callback());
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+attempt.async = asyncAttempt;
+attempt.flow = attemptFlow;
+attempt.match = matchResult;
+attempt.pipe = attemptPipe;
+attempt.promise = attemptPromise;
 function getNumberOrDefault$1(value) {
 	return typeof value === "number" && value > 0 ? value : 0;
 }
@@ -3338,6 +3491,9 @@ function getPromisesOptions(input) {
 		strategy: getStrategyOrDefault(options.strategy)
 	};
 }
+function getResultsFromPromises(promised) {
+	return promised.map((result) => isFulfilled(result) ? ok(result.value) : error(result.reason));
+}
 function getStrategyOrDefault(value) {
 	return PROMISE_STRATEGY_ALL.has(value) ? value : PROMISE_STRATEGY_DEFAULT;
 }
@@ -3360,77 +3516,6 @@ function isRejected(value) {
 function isType(value, type) {
 	return typeof value === "object" && value !== null && value.status === type;
 }
-function error(value, original) {
-	return getError(value, original);
-}
-function getError(value, original) {
-	const errorResult = {
-		error: value,
-		ok: false
-	};
-	if (original instanceof Error) errorResult.original = original;
-	return errorResult;
-}
-/**
-* Creates an ok result
-* @param value Value
-* @returns Ok result
-*/
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
-}
-/**
-* Converts a result to a promise
-*
-* Resolves if ok, rejects for error
-* @param result Result to convert
-* @returns Promised result
-*/
-async function toPromise(result) {
-	const actual = typeof result === "function" ? result() : result;
-	if (!isResult(actual)) return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
-	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
-}
-function unwrap(value, defaultValue) {
-	return isOk(value) ? value.value : defaultValue;
-}
-const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
-/**
-* Create a cancelable promise
-* @param executor Executor function for the promise
-* @returns Cancelable promise
-*/
-function cancelable(executor) {
-	return new CancelablePromise(executor);
-}
-function handleResult(status, parameters) {
-	const { abort, complete, data, handlers, index, signal, value } = parameters;
-	if (signal?.aborted ?? false) return;
-	if (!complete && status === "rejected") {
-		settlePromise(abort, handlers.reject, value, signal);
-		return;
-	}
-	data.result[index] = !complete ? value : status === "fulfilled" ? {
-		status,
-		value
-	} : {
-		status,
-		reason: value
-	};
-	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
-}
-function settlePromise(aborter, settler, value, signal) {
-	signal?.removeEventListener(PROMISE_EVENT_NAME, aborter);
-	settler(value);
-}
-async function toResult(value) {
-	const actual = typeof value === "function" ? value() : value;
-	if (!(actual instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
-	return actual.then((result) => ok(result)).catch((reason) => error(reason));
-}
 async function getTimedPromise(promise, time, signal) {
 	function abort() {
 		timer.cancel();
@@ -3507,7 +3592,7 @@ async function promises(items, options) {
 	if (!Array.isArray(items)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_PROMISES));
 	const actual = items.filter((item) => item instanceof Promise);
 	const { length } = actual;
-	if (length === 0) return actual;
+	if (length === 0) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_PROMISES));
 	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
 	function abort() {
 		handlers.reject(signal.reason);
@@ -3542,6 +3627,10 @@ async function promises(items, options) {
 		}));
 	});
 }
+promises.result = resultPromises;
+async function resultPromises(items, signal) {
+	return promises(items, signal).then(getResultsFromPromises);
+}
 /**
 * Convert a query string to a plain _(nested)_ object
 * @param query Query string to convert
@@ -3869,88 +3958,6 @@ const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
 const BOOLEAN_MODIFIER = .5;
 const HEX_CHARACTERS = "0123456789ABCDEF";
 const HEX_MAXIMUM = 15;
-async function asyncMatchResult(result, first, error) {
-	let value;
-	if (typeof result === "function") value = await result();
-	else if (result instanceof Promise) value = await result;
-	else value = result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
-	const hasObj = typeof first === "object" && first !== null;
-	const okHandler = hasObj ? first.ok : first;
-	const errorHandler = hasObj ? first.error : error;
-	if (isOk(value)) return okHandler(value.value);
-	return errorHandler(value.error, value.original);
-}
-function matchResult(result, first, error) {
-	const value = typeof result === "function" ? result() : result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
-	const hasObj = typeof first === "object" && first !== null;
-	const okHandler = hasObj ? first.ok : first;
-	const errorHandler = hasObj ? first.error : error;
-	if (isOk(value)) return okHandler(value.value);
-	return errorHandler(value.error, value.original);
-}
-matchResult.async = asyncMatchResult;
-const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
-function attemptAsyncFlow(...fns) {
-	let Flow;
-	return (...args) => attempt.async(() => {
-		Flow ??= flow.async(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
-	});
-}
-function attemptFlow(...fns) {
-	let Flow;
-	return (...args) => attempt(() => {
-		Flow ??= flow(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
-	});
-}
-attemptFlow.async = attemptAsyncFlow;
-async function attemptAsyncPipe(initial, first, ...seconds) {
-	return attempt.async(() => {
-		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
-		if (first == null) return value;
-		return pipe.async(value, ...[first, ...seconds]);
-	});
-}
-function attemptPipe(initial, first, ...seconds) {
-	return attempt(() => {
-		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
-		if (first == null) return value;
-		return pipe(value, ...[first, ...seconds]);
-	});
-}
-attemptPipe.async = attemptAsyncPipe;
-async function asyncAttempt(value, err) {
-	try {
-		let result = typeof value === "function" ? value() : await value;
-		if (result instanceof Promise) result = await result;
-		return ok(result);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-function attempt(callback, err) {
-	try {
-		return ok(callback());
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-attempt.async = asyncAttempt;
-attempt.flow = attemptFlow;
-attempt.match = matchResult;
-attempt.pipe = attemptPipe;
-attempt.promise = attemptPromise;
 /**
 * - A Set with a maximum size
 * - Behavior is similar to a _LRU_-cache, where the oldest values are removed

package/dist/index.js

@@ -65,16 +65,16 @@ import { merge } from "./value/merge.js";
 import { isEmpty, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumerical, isObject, isPrimitive } from "./is.js";
 import { logger } from "./logger.js";
 import { average, ceil, count, floor, median, min, round, sum } from "./math.js";
-import { CancelablePromise, PromiseTimeoutError } from "./promise/models.js";
-import { isFulfilled, isRejected } from "./promise/helpers.js";
 import { error, ok, toPromise, unwrap } from "./result/misc.js";
+import { CancelablePromise, PromiseTimeoutError } from "./promise/models.js";
 import { cancelable, toResult } from "./promise/misc.js";
+import { attempt } from "./result/index.js";
+import { isFulfilled, isRejected } from "./promise/helpers.js";
 import { timed } from "./promise/timed.js";
 import { delay } from "./promise/delay.js";
 import { attemptPromise, promises } from "./promise/index.js";
 import { fromQuery, toQuery } from "./query.js";
 import { QueueError, queue } from "./queue.js";
 import { getRandomBoolean, getRandomCharacters, getRandomColor, getRandomHex, getRandomItem, getRandomItems } from "./random.js";
-import { attempt } from "./result/index.js";
 import { SizedSet } from "./sized/set.js";
 export { CancelablePromise, PromiseTimeoutError, QueueError, RetryError, SizedMap, SizedSet, attempt, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, delay, diff, difference, drop, endsWith, equal, error, exists, filter, find, flatten, floor, flow, toResult as fromPromise, fromQuery, toPromise as fromResult, getArray, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getUuid, getValue, groupBy, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, includes, indexOf, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonNullable, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, logger, lowerCase, max, median, memoize, merge, min, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, shuffle, slice, smush, snakeCase, sort, splice, startsWith, sum, take, template, throttle, timed, times, titleCase, toMap, toPromise, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/promise/delay.js

@@ -1,7 +1,7 @@
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.js";
 import { PROMISE_ABORT_OPTIONS } from "./models.js";
-import { getPromiseOptions } from "./helpers.js";
 import { settlePromise } from "./misc.js";
+import { getPromiseOptions } from "./helpers.js";
 function delay(options) {
 	const { signal, time } = getPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal.reason);

package/dist/promise/helpers.js

@@ -1,4 +1,6 @@
+import { error, ok } from "../result/misc.js";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./models.js";
+import "../result/index.js";
 function getNumberOrDefault(value) {
 	return typeof value === "number" && value > 0 ? value : 0;
 }
@@ -26,6 +28,9 @@ function getPromisesOptions(input) {
 		strategy: getStrategyOrDefault(options.strategy)
 	};
 }
+function getResultsFromPromises(promised) {
+	return promised.map((result) => isFulfilled(result) ? ok(result.value) : error(result.reason));
+}
 function getStrategyOrDefault(value) {
 	return PROMISE_STRATEGY_ALL.has(value) ? value : PROMISE_STRATEGY_DEFAULT;
 }
@@ -48,4 +53,4 @@ function isRejected(value) {
 function isType(value, type) {
 	return typeof value === "object" && value !== null && value.status === type;
 }
-export { getPromiseOptions, getPromisesOptions, getStrategyOrDefault, isFulfilled, isRejected };
+export { getPromiseOptions, getPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/index.js

@@ -1,7 +1,7 @@
-import { CancelablePromise, PROMISE_ABORT_OPTIONS, PROMISE_EVENT_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_PROMISES, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError } from "./models.js";
-import { getPromiseOptions, getPromisesOptions, isFulfilled, isRejected } from "./helpers.js";
 import { toPromise } from "../result/misc.js";
+import { CancelablePromise, PROMISE_ABORT_OPTIONS, PROMISE_EVENT_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_PROMISES, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError } from "./models.js";
 import { cancelable, handleResult, settlePromise, toResult } from "./misc.js";
+import { getPromiseOptions, getPromisesOptions, getResultsFromPromises, isFulfilled, isRejected } from "./helpers.js";
 import { getTimedPromise, timed } from "./timed.js";
 import { delay } from "./delay.js";
 async function attemptPromise(value, options) {
@@ -35,7 +35,7 @@ async function promises(items, options) {
 	if (!Array.isArray(items)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_PROMISES));
 	const actual = items.filter((item) => item instanceof Promise);
 	const { length } = actual;
-	if (length === 0) return actual;
+	if (length === 0) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_PROMISES));
 	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
 	function abort() {
 		handlers.reject(signal.reason);
@@ -70,4 +70,8 @@ async function promises(items, options) {
 		}));
 	});
 }
+promises.result = resultPromises;
+async function resultPromises(items, signal) {
+	return promises(items, signal).then(getResultsFromPromises);
+}
 export { CancelablePromise, PromiseTimeoutError, attemptPromise, cancelable, delay, toPromise as fromResult, isFulfilled, isRejected, promises, timed, toResult };

package/dist/promise/misc.js

@@ -1,5 +1,5 @@
-import { CancelablePromise, PROMISE_EVENT_NAME, PROMISE_MESSAGE_EXPECTATION_RESULT } from "./models.js";
 import { error, ok } from "../result/misc.js";
+import { CancelablePromise, PROMISE_EVENT_NAME, PROMISE_MESSAGE_EXPECTATION_RESULT } from "./models.js";
 /**
 * Create a cancelable promise
 * @param executor Executor function for the promise

package/dist/promise/timed.js

@@ -1,7 +1,7 @@
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.js";
 import { PROMISE_ABORT_OPTIONS, PROMISE_EVENT_NAME, PROMISE_MESSAGE_EXPECTATION_TIMED, PromiseTimeoutError } from "./models.js";
-import { getPromiseOptions } from "./helpers.js";
 import { settlePromise } from "./misc.js";
+import { getPromiseOptions } from "./helpers.js";
 async function getTimedPromise(promise, time, signal) {
 	function abort() {
 		timer.cancel();

package/dist/result/index.js

@@ -1,10 +1,10 @@
 import { isError, isOk, isResult } from "../internal/result.js";
-import { error, getError, ok, toPromise, unwrap } from "./misc.js";
-import { toResult } from "../promise/misc.js";
-import { attemptPromise } from "../promise/index.js";
 import { matchResult } from "./match.js";
+import { error, getError, ok, toPromise, unwrap } from "./misc.js";
 import { attemptFlow } from "./work/flow.js";
 import { attemptPipe } from "./work/pipe.js";
+import { toResult } from "../promise/misc.js";
+import { attemptPromise } from "../promise/index.js";
 async function asyncAttempt(value, err) {
 	try {
 		let result = typeof value === "function" ? value() : await value;

package/package.json

@@ -184,5 +184,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.158.0"
+	"version": "0.159.0"
 }

package/src/promise/helpers.ts

@@ -1,14 +1,16 @@
 import type {RequiredKeys} from '../models';
+import {error, ok} from '../result';
+import type {Result} from '../result/models';
 import {
-	PROMISE_STRATEGY_DEFAULT,
 	PROMISE_STRATEGY_ALL,
+	PROMISE_STRATEGY_DEFAULT,
 	PROMISE_TYPE_FULFILLED,
 	PROMISE_TYPE_REJECTED,
 	type FulfilledPromise,
 	type PromiseOptions,
 	type PromisesOptions,
-	type PromisesResultItem,
 	type PromiseStrategy,
+	type PromisesValue,
 	type RejectedPromise,
 } from './models';
 
@@ -56,6 +58,14 @@ export function getPromisesOptions(input: unknown): RequiredKeys<PromisesOptions
 	};
 }
 
+export function getResultsFromPromises<Value>(
+	promised: PromisesValue<Value>[],
+): Result<Value>[] {
+	return promised.map(result =>
+		isFulfilled(result) ? ok(result.value) : error(result.reason),
+	) as Result<Value>[];
+}
+
 export function getStrategyOrDefault(value: unknown): PromiseStrategy {
 	return PROMISE_STRATEGY_ALL.has(value as PromiseStrategy)
 		? (value as PromiseStrategy)
@@ -84,7 +94,7 @@ function isType(value: unknown, type: string): boolean {
 	return (
 		typeof value === 'object' &&
 		value !== null &&
-		(value as PromisesResultItem<unknown>).status === type
+		(value as PromisesValue<unknown>).status === type
 	);
 }
 

package/src/promise/index.ts

@@ -1,4 +1,5 @@
-import {getPromiseOptions, getPromisesOptions} from './helpers';
+import type {Result} from '../result/models';
+import {getPromiseOptions, getPromisesOptions, getResultsFromPromises} from './helpers';
 import {handleResult, settlePromise} from './misc';
 import {
 	PROMISE_ABORT_OPTIONS,
@@ -11,9 +12,11 @@ import {
 	type PromiseData,
 	type PromiseHandlers,
 	type PromiseOptions,
-	type Promises,
+	type PromisesItems,
 	type PromisesOptions,
 	type PromisesResult,
+	type PromisesValue,
+	type PromisesValues,
 } from './models';
 import {getTimedPromise} from './timed';
 
@@ -111,9 +114,22 @@ export async function attemptPromise<Value>(
  * @returns List of results
  */
 export async function promises<Items extends unknown[], Options extends PromisesOptions>(
-	items: Promises<Items>,
+	items: [...Items],
 	options?: Options,
-): Promise<Options['strategy'] extends 'first' ? Items : PromisesResult<Items>>;
+): Promise<Options['strategy'] extends 'first' ? Items : PromisesValues<PromisesItems<Items>>>;
+
+/**
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * @param items List of promises
+ * @param options Options for handling the promises
+ * @returns List of results
+ */
+export async function promises<Value, Options extends PromisesOptions>(
+	items: Promise<Value>[],
+	options?: Options,
+): Promise<Options['strategy'] extends 'first' ? Value[] : PromisesValue<Value>[]>;
 
 /**
  * Handle a list of promises, returning their results in an ordered array.
@@ -124,9 +140,19 @@ export async function promises<Items extends unknown[], Options extends Promises
  * @returns List of results
  */
 export async function promises<Items extends unknown[]>(
-	items: Promises<Items>,
+	items: [...Items],
 	strategy: 'first',
-): Promise<Items>;
+): Promise<PromisesItems<Items>>;
+
+/**
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * If any promise in the list is rejected, the whole function will reject
+ * @param items List of promises
+ * @param strategy Strategy for handling the promises; rejects on the first error encountered
+ * @returns List of results
+ */
+export async function promises<Value>(items: Promise<Value>[], strategy: 'first'): Promise<Value[]>;
 
 /**
  * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
@@ -135,14 +161,22 @@ export async function promises<Items extends unknown[]>(
  * @returns List of results
  */
 export async function promises<Items extends unknown[]>(
-	items: Promises<Items>,
+	items: [...Items],
 	signal?: AbortSignal,
-): Promise<PromisesResult<Items>>;
+): Promise<PromisesValues<PromisesItems<Items>>>;
 
-export async function promises<Items extends unknown[]>(
-	items: Promises<Items>,
-	options?: unknown,
-): Promise<Items | PromisesResult<Items>> {
+/**
+ * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
+ * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
+ * @returns List of results
+ */
+export async function promises<Value>(
+	items: Promise<Value>[],
+	signal?: AbortSignal,
+): Promise<PromisesValue<Value>[]>;
+
+export async function promises(items: unknown[], options?: unknown): Promise<unknown[]> {
 	const {signal, strategy} = getPromisesOptions(options);
 
 	if (signal?.aborted ?? false) {
@@ -157,7 +191,7 @@ export async function promises<Items extends unknown[]>(
 	const {length} = actual;
 
 	if (length === 0) {
-		return actual as unknown as Items | PromisesResult<Items>;
+		return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_PROMISES));
 	}
 
 	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
@@ -168,12 +202,12 @@ export async function promises<Items extends unknown[]>(
 
 	signal?.addEventListener('abort', abort, PROMISE_ABORT_OPTIONS);
 
-	const data: PromiseData<Items> = {
+	const data: PromiseData = {
 		last: length - 1,
-		result: [] as unknown as Items | PromisesResult<Items>,
+		result: [] as unknown[],
 	};
 
-	let handlers: PromiseHandlers<Items>;
+	let handlers: PromiseHandlers;
 
 	return new Promise((resolve, reject) => {
 		handlers = {reject, resolve};
@@ -206,6 +240,41 @@ export async function promises<Items extends unknown[]>(
 	});
 }
 
+promises.result = resultPromises;
+
+/**
+ * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
+ * @returns List of results
+ */
+async function resultPromises<Items extends unknown[]>(
+	items: [...Items],
+	signal?: AbortSignal,
+): Promise<PromisesResult<PromisesItems<Items>>>;
+
+/**
+ * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
+ * @returns List of results
+ */
+async function resultPromises<Value>(
+	items: Promise<Value>[],
+	signal?: AbortSignal,
+): Promise<Result<Awaited<Value>>[]>;
+
+async function resultPromises(
+	items: Promise<unknown>[],
+	signal?: AbortSignal,
+): Promise<Result<unknown>[]> {
+	return promises(items, signal).then(getResultsFromPromises);
+}
+
 // #endregion
 
 // #region Exports
@@ -218,12 +287,13 @@ export {
 	CancelablePromise,
 	PromiseTimeoutError,
 	type FulfilledPromise,
-	type RejectedPromise,
 	type PromiseOptions,
-	type PromiseStrategy,
 	type PromisesOptions,
 	type PromisesResult,
-	type PromisesResultItem,
+	type PromiseStrategy,
+	type PromisesValues as PromisesValue,
+	type PromisesValue as PromisesValueItem,
+	type RejectedPromise,
 } from './models';
 export {timed} from './timed';
 

package/src/promise/misc.ts

@@ -22,10 +22,7 @@ export function cancelable<Value>(
 	return new CancelablePromise(executor);
 }
 
-export function handleResult<Items extends unknown[]>(
-	status: string,
-	parameters: PromiseParameters<Items>,
-): void {
+export function handleResult(status: string, parameters: PromiseParameters): void {
 	const {abort, complete, data, handlers, index, signal, value} = parameters;
 
 	if (signal?.aborted ?? false) {

package/src/promise/models.ts

@@ -1,3 +1,5 @@
+import type {Result} from '../result/models';
+
 // #region Types
 
 export class CancelablePromise<Value = void> extends Promise<Value> {
@@ -28,16 +30,16 @@ export class CancelablePromise<Value = void> extends Promise<Value> {
 
 export type FulfilledPromise<Value> = {
 	status: typeof PROMISE_TYPE_FULFILLED;
-	value: Value;
+	value: Awaited<Value>;
 };
 
-export type PromiseData<Items extends unknown[]> = {
+export type PromiseData = {
 	last: number;
-	result: Items | PromisesResult<Items>;
+	result: unknown[];
 };
 
-export type PromiseHandlers<Items extends unknown[]> = {
-	resolve: (value: Items | PromisesResult<Items>) => void;
+export type PromiseHandlers = {
+	resolve: (value: unknown[]) => void;
 	reject: (reason: unknown) => void;
 };
 
@@ -52,11 +54,11 @@ export type PromiseOptions = {
 	time?: number;
 };
 
-export type PromiseParameters<Items extends unknown[]> = {
+export type PromiseParameters = {
 	abort: () => void;
 	complete: boolean;
-	data: PromiseData<Items>;
-	handlers: PromiseHandlers<Items>;
+	data: PromiseData;
+	handlers: PromiseHandlers;
 	index: number;
 	signal?: AbortSignal;
 	value?: unknown;
@@ -64,7 +66,7 @@ export type PromiseParameters<Items extends unknown[]> = {
 
 /**
  * Promise handling strategy
- * 
+ *
  * - `complete`: wait for all promises to settle, then return the results
  * 	- Returns an array of fulfilled and/or rejected results
  * - `first`: rejects on the first rejected promise
@@ -80,7 +82,7 @@ export class PromiseTimeoutError extends Error {
 	}
 }
 
-export type Promises<Items extends unknown[]> = {
+export type PromisesItems<Items extends unknown[]> = {
 	[K in keyof Items]: Promise<Items[K]>;
 };
 
@@ -90,10 +92,14 @@ export type PromisesOptions = {
 };
 
 export type PromisesResult<Items extends unknown[]> = {
-	[K in keyof Items]: Items[K] extends Promise<infer Value> ? PromisesResultItem<Value> : never;
+	[K in keyof Items]: Items[K] extends Promise<infer Value> ? Result<Awaited<Value>> : never;
 };
 
-export type PromisesResultItem<Value> = FulfilledPromise<Value> | RejectedPromise;
+export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
+
+export type PromisesValues<Items extends unknown[]> = {
+	[K in keyof Items]: Items[K] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never;
+};
 
 export type RejectedPromise = {
 	status: typeof PROMISE_TYPE_REJECTED;

package/types/promise/helpers.d.ts

@@ -1,7 +1,9 @@
 import type { RequiredKeys } from '../models';
-import { type FulfilledPromise, type PromiseOptions, type PromisesOptions, type PromiseStrategy, type RejectedPromise } from './models';
+import type { Result } from '../result/models';
+import { type FulfilledPromise, type PromiseOptions, type PromisesOptions, type PromiseStrategy, type PromisesValue, type RejectedPromise } from './models';
 export declare function getPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;
 export declare function getPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
+export declare function getResultsFromPromises<Value>(promised: PromisesValue<Value>[]): Result<Value>[];
 export declare function getStrategyOrDefault(value: unknown): PromiseStrategy;
 /**
  * Is the value a fulfilled promise result?

package/types/promise/index.d.ts

@@ -1,4 +1,5 @@
-import { type PromiseOptions, type Promises, type PromisesOptions, type PromisesResult } from './models';
+import type { Result } from '../result/models';
+import { type PromiseOptions, type PromisesItems, type PromisesOptions, type PromisesResult, type PromisesValue, type PromisesValues } from './models';
 /**
  * Wrap a promise with safety handlers, with optional abort capabilities and timeout
  * @param promise Promise to wrap
@@ -28,7 +29,25 @@ export declare function attemptPromise<Value>(callback: () => Value, options?: P
  * @param options Options for handling the promises
  * @returns List of results
  */
-export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: Promises<Items>, options?: Options): Promise<Options['strategy'] extends 'first' ? Items : PromisesResult<Items>>;
+export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: [...Items], options?: Options): Promise<Options['strategy'] extends 'first' ? Items : PromisesValues<PromisesItems<Items>>>;
+/**
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * @param items List of promises
+ * @param options Options for handling the promises
+ * @returns List of results
+ */
+export declare function promises<Value, Options extends PromisesOptions>(items: Promise<Value>[], options?: Options): Promise<Options['strategy'] extends 'first' ? Value[] : PromisesValue<Value>[]>;
+/**
+ * Handle a list of promises, returning their results in an ordered array.
+ *
+ * If any promise in the list is rejected, the whole function will reject
+ * @param items List of promises
+ * @param strategy Strategy for handling the promises; rejects on the first error encountered
+ * @returns List of results
+ */
+export declare function promises<Items extends unknown[]>(items: [...Items], strategy: 'first'): Promise<PromisesItems<Items>>;
 /**
  * Handle a list of promises, returning their results in an ordered array.
  *
@@ -37,17 +56,45 @@ export declare function promises<Items extends unknown[], Options extends Promis
  * @param strategy Strategy for handling the promises; rejects on the first error encountered
  * @returns List of results
  */
-export declare function promises<Items extends unknown[]>(items: Promises<Items>, strategy: 'first'): Promise<Items>;
+export declare function promises<Value>(items: Promise<Value>[], strategy: 'first'): Promise<Value[]>;
+/**
+ * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
+ * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
+ * @returns List of results
+ */
+export declare function promises<Items extends unknown[]>(items: [...Items], signal?: AbortSignal): Promise<PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle a list of promises, returning their results in an ordered array of rejected and resolved results
  * @param items List of promises
  * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
  * @returns List of results
  */
-export declare function promises<Items extends unknown[]>(items: Promises<Items>, signal?: AbortSignal): Promise<PromisesResult<Items>>;
+export declare function promises<Value>(items: Promise<Value>[], signal?: AbortSignal): Promise<PromisesValue<Value>[]>;
+export declare namespace promises {
+    var result: typeof resultPromises;
+}
+/**
+ * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
+ * @returns List of results
+ */
+declare function resultPromises<Items extends unknown[]>(items: [...Items], signal?: AbortSignal): Promise<PromisesResult<PromisesItems<Items>>>;
+/**
+ * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
+ *
+ * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * @param items List of promises
+ * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
+ * @returns List of results
+ */
+declare function resultPromises<Value>(items: Promise<Value>[], signal?: AbortSignal): Promise<Result<Awaited<Value>>[]>;
 export { toPromise as fromResult } from '../result/misc';
 export { delay } from './delay';
 export { isFulfilled, isRejected } from './helpers';
 export { cancelable, toResult } from './misc';
-export { CancelablePromise, PromiseTimeoutError, type FulfilledPromise, type RejectedPromise, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type PromisesResult, type PromisesResultItem, } from './models';
+export { CancelablePromise, PromiseTimeoutError, type FulfilledPromise, type PromiseOptions, type PromisesOptions, type PromisesResult, type PromiseStrategy, type PromisesValues as PromisesValue, type PromisesValue as PromisesValueItem, type RejectedPromise, } from './models';
 export { timed } from './timed';

package/types/promise/misc.d.ts

@@ -6,7 +6,7 @@ import { CancelablePromise, type PromiseParameters } from './models';
  * @returns Cancelable promise
  */
 export declare function cancelable<Value>(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void): CancelablePromise<Value>;
-export declare function handleResult<Items extends unknown[]>(status: string, parameters: PromiseParameters<Items>): void;
+export declare function handleResult(status: string, parameters: PromiseParameters): void;
 export declare function settlePromise(aborter: () => void, settler: (value: any) => void, value: unknown, signal?: AbortSignal): void;
 /**
  * Converts a promise to a promised result

package/types/promise/models.d.ts

@@ -1,3 +1,4 @@
+import type { Result } from '../result/models';
 export declare class CancelablePromise<Value = void> extends Promise<Value> {
     #private;
     constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
@@ -9,14 +10,14 @@ export declare class CancelablePromise<Value = void> extends Promise<Value> {
 }
 export type FulfilledPromise<Value> = {
     status: typeof PROMISE_TYPE_FULFILLED;
-    value: Value;
+    value: Awaited<Value>;
 };
-export type PromiseData<Items extends unknown[]> = {
+export type PromiseData = {
     last: number;
-    result: Items | PromisesResult<Items>;
+    result: unknown[];
 };
-export type PromiseHandlers<Items extends unknown[]> = {
-    resolve: (value: Items | PromisesResult<Items>) => void;
+export type PromiseHandlers = {
+    resolve: (value: unknown[]) => void;
     reject: (reason: unknown) => void;
 };
 export type PromiseOptions = {
@@ -29,11 +30,11 @@ export type PromiseOptions = {
      */
     time?: number;
 };
-export type PromiseParameters<Items extends unknown[]> = {
+export type PromiseParameters = {
     abort: () => void;
     complete: boolean;
-    data: PromiseData<Items>;
-    handlers: PromiseHandlers<Items>;
+    data: PromiseData;
+    handlers: PromiseHandlers;
     index: number;
     signal?: AbortSignal;
     value?: unknown;
@@ -50,7 +51,7 @@ export type PromiseStrategy = 'complete' | 'first';
 export declare class PromiseTimeoutError extends Error {
     constructor();
 }
-export type Promises<Items extends unknown[]> = {
+export type PromisesItems<Items extends unknown[]> = {
     [K in keyof Items]: Promise<Items[K]>;
 };
 export type PromisesOptions = {
@@ -58,9 +59,12 @@ export type PromisesOptions = {
     strategy?: PromiseStrategy;
 };
 export type PromisesResult<Items extends unknown[]> = {
-    [K in keyof Items]: Items[K] extends Promise<infer Value> ? PromisesResultItem<Value> : never;
+    [K in keyof Items]: Items[K] extends Promise<infer Value> ? Result<Awaited<Value>> : never;
+};
+export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
+export type PromisesValues<Items extends unknown[]> = {
+    [K in keyof Items]: Items[K] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never;
 };
-export type PromisesResultItem<Value> = FulfilledPromise<Value> | RejectedPromise;
 export type RejectedPromise = {
     status: typeof PROMISE_TYPE_REJECTED;
     reason: unknown;