@oscarpalmer/atoms 0.76.0 → 0.77.0

package/src/js/array/sort.ts

@@ -1,8 +1,4 @@
-import type {
-	SortKey,
-	SortKeyCallback,
-	SortKeyWithCallback,
-} from '~/array/models';
+import type {SortKey, SortKeyWithCallback} from '~/array/models';
 import {isKey} from '~/is';
 import type {Key, PlainObject} from '~/models';
 import {compare} from '~/value/compare';
@@ -18,7 +14,7 @@ export function sort<Item>(array: Item[], descending?: boolean): Item[];
  */
 export function sort<Item>(
 	array: Item[],
-	key: Key | SortKey<Item> | SortKeyCallback<Item>,
+	key: Key | SortKey<Item> | ((item: Item) => Key),
 	descending?: boolean,
 ): Item[];
 
@@ -28,7 +24,7 @@ export function sort<Item>(
  */
 export function sort<Item>(
 	array: Item[],
-	keys: Array<Key | SortKey<Item> | SortKeyCallback<Item>>,
+	keys: Array<Key | SortKey<Item> | ((item: Item) => Key)>,
 	descending?: boolean,
 ): Item[];
 

package/src/js/array/to-map.ts

@@ -1,6 +1,5 @@
-import type {KeyCallback, ValueCallback} from '~/array/models';
 import {getCallbacks} from '~/internal/array/callbacks';
-import type {Key, KeyedValue} from '~/models';
+import type {KeyedValue, Key as SimpleKey} from '~/models';
 
 /**
  * Create a map from an array of items _(using their indices as keys)_
@@ -27,19 +26,18 @@ export function toMap<Item, Key extends keyof Item>(
 /**
  * Create a map from an array of items using a specific key
  */
-export function toMap<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-): Map<ReturnType<Key>, Item>;
+export function toMap<
+	Item,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+>(array: Item[], key: Key): Map<ReturnType<Key>, Item>;
 
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
-export function toMap<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Map<ReturnType<Key>, Item[]>;
+export function toMap<
+	Item,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+>(array: Item[], key: Key, arrays: true): Map<ReturnType<Key>, Item[]>;
 
 /**
  * Create a map from an array of items using a specific key and value
@@ -66,7 +64,7 @@ export function toMap<Item, Key extends keyof Item, Value extends keyof Item>(
 export function toMap<
 	Item,
 	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,
@@ -79,7 +77,7 @@ export function toMap<
 export function toMap<
 	Item,
 	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,
@@ -92,7 +90,7 @@ export function toMap<
  */
 export function toMap<
 	Item,
-	Key extends KeyCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
 	Value extends keyof Item,
 >(
 	array: Item[],
@@ -105,7 +103,7 @@ export function toMap<
  */
 export function toMap<
 	Item,
-	Key extends KeyCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
 	Value extends keyof Item,
 >(
 	array: Item[],
@@ -119,8 +117,8 @@ export function toMap<
  */
 export function toMap<
 	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,
@@ -132,8 +130,8 @@ export function toMap<
  */
 export function toMap<
 	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,
@@ -146,10 +144,10 @@ export function toMap(
 	first?: unknown,
 	second?: unknown,
 	third?: unknown,
-): Map<Key, unknown> {
+): Map<SimpleKey, unknown> {
 	const asArrays = first === true || second === true || third === true;
 	const callbacks = getCallbacks(undefined, first, second);
-	const map = new Map<Key, unknown>();
+	const map = new Map<SimpleKey, unknown>();
 	const {length} = array;
 
 	for (let index = 0; index < length; index += 1) {

package/src/js/array/to-record.ts

@@ -1,6 +1,5 @@
 import {groupValues} from '~/array/group-by';
-import type {KeyCallback, ValueCallback} from '~/array/models';
-import type {KeyedValue, PlainObject} from '~/models';
+import type {KeyedValue, PlainObject, Key as SimpleKey} from '~/models';
 
 /**
  * Create a record from an array of items _(using their indices as keys)_
@@ -27,19 +26,18 @@ export function toRecord<Item, Key extends keyof Item>(
 /**
  * Create a record from an array of items using a specific key
  */
-export function toRecord<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-): Record<ReturnType<Key>, Item>;
+export function toRecord<
+	Item,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
 
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export function toRecord<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-	arrays: true,
-): Record<ReturnType<Key>, Item[]>;
+export function toRecord<
+	Item,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
 
 /**
  * Create a record from an array of items using a specific key and value
@@ -74,7 +72,7 @@ export function toRecord<
 export function toRecord<
 	Item,
 	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,
@@ -87,7 +85,7 @@ export function toRecord<
 export function toRecord<
 	Item,
 	Key extends keyof Item,
-	Value extends ValueCallback<Item>,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,
@@ -100,7 +98,7 @@ export function toRecord<
  */
 export function toRecord<
 	Item,
-	Key extends KeyCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
 	Value extends keyof Item,
 >(
 	array: Item[],
@@ -113,7 +111,7 @@ export function toRecord<
  */
 export function toRecord<
 	Item,
-	Key extends KeyCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
 	Value extends keyof Item,
 >(
 	array: Item[],
@@ -127,8 +125,8 @@ export function toRecord<
  */
 export function toRecord<
 	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,
@@ -140,8 +138,8 @@ export function toRecord<
  */
 export function toRecord<
 	Item,
-	Key extends KeyCallback<Item>,
-	Value extends ValueCallback<Item>,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+	Value extends (item: Item, index: number, array: Item[]) => unknown,
 >(
 	array: Item[],
 	key: Key,

package/src/js/array/unique.ts

@@ -1,5 +1,5 @@
-import type {KeyCallback} from '~/array/models';
 import {findValues} from '~/internal/array/find';
+import type {Key as SimpleKey} from '~/models';
 
 /**
  * Get an array of unique items
@@ -8,7 +8,7 @@ export function unique<Item>(array: Item[]): Item[];
 
 /**
  * - Get an array of unique items
- * - Use `key` to find a comparison value to match with `value`
+ * - Use `key` to find a comparison value for an item
  */
 export function unique<Item, Key extends keyof Item>(
 	array: Item[],
@@ -17,13 +17,13 @@ export function unique<Item, Key extends keyof Item>(
 
 /**
  * - Get an array of unique items
- * - Use `key` to find a comparison value to match with `value`
+ * - Use `key` to find a comparison value for an item
  */
-export function unique<Item, Key extends KeyCallback<Item>>(
-	array: Item[],
-	key: Key,
-): Item[];
+export function unique<
+	Item,
+	Key extends (item: Item, index: number, array: Item[]) => SimpleKey,
+>(array: Item[], key: Key): Item[];
 
 export function unique(array: unknown[], key?: unknown): unknown[] {
-	return findValues('unique', array, undefined, key, undefined);
+	return findValues('unique', array, [key, undefined]);
 }

package/src/js/internal/array/callbacks.ts

@@ -1,4 +1,4 @@
-import type {BooleanCallback, Callbacks, KeyCallback} from '~/array/models';
+import type {Callbacks} from '~/array/models';
 import type {GenericCallback, PlainObject} from '~/models';
 
 function getCallback(value: unknown): GenericCallback | undefined {
@@ -23,11 +23,11 @@ export function getCallbacks(
 	value?: unknown,
 ): Callbacks | undefined {
 	if (typeof bool === 'function') {
-		return {bool: bool as BooleanCallback<unknown>};
+		return {bool: bool as GenericCallback};
 	}
 
 	return {
-		key: getCallback(key) as KeyCallback<unknown>,
-		value: getCallback(value) as GenericCallback,
+		key: getCallback(key),
+		value: getCallback(value),
 	};
 }

package/src/js/internal/array/find.ts

@@ -1,13 +1,19 @@
 import type {FindType} from '~/array/models';
 import {getCallbacks} from '~/internal/array/callbacks';
 
+type Parameters = {
+	bool?: unknown;
+	key?: unknown;
+	value?: unknown;
+};
+
 export function findValue(
 	type: FindType,
 	array: unknown[],
-	bool: unknown,
-	key: unknown,
-	value: unknown,
+	parameters: unknown[],
 ): unknown {
+	const {bool, key, value} = getParameters(parameters);
+
 	const callbacks = getCallbacks(bool, key);
 
 	if (callbacks?.bool == null && callbacks?.key == null) {
@@ -38,11 +44,12 @@ export function findValue(
 export function findValues(
 	type: 'all' | 'unique',
 	array: unknown[],
-	bool: unknown,
-	key: unknown,
-	value: unknown,
+	parameters: unknown[],
 ): unknown[] {
+	const {bool, key, value} = getParameters(parameters);
+
 	const callbacks = getCallbacks(bool, key);
+
 	const {length} = array;
 
 	if (type === 'unique' && callbacks?.key == null && length >= 100) {
@@ -78,3 +85,19 @@ export function findValues(
 
 	return result;
 }
+
+function getParameters(original: unknown[]): Parameters {
+	const {length} = original;
+
+	return {
+		bool:
+			length === 1 && typeof original[0] === 'function'
+				? original[0]
+				: undefined,
+		key: length === 2 ? original[0] : undefined,
+		value:
+			length === 1 && typeof original[0] !== 'function'
+				? original[0]
+				: original[1],
+	};
+}

package/types/array/count.d.cts

@@ -1,9 +1,6 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type Key = number | string;
-export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
-export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
-export type KeyCallback<Item> = ArrayCallback<Item, Key>;
 /**
  * Get the number of items _(count)_ that match the given value
  */
@@ -11,7 +8,7 @@ export declare function count<Item>(array: Item[], value: Item): number;
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Item>(array: Item[], matches: BooleanCallback<Item>): number;
+export declare function count<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the number of items _(count)_ that match the given value
  */
@@ -19,6 +16,6 @@ export declare function count<Item, Key extends keyof Item>(array: Item[], key:
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): number;
+export declare function count<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): number;
 
 export {};

package/types/array/count.d.ts

@@ -1,4 +1,4 @@
-import type { BooleanCallback, KeyCallback } from '~/array/models';
+import type { Key as SimpleKey } from '~/models';
 /**
  * Get the number of items _(count)_ that match the given value
  */
@@ -6,7 +6,7 @@ export declare function count<Item>(array: Item[], value: Item): number;
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Item>(array: Item[], matches: BooleanCallback<Item>): number;
+export declare function count<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): number;
 /**
  * Get the number of items _(count)_ that match the given value
  */
@@ -14,4 +14,4 @@ export declare function count<Item, Key extends keyof Item>(array: Item[], key:
 /**
  * Get the number of items _(count)_ that match the given value
  */
-export declare function count<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): number;
+export declare function count<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey>(array: Item[], key: Key, value: ReturnType<Key>): number;

package/types/array/exists.d.cts

@@ -1,9 +1,6 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type Key = number | string;
-export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
-export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
-export type KeyCallback<Item> = ArrayCallback<Item, Key>;
 /**
  * Does the value exist in array?
  */
@@ -11,7 +8,7 @@ export declare function exists<Item>(array: Item[], value: Item): boolean;
 /**
  * Does the value exist in array?
  */
-export declare function exists<Item>(array: Item[], matches: BooleanCallback<Item>): boolean;
+export declare function exists<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): boolean;
 /**
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
@@ -21,6 +18,6 @@ export declare function exists<Item, Key extends keyof Item>(array: Item[], key:
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function exists<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): boolean;
+export declare function exists<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): boolean;
 
 export {};

package/types/array/exists.d.ts

@@ -1,4 +1,4 @@
-import type { BooleanCallback, KeyCallback } from './models';
+import type { Key as SimpleKey } from '~/models';
 /**
  * Does the value exist in array?
  */
@@ -6,7 +6,7 @@ export declare function exists<Item>(array: Item[], value: Item): boolean;
 /**
  * Does the value exist in array?
  */
-export declare function exists<Item>(array: Item[], matches: BooleanCallback<Item>): boolean;
+export declare function exists<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): boolean;
 /**
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
@@ -16,4 +16,4 @@ export declare function exists<Item, Key extends keyof Item>(array: Item[], key:
  * - Does the value exist in array?
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function exists<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): boolean;
+export declare function exists<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey>(array: Item[], key: Key, value: ReturnType<Key>): boolean;

package/types/array/filter.d.cts

@@ -1,9 +1,6 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type Key = number | string;
-export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
-export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
-export type KeyCallback<Item> = ArrayCallback<Item, Key>;
 /**
  * Get a filtered array of items matching `value`
  */
@@ -11,7 +8,7 @@ export declare function filter<Item>(array: Item[], value: Item): Item[];
 /**
  * Get a filtered array of items matching `value`
  */
-export declare function filter<Item>(array: Item[], matches: BooleanCallback<Item>): Item[];
+export declare function filter<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
  * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
@@ -21,6 +18,6 @@ export declare function filter<Item, Key extends keyof Item>(array: Item[], key:
  * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function filter<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): Item[];
+export declare function filter<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): Item[];
 
 export {};

package/types/array/filter.d.ts

@@ -1,4 +1,4 @@
-import type { BooleanCallback, KeyCallback } from '~/array/models';
+import type { Key as SimpleKey } from '~/models';
 /**
  * Get a filtered array of items matching `value`
  */
@@ -6,7 +6,7 @@ export declare function filter<Item>(array: Item[], value: Item): Item[];
 /**
  * Get a filtered array of items matching `value`
  */
-export declare function filter<Item>(array: Item[], matches: BooleanCallback<Item>): Item[];
+export declare function filter<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
  * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
@@ -16,4 +16,4 @@ export declare function filter<Item, Key extends keyof Item>(array: Item[], key:
  * - Get a filtered array of items
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function filter<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): Item[];
+export declare function filter<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey>(array: Item[], key: Key, value: ReturnType<Key>): Item[];

package/types/array/find.d.cts

@@ -1,9 +1,6 @@
 // Generated by dts-bundle-generator v9.5.1
 
 export type Key = number | string;
-export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
-export type BooleanCallback<Item> = ArrayCallback<Item, boolean>;
-export type KeyCallback<Item> = ArrayCallback<Item, Key>;
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
  */
@@ -11,7 +8,7 @@ export declare function find<Item>(array: Item[], value: Item): Item | undefined
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
  */
-export declare function find<Item>(array: Item[], matches: BooleanCallback<Item>): Item | undefined;
+export declare function find<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 /**
  * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
@@ -21,6 +18,6 @@ export declare function find<Item, Key extends keyof Item>(array: Item[], key: K
  * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function find<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): Item | undefined;
+export declare function find<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, value: ReturnType<Key>): Item | undefined;
 
 export {};

package/types/array/find.d.ts

@@ -1,4 +1,4 @@
-import type { BooleanCallback, KeyCallback } from '~/array/models';
+import type { Key as SimpleKey } from '~/models';
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
  */
@@ -6,7 +6,7 @@ export declare function find<Item>(array: Item[], value: Item): Item | undefined
 /**
  * Get the first item matching `value` _(or `undefined` if no match is found)_
  */
-export declare function find<Item>(array: Item[], matches: BooleanCallback<Item>): Item | undefined;
+export declare function find<Item>(array: Item[], matches: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
 /**
  * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
@@ -16,4 +16,4 @@ export declare function find<Item, Key extends keyof Item>(array: Item[], key: K
  * - Get the first matching item _(or `undefined` if no match is found)_
  * - Use `key` to find a comparison value to match with `value`
  */
-export declare function find<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, value: ReturnType<Key>): Item | undefined;
+export declare function find<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey>(array: Item[], key: Key, value: ReturnType<Key>): Item | undefined;

package/types/array/group-by.d.cts

@@ -2,9 +2,6 @@
 
 export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey ? Item[Key] : never;
 export type Key = number | string;
-export type ArrayCallback<Item, Value> = (item: Item, index: number, array: Item[]) => Value;
-export type KeyCallback<Item> = ArrayCallback<Item, Key>;
-export type ValueCallback<Item> = ArrayCallback<Item, unknown>;
 /**
  * Create a record from an array of items using a specific key
  */
@@ -16,11 +13,11 @@ export declare function groupBy<Item, Key extends keyof Item>(array: Item[], key
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
 /**
  * Create a record from an array of items using a specific key and value
  */
@@ -32,27 +29,27 @@ export declare function groupBy<Item, Key extends keyof Item, Value extends keyo
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => Key, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
 export declare function groupValues(array: unknown[], key: unknown, value: unknown, arrays: boolean): Record<Key, unknown>;
 
 export {};

package/types/array/group-by.d.ts

@@ -1,5 +1,4 @@
-import type { KeyCallback, ValueCallback } from '~/array/models';
-import type { Key, KeyedValue } from '~/models';
+import type { Key as SimpleKey, KeyedValue } from '~/models';
 /**
  * Create a record from an array of items using a specific key
  */
@@ -11,11 +10,11 @@ export declare function groupBy<Item, Key extends keyof Item>(array: Item[], key
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey>(array: Item[], key: Key): Record<ReturnType<Key>, Item>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey>(array: Item[], key: Key, arrays: true): Record<ReturnType<Key>, Item[]>;
 /**
  * Create a record from an array of items using a specific key and value
  */
@@ -27,25 +26,25 @@ export declare function groupBy<Item, Key extends keyof Item, Value extends keyo
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<KeyedValue<Item, Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends keyof Item, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
+export declare function groupBy<Item, Key extends keyof Item, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<KeyedValue<Item, Key>, Array<ReturnType<Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey, Value extends keyof Item>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, KeyedValue<Item, Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey, Value extends keyof Item>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<KeyedValue<Item, Value>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value): Record<ReturnType<Key>, ReturnType<Value>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item, Key extends KeyCallback<Item>, Value extends ValueCallback<Item>>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
-export declare function groupValues(array: unknown[], key: unknown, value: unknown, arrays: boolean): Record<Key, unknown>;
+export declare function groupBy<Item, Key extends (item: Item, index: number, array: Item[]) => SimpleKey, Value extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: Key, value: Value, arrays: true): Record<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function groupValues(array: unknown[], key: unknown, value: unknown, arrays: boolean): Record<SimpleKey, unknown>;