@oscarpalmer/atoms 0.195.0 → 0.196.0

package/dist/function/limit.d.mts

@@ -36,6 +36,9 @@ declare function asyncThrottle<Callback extends GenericAsyncCallback | GenericCa
  * @returns Debounced callback handler with a `cancel` method
  */
 declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+declare namespace debounce {
+  var async: typeof asyncDebounce;
+}
 /**
  * Throttle a function, ensuring it is only called once every `time` milliseconds
  *
@@ -44,5 +47,8 @@ declare function debounce<Callback extends GenericCallback>(callback: Callback,
  * @returns Throttled callback handler with a `cancel` method
  */
 declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+declare namespace throttle {
+  var async: typeof asyncThrottle;
+}
 //#endregion
 export { asyncDebounce, asyncThrottle, debounce, throttle };

package/dist/function/limit.mjs

@@ -52,6 +52,8 @@ function debounce(callback, time) {
 function throttle(callback, time) {
 	return getTimer(TIMER_THROTTLE, callback, time);
 }
+debounce.async = asyncDebounce;
+throttle.async = asyncThrottle;
 Object.defineProperty(debounce, "async", { value: asyncDebounce });
 Object.defineProperty(throttle, "async", { value: asyncThrottle });
 //#endregion

package/dist/function/once.d.mts

@@ -16,5 +16,8 @@ declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Call
  * @returns _Once_ callback
  */
 declare function once<Callback extends GenericCallback>(callback: Callback): OnceCallback<Callback>;
+declare namespace once {
+  var async: typeof asyncOnce;
+}
 //#endregion
 export { asyncOnce, once };

package/dist/function/once.mjs

@@ -113,6 +113,7 @@ function once(callback) {
 }
 const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
+once.async = asyncOnce;
 Object.defineProperty(once, "async", { value: asyncOnce });
 //#endregion
 export { asyncOnce, once };

package/dist/function/retry.d.mts

@@ -1,4 +1,4 @@
-import { GenericCallback } from "../models.mjs";
+import { GenericAsyncCallback, GenericCallback } from "../models.mjs";
 //#region src/function/retry.d.ts
 /**
  * An error thrown when a retry fails
@@ -12,6 +12,26 @@ type RetryOptions = {
   times?: number;
   when?: (error: unknown) => boolean;
 };
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ *
+ * _Available as `asyncRetry` and `retry.async`_
+ *
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericAsyncCallback>(callback: Callback, options?: RetryOptions): Promise<Awaited<ReturnType<Callback>>>;
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ *
+ * _Available as `asyncRetry` and `retry.async`_
+ *
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericCallback>(callback: Callback, options?: RetryOptions): Promise<ReturnType<Callback>>;
 /**
  * Retry a callback a specified number of times
  *
@@ -20,5 +40,8 @@ type RetryOptions = {
  * @returns Callback result
  */
 declare function retry<Callback extends GenericCallback>(callback: Callback, options?: Omit<RetryOptions, 'delay'>): ReturnType<Callback>;
+declare namespace retry {
+  var async: typeof asyncRetry;
+}
 //#endregion
 export { RetryError, RetryOptions, retry };

package/dist/function/retry.mjs

@@ -84,6 +84,7 @@ function shouldRetry() {
 const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
+retry.async = asyncRetry;
 Object.defineProperty(retry, "async", { value: asyncRetry });
 //#endregion
 export { RetryError, retry };

package/dist/index.d.mts

@@ -31,13 +31,6 @@ type CancelableCallback<Callback extends GenericCallback> = Callback & {
  * A generic class constructor
  */
 type Constructor<Instance = unknown> = new (...args: any[]) => Instance;
-/**
- * Position of an event
- */
-type EventPosition = {
-  x: number;
-  y: number;
-};
 /**
  * A generic async callback function
  */
@@ -3829,6 +3822,9 @@ declare function asyncThrottle<Callback extends GenericAsyncCallback | GenericCa
  * @returns Debounced callback handler with a `cancel` method
  */
 declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+declare namespace debounce {
+  var async: typeof asyncDebounce;
+}
 /**
  * Throttle a function, ensuring it is only called once every `time` milliseconds
  *
@@ -3837,6 +3833,9 @@ declare function debounce<Callback extends GenericCallback>(callback: Callback,
  * @returns Throttled callback handler with a `cancel` method
  */
 declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+declare namespace throttle {
+  var async: typeof asyncThrottle;
+}
 //#endregion
 //#region src/function/once.d.ts
 /**
@@ -3855,6 +3854,9 @@ declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Call
  * @returns _Once_ callback
  */
 declare function once<Callback extends GenericCallback>(callback: Callback): OnceCallback<Callback>;
+declare namespace once {
+  var async: typeof asyncOnce;
+}
 //#endregion
 //#region src/function/retry.d.ts
 /**
@@ -3869,6 +3871,26 @@ type RetryOptions = {
   times?: number;
   when?: (error: unknown) => boolean;
 };
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ *
+ * _Available as `asyncRetry` and `retry.async`_
+ *
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericAsyncCallback>(callback: Callback, options?: RetryOptions): Promise<Awaited<ReturnType<Callback>>>;
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ *
+ * _Available as `asyncRetry` and `retry.async`_
+ *
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericCallback>(callback: Callback, options?: RetryOptions): Promise<ReturnType<Callback>>;
 /**
  * Retry a callback a specified number of times
  *
@@ -3877,6 +3899,9 @@ type RetryOptions = {
  * @returns Callback result
  */
 declare function retry<Callback extends GenericCallback>(callback: Callback, options?: Omit<RetryOptions, 'delay'>): ReturnType<Callback>;
+declare namespace retry {
+  var async: typeof asyncRetry;
+}
 //#endregion
 //#region src/internal/result/models.d.ts
 /**
@@ -5396,6 +5421,9 @@ declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedRes
  * @returns Callback result
  */
 declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
+declare namespace attempt {
+  var async: typeof asyncAttempt;
+}
 //#endregion
 //#region src/result/match.d.ts
 /**
@@ -5436,6 +5464,9 @@ declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value
  * @returns Matched value
  */
 declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Returned;
+declare namespace matchResult {
+  var async: typeof asyncMatchResult;
+}
 //#endregion
 //#region src/result/work/flow.d.ts
 /**
@@ -5614,6 +5645,9 @@ declare function attemptFlow<First extends GenericCallback>(first: First, ...fns
  * @returns _Flow_ function
  */
 declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
+declare namespace attemptFlow {
+  var async: typeof attemptAsyncFlow;
+}
 //#endregion
 //#region src/result/work/pipe.d.ts
 type WrapValue<Value> = Result<UnwrapValue<Value>>;
@@ -5793,6 +5827,9 @@ declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth
  * @returns _Piped_ result
  */
 declare function attemptPipe<Initial>(initial: GenericCallback | Initial | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
+declare namespace attemptPipe {
+  var async: typeof attemptAsyncPipe;
+}
 //#endregion
 //#region src/string/fuzzy.d.ts
 /**
@@ -7819,16 +7856,17 @@ declare const Logger: Logger;
  * max(
  *   [{id: 1, value: 10}, {id: 2, value: 20}],
  *   item => item.value,
- * ); // => 20
+ * ); // => [{id: 2, value: 20}]
  *
- * max([], item => item.value); // => Number.NaN
+ * max([], item => item.value); // => []
  * ```
  *
  * @param items List of items
  * @param callback Callback to get an item's value
- * @returns Maximum value, or `Number.NaN` if no maximum can be found
+ * @param first Return only the first item with the maximum value
+ * @returns Item with the maximum value, or `undefined` if no maximum can be found
  */
-declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item | undefined;
 /**
  * Get the maximum value from a list of items
  *
@@ -7837,16 +7875,53 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
  * max(
  *   [{id: 1, value: 10}, {id: 2, value: 20}],
  *   'value',
- * ); // => 20
+ * ); // => [{id: 2, value: 20}]
  *
- * max([], 'value'); // => Number.NaN
+ * max([], 'value'); // => []
  * ```
  *
  * @param items List of items
  * @param key Key to use for value
- * @returns Maximum value, or `Number.NaN` if no maximum can be found
+ * @param first Return only the first item with the maximum value
+ * @returns Item with the maximum value, or `undefined` if no maximum can be found
  */
-declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): number;
+declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey, first: true): Item | undefined;
+/**
+ * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   item => item.value,
+ * ); // => [{id: 2, value: 20}]
+ *
+ * max([], item => item.value); // => []
+ * ```
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @returns Items with the maximum value
+ */
+declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
+/**
+ * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   'value',
+ * ); // => [{id: 2, value: 20}]
+ *
+ * max([], 'value'); // => []
+ * ```
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @returns Items with the maximum value
+ */
+declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): Item[];
 /**
  * Get the maximum value from a list of numbers
  *
@@ -7964,17 +8039,35 @@ declare function median(array: number[]): number;
  *
  * @param items List of items
  * @param callback Callback to get an item's value
- * @returns Minimum value, or `Number.NaN` if no minimum can be found
+ * @param first Return only the first item with the minimum value
+ * @returns Items with the minimum value
  */
-declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item[];
 /**
  * Get the minimum value from a list of items
  *
  * @param items List of items
  * @param key Key to use for value
- * @returns Minimum value, or `Number.NaN` if no minimum can be found
+ * @param first Return only the first item with the minimum value
+ * @returns Items with the minimum value
+ */
+declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item[];
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @returns Items with the minimum value
+ */
+declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @returns Items with the minimum value
  */
-declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
+declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
 /**
  * Get the minimum value from a list of numbers
  *
@@ -8424,4 +8517,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparison, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArraySorter, ArraySorters, ArrayValueSorter, AssertProperty, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, Beacon, BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, KeyedQueue, KeyedValue, Logger, Memoized, MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, Observable, Ok, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, Queue, QueueError, QueueOptions, Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, type Shaken, Simplify, SizedMap, SizedSet, type Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type TimedLogger, ToString, Transformer, TypedArray, UnionToIntersection, type Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparison, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArraySorter, ArraySorters, ArrayValueSorter, AssertProperty, Asserter, AssignOptions, Assigner, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, Beacon, BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, ExtendedErr, ExtendedResult, Flow, FlowPromise, Frozen, FulfilledPromise, Fuzzy, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, KeyedQueue, KeyedValue, Logger, Memoized, MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NormalizeOptions, Normalizer, NumericalKeys, NumericalValues, Observable, Ok, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, Queue, QueueError, QueueOptions, Queued, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, type Shaken, Simplify, SizedMap, SizedSet, type Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type TimedLogger, ToString, Transformer, TypedArray, UnionToIntersection, type Unsmushed, Unsubscriber, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/index.mjs

@@ -881,49 +881,70 @@ function moveToIndex(array, value, index, key) {
 }
 //#endregion
 //#region src/internal/math/aggregate.ts
-function aggregate(type, array, key) {
+function aggregate(type, array, key, first) {
 	const length = Array.isArray(array) ? array.length : 0;
-	if (length === 0) return {
+	const aggregation = {
+		array: false,
 		count: 0,
+		first: first === true,
 		value: NaN
 	};
+	if (length === 0) return aggregation;
 	const aggregator = aggregators[type];
 	const callback = getAggregateCallback(key);
-	let counted = 0;
-	let aggregated = NaN;
+	aggregation.array = callback != null && (type === "max" || type === "min");
 	let notNumber = true;
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
 		const value = callback == null ? item : callback(item, index, array);
 		if (isNonNumber(value)) continue;
-		aggregated = aggregator(aggregated, value, notNumber);
-		counted += 1;
+		aggregation.value = aggregator(aggregation, value, notNumber, item);
+		aggregation.count += 1;
 		notNumber = false;
 	}
-	return {
-		count: counted,
-		value: aggregated
-	};
+	return aggregation;
+}
+function calculateSum(aggregation, value, notNumber) {
+	return notNumber ? value : aggregation.value + value;
+}
+function getAbsoluteValue(condition, aggregation, value, notNumber, item) {
+	if (notNumber || condition(aggregation, value)) {
+		if (aggregation.array) {
+			aggregation.items ??= {};
+			aggregation.items[value] ??= [];
+			aggregation.items[value].push(item);
+		}
+		return value;
+	}
+	return aggregation.value;
 }
 function getAggregateCallback(key) {
 	if (key == null) return;
 	return typeof key === "function" ? key : (item) => item[key];
 }
-function max(array, key) {
-	return getAggregated("max", array, key);
+function getAggregated(type, array, key, first) {
+	const aggregation = aggregate(type, array, key, first);
+	if (aggregation.count === 0) return aggregation.array ? aggregation.first ? void 0 : [] : NaN;
+	if (aggregation.array) {
+		const array = aggregation.items[aggregation.value];
+		return aggregation.first ? array[0] : array;
+	}
+	return aggregation.value;
+}
+function isMaxValue(aggregation, value) {
+	return aggregation.array ? value >= aggregation.value : value > aggregation.value;
 }
-function calculateSum(current, value, notNumber) {
-	return notNumber ? value : current + value;
+function isMinValue(aggregation, value) {
+	return aggregation.array ? value <= aggregation.value : value < aggregation.value;
 }
-function getAggregated(type, array, key) {
-	const aggregated = aggregate(type, array, key);
-	return aggregated.count > 0 ? aggregated.value : NaN;
+function max(array, key, first) {
+	return getAggregated("max", array, key, first);
 }
 const AGGREGATION_AVERAGE = "average";
 const aggregators = {
 	average: calculateSum,
-	max: (current, value, notNumber) => notNumber || value > current ? value : current,
-	min: (current, value, notNumber) => notNumber || value < current ? value : current,
+	max: getAbsoluteValue.bind(void 0, isMaxValue),
+	min: getAbsoluteValue.bind(void 0, isMinValue),
 	sum: calculateSum
 };
 //#endregion
@@ -1528,6 +1549,8 @@ function debounce(callback, time) {
 function throttle(callback, time) {
 	return getTimer(TIMER_THROTTLE, callback, time);
 }
+debounce.async = asyncDebounce;
+throttle.async = asyncThrottle;
 Object.defineProperty(debounce, "async", { value: asyncDebounce });
 Object.defineProperty(throttle, "async", { value: asyncThrottle });
 //#endregion
@@ -1841,6 +1864,7 @@ function once(callback) {
 }
 const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
+once.async = asyncOnce;
 Object.defineProperty(once, "async", { value: asyncOnce });
 //#endregion
 //#region src/function/retry.ts
@@ -1927,6 +1951,7 @@ function shouldRetry() {
 const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
+retry.async = asyncRetry;
 Object.defineProperty(retry, "async", { value: asyncRetry });
 //#endregion
 //#region src/internal/function/work.ts
@@ -2822,6 +2847,7 @@ function attempt(callback, err) {
 		return getError(err ?? thrown, err == null ? void 0 : thrown);
 	}
 }
+attempt.async = asyncAttempt;
 Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#endregion
 //#region src/result/match.ts
@@ -2847,6 +2873,7 @@ function matchResult(result, first, error) {
 	return errorHandler(value.error, value.original);
 }
 const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
+matchResult.async = asyncMatchResult;
 Object.defineProperty(matchResult, "async", { value: asyncMatchResult });
 //#endregion
 //#region src/result/work/flow.ts
@@ -2870,6 +2897,7 @@ function attemptFlow(...fns) {
 		}));
 	});
 }
+attemptFlow.async = attemptAsyncFlow;
 Object.defineProperty(attemptFlow, "async", { value: attemptAsyncFlow });
 //#endregion
 //#region src/result/work/pipe.ts
@@ -2889,6 +2917,7 @@ function attemptPipe(initial, first, ...seconds) {
 		return pipe(value, ...[first, ...seconds]);
 	});
 }
+attemptPipe.async = attemptAsyncPipe;
 Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 //#region src/string/match.ts
@@ -5745,8 +5774,8 @@ function median(array, key) {
 	}
 	return numbers[Math.floor(length / 2)];
 }
-function min(array, key) {
-	return getAggregated("min", array, key);
+function min(array, key, first) {
+	return getAggregated("min", array, key, first);
 }
 function sum(array, key) {
 	return getAggregated("sum", array, key);

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

@@ -1,13 +1,17 @@
 import { NumericalValues, PlainObject } from "../../models.mjs";
 //#region src/internal/math/aggregate.d.ts
 type Aggregation = {
+  array: boolean;
   count: number;
+  first: boolean;
+  items?: Record<number, unknown[]>;
   value: number;
 };
 type AggregationType = 'average' | 'max' | 'min' | 'sum';
 type NonAverageAggregationType = 'max' | 'min' | 'sum';
-declare function aggregate(type: AggregationType, array: unknown[], key: unknown): Aggregation;
+declare function aggregate(type: AggregationType, array: unknown[], key: unknown, first?: unknown): Aggregation;
 declare function getAggregateCallback(key: unknown): Function | undefined;
+declare function getAggregated(type: NonAverageAggregationType, array: unknown[], key?: unknown, first?: unknown): unknown;
 /**
  * Get the maximum value from a list of items
  *
@@ -16,16 +20,17 @@ declare function getAggregateCallback(key: unknown): Function | undefined;
  * max(
  *   [{id: 1, value: 10}, {id: 2, value: 20}],
  *   item => item.value,
- * ); // => 20
+ * ); // => [{id: 2, value: 20}]
  *
- * max([], item => item.value); // => Number.NaN
+ * max([], item => item.value); // => []
  * ```
  *
  * @param items List of items
  * @param callback Callback to get an item's value
- * @returns Maximum value, or `Number.NaN` if no maximum can be found
+ * @param first Return only the first item with the maximum value
+ * @returns Item with the maximum value, or `undefined` if no maximum can be found
  */
-declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item | undefined;
 /**
  * Get the maximum value from a list of items
  *
@@ -34,16 +39,53 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
  * max(
  *   [{id: 1, value: 10}, {id: 2, value: 20}],
  *   'value',
- * ); // => 20
+ * ); // => [{id: 2, value: 20}]
  *
- * max([], 'value'); // => Number.NaN
+ * max([], 'value'); // => []
  * ```
  *
  * @param items List of items
  * @param key Key to use for value
- * @returns Maximum value, or `Number.NaN` if no maximum can be found
+ * @param first Return only the first item with the maximum value
+ * @returns Item with the maximum value, or `undefined` if no maximum can be found
+ */
+declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey, first: true): Item | undefined;
+/**
+ * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   item => item.value,
+ * ); // => [{id: 2, value: 20}]
+ *
+ * max([], item => item.value); // => []
+ * ```
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @returns Items with the maximum value
+ */
+declare function max<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
+/**
+ * Get the maximum value from a list of items
+ *
+ * @example
+ * ```typescript
+ * max(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}],
+ *   'value',
+ * ); // => [{id: 2, value: 20}]
+ *
+ * max([], 'value'); // => []
+ * ```
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @returns Items with the maximum value
  */
-declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): number;
+declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): Item[];
 /**
  * Get the maximum value from a list of numbers
  *
@@ -57,7 +99,6 @@ declare function max<Item extends PlainObject, ItemKey extends keyof NumericalVa
  * @returns Maximum value, or `Number.NaN` if no maximum can be found
  */
 declare function max(values: number[]): number;
-declare function getAggregated(type: NonAverageAggregationType, array: unknown[], key?: unknown): number;
 declare const AGGREGATION_AVERAGE: AggregationType;
 declare const AGGREGATION_MAX = "max";
 declare const AGGREGATION_MIN = "min";

package/dist/internal/math/aggregate.mjs

@@ -1,42 +1,63 @@
 import { isNonNumber } from "../is.mjs";
 //#region src/internal/math/aggregate.ts
-function aggregate(type, array, key) {
+function aggregate(type, array, key, first) {
 	const length = Array.isArray(array) ? array.length : 0;
-	if (length === 0) return {
+	const aggregation = {
+		array: false,
 		count: 0,
+		first: first === true,
 		value: NaN
 	};
+	if (length === 0) return aggregation;
 	const aggregator = aggregators[type];
 	const callback = getAggregateCallback(key);
-	let counted = 0;
-	let aggregated = NaN;
+	aggregation.array = callback != null && (type === "max" || type === "min");
 	let notNumber = true;
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
 		const value = callback == null ? item : callback(item, index, array);
 		if (isNonNumber(value)) continue;
-		aggregated = aggregator(aggregated, value, notNumber);
-		counted += 1;
+		aggregation.value = aggregator(aggregation, value, notNumber, item);
+		aggregation.count += 1;
 		notNumber = false;
 	}
-	return {
-		count: counted,
-		value: aggregated
-	};
+	return aggregation;
+}
+function calculateSum(aggregation, value, notNumber) {
+	return notNumber ? value : aggregation.value + value;
+}
+function getAbsoluteValue(condition, aggregation, value, notNumber, item) {
+	if (notNumber || condition(aggregation, value)) {
+		if (aggregation.array) {
+			aggregation.items ??= {};
+			aggregation.items[value] ??= [];
+			aggregation.items[value].push(item);
+		}
+		return value;
+	}
+	return aggregation.value;
 }
 function getAggregateCallback(key) {
 	if (key == null) return;
 	return typeof key === "function" ? key : (item) => item[key];
 }
-function max(array, key) {
-	return getAggregated("max", array, key);
+function getAggregated(type, array, key, first) {
+	const aggregation = aggregate(type, array, key, first);
+	if (aggregation.count === 0) return aggregation.array ? aggregation.first ? void 0 : [] : NaN;
+	if (aggregation.array) {
+		const array = aggregation.items[aggregation.value];
+		return aggregation.first ? array[0] : array;
+	}
+	return aggregation.value;
+}
+function isMaxValue(aggregation, value) {
+	return aggregation.array ? value >= aggregation.value : value > aggregation.value;
 }
-function calculateSum(current, value, notNumber) {
-	return notNumber ? value : current + value;
+function isMinValue(aggregation, value) {
+	return aggregation.array ? value <= aggregation.value : value < aggregation.value;
 }
-function getAggregated(type, array, key) {
-	const aggregated = aggregate(type, array, key);
-	return aggregated.count > 0 ? aggregated.value : NaN;
+function max(array, key, first) {
+	return getAggregated("max", array, key, first);
 }
 const AGGREGATION_AVERAGE = "average";
 const AGGREGATION_MAX = "max";
@@ -44,8 +65,8 @@ const AGGREGATION_MIN = "min";
 const AGGREGATION_SUM = "sum";
 const aggregators = {
 	average: calculateSum,
-	max: (current, value, notNumber) => notNumber || value > current ? value : current,
-	min: (current, value, notNumber) => notNumber || value < current ? value : current,
+	max: getAbsoluteValue.bind(void 0, isMaxValue),
+	min: getAbsoluteValue.bind(void 0, isMinValue),
 	sum: calculateSum
 };
 //#endregion

package/dist/math.d.mts

@@ -94,17 +94,35 @@ declare function median(array: number[]): number;
  *
  * @param items List of items
  * @param callback Callback to get an item's value
- * @returns Minimum value, or `Number.NaN` if no minimum can be found
+ * @param first Return only the first item with the minimum value
+ * @returns Items with the minimum value
  */
-declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): number;
+declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number, first: true): Item[];
 /**
  * Get the minimum value from a list of items
  *
  * @param items List of items
  * @param key Key to use for value
- * @returns Minimum value, or `Number.NaN` if no minimum can be found
+ * @param first Return only the first item with the minimum value
+ * @returns Items with the minimum value
+ */
+declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item[];
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param callback Callback to get an item's value
+ * @returns Items with the minimum value
+ */
+declare function min<Item>(items: Item[], callback: (item: Item, index: number, array: Item[]) => number): Item[];
+/**
+ * Get the minimum value from a list of items
+ *
+ * @param items List of items
+ * @param key Key to use for value
+ * @returns Items with the minimum value
  */
-declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): number;
+declare function min<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
 /**
  * Get the minimum value from a list of numbers
  *

package/dist/math.mjs

@@ -54,8 +54,8 @@ function median(array, key) {
 	}
 	return numbers[Math.floor(length / 2)];
 }
-function min(array, key) {
-	return getAggregated("min", array, key);
+function min(array, key, first) {
+	return getAggregated("min", array, key, first);
 }
 function sum(array, key) {
 	return getAggregated("sum", array, key);

package/dist/models.d.mts

@@ -31,13 +31,6 @@ type CancelableCallback<Callback extends GenericCallback> = Callback & {
  * A generic class constructor
  */
 type Constructor<Instance = unknown> = new (...args: any[]) => Instance;
-/**
- * Position of an event
- */
-type EventPosition = {
-  x: number;
-  y: number;
-};
 /**
  * A generic async callback function
  */
@@ -161,4 +154,4 @@ type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Un
  */
 type Unsubscriber = () => void;
 //#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, UnionToIntersection, Unsubscriber };
+export { ArrayOrPlainObject, AsyncCancelableCallback, BuiltIns, CancelableCallback, Constructor, GenericAsyncCallback, GenericCallback, Key, KeyedValue, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, OnceAsyncCallback, OnceCallback, PlainObject, Primitive, RequiredKeys, Simplify, ToString, TypedArray, UnionToIntersection, Unsubscriber };

package/dist/result/index.d.mts

@@ -53,5 +53,8 @@ declare function attempt<Value, E>(callback: () => Value, error: E): ExtendedRes
  * @returns Callback result
  */
 declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
+declare namespace attempt {
+  var async: typeof asyncAttempt;
+}
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/index.mjs

@@ -17,6 +17,7 @@ function attempt(callback, err) {
 		return getError(err ?? thrown, err == null ? void 0 : thrown);
 	}
 }
+attempt.async = asyncAttempt;
 Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#endregion
 export { asyncAttempt, attempt };

package/dist/result/match.d.mts

@@ -38,5 +38,8 @@ declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value
  * @returns Matched value
  */
 declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Returned;
+declare namespace matchResult {
+  var async: typeof asyncMatchResult;
+}
 //#endregion
 export { asyncMatchResult, matchResult };

package/dist/result/match.mjs

@@ -22,6 +22,7 @@ function matchResult(result, first, error) {
 	return errorHandler(value.error, value.original);
 }
 const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
+matchResult.async = asyncMatchResult;
 Object.defineProperty(matchResult, "async", { value: asyncMatchResult });
 //#endregion
 export { asyncMatchResult, matchResult };

package/dist/result/work/flow.d.mts

@@ -177,5 +177,8 @@ declare function attemptFlow<First extends GenericCallback>(first: First, ...fns
  * @returns _Flow_ function
  */
 declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
+declare namespace attemptFlow {
+  var async: typeof attemptAsyncFlow;
+}
 //#endregion
 export { AttemptFlow, AttemptFlowPromise, attemptAsyncFlow, attemptFlow };

package/dist/result/work/flow.mjs

@@ -22,6 +22,7 @@ function attemptFlow(...fns) {
 		}));
 	});
 }
+attemptFlow.async = attemptAsyncFlow;
 Object.defineProperty(attemptFlow, "async", { value: attemptAsyncFlow });
 //#endregion
 export { attemptAsyncFlow, attemptFlow };

package/dist/result/work/pipe.d.mts

@@ -178,5 +178,8 @@ declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth
  * @returns _Piped_ result
  */
 declare function attemptPipe<Initial>(initial: GenericCallback | Initial | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
+declare namespace attemptPipe {
+  var async: typeof attemptAsyncPipe;
+}
 //#endregion
 export { attemptAsyncPipe, attemptPipe };

package/dist/result/work/pipe.mjs

@@ -18,6 +18,7 @@ function attemptPipe(initial, first, ...seconds) {
 		return pipe(value, ...[first, ...seconds]);
 	});
 }
+attemptPipe.async = attemptAsyncPipe;
 Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 export { attemptAsyncPipe, attemptPipe };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.195.0",
+	"version": "0.196.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",