@oscarpalmer/atoms 0.198.0 → 0.200.0

package/dist/internal/value/handlers.d.mts

@@ -4,15 +4,15 @@ type Options = {
   callback: GenericCallback;
   method?: string;
 };
-declare function getCompareHandlers<Value>(owner: GenericCallback, options: Options): {
+declare function createCompareHandlers<Value>(owner: GenericCallback, options: Options): {
   deregister(constructor: Constructor): void;
   handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
   register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
-declare function getSelfHandlers(owner: GenericCallback, options: Options): {
+declare function createSelfHandlers(owner: GenericCallback, options: Options): {
   deregister(constructor: Constructor): void;
   handle(value: unknown, ...parameters: unknown[]): unknown;
   register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 //#endregion
-export { getCompareHandlers, getSelfHandlers };
+export { createCompareHandlers, createSelfHandlers };

package/dist/internal/value/handlers.mjs

@@ -1,7 +1,7 @@
 import { isNonConstructor } from "../is.mjs";
 //#region src/internal/value/handlers.ts
-function getCompareHandlers(owner, options) {
-	const handlers = getHandlers(owner, options);
+function createCompareHandlers(owner, options) {
+	const handlers = createHandlers(owner, options);
 	return {
 		deregister(constructor) {
 			handlers.deregister(constructor);
@@ -16,7 +16,7 @@ function getCompareHandlers(owner, options) {
 		}
 	};
 }
-function getHandlers(owner, options) {
+function createHandlers(owner, options) {
 	const handlers = /* @__PURE__ */ new WeakMap();
 	return {
 		deregister(constructor) {
@@ -34,8 +34,8 @@ function getHandlers(owner, options) {
 		}
 	};
 }
-function getSelfHandlers(owner, options) {
-	const handlers = getHandlers(owner, options);
+function createSelfHandlers(owner, options) {
+	const handlers = createHandlers(owner, options);
 	return {
 		deregister(constructor) {
 			handlers.deregister(constructor);
@@ -54,4 +54,4 @@ function isConstructable(value) {
 	return typeof value === "object" && value !== null;
 }
 //#endregion
-export { getCompareHandlers, getSelfHandlers };
+export { createCompareHandlers, createSelfHandlers };

package/dist/promise/constants.d.mts

@@ -6,6 +6,8 @@ declare const PROMISE_ABORT_OPTIONS: {
 };
 declare const PROMISE_ERROR_NAME = "PromiseTimeoutError";
 declare const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
+declare const PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY = "promises expected at least one promise-function or promise in the array or object";
+declare const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 declare const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
 declare const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
 declare const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
@@ -14,4 +16,4 @@ declare const PROMISE_STRATEGY_DEFAULT: PromiseStrategy;
 declare const PROMISE_TYPE_FULFILLED = "fulfilled";
 declare const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
-export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };
+export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };

package/dist/promise/constants.mjs

@@ -3,6 +3,8 @@ const PROMISE_ABORT_EVENT = "abort";
 const PROMISE_ABORT_OPTIONS = { once: true };
 const PROMISE_ERROR_NAME = "PromiseTimeoutError";
 const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
+const PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY = "promises expected at least one promise-function or promise in the array or object";
+const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
 const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
 const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
@@ -11,4 +13,4 @@ const PROMISE_STRATEGY_DEFAULT = "complete";
 const PROMISE_TYPE_FULFILLED = "fulfilled";
 const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
-export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };
+export { PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED };

package/dist/promise/delay.mjs

@@ -1,10 +1,10 @@
 import { createAborter } from "../internal/abort.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
-import { getPromiseOptions } from "./helpers.mjs";
+import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/delay.ts
 function delay(options) {
-	const { signal, time } = getPromiseOptions(options);
+	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	const aborter = createAborter(signal, () => {
 		timer.cancel();

package/dist/promise/helpers.d.mts

@@ -1,10 +1,9 @@
 import { RequiredKeys } from "../models.mjs";
-import { Result } from "../internal/result/models.mjs";
 import { FulfilledPromise, PromiseOptions, PromiseStrategy, PromisesOptions, PromisesValue, RejectedPromise } from "./models.mjs";
 //#region src/promise/helpers.d.ts
-declare function getPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;
-declare function getPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
-declare function getResultsFromPromises<Value>(promised: PromisesValue<Value>[]): Result<Value>[];
+declare function createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;
+declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
+declare function getResultsFromPromises(promised: Array<PromisesValue<unknown>> | Record<string, PromisesValue<unknown>>): unknown;
 declare function getStrategyOrDefault(value: unknown): PromiseStrategy;
 /**
  * Is the value a fulfilled _Promise_ result?
@@ -21,4 +20,4 @@ declare function isFulfilled<Value>(value: unknown): value is FulfilledPromise<V
  */
 declare function isRejected(value: unknown): value is RejectedPromise;
 //#endregion
-export { getPromiseOptions, getPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };
+export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/helpers.mjs

@@ -1,8 +1,8 @@
-import { error, ok } from "../internal/result/misc.mjs";
 import { getNumberOrDefault } from "../internal/defaults.mjs";
+import { error, ok } from "../internal/result/misc.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
 //#region src/promise/helpers.ts
-function getPromiseOptions(input) {
+function createPromiseOptions(input) {
 	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
 	if (input instanceof AbortSignal) return {
 		signal: input,
@@ -14,7 +14,7 @@ function getPromiseOptions(input) {
 		time: getNumberOrDefault(options.time, 0)
 	};
 }
-function getPromisesOptions(input) {
+function createPromisesOptions(input) {
 	if (typeof input === "string") return { strategy: getStrategyOrDefault(input) };
 	if (input instanceof AbortSignal) return {
 		signal: input,
@@ -27,7 +27,15 @@ function getPromisesOptions(input) {
 	};
 }
 function getResultsFromPromises(promised) {
-	return promised.map((result) => isFulfilled(result) ? ok(result.value) : error(result.reason));
+	const isArray = Array.isArray(promised);
+	const entries = isArray ? promised.map((value, index) => [index, value]) : Object.entries(promised);
+	const { length } = entries;
+	const results = isArray ? [] : {};
+	for (let index = 0; index < length; index += 1) {
+		const [key, value] = entries[index];
+		results[key] = isFulfilled(value) ? ok(value.value) : error(value.reason);
+	}
+	return results;
 }
 function getStrategyOrDefault(value) {
 	return PROMISE_STRATEGY_ALL.has(value) ? value : PROMISE_STRATEGY_DEFAULT;
@@ -54,4 +62,4 @@ function isType(value, type) {
 	return typeof value === "object" && value !== null && value.status === type;
 }
 //#endregion
-export { getPromiseOptions, getPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };
+export { createPromiseOptions, createPromisesOptions, getResultsFromPromises, getStrategyOrDefault, isFulfilled, isRejected };

package/dist/promise/index.d.mts

@@ -1,8 +1,8 @@
-import { Result } from "../internal/result/models.mjs";
-import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues } from "./models.mjs";
+import { PlainObject } from "../models.mjs";
+import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "./models.mjs";
 //#region src/promise/index.d.ts
 /**
- * Wrap a _Promise_ with safety handlers, with optional abort capabilities and timeout
+ * Wrap a _Promise_ with safety handlers
  *
  * @param promise _Promise_ to wrap
  * @param options Options for the _Promise_
@@ -10,7 +10,7 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
  */
 declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
- * Wrap a _Promise_-returning callback with safety handlers, with optional abort capabilities and timeout
+ * Wrap a _Promise_-returning callback with safety handlers
  *
  * @param callback Callback to wrap
  * @param options Options for the _Promise_
@@ -18,7 +18,7 @@ declare function attemptPromise<Value>(promise: Promise<Value>, options?: Promis
  */
 declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
- * Wrap a callback with a _Promise_ and safety handlers, with optional abort capabilities and timeout
+ * Wrap a callback with a _Promise_ and safety handlers
  *
  * @param callback Callback to wrap
  * @param options Options for the _Promise_
@@ -28,7 +28,7 @@ declare function attemptPromise<Value>(callback: () => Value, options?: PromiseO
 /**
  * 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
+ * _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_
@@ -36,77 +36,75 @@ declare function attemptPromise<Value>(callback: () => Value, options?: PromiseO
  */
 declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: [...Items], options?: Options): Promise<Options['strategy'] extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
- * Handle a list of _Promises_, returning their results in an ordered array
+ * Handle keyed _Promises_, returning their results in a similarly keyed object
  *
- * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ * _Depending on the strategy, the function will either reject on the first error encountered or return an object of rejected and resolved results_
  *
- * @param items List of _Promises_
+ * @param items Keyed _Promises_
  * @param options Options for handling the _Promises_
- * @returns List of results
+ * @returns Keyed object of results
  */
-declare function promises<Value, Options extends PromisesOptions>(items: Promise<Value>[], options?: Options): Promise<Options['strategy'] extends 'first' ? Value[] : PromisesValue<Value>[]>;
+declare function promises<Items extends PlainObject, Options extends PromisesOptions>(items: Items, options?: Options): Promise<Options['strategy'] extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<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
+ * _If the strategy is `first`, the function will reject on the first error encountered; otherwise, it returns an array of rejected and resolved results_
  *
  * @param items List of _Promises_
- * @param strategy Strategy for handling the _Promises_; rejects on the first error encountered
+ * @param strategy Strategy for handling the _Promises_
  * @returns List of results
  */
-declare function promises<Items extends unknown[]>(items: [...Items], strategy: 'first'): Promise<PromisesUnwrapped<Items>>;
+declare function promises<Items extends unknown[], Strategy extends PromiseStrategy>(items: [...Items], strategy: Strategy): Promise<Strategy extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
- * Handle a list of _Promises_, returning their results in an ordered array
+ * Handle keyed _Promises_, returning their results in a similarly keyed object
  *
- * If any _Promise_ in the list is rejected, the whole function will reject
+ * _If the strategy is `first`, the function will reject on the first error encountered; otherwise, it returns an object of rejected and resolved results_
  *
- * @param items List of _Promises_
- * @param strategy Strategy for handling the _Promises_; rejects on the first error encountered
- * @returns List of results
+ * @param items Keyed _Promises_
+ * @param strategy Strategy for handling the _Promises_
+ * @returns Keyed object of results
  */
-declare function promises<Value>(items: Promise<Value>[], strategy: 'first'): Promise<Value[]>;
+declare function promises<Items extends PlainObject, Strategy extends PromiseStrategy>(items: Items, strategy: Strategy): Promise<Strategy extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
- * Handle a list of _Promises_, returning their results in an ordered array of rejected and resolved results
+ * Handle a list of _Promises_, returning their results in an ordered array
  *
  * @param items List of _Promises_
- * @param signal AbortSignal for aborting the operation _(when aborted, the _Promise_ will reject with the reason of the signal)_
+ * @param signal _AbortSignal_ for aborting all _Promises_
  * @returns List of results
  */
 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
+ * Handle keyed _Promises_, returning their results in a similarly keyed object
  *
- * @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
+ * @param items Keyed _Promises_
+ * @param signal _AbortSignal_ for aborting all _Promises_
+ * @returns Keyed object of results
  */
-declare function promises<Value>(items: Array<Promise<Value> | (() => Promise<Value>)>, signal?: AbortSignal): Promise<PromisesValue<Value>[]>;
+declare function promises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesValues<PromisesItems<Items>>>;
 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
+ * _Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results_
  *
  * _Available as `resultPromises` and `promises.result`_
  *
  * @param items List of _Promises_
- * @param signal AbortSignal for aborting the operation _(when aborted, the _Promise_ will reject with the reason of the signal)_
+ * @param signal AbortSignal for aborting all _Promises_
  * @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
+ * Handle keyed _Promises_, returning their results in a similarly keyed object of results _({@link Result})_
  *
  * _Available as `resultPromises` and `promises.result`_
  *
- * @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
+ * @param items Keyed _Promises_
+ * @param signal AbortSignal for aborting all _Promises_
+ * @returns Keyed object of results
  */
-declare function resultPromises<Value>(items: Promise<Value>[], signal?: AbortSignal): Promise<Result<Awaited<Value>>[]>;
+declare function resultPromises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesResult<PromisesItems<Items>>>;
 //#endregion
 export { attemptPromise, promises, resultPromises };

package/dist/promise/index.mjs

@@ -1,13 +1,14 @@
+import { isArrayOrPlainObject } from "../internal/is.mjs";
 import { createAborter } from "../internal/abort.mjs";
-import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
-import { getPromiseOptions, getPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
+import { PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
+import { createPromiseOptions, createPromisesOptions, getResultsFromPromises } from "./helpers.mjs";
 import { handleResult, settlePromise } from "./misc.mjs";
 import { getTimedPromise } from "./timed.mjs";
 //#region src/promise/index.ts
 async function attemptPromise(value, options) {
 	const isFunction = typeof value === "function";
 	if (!isFunction && !(value instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT));
-	const { signal, time } = getPromiseOptions(options);
+	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	const aborter = createAborter(signal, () => {
 		rejector(signal?.reason);
@@ -29,19 +30,20 @@ async function attemptPromise(value, options) {
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }
 async function promises(items, options) {
-	const { signal, strategy } = getPromisesOptions(options);
+	const { signal, strategy } = createPromisesOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
-	if (!Array.isArray(items)) return Promise.resolve([]);
-	const actual = items.map((item) => typeof item === "function" ? item() : item).filter((item) => item instanceof Promise);
+	if (!isArrayOrPlainObject(items)) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE);
+	const isArray = Array.isArray(items);
+	const actual = (isArray ? items.map((item, index) => [index, item]) : Object.entries(items)).map(([key, value]) => [key, typeof value === "function" ? value() : value]).filter(([, value]) => value instanceof Promise);
 	const { length } = actual;
-	if (length === 0) return Promise.resolve([]);
+	if (length === 0) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY);
 	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
 	const aborter = createAborter(signal, () => {
 		handlers.reject(signal?.reason);
 	});
 	const data = {
 		last: length - 1,
-		result: []
+		result: isArray ? [] : {}
 	};
 	let handlers;
 	return new Promise((resolve, reject) => {
@@ -49,21 +51,24 @@ async function promises(items, options) {
 			reject,
 			resolve
 		};
-		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(PROMISE_TYPE_FULFILLED, {
-			aborter,
-			complete,
-			data,
-			handlers,
-			index,
-			value
-		})).catch((reason) => handleResult(PROMISE_TYPE_REJECTED, {
-			aborter,
-			complete,
-			data,
-			handlers,
-			index,
-			value: reason
-		}));
+		for (let index = 0; index < length; index += 1) {
+			const [key, promise] = actual[index];
+			const parameters = {
+				aborter,
+				complete,
+				data,
+				handlers,
+				index,
+				key
+			};
+			promise.then((value) => {
+				parameters.value = value;
+				handleResult(PROMISE_TYPE_FULFILLED, parameters);
+			}).catch((reason) => {
+				parameters.value = reason;
+				handleResult(PROMISE_TYPE_REJECTED, parameters);
+			});
+		}
 	});
 }
 async function resultPromises(items, signal) {

package/dist/promise/misc.mjs

@@ -14,13 +14,13 @@ function cancelable(executor) {
 	return new CancelablePromise(executor);
 }
 function handleResult(status, parameters) {
-	const { aborter, complete, data, handlers, index, value } = parameters;
+	const { aborter, complete, data, handlers, index, key, value } = parameters;
 	if (aborter?.signal.aborted ?? false) return;
 	if (!complete && status === "rejected") {
 		settlePromise(handlers.reject, value, aborter);
 		return;
 	}
-	data.result[index] = !complete ? value : status === "fulfilled" ? {
+	data.result[key] = !complete ? value : status === "fulfilled" ? {
 		status,
 		value
 	} : {

package/dist/promise/models.d.mts

@@ -1,4 +1,4 @@
-import { GenericCallback } from "../models.mjs";
+import { ArrayOrPlainObject, GenericCallback, Key } from "../models.mjs";
 import { Result } from "../internal/result/models.mjs";
 import { Aborter } from "../internal/abort.mjs";
 import { PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./constants.mjs";
@@ -31,7 +31,7 @@ type FulfilledPromise<Value> = {
 };
 type PromiseData = {
   last: number;
-  result: unknown[];
+  result: ArrayOrPlainObject;
 };
 type PromiseHandlers = {
   resolve: (value: unknown[]) => void;
@@ -56,6 +56,7 @@ type PromiseParameters = {
   data: PromiseData;
   handlers: PromiseHandlers;
   index: number;
+  key: Key;
   value?: unknown;
 };
 /**
@@ -71,7 +72,7 @@ type PromiseStrategy = 'complete' | 'first';
 declare class PromiseTimeoutError extends Error {
   constructor();
 }
-type PromisesItems<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
+type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
 /**
  * Options for handling multiple _Promises_
  */
@@ -85,10 +86,10 @@ type PromisesOptions = {
    */
   strategy?: PromiseStrategy;
 };
-type PromisesResult<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-type PromisesUnwrapped<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; };
+type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
+type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; };
 type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
-type PromisesValues<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never : Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
+type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
 /**
  * A _Promise_ that was rejected
  */

package/dist/promise/timed.mjs

@@ -2,7 +2,7 @@ import { createAborter } from "../internal/abort.mjs";
 import { TIMER_WAIT, getTimer } from "../internal/function/timer.mjs";
 import { PROMISE_MESSAGE_EXPECTATION_TIMED } from "./constants.mjs";
 import { PromiseTimeoutError } from "./models.mjs";
-import { getPromiseOptions } from "./helpers.mjs";
+import { createPromiseOptions } from "./helpers.mjs";
 import { settlePromise } from "./misc.mjs";
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
@@ -24,7 +24,7 @@ async function getTimedPromise(promise, time, signal) {
 }
 async function timed(promise, options) {
 	if (!(promise instanceof Promise)) return Promise.reject(new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
-	const { signal, time } = getPromiseOptions(options);
+	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }

package/dist/queue.d.mts

@@ -216,6 +216,8 @@ declare function isQueueInstance<Instance>(name: string, value: unknown): value
 /**
  * Create a keyed queue for an asynchronous callback function, where each key has its own queue
  *
+ * _Available as `keyedQueue` and `queue.keyed`_
+ *
  * @param callback Callback function for queued items
  * @param options Queue options
  */
@@ -223,6 +225,8 @@ declare function keyedQueue<Callback extends (key: string, ...parameters: any[])
 /**
  * Create a keyed queue for an asynchronous callback function, where each key has its own queue
  *
+ * _Available as `keyedQueue` and `queue.keyed`_
+ *
  * @param callback Callback function for queued items
  * @param options Queue options
  */

package/dist/queue.mjs

@@ -54,7 +54,7 @@ function createQueue(callback, options, key) {
 		handled: [],
 		id: 0,
 		items: [],
-		options: getOptions(options),
+		options: createQueueOptions(options),
 		paused: !getBooleanOrDefault(options?.autostart, true),
 		runners: 0
 	};
@@ -104,7 +104,7 @@ function createQueue(callback, options, key) {
 	});
 	return Object.freeze(instance);
 }
-function getOptions(input) {
+function createQueueOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
 		autostart: getBooleanOrDefault(options.autostart, true),
@@ -182,7 +182,7 @@ function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
-		options: getOptions(options),
+		options: createQueueOptions(options),
 		queues: /* @__PURE__ */ new Map()
 	};
 	const instance = {

package/dist/string/fuzzy.d.mts

@@ -115,6 +115,8 @@ declare namespace fuzzy {
 /**
  * Does the needle match the haystack in a fuzzy way?
  *
+ * _Available as `fuzzyMatch` and `fuzzy.match`_
+ *
  * @param haystack Haystack to search through
  * @param needle Needle to search for
  * @returns `true` if the needle matches the haystack in a fuzzy way, otherwise `false`

package/dist/string/fuzzy.mjs

@@ -3,20 +3,7 @@ import { getString } from "../internal/string/misc.mjs";
 import { lowerCase } from "../internal/string/case.mjs";
 import { includes } from "./match.mjs";
 //#region src/string/fuzzy.ts
-function getHandler(input) {
-	if (input == null || input === getString) return getString;
-	switch (typeof input) {
-		case "function": return input;
-		case "string": return (item) => item[input];
-		default:
-			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(FUZZY_MESSAGE_HANDLER);
-	}
-}
-function getFuzzyItems(items) {
-	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
-}
-function getFuzzyOptions(input, state) {
+function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
 	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = Math.floor(limit);
@@ -24,9 +11,9 @@ function getFuzzyOptions(input, state) {
 	options.tolerance = getTolerance(options.tolerance, state);
 	return options;
 }
-function getFuzzyState(items, input) {
+function createFuzzyState(items, input) {
 	const handler = getHandler(input);
-	const options = getFuzzyOptions(input);
+	const options = createFuzzyOptions(input);
 	return {
 		handler,
 		items: items.slice(),
@@ -35,14 +22,27 @@ function getFuzzyState(items, input) {
 		tolerance: options.tolerance
 	};
 }
+function getHandler(input) {
+	if (input == null || input === getString) return getString;
+	switch (typeof input) {
+		case "function": return input;
+		case "string": return (item) => item[input];
+		default:
+			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
+	}
+}
+function getFuzzyItems(items) {
+	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+}
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
 	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	const state = getFuzzyState(items, configuration);
-	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
+	const state = createFuzzyState(items, configuration);
+	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : createFuzzyOptions(options, state)) };
 	Object.defineProperties(instance, {
 		items: {
 			enumerable: true,
@@ -58,6 +58,8 @@ function fuzzy(items, configuration) {
 }
 /**
 * Does the needle match the haystack in a fuzzy way?
+* 
+* _Available as `fuzzyMatch` and `fuzzy.match`_
 *
 * @param haystack Haystack to search through
 * @param needle Needle to search for