@oscarpalmer/atoms 0.184.2 → 0.186.0

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

@@ -1,9 +1,15 @@
 //#region src/internal/array/chunk.d.ts
 /**
  * Chunk an array into smaller arrays
+ *
  * @param array Array to chunk
  * @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
  * @returns Array of arrays
+ *
+ * @example
+ * ```typescript
+ * chunk([1, 2, 3, 4, 5], 2); // => [[1, 2], [3, 4], [5]]
+ * ```
  */
 declare function chunk<Item>(array: Item[], size?: number): Item[][];
 //#endregion

package/dist/internal/array/chunk.mjs

@@ -1,9 +1,15 @@
 //#region src/internal/array/chunk.ts
 /**
 * Chunk an array into smaller arrays
+*
 * @param array Array to chunk
 * @param size Size of each chunk _(minimum is `1`, maximum is `5000`; defaults to `5000`)_
 * @returns Array of arrays
+*
+* @example
+* ```typescript
+* chunk([1, 2, 3, 4, 5], 2); // => [[1, 2], [3, 4], [5]]
+* ```
 */
 function chunk(array, size) {
 	if (!Array.isArray(array)) return [];

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

@@ -1,15 +1,27 @@
 //#region src/internal/array/compact.d.ts
 /**
  * Compact an array _(removing all false-y values)_
+ *
  * @param array Array to compact
  * @param strict True to remove all false-y values
  * @returns Compacted array
+ *
+ * @example
+ * ```typescript
+ * 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>[];
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
+ *
  * @param array Array to compact
  * @returns Compacted array
+ *
+ * @example
+ * ```typescript
+ * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [0, 1, '', 'hello', false, true]
+ * ```
  */
 declare function compact<Item>(array: Item[]): Exclude<Item, null | undefined>[];
 //#endregion

package/dist/internal/array/index-of.d.mts

@@ -3,32 +3,67 @@ import { PlainObject } from "../../models.mjs";
 //#region src/internal/array/index-of.d.ts
 /**
  * Get the index of the first matching item by callback
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value
  * @param value Value to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the first matching item by key
+ *
  * @param array Array to search in
  * @param key Key to match items by
  * @param value Value to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the first item matching the filter
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => 1
+ * ```
  */
 declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the first item matching the given item
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf([1, 2, 3, 4, 5], 3); // => 2
+ * ```
  */
 declare function indexOf<Item>(array: Item[], item: Item): number;
 declare namespace indexOf {
@@ -38,38 +73,73 @@ declare namespace indexOf {
  * Get the index of the last matching item by callback
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param callback Callback to get an item's value
  * @param value Value to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id,
+ *   2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
 /**
  * Get the index of the last matching item by key
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param key Key to match items by
  * @param value Value to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   'id',
+ *   2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
 /**
  * Get the index of the last item matching the filter
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param filter Filter callback to match items
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id === 2,
+ * ); // => 3
+ * ```
  */
 declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the index of the last item matching the given item
  *
  * Available as `lastIndexOf` and `indexOf.last`
+ *
  * @param array Array to search in
  * @param item Item to match against
  * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf([1, 2, 3, 2, 1], 2); // => 3
+ * ```
  */
 declare function lastIndexOf<Item>(array: Item[], item: Item): number;
 //#endregion

package/dist/internal/math/aggregate.d.mts

@@ -11,6 +11,17 @@ declare function aggregate(type: AggregationType, array: unknown[], key: unknown
 declare function getAggregateCallback(key: unknown): Function | undefined;
 /**
  * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   item => item.value,
+ * ); // 20
+ *
+ * max([], item => item.value); // Number.NaN
+ * ```
+ *
  * @param items List of items
  * @param callback Callback to get an item's value
  * @returns Maximum value, or `NaN` if no maximum can be found
@@ -18,6 +29,17 @@ declare function getAggregateCallback(key: unknown): Function | undefined;
 declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
 /**
  * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   'value',
+ * ); // 20
+ *
+ * max([], 'value'); // Number.NaN
+ * ```
+ *
  * @param items List of items
  * @param key Key to use for value
  * @returns Maximum value, or `NaN` if no maximum can be found
@@ -25,6 +47,13 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
 declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): number;
 /**
  * Get the maximum value from a list of numbers
+ *
+ * @example
+ * ```typescript
+ * max([10, 20]); // 20
+ * max([]);       // Number.NaN
+ * ```
+ *
  * @param values List of numbers
  * @returns Maximum value, or `NaN` if no maximum can be found
  */

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

@@ -1,6 +1,7 @@
 import { Constructor, GenericCallback } from "../../models.mjs";
 
 //#region src/internal/value/compare.d.ts
+type Comparator<Value = any> = (first: Value, second: Value) => number;
 /**
  * Compare two values _(for sorting purposes)_
  * @param first First value
@@ -31,6 +32,6 @@ declare function deregisterComparator<Instance>(constructor: Constructor<Instanc
  * @param constructor Class constructor
  * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => number)): void;
+declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | Comparator<Instance>): void;
 //#endregion
 export { compare, deregisterComparator, registerComparator };

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

@@ -18,6 +18,11 @@ type EqualOptions = {
    */
   relaxedNullish?: boolean;
 };
+/**
+ * An equalizer function for comparing values for equality, with predefined options
+ *
+ * Can be used to compare values, and register or deregister equality comparison handlers for specific classes
+ */
 type Equalizer = {
   /**
    * Are two strings equal?

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

@@ -1,18 +1,40 @@
-import { NestedKeys, NestedValue, PlainObject, ToString } from "../../models.mjs";
+import { NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
 
 //#region src/internal/value/get.d.ts
 /**
  * Get the value from an object using a known path
+ *
+ * @example
+ * ```typescript
+ * const data = {foo: {bar: {baz: 42}}};
+ *
+ * getValue(data, 'foo');         // {bar: {baz: 42}}
+ * getValue(data, 'foo.bar');     // {baz: 42}
+ * getValue(data, 'foo.bar.baz'); // 42
+ * getValue(data, 'foo.nope');    // undefined
+ * ```
+ *
  * @param data Object to get value from
- * @param path Path for value, e.g., `foo.bar.baz`
+ * @param path Path for value
  * @returns Found value, or `undefined`
  */
-declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, ToString<Path>>;
+declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
 /**
  * Get the value from an object using an unknown path
+ *
+ * @example
+ * ```typescript
+ * const data = {foo: {bar: {baz: 42}}};
+ *
+ * getValue(data, 'foo');               // {bar: {baz: 42}}
+ * getValue(data, 'foo.bar');           // {baz: 42}
+ * getValue(data, 'Foo.Bar.Baz', true); // 42
+ * getValue(data, 'foo.nope');          // undefined
+ * ```
+ *
  * @param data Object to get value from
- * @param path Path for value, e.g., `foo.bar.baz`
- * @param ignoreCase If `true`, the path matching is case-insensitive
+ * @param path Path for value
+ * @param ignoreCase If `true`, path matching is case-insensitive
  * @returns Found value, or `undefined`
  */
 declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;

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

@@ -6,7 +6,7 @@ import { Result } from "../../result/models.mjs";
  * Check if a nested property is defined in an object
  * @param data Object to check in
  * @param path Path for property
- * @return `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, `false` otherwise
  */
 declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): boolean;
 /**
@@ -14,7 +14,7 @@ declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return `true` if the property exists, `false` otherwise
+ * @returns `true` if the property exists, `false` otherwise
  */
 declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
 declare namespace hasValue {
@@ -27,9 +27,9 @@ declare namespace hasValue {
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return Result object
+ * @returns Result object
  */
-declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, undefined>;
+declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, string>;
 /**
  * Check if a nested property is defined in an object, and get its value if it is
  *
@@ -37,8 +37,8 @@ declare function hasValueResult<Data extends PlainObject, Path extends NestedKey
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
- * @return Result object
+ * @returns Result object
  */
-declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, undefined>;
+declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
 //#endregion
-export { hasValue };
+export { hasValue, hasValueResult };

package/dist/internal/value/has.mjs

@@ -8,4 +8,4 @@ function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 //#endregion
-export { hasValue };
+export { hasValue, hasValueResult };

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

@@ -2,9 +2,9 @@ import { Result } from "../../result/models.mjs";
 
 //#region src/internal/value/misc.d.ts
 declare function findKey(needle: string, haystack: object): string;
-declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, undefined>;
+declare function getNestedValue(data: object, path: string, ignoreCase: boolean): Result<unknown, string>;
 declare function getPaths(path: string, lowercase: boolean): string | string[];
-declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, undefined>;
+declare function handleValue(data: object, path: string, value: unknown, get: true, ignoreCase: boolean): Result<unknown, string>;
 declare function handleValue(data: object, path: string, value: unknown, get: false, ignoreCase: boolean): void;
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/internal/value/misc.mjs

@@ -7,7 +7,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return error(void 0);
+	if (typeof data !== "object" || data === null) return error(NESTED_MESSAGE_INPUT);
+	if (typeof path !== "string" || path.trim().length === 0) return error(NESTED_MESSAGE_PATH);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -27,15 +28,20 @@ function getPaths(path, lowercase) {
 	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
-	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
+	if (typeof data === "object" && data !== null) {
+		if (ignoreKey(path)) return error(NESTED_MESSAGE_UNSAFE);
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(void 0);
+		if (get) return key in data ? ok(data[key]) : error(NESTED_MESSAGE_MISSING);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return error(void 0);
+	if (get) return error(NESTED_MESSAGE_MISSING);
 }
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;
 const EXPRESSION_NESTED = /\.|\[\w+\]/;
+const NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const NESTED_MESSAGE_PATH = "Expected path to be a string";
+const NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 //#endregion
 export { findKey, getNestedValue, getPaths, handleValue };

package/dist/logger.d.mts

@@ -1,4 +1,9 @@
 //#region src/logger.d.ts
+/**
+ * A logger that can be used to log messages to the console
+ *
+ * _(Logging can be enabled or disabled by setting the `enabled` property)_
+ */
 declare class Logger {
   /**
    * Log any number of values at the "debug" log level
@@ -47,8 +52,14 @@ declare class Logger {
    */
   time(label: string): Time;
 }
+/**
+ * A named timer that can be used to log durations to the console
+ */
 declare class Time {
   #private;
+  /**
+   * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
+   */
   get active(): boolean;
   /**
    * Log the current duration of the timer _(ignored if logging is disabled)_

package/dist/logger.mjs

@@ -1,5 +1,10 @@
 import { noop } from "./internal/function/misc.mjs";
 //#region src/logger.ts
+/**
+* A logger that can be used to log messages to the console
+*
+* _(Logging can be enabled or disabled by setting the `enabled` property)_
+*/
 var Logger = class {
 	/**
 	* Log any number of values at the "debug" log level
@@ -70,10 +75,16 @@ var Logger = class {
 		return new Time(label);
 	}
 };
+/**
+* A named timer that can be used to log durations to the console
+*/
 var Time = class {
 	#logger;
 	#stopper;
 	#state;
+	/**
+	* Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
+	*/
 	get active() {
 		return this.#state.started && !this.#state.stopped && enabled;
 	}

package/dist/models.d.mts

@@ -143,5 +143,18 @@ type ToString<Value> = Value extends string | number ? `${Value}` : never;
  * A union type of all typed arrays
  */
 type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Converts a union type to an intersection type
+ *
+ * @example
+ * ```typescript
+ * type A = {a: string};
+ * type B = {b: number};
+ * type C = UnionToIntersection<A | B>; // {a: string} & {b: number}
+ * ```
+ *
+ * Thanks, type-fest!
+ */
+type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends ((mergedIntersection: infer Intersection) => void) ? Intersection & Union : never;
 //#endregion
-export { ArrayOrPlainObject, AsyncCancelableCallback, BuiltIns, CancelableCallback, Constructor, EventPosition, GenericAsyncCallback, GenericCallback, Key, KeyedValue, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, RequiredKeys, Simplify, ToString, TypedArray };
+export { ArrayOrPlainObject, AsyncCancelableCallback, BuiltIns, CancelableCallback, Constructor, EventPosition, GenericAsyncCallback, GenericCallback, Key, KeyedValue, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, RequiredKeys, Simplify, ToString, TypedArray, UnionToIntersection };

package/dist/promise/helpers.mjs

@@ -1,5 +1,5 @@
-import { getNumberOrDefault } from "../internal/number.mjs";
 import { error, ok } from "../result/misc.mjs";
+import { getNumberOrDefault } from "../internal/number.mjs";
 import { PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED } from "./models.mjs";
 //#region src/promise/helpers.ts
 function getPromiseOptions(input) {

package/dist/promise/index.d.mts

@@ -4,8 +4,6 @@ import { PromiseOptions, PromisesItems, PromisesOptions, PromisesResult, Promise
 //#region src/promise/index.d.ts
 /**
  * Wrap a promise with safety handlers, with optional abort capabilities and timeout
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param promise Promise to wrap
  * @param options Options for the promise
  * @returns Wrapped promise
@@ -13,8 +11,6 @@ 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
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback
@@ -22,8 +18,6 @@ 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
- *
- * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback

package/dist/promise/models.d.mts

@@ -2,6 +2,9 @@ import { GenericCallback } from "../models.mjs";
 import { Result } from "../result/models.mjs";
 
 //#region src/promise/models.d.ts
+/**
+ * A promise that can be canceled
+ */
 declare class CancelablePromise<Value = void> extends Promise<Value> {
   #private;
   constructor(executor: (resolve: (value: Value) => void, reject: (reason: unknown) => void) => void);
@@ -11,8 +14,17 @@ declare class CancelablePromise<Value = void> extends Promise<Value> {
    */
   cancel(reason?: unknown): void;
 }
+/**
+ * A promise that was fulfilled
+ */
 type FulfilledPromise<Value> = {
+  /**
+   * Status of the promise
+   */
   status: typeof PROMISE_TYPE_FULFILLED;
+  /**
+   * Value of the promise
+   */
   value: Awaited<Value>;
 };
 type PromiseData = {
@@ -23,6 +35,9 @@ type PromiseHandlers = {
   resolve: (value: unknown[]) => void;
   reject: (reason: unknown) => void;
 };
+/**
+ * Options for a promise-handling function
+ */
 type PromiseOptions = {
   /**
    * AbortSignal for aborting the promise; when aborted, the promise will reject with the reason of the signal
@@ -51,20 +66,41 @@ type PromiseParameters = {
  * 	- Returns an array of values
  */
 type PromiseStrategy = 'complete' | 'first';
+/**
+ * An error thrown when a promise times out
+ */
 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]> };
+/**
+ * Options for handling multiple promises
+ */
 type PromisesOptions = {
+  /**
+   * AbortSignal for aborting the promises; when aborted, the promises will reject with the reason of the signal
+   */
   signal?: AbortSignal;
+  /**
+   * Strategy for handling the promises; defaults to `complete`
+   */
   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 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 };
+/**
+ * A promise that was rejected
+ */
 type RejectedPromise = {
+  /**
+   * Status of the promise
+   */
   status: typeof PROMISE_TYPE_REJECTED;
+  /**
+   * Reason for the rejection
+   */
   reason: unknown;
 };
 declare const PROMISE_ABORT_EVENT = "abort";

package/dist/promise/models.mjs

@@ -1,4 +1,7 @@
 //#region src/promise/models.ts
+/**
+* A promise that can be canceled
+*/
 var CancelablePromise = class extends Promise {
 	#rejector;
 	constructor(executor) {
@@ -17,6 +20,9 @@ var CancelablePromise = class extends Promise {
 		this.#rejector(reason);
 	}
 };
+/**
+* An error thrown when a promise times out
+*/
 var PromiseTimeoutError = class extends Error {
 	constructor() {
 		super(PROMISE_MESSAGE_TIMEOUT);