`Object.groupBy` should not return `Partial<Record<string, T>>` or `Partial<Record<number, T>>`

[joshkel]

⚙ Compilation target

es2022

⚙ Library

lib.es2024.object

Missing / Incorrect Definition

The type definitions for Object.groupBy<K, T> state that it returns a Partial<Record<K, T>>. This is useful if K is a union, enum, etc. - the result is is likely Partial, and the result is consistent with a Partial<Record<K, T>> literal, and having Partial helps prevent mistakes from assuming that every key is present in the resulting record. However, it's unnecessary if K is a unrestricted number or string: there's no way that a declared key within the result can have an undefined value, and the result is more consistent with a Record<string | number, T> literal than a Partial<Record<string | number, T>> literal, and any mistakes are more consistently dealt with using TypeScript's noUncheckedIndexedAccess option.

See #56805 (comment) and #56805 (comment) from the PR that originally added types for Object.groupBy.

Sample Code

type Employee = { name: string, role: 'ic' | 'manager' };
const employees: Set<Employee> = new Set();

const byName = Object.groupBy(employees, x => x.name);
for (const [name, nameGroup] of byName) {
  // TypeScript gives an error that nameGroup may be undefined,
  // but it's always defined
  console.log(nameGroup.length);
}

Documentation Link

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/groupBy

[joshkel]

A possible implementation of this change:

/**
 * Identifies unrestricted strings and numbers (i.e., not unions, not numeric
 * enums which can broaden to numbers, etc.).
 */
type IsAnyStringOrNumber<K extends PropertyKey> = K extends string | number
  ? string extends K
    ? K
    : `${number}` extends `${K}`
    ? K
    : string | number extends K
    ? K
    : never
  : never;

interface ObjectConstructor {
    /**
     * Groups members of an iterable according to the return value of the passed callback.
     * @param items An iterable.
     * @param keySelector A callback which will be invoked for each item in items.
     */
    groupBy<K extends PropertyKey, T>(
        items: Iterable<T>,
        keySelector: (item: T, index: number) => K,
    ): [K] extends [IsAnyStringOrNumber<K>] ? Record<K, T[]> : Partial<Record<K, T[]>>;
}

[RyanCavanaugh]

Changing this would introduce a confusing variance break where you can have code that is legal become illegal when an input type becomes narrower, which is usually not possible.