@oscarpalmer/atoms 0.77.2 → 0.78.0

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

@@ -31,17 +31,77 @@ isObject('hello');
 @category Object
 */
 export type UnknownRecord = Record<PropertyKey, unknown>;
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
+*/
+export type Simplify<T> = {
+	[KeyType in keyof T]: T[KeyType];
+} & {};
 export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey ? Item[Key] : never;
 export type Key = number | string;
 export type PlainObject = UnknownRecord;
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Record<KeyedValue<Item, ItemKey>, Item>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Record<KeyedValue<Item, ItemKey>, Item[]>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 /**
  * Create a record from an array of items using a specific key
  */
@@ -53,31 +113,31 @@ export declare function groupBy<Item, ItemKey extends (item: Item, index: number
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<Item[ItemValue]>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, Item[ItemValue]>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, ReturnType<ItemValue>>;
+export declare function groupBy<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<ReturnType<ItemKey>, ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */

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

@@ -1,12 +1,13 @@
+import type { Simplify } from 'type-fest';
 import type { Key, KeyedValue, PlainObject } from '~/models';
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Record<KeyedValue<Item, ItemKey>, Item>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Record<KeyedValue<Item, ItemKey>, Item[]>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 /**
  * Create a record from an array of items using a specific key
  */
@@ -18,31 +19,31 @@ export declare function groupBy<Item, ItemKey extends (item: Item, index: number
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<Item[ItemValue]>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, Item[ItemValue]>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, ReturnType<ItemValue>>;
+export declare function groupBy<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<ReturnType<ItemKey>, ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */

package/types/array/index.d.cts

@@ -31,6 +31,66 @@ isObject('hello');
 @category Object
 */
 export type UnknownRecord = Record<PropertyKey, unknown>;
+/**
+Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+type PositionProps = {
+	top: number;
+	left: number;
+};
+
+type SizeProps = {
+	width: number;
+	height: number;
+};
+
+// In your editor, hovering over `Props` will show a flattened object with all the properties.
+type Props = Simplify<PositionProps & SizeProps>;
+```
+
+Sometimes it is desired to pass a value as a function argument that has a different type. At first inspection it may seem assignable, and then you discover it is not because the `value`'s type definition was defined as an interface. In the following example, `fn` requires an argument of type `Record<string, unknown>`. If the value is defined as a literal, then it is assignable. And if the `value` is defined as type using the `Simplify` utility the value is assignable.  But if the `value` is defined as an interface, it is not assignable because the interface is not sealed and elsewhere a non-string property could be added to the interface.
+
+If the type definition must be an interface (perhaps it was defined in a third-party npm package), then the `value` can be defined as `const value: Simplify<SomeInterface> = ...`. Then `value` will be assignable to the `fn` argument.  Or the `value` can be cast as `Simplify<SomeInterface>` if you can't re-declare the `value`.
+
+@example
+```
+import type {Simplify} from 'type-fest';
+
+interface SomeInterface {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+}
+
+type SomeType = {
+	foo: number;
+	bar?: string;
+	baz: number | undefined;
+};
+
+const literal = {foo: 123, bar: 'hello', baz: 456};
+const someType: SomeType = literal;
+const someInterface: SomeInterface = literal;
+
+function fn(object: Record<string, unknown>): void {}
+
+fn(literal); // Good: literal object type is sealed
+fn(someType); // Good: type is sealed
+fn(someInterface); // Error: Index signature for type 'string' is missing in type 'someInterface'. Because `interface` can be re-opened
+fn(someInterface as Simplify<SomeInterface>); // Good: transform an `interface` into a `type`
+```
+
+@link https://github.com/microsoft/TypeScript/issues/15300
+@see SimplifyDeep
+@category Object
+*/
+export type Simplify<T> = {
+	[KeyType in keyof T]: T[KeyType];
+} & {};
 export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey ? Item[Key] : never;
 export type NestedArrayType<Value> = Value extends Array<infer NestedValue> ? NestedArrayType<NestedValue> : Value;
 export type Key = number | string;
@@ -120,11 +180,11 @@ export declare function find<Item, ItemKey extends (item: Item, index: number, a
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Record<KeyedValue<Item, ItemKey>, Item>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Record<KeyedValue<Item, ItemKey>, Item[]>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 /**
  * Create a record from an array of items using a specific key
  */
@@ -136,31 +196,31 @@ export declare function groupBy<Item, ItemKey extends (item: Item, index: number
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<Item[ItemValue]>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, Item[ItemValue]>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function groupBy<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function groupBy<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, ReturnType<ItemValue>>;
+export declare function groupBy<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<ReturnType<ItemKey>, ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
@@ -250,11 +310,11 @@ export declare function toMap<Item>(array: Item[]): Map<number, Item>;
 /**
  * Create a map from an array of items using a specific key
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<KeyedValue<Item, ItemKey>, Item>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item>;
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Map<KeyedValue<Item, ItemKey>, Item[]>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Map<Item[ItemKey], Item[]>;
 /**
  * Create a map from an array of items using a specific key
  */
@@ -266,35 +326,35 @@ export declare function toMap<Item, ItemKey extends (item: Item, index: number,
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue]>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<Item[ItemKey], Array<Item[ItemValue]>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], ReturnType<ItemValue>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<Item[ItemKey], Array<ReturnType<ItemValue>>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, Item[ItemValue]>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<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): Map<ReturnType<Key>, ReturnType<Value>>;
+export declare function toMap<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, ReturnType<ItemValue>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<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): Map<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function toMap<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items _(using their indices as keys)_
  */
@@ -302,11 +362,11 @@ export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
 /**
  * Create a record from an array of items using a specific key
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Record<KeyedValue<Item, ItemKey>, Item>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
 /**
  * Create a record from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Record<KeyedValue<Item, ItemKey>, Item[]>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 /**
  * Create a record from an array of items using a specific key
  */
@@ -318,27 +378,27 @@ export declare function toRecord<Item, ItemKey extends (item: Item, index: numbe
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<Item[ItemValue]>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>>;
 /**
  * Create a record from an array of items using a specific key and value
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Record<ReturnType<ItemKey>, Item[ItemValue]>;
 /**
  * Create a record from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toRecord<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toRecord<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Record<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 /**
  * Create a record from an array of items using a specific key and value
  */

package/types/array/to-map.d.cts

@@ -31,7 +31,6 @@ isObject('hello');
 @category Object
 */
 export type UnknownRecord = Record<PropertyKey, unknown>;
-export type KeyedValue<Item, Key extends keyof Item> = Item[Key] extends PropertyKey ? Item[Key] : never;
 export type Key = number | string;
 export type PlainObject = UnknownRecord;
 /**
@@ -41,11 +40,11 @@ export declare function toMap<Item>(array: Item[]): Map<number, Item>;
 /**
  * Create a map from an array of items using a specific key
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<KeyedValue<Item, ItemKey>, Item>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item>;
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Map<KeyedValue<Item, ItemKey>, Item[]>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Map<Item[ItemKey], Item[]>;
 /**
  * Create a map from an array of items using a specific key
  */
@@ -57,34 +56,34 @@ export declare function toMap<Item, ItemKey extends (item: Item, index: number,
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue]>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<Item[ItemKey], Array<Item[ItemValue]>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], ReturnType<ItemValue>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<Item[ItemKey], Array<ReturnType<ItemValue>>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, Item[ItemValue]>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<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): Map<ReturnType<Key>, ReturnType<Value>>;
+export declare function toMap<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, ReturnType<ItemValue>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<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): Map<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function toMap<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<ReturnType<ItemValue>>>;
 
 export {};

package/types/array/to-map.d.ts

@@ -1,4 +1,4 @@
-import type { Key, KeyedValue, PlainObject } from '~/models';
+import type { Key, PlainObject } from '~/models';
 /**
  * Create a map from an array of items _(using their indices as keys)_
  */
@@ -6,11 +6,11 @@ export declare function toMap<Item>(array: Item[]): Map<number, Item>;
 /**
  * Create a map from an array of items using a specific key
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<KeyedValue<Item, ItemKey>, Item>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item>;
 /**
  * Create a map from an array of items using a specific key, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Map<KeyedValue<Item, ItemKey>, Item[]>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, arrays: true): Map<Item[ItemKey], Item[]>;
 /**
  * Create a map from an array of items using a specific key
  */
@@ -22,32 +22,32 @@ export declare function toMap<Item, ItemKey extends (item: Item, index: number,
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<KeyedValue<Item, ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue]>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<KeyedValue<Item, ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<Item[ItemKey], Array<Item[ItemValue]>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<KeyedValue<Item, ItemKey>, ReturnType<ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], ReturnType<ItemValue>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<KeyedValue<Item, ItemKey>, Array<ReturnType<ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<Item[ItemKey], Array<ReturnType<ItemValue>>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, KeyedValue<Item, ItemValue>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, Item[ItemValue]>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<KeyedValue<Item, ItemValue>>>;
+export declare function toMap<Item extends PlainObject, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<Item[ItemValue]>>;
 /**
  * Create a map from an array of items using a specific key and value
  */
-export declare function toMap<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): Map<ReturnType<Key>, ReturnType<Value>>;
+export declare function toMap<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue): Map<ReturnType<ItemKey>, ReturnType<ItemValue>>;
 /**
  * Create a map from an array of items using a specific key and value, and grouping them into arrays
  */
-export declare function toMap<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): Map<ReturnType<Key>, Array<ReturnType<Value>>>;
+export declare function toMap<Item, ItemKey extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ItemValue, arrays: true): Map<ReturnType<ItemKey>, Array<ReturnType<ItemValue>>>;