@oscarpalmer/atoms 0.179.0 → 0.180.0

package/src/array/last.ts

@@ -55,26 +55,30 @@ last.default = lastOrDefault;
 
 /**
  * Get the last item matching the given value
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
  * @returns Last item that matches the value, or the default value if no match is found
  */
-function lastOrDefault<
+export function lastOrDefault<
 	Item,
 	Callback extends (item: Item, index: number, array: Item[]) => unknown,
 >(array: Item[], defaultValue: Item, callback: Callback, value: ReturnType<Callback>): Item;
 
 /**
  * Get the last item matching the given value by key
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param key Key to get an item's value for matching
  * @param value Value to match against
  * @returns Last item that matches the value, or the default value if no match is found
  */
-function lastOrDefault<Item extends PlainObject, ItemKey extends keyof Item>(
+export function lastOrDefault<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	defaultValue: Item,
 	key: ItemKey,
@@ -83,12 +87,14 @@ function lastOrDefault<Item extends PlainObject, ItemKey extends keyof Item>(
 
 /**
  * Get the last item matching the filter
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param filter Filter callback to match items
  * @returns Last item that matches the filter, or the default value if no match is found
  */
-function lastOrDefault<Item>(
+export function lastOrDefault<Item>(
 	array: Item[],
 	defaultValue: Item,
 	filter: (item: Item, index: number, array: Item[]) => boolean,
@@ -96,13 +102,19 @@ function lastOrDefault<Item>(
 
 /**
  * Get the last item from an array
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to get from
  * @param defaultValue Default value to return if the array is empty
  * @return Last item from the array, or the default value if the array is empty
  */
-function lastOrDefault<Item>(array: Item[], defaultValue: Item): Item;
+export function lastOrDefault<Item>(array: Item[], defaultValue: Item): Item;
 
-function lastOrDefault(array: unknown[], defaultValue: unknown, ...parameters: unknown[]): unknown {
+export function lastOrDefault(
+	array: unknown[],
+	defaultValue: unknown,
+	...parameters: unknown[]
+): unknown {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
 

package/src/array/move.ts

@@ -112,12 +112,14 @@ move.toIndex = moveToIndex;
  * Move an item from one index to another within an array
  *
  * If the from index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveIndices` and `move.indices`
  * @param array Array to move within
  * @param from Index to move from
  * @param to Index to move to
  * @returns Original array with item moved _(or unchanged if unable to move)_
  */
-function moveIndices<Item>(array: Item[], from: number, to: number): Item[] {
+export function moveIndices<Item>(array: Item[], from: number, to: number): Item[] {
 	if (!Array.isArray(array)) {
 		return [];
 	}
@@ -150,13 +152,15 @@ function moveIndices<Item>(array: Item[], from: number, to: number): Item[] {
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
  * @param key Key to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-function moveToIndex<Item extends PlainObject, ItemKey extends keyof Item>(
+export function moveToIndex<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	value: Item | Item[],
 	index: number,
@@ -167,13 +171,15 @@ function moveToIndex<Item extends PlainObject, ItemKey extends keyof Item>(
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
  * @param callback Callback to get an item's value for matching
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-function moveToIndex<Item>(
+export function moveToIndex<Item>(
 	array: Item[],
 	value: Item | Item[],
 	index: number,
@@ -184,14 +190,21 @@ function moveToIndex<Item>(
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
  * @returns Original array with items moved _(or unchanged if unable to move)_
  */
-function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
+export function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
 
-function moveToIndex(array: unknown[], value: unknown, index: number, key?: unknown): unknown[] {
+export function moveToIndex(
+	array: unknown[],
+	value: unknown,
+	index: number,
+	key?: unknown,
+): unknown[] {
 	if (!Array.isArray(array)) {
 		return [];
 	}

package/src/array/reverse.ts

@@ -1,3 +1,8 @@
+/**
+ * Reverse the order of items in an array
+ * @param array Array to reverse
+ * @returns Reversed array
+ */
 export function reverse<Item>(array: Item[]): Item[] {
 	if (!Array.isArray(array)) {
 		return [];

package/src/array/select.ts

@@ -152,7 +152,7 @@ export function select<Item extends PlainObject, MapKey extends keyof Item>(
 export function select<
 	Item,
 	MapCallback extends (item: Item, index: number, array: Item[]) => unknown,
->(array: Item[], filter: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
+>(array: Item[], item: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
 
 /**
  * Get a filtered and mapped array of items
@@ -163,7 +163,7 @@ export function select<
  */
 export function select<Item extends PlainObject, MapKey extends keyof Item>(
 	array: Item[],
-	filter: Item,
+	item: Item,
 	map: MapKey,
 ): Array<Item[MapKey]>;
 

package/src/array/sort.ts

@@ -172,17 +172,87 @@ function getComparisonValue(
 	return 0;
 }
 
+function getIndex(array: unknown[], item: unknown, sorters: InternalSorter[]): number {
+	if (!Array.isArray(array)) {
+		return -1;
+	}
+
+	const {length} = array;
+
+	if (length === 0) {
+		return 0;
+	}
+
+	const sortersLength = sorters.length;
+
+	if (getComparisonValue(item, array[0], sorters, sortersLength) < 0) {
+		return 0;
+	}
+
+	if (getComparisonValue(item, array[length - 1], sorters, sortersLength) >= 0) {
+		return length;
+	}
+
+	let low = 0;
+	let high = length - 1;
+
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+
+		if (getComparisonValue(item, array[mid], sorters, sortersLength) < 0) {
+			high = mid - 1;
+		} else {
+			low = mid + 1;
+		}
+	}
+
+	return low;
+}
+
+function getModifier(first: unknown, second: unknown): number {
+	const direction =
+		first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING;
+
+	return modifiers[direction];
+}
+
+function getObjectSorter(obj: PlainObject, modifier: number): InternalSorter | undefined {
+	let sorter: InternalSorter | undefined;
+
+	if (typeof obj.comparison === 'function') {
+		sorter = getComparisonSorter(obj.comparison, modifier);
+	} else if (typeof obj.key === 'string') {
+		sorter = getValueSorter(obj.key, modifier);
+
+		if (typeof obj.compare === 'function') {
+			sorter.compare = {
+				complex: obj.compare,
+			};
+		}
+	} else if (typeof obj.value === 'function') {
+		sorter = getValueSorter(obj.value, modifier);
+	}
+
+	if (sorter != null && typeof obj.direction === 'string') {
+		sorter.modifier = modifiers[obj.direction as SortDirection] ?? modifier;
+	}
+
+	return sorter;
+}
+
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on sorters _(and an optional default direction)_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorters Sorters to use to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-function getIndex<Item>(
+export function getSortedIndex<Item>(
 	array: Item[],
 	item: Item,
 	sorters: Array<ArraySorter<Item>>,
@@ -193,13 +263,15 @@ function getIndex<Item>(
  * Get the index for an item _(to be inserted into an array of items)_ based on a sorter _(and an optional default direction)_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorter Sorter to use to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-function getIndex<Item>(
+export function getSortedIndex<Item>(
 	array: Item[],
 	item: Item,
 	sorter: ArraySorter<Item>,
@@ -210,83 +282,22 @@ function getIndex<Item>(
  * Get the index for an item _(to be inserted into an array of items)_ based on an optional default direction_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns Index for item
  */
-function getIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
-
-function getIndex(array: unknown[], item: unknown, first?: unknown, second?: unknown): number {
-	return getSortedIndex(array, item, getSorters(first, getModifier(first, second)));
-}
-
-function getModifier(first: unknown, second: unknown): number {
-	const direction =
-		first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING;
+export function getSortedIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
 
-	return modifiers[direction];
-}
-
-function getObjectSorter(obj: PlainObject, modifier: number): InternalSorter | undefined {
-	let sorter: InternalSorter | undefined;
-
-	if (typeof obj.comparison === 'function') {
-		sorter = getComparisonSorter(obj.comparison, modifier);
-	} else if (typeof obj.key === 'string') {
-		sorter = getValueSorter(obj.key, modifier);
-
-		if (typeof obj.compare === 'function') {
-			sorter.compare = {
-				complex: obj.compare,
-			};
-		}
-	} else if (typeof obj.value === 'function') {
-		sorter = getValueSorter(obj.value, modifier);
-	}
-
-	if (sorter != null && typeof obj.direction === 'string') {
-		sorter.modifier = modifiers[obj.direction as SortDirection] ?? modifier;
-	}
-
-	return sorter;
-}
-
-function getSortedIndex(array: unknown[], item: unknown, sorters: InternalSorter[]): number {
-	if (!Array.isArray(array)) {
-		return -1;
-	}
-
-	const {length} = array;
-
-	if (length === 0) {
-		return 0;
-	}
-
-	const sortersLength = sorters.length;
-
-	if (getComparisonValue(item, array[0], sorters, sortersLength) < 0) {
-		return 0;
-	}
-
-	if (getComparisonValue(item, array[length - 1], sorters, sortersLength) >= 0) {
-		return length;
-	}
-
-	let low = 0;
-	let high = length - 1;
-
-	while (low <= high) {
-		const mid = Math.floor((low + high) / 2);
-
-		if (getComparisonValue(item, array[mid], sorters, sortersLength) < 0) {
-			high = mid - 1;
-		} else {
-			low = mid + 1;
-		}
-	}
-
-	return low;
+export function getSortedIndex(
+	array: unknown[],
+	item: unknown,
+	first?: unknown,
+	second?: unknown,
+): number {
+	return getIndex(array, item, getSorters(first, getModifier(first, second)));
 }
 
 function getSorter(value: unknown, modifier: number): InternalSorter | undefined {
@@ -348,36 +359,45 @@ function getValueSorter(value: string | Function, modifier: number): InternalSor
 
 /**
  * Initialize a sort handler with sorters _(and an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param sorters Sorters to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-function initializeSort<Item>(
+export function initializeSorter<Item>(
 	sorters: Array<ArraySorter<Item>>,
 	descending?: boolean,
 ): Sorter<Item>;
 
 /**
  * Initialize a sort handler with a sorter _(and an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param sorter Sorter to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+export function initializeSorter<Item>(
+	sorter: ArraySorter<Item>,
+	descending?: boolean,
+): Sorter<Item>;
 
 /**
  * Initialize a sort handler _(with an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param descending Sort in descending order? _(defaults to `false`)_
  * @returns Sort handler
  */
-function initializeSort<Item>(descending?: boolean): Sorter<Item>;
+export function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 
-function initializeSort(first?: unknown, second?: unknown): Sorter<unknown> {
+export function initializeSorter(first?: unknown, second?: unknown): Sorter<unknown> {
 	const sorters = getSorters(first, getModifier(first, second));
 
 	const sorter = (array: unknown[]) => sortArray(array, sorters);
 
-	sorter.index = (array: unknown[], item: unknown) => getSortedIndex(array, item, sorters);
+	sorter.index = (array: unknown[], item: unknown) => getIndex(array, item, sorters);
 	sorter.is = (array: unknown[]) => isSortedArray(array, sorters);
 
 	return sorter as unknown as Sorter<unknown>;
@@ -390,7 +410,7 @@ function initializeSort(first?: unknown, second?: unknown): Sorter<unknown> {
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns `true` if sorted, otherwise `false`
  */
-function isSorted<Item>(
+export function isSorted<Item>(
 	array: Item[],
 	sorters: Array<ArraySorter<Item>>,
 	descending?: boolean,
@@ -403,17 +423,23 @@ function isSorted<Item>(
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns `true` if sorted, otherwise `false`
  */
-function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): boolean;
+export function isSorted<Item>(
+	array: Item[],
+	sorter: ArraySorter<Item>,
+	descending?: boolean,
+): boolean;
 
 /**
  * Is the array sorted?
+ *
+ * Available as `isSorted` and `sort.is`
  * @param array Array to check
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns `true` if sorted, otherwise `false`
  */
-function isSorted<Item>(array: Item[], descending?: boolean): boolean;
+export function isSorted<Item>(array: Item[], descending?: boolean): boolean;
 
-function isSorted(array: unknown[], first?: unknown, second?: unknown): boolean {
+export function isSorted(array: unknown[], first?: unknown, second?: unknown): boolean {
 	return isSortedArray(array, getSorters(first, getModifier(first, second)));
 }
 
@@ -513,10 +539,8 @@ function sortArray(array: unknown[], sorters: InternalSorter[]): unknown[] {
 		: array;
 }
 
-sort.index = getIndex;
-
-sort.initialize = initializeSort;
-
+sort.index = getSortedIndex;
+sort.initialize = initializeSorter;
 sort.is = isSorted;
 
 // #endregion

package/src/array/swap.ts

@@ -163,6 +163,8 @@ function swapArrays(array: unknown[], from: unknown[], to: unknown[], key: unkno
  * Swap two indiced items in an array
  *
  * If either index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `swapIndices` and `swap.indices`
  * @param array Array of items to swap
  * @param first First index _(can be negative to count from the end)_
  * @param second Second index _(can be negative to count from the end)_

package/src/array/to-map.ts

@@ -144,12 +144,14 @@ toMap.arrays = toMapArrays;
 
 /**
  * Create a Map from an array of items using callbacks, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
  * @returns Map of keyed arrays of values
  */
-function toMapArrays<
+export function toMapArrays<
 	Item,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -161,12 +163,14 @@ function toMapArrays<
 
 /**
  * Create a Map from an array of items using a callback and value, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Key to use for value
  * @returns Map of keyed arrays of values
  */
-function toMapArrays<
+export function toMapArrays<
 	Item extends PlainObject,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ItemValue extends keyof Item,
@@ -178,12 +182,14 @@ function toMapArrays<
 
 /**
  * Create a Map from an array of items using a key and callback, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Callback to get an item's value
  * @returns Map of keyed arrays of values
  */
-function toMapArrays<
+export function toMapArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -195,12 +201,14 @@ function toMapArrays<
 
 /**
  * Create a Map from an array of items using a key and value, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
  * @returns Map of keyed arrays of values
  */
-function toMapArrays<
+export function toMapArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ItemValue extends keyof Item,
@@ -208,27 +216,31 @@ function toMapArrays<
 
 /**
  * Create a Map from an array of items using a callback, grouping items into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Map of keyed arrays of items
  */
-function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
-	array: Item[],
-	callback: Callback,
-): Map<ReturnType<Callback>, Item[]>;
+export function toMapArrays<
+	Item,
+	Callback extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
 
 /**
  * Create a Map from an array of items using a key, grouping items into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Map of keyed arrays of items
  */
-function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(
+export function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	key: ItemKey,
 ): Map<Item[ItemKey], Item[]>;
 
-function toMapArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
+export function toMapArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
 	return getMapValues(array, first, second, true);
 }
 

package/src/array/to-record.ts

@@ -120,12 +120,14 @@ toRecord.arrays = toRecordArrays;
 
 /**
  * Create a record from an array of items using callbacks, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
  * @returns Record of keyed arrays of values
  */
-function toRecordArrays<
+export function toRecordArrays<
 	Item,
 	KeyCallback extends (item: Item, index: number, array: Item[]) => Key,
 	ValueCallback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -137,12 +139,14 @@ function toRecordArrays<
 
 /**
  * Create a record from an array of items using a callback and value, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
  */
-function toRecordArrays<
+export function toRecordArrays<
 	Item extends PlainObject,
 	Callback extends (item: Item, index: number, array: Item[]) => Key,
 	ItemValue extends keyof Item,
@@ -154,12 +158,14 @@ function toRecordArrays<
 
 /**
  * Create a record from an array of items using a key and callback, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param callback Callback to get an item's value
  * @returns Record of keyed arrays of values
  */
-function toRecordArrays<
+export function toRecordArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	Callback extends (item: Item, index: number, array: Item[]) => unknown,
@@ -171,12 +177,14 @@ function toRecordArrays<
 
 /**
  * Create a record from an array of items using a key and value, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
  * @returns Record of keyed arrays of values
  */
-function toRecordArrays<
+export function toRecordArrays<
 	Item extends PlainObject,
 	ItemKey extends keyof Item,
 	ItemValue extends keyof Item,
@@ -188,27 +196,31 @@ function toRecordArrays<
 
 /**
  * Create a record from an array of items using a callback, grouping items into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed arrays of items
  */
-function toRecordArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(
-	array: Item[],
-	callback: Callback,
-): Record<ReturnType<Callback>, Item[]>;
+export function toRecordArrays<
+	Item,
+	Callback extends (item: Item, index: number, array: Item[]) => Key,
+>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
 
 /**
  * Create a record from an array of items using a key, grouping items into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Record of keyed arrays of items
  */
-function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(
+export function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(
 	array: Item[],
 	key: ItemKey,
 ): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 
-function toRecordArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
+export function toRecordArrays(array: unknown[], first?: unknown, second?: unknown): unknown {
 	return groupValues(array, first, second, true);
 }