@oscarpalmer/atoms 0.195.1 → 0.196.0

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
  */
@@ -7863,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
  *
@@ -7881,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, 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 extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): number;
+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
  *
@@ -8008,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
  *
@@ -8468,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
@@ -5753,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/package.json

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