@oscarpalmer/atoms 0.199.0 → 0.200.0

package/dist/array/flatten.d.mts

@@ -11,6 +11,6 @@ import { NestedArray } from "../models.mjs";
  * flatten([1, [2, [3, 4], 5], 6]); // => [1, 2, 3, 4, 5, 6]
  * ```
  */
-declare function flatten<Item>(array: Item[]): NestedArray<Item>[];
+declare function flatten<Item>(array: Item[]): Array<NestedArray<Item>>;
 //#endregion
 export { flatten };

package/dist/array/from.d.mts

@@ -62,7 +62,7 @@ declare function times(length: number): number[];
  * times(5, index => index * 2); // => [0, 2, 4, 6, 8]
  * ```
  */
-declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): ReturnType<Callback>[];
+declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): Array<ReturnType<Callback>>;
 /**
  * Get an array with a specified length, filled with a specified value
  *

package/dist/array/group-by.d.mts

@@ -155,7 +155,7 @@ declare namespace groupBy {
  *    // }
  * ```
  */
-declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  *
@@ -201,7 +201,7 @@ declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (it
  *    // }
  * ```
  */
-declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>[]>>;
+declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ValueCallback>>>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  *

package/dist/array/sort.d.mts

@@ -172,6 +172,8 @@ declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Is the array sorted according to the sorters _(and the optional default direction)_?
  *
+ * _Available as `isSorted` and `sort.is`_
+ *
  * @param array Array to check
  * @param sorters Sorters to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
@@ -181,6 +183,8 @@ declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter<Item>>
 /**
  * Is the array sorted according to the sorter _(and the optional default direction)_?
  *
+ * _Available as `isSorted` and `sort.is`_
+ *
  * @param array Array to check
  * @param sorter Sorter to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_

package/dist/array/to-map.d.mts

@@ -152,7 +152,7 @@ declare namespace toMap {
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a _Map_ from an array of items using a callback and value, grouping values into arrays
  *
@@ -192,7 +192,7 @@ declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>[]>;
+declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], Array<ReturnType<ValueCallback>>>;
 /**
  * Create a _Map_ from an array of items using a key and value, grouping values into arrays
  *

package/dist/array/to-record.d.mts

@@ -152,7 +152,7 @@ declare namespace toRecord {
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a callback and value, grouping values into arrays
  *
@@ -192,7 +192,7 @@ declare function toRecordArrays<Item extends PlainObject, Callback extends (item
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>[]>>;
+declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<Callback>>>>;
 /**
  * Create a record from an array of items using a key and value, grouping values into arrays
  *

package/dist/index.d.mts

@@ -604,7 +604,7 @@ export declare namespace groupBy {
  *    // }
  * ```
  */
-export declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+export declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  *
@@ -650,7 +650,7 @@ export declare function groupArraysBy<Item extends PlainObject, KeyCallback exte
  *    // }
  * ```
  */
-export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>[]>>;
+export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ValueCallback>>>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
  *
@@ -745,7 +745,7 @@ export declare function chunk<Item>(array: Item[], size?: number): Item[][];
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [1, 'hello', true]
  * ```
  */
-export declare function compact<Item>(array: Item[], strict: true): Exclude<Item, 0 | '' | false | null | undefined>[];
+export declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | '' | false | null | undefined>>;
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  *
@@ -757,7 +757,7 @@ export declare function compact<Item>(array: Item[], strict: true): Exclude<Item
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [0, 1, '', 'hello', false, true]
  * ```
  */
-export declare function compact<Item>(array: Item[]): Exclude<Item, null | undefined>[];
+export declare function compact<Item>(array: Item[]): Array<Exclude<Item, null | undefined>>;
 //#endregion
 //#region src/internal/array/get.d.ts
 /**
@@ -1516,7 +1516,7 @@ export declare function findLast<Item>(array: Item[], value: Item): Item | undef
  * flatten([1, [2, [3, 4], 5], 6]); // => [1, 2, 3, 4, 5, 6]
  * ```
  */
-export declare function flatten<Item>(array: Item[]): NestedArray<Item>[];
+export declare function flatten<Item>(array: Item[]): Array<NestedArray<Item>>;
 //#endregion
 //#region src/array/from.d.ts
 /**
@@ -1582,7 +1582,7 @@ export declare function times(length: number): number[];
  * times(5, index => index * 2); // => [0, 2, 4, 6, 8]
  * ```
  */
-export declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): ReturnType<Callback>[];
+export declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): Array<ReturnType<Callback>>;
 /**
  * Get an array with a specified length, filled with a specified value
  *
@@ -3017,6 +3017,8 @@ export declare function initializeSorter<Item>(descending?: boolean): Sorter<Ite
 /**
  * Is the array sorted according to the sorters _(and the optional default direction)_?
  *
+ * _Available as `isSorted` and `sort.is`_
+ *
  * @param array Array to check
  * @param sorters Sorters to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
@@ -3026,6 +3028,8 @@ export declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter
 /**
  * Is the array sorted according to the sorter _(and the optional default direction)_?
  *
+ * _Available as `isSorted` and `sort.is`_
+ *
  * @param array Array to check
  * @param sorter Sorter to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
@@ -3430,7 +3434,7 @@ export declare namespace toMap {
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-export declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+export declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a _Map_ from an array of items using a callback and value, grouping values into arrays
  *
@@ -3470,7 +3474,7 @@ export declare function toMapArrays<Item extends PlainObject, KeyCallback extend
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>[]>;
+export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], Array<ReturnType<ValueCallback>>>;
 /**
  * Create a _Map_ from an array of items using a key and value, grouping values into arrays
  *
@@ -3681,7 +3685,7 @@ export declare namespace toRecord {
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-export declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
+export declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
 /**
  * Create a record from an array of items using a callback and value, grouping values into arrays
  *
@@ -3721,7 +3725,7 @@ export declare function toRecordArrays<Item extends PlainObject, Callback extend
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>[]>>;
+export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<Callback>>>>;
 /**
  * Create a record from an array of items using a key and value, grouping values into arrays
  *
@@ -5008,7 +5012,7 @@ export type FulfilledPromise<Value> = {
 };
 export type PromiseData = {
   last: number;
-  result: unknown[];
+  result: ArrayOrPlainObject;
 };
 export type PromiseHandlers = {
   resolve: (value: unknown[]) => void;
@@ -5033,6 +5037,7 @@ export type PromiseParameters = {
   data: PromiseData;
   handlers: PromiseHandlers;
   index: number;
+  key: Key$1;
   value?: unknown;
 };
 /**
@@ -5048,7 +5053,7 @@ export type PromiseStrategy = 'complete' | 'first';
 export declare class PromiseTimeoutError extends Error {
   constructor();
 }
-export 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]>; };
+export 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_
  */
@@ -5062,10 +5067,10 @@ export type PromisesOptions = {
    */
   strategy?: PromiseStrategy;
 };
-export type PromisesResult<Items extends unknown[]> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-export 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; };
+export type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
+export 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; };
 export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
-export 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; };
+export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
 /**
  * A _Promise_ that was rejected
  */
@@ -5098,7 +5103,7 @@ export declare function delay(time?: number): Promise<void>;
 //#endregion
 //#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_
@@ -5106,7 +5111,7 @@ export declare function delay(time?: number): Promise<void>;
  */
 export 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_
@@ -5114,7 +5119,7 @@ export declare function attemptPromise<Value>(promise: Promise<Value>, options?:
  */
 export 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_
@@ -5124,7 +5129,7 @@ export declare function attemptPromise<Value>(callback: () => Value, options?: P
 /**
  * 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_
@@ -5132,78 +5137,76 @@ export declare function attemptPromise<Value>(callback: () => Value, options?: P
  */
 export 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
  */
-export declare function promises<Value, Options extends PromisesOptions>(items: Promise<Value>[], options?: Options): Promise<Options['strategy'] extends 'first' ? Value[] : PromisesValue<Value>[]>;
+export 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
  */
-export declare function promises<Items extends unknown[]>(items: [...Items], strategy: 'first'): Promise<PromisesUnwrapped<Items>>;
+export 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
  */
-export declare function promises<Value>(items: Promise<Value>[], strategy: 'first'): Promise<Value[]>;
+export 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
  */
 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
+ * 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
  */
-export declare function promises<Value>(items: Array<Promise<Value> | (() => Promise<Value>)>, signal?: AbortSignal): Promise<PromisesValue<Value>[]>;
+export declare function promises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesValues<PromisesItems<Items>>>;
 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
+ * _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
  */
 export 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
  */
-export declare function resultPromises<Value>(items: Promise<Value>[], signal?: AbortSignal): Promise<Result<Awaited<Value>>[]>;
+export declare function resultPromises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesResult<PromisesItems<Items>>>;
 //#endregion
 //#region src/internal/result/misc.d.ts
 /**
@@ -5947,6 +5950,8 @@ export 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`
@@ -6486,6 +6491,8 @@ export declare namespace freeze {
 /**
  * Is the value frozen?
  *
+ * _Available as `isFrozen` and `freeze.is`_
+ *
  * @param value Value to check
  * @returns `true` if the value is frozen, otherwise `false`
  */
@@ -6615,7 +6622,7 @@ export type Merger = {
    * @param values Values to merge
    * @returns Merged value
    */
-  <Values extends ArrayOrPlainObject[]>(values: NestedPartial<Values[number]>[]): UnionToIntersection<Values[number]>;
+  <Values extends ArrayOrPlainObject[]>(values: Array<NestedPartial<Values[number]>>): UnionToIntersection<Values[number]>;
 };
 /**
  * Assign values from one or more objects to the first one
@@ -8499,6 +8506,8 @@ export declare function isQueueInstance<Instance>(name: string, value: unknown):
 /**
  * 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
  */
@@ -8506,6 +8515,8 @@ export declare function keyedQueue<Callback extends (key: string, ...parameters:
 /**
  * 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/index.mjs

@@ -2597,6 +2597,8 @@ const ABORT_OPTIONS = { once: true };
 //#region src/promise/constants.ts
 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";
@@ -2665,7 +2667,15 @@ function createPromisesOptions(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;
@@ -2719,13 +2729,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
 	} : {
@@ -2816,17 +2826,18 @@ async function attemptPromise(value, options) {
 async function promises(items, 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) => {
@@ -2834,21 +2845,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) {
@@ -3050,6 +3064,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
@@ -3792,6 +3808,8 @@ function freezeValue(value, references, flat) {
 }
 /**
 * Is the value frozen?
+* 
+* _Available as `isFrozen` and `freeze.is`_
 *
 * @param value Value to check
 * @returns `true` if the value is frozen, otherwise `false`
@@ -3968,7 +3986,8 @@ function createMergeOptions(options) {
 }
 function getReplaceableObjects(value) {
 	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
-	if (items.length > 0) return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
+	if (items.length === 0) return;
+	return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
 }
 /**
 * Create an assigner with predefined options

package/dist/internal/array/compact.d.mts

@@ -11,7 +11,7 @@
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [1, 'hello', true]
  * ```
  */
-declare function compact<Item>(array: Item[], strict: true): Exclude<Item, 0 | '' | false | null | undefined>[];
+declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | '' | false | null | undefined>>;
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  *
@@ -23,6 +23,6 @@ declare function compact<Item>(array: Item[], strict: true): Exclude<Item, 0 | '
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [0, 1, '', 'hello', false, true]
  * ```
  */
-declare function compact<Item>(array: Item[]): Exclude<Item, null | undefined>[];
+declare function compact<Item>(array: Item[]): Array<Exclude<Item, null | undefined>>;
 //#endregion
 export { compact };

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/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 createPromiseOptions(input: unknown): RequiredKeys<PromiseOptions, 'time'>;
 declare function createPromisesOptions(input: unknown): RequiredKeys<PromisesOptions, 'strategy'>;
-declare function getResultsFromPromises<Value>(promised: PromisesValue<Value>[]): Result<Value>[];
+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?

package/dist/promise/helpers.mjs

@@ -27,7 +27,15 @@ function createPromisesOptions(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;

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,5 +1,6 @@
+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 { 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";
@@ -31,17 +32,18 @@ async function attemptPromise(value, options) {
 async function promises(items, 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/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/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

@@ -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

package/dist/value/freeze.d.mts

@@ -135,6 +135,8 @@ declare namespace freeze {
 /**
  * Is the value frozen?
  *
+ * _Available as `isFrozen` and `freeze.is`_
+ *
  * @param value Value to check
  * @returns `true` if the value is frozen, otherwise `false`
  */

package/dist/value/freeze.mjs

@@ -65,6 +65,8 @@ function freezeValue(value, references, flat) {
 }
 /**
 * Is the value frozen?
+* 
+* _Available as `isFrozen` and `freeze.is`_
 *
 * @param value Value to check
 * @returns `true` if the value is frozen, otherwise `false`

package/dist/value/merge.d.mts

@@ -60,7 +60,7 @@ type Merger = {
    * @param values Values to merge
    * @returns Merged value
    */
-  <Values extends ArrayOrPlainObject[]>(values: NestedPartial<Values[number]>[]): UnionToIntersection<Values[number]>;
+  <Values extends ArrayOrPlainObject[]>(values: Array<NestedPartial<Values[number]>>): UnionToIntersection<Values[number]>;
 };
 /**
  * Assign values from one or more objects to the first one

package/dist/value/merge.mjs

@@ -29,7 +29,8 @@ function createMergeOptions(options) {
 }
 function getReplaceableObjects(value) {
 	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
-	if (items.length > 0) return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
+	if (items.length === 0) return;
+	return (name) => items.some((item) => typeof item === "string" ? item === name : item.test(name));
 }
 /**
 * Create an assigner with predefined options

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.199.0",
+	"version": "0.200.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -278,10 +278,10 @@
 		"watch": "npx vite build --watch"
 	},
 	"devDependencies": {
-		"@oxlint/plugins": "^1.81",
-		"@types/node": "^26.4",
+		"@oxlint/plugins": "^1.82",
+		"@types/node": "^26.5",
 		"@vitest/coverage-istanbul": "^4.1",
-		"eslint": "^10.9",
+		"eslint": "^10.10",
 		"jsdom": "^30",
 		"tsdown": "^0.23",
 		"typescript": "^6",

package/plugin/index.js

@@ -29,7 +29,7 @@ export const mathPlugins = [
 export const miscPlugins = [
 	tryCatchPlugin,
 	getPlugin('number', 'getNumber', new Set(['Number']), true, true),
-	getPlugin('promise', 'promises', new Set(['all', 'allSettled']), true),
+	getPlugin('promise', 'promises', new Set(['all', 'allKeyed', 'allSettled']), true),
 	getPlugin('value', 'assign', new Set(['assign']), true),
 	getPlugin('value', 'clone', new Set(['structuredClone']), true, true),
 	getPlugin('value', 'equal', new Set(['is']), true),