ts-02-groupby

# Generic `groupBy`

Implement **`solution.ts`** exporting a generic function:

```ts
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]>
```

Group the `items` into a record keyed by the result of `keyFn(item)`. Each value is
the array of items that produced that key, **in their original order**.

- `groupBy([1, 2, 3, 4], (n) => (n % 2 === 0 ? "even" : "odd"))`
  → `{ odd: [1, 3], even: [2, 4] }`
- `groupBy([], (n: number) => n)` → `{}`
- A numeric key works too:
  `groupBy(["a", "bb", "ccc", "dd"], (s) => s.length)`
  → `{ 1: ["a"], 2: ["bb", "dd"], 3: ["ccc"] }`

Keep it fully typed (must pass `tsc --noEmit` in strict mode). Do not use `any` in the
public API.

import { test } from "node:test";
import { strict as assert } from "node:assert";
import { groupBy } from "./solution.ts";

test("groups by string key, preserving order", () => {
  const r = groupBy([1, 2, 3, 4, 5], (n) => (n % 2 === 0 ? "even" : "odd"));
  assert.deepEqual(r, { odd: [1, 3, 5], even: [2, 4] });
});

test("empty input yields empty record", () => {
  assert.deepEqual(groupBy<number, number>([], (n) => n), {});
});

test("groups by numeric key", () => {
  const r = groupBy(["a", "bb", "ccc", "dd"], (s) => s.length);
  assert.deepEqual(r, { 1: ["a"], 2: ["bb", "dd"], 3: ["ccc"] });
});

test("groups objects by a property", () => {
  const people = [
    { name: "Ana", city: "NYC" },
    { name: "Bo", city: "LA" },
    { name: "Cy", city: "NYC" },
  ];
  const r = groupBy(people, (p) => p.city);
  assert.deepEqual(r, {
    NYC: [
      { name: "Ana", city: "NYC" },
      { name: "Cy", city: "NYC" },
    ],
    LA: [{ name: "Bo", city: "LA" }],
  });
});

test("single group when keyFn is constant", () => {
  const r = groupBy([1, 2, 3], () => "all");
  assert.deepEqual(r, { all: [1, 2, 3] });
});

test("does not mutate the input array", () => {
  const input = [3, 1, 2];
  groupBy(input, (n) => n);
  assert.deepEqual(input, [3, 1, 2]);
});

You are an expert programmer. Solve the task exactly as specified. Output your solution as fenced code blocks using the required file name(s) and the exact function/type signatures requested. Prefer correctness; do not include prose outside code unless asked.

To solve this problem, we need to implement a generic function `groupBy` that takes an array of items and a function to determine the key for each item. The function will group the items into a record where each key maps to an array of items that share that key, maintaining their original order.

### Approach
1. **Initialize an empty result object**: This object will hold the groups of items, where each key corresponds to an array of items.
2. **Iterate over each item**: For each item in the input array, compute the key using the provided key function.
3. **Check for existing key**: If the key does not exist in the result object, initialize it with an empty array.
4. **Add item to the corresponding group**: Push the current item into the array associated with its computed key.
5. **Return the result object**: After processing all items, return the result object containing all grouped items.

This approach ensures that items are grouped correctly and maintains their original order in the input array.

### Solution Code
```typescript
export function groupBy<T, K extends string | number>(
  items: T[],
  keyFn: (item: T) => K,
): Record<K, T[]> {
  const result: Record<K, T[]> = {};
  for (const item of items) {
    const key = keyFn(item);
    if (!result.hasOwnProperty(key)) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}
```

### Explanation
- **Initialization**: We start by creating an empty object `result` to store the grouped items.
- **Iteration**: For each item in the input array, we compute the key using the provided function `keyFn`.
- **Key Check**: We check if the computed key already exists in the result object. If not, we initialize it with an empty array.
- **Grouping**: We add the item to the array corresponding to its computed key, ensuring the order is maintained as per the input array.
- **Return**: Finally, we return the result object containing all the grouped items.

This solution efficiently groups items while maintaining their order and handles both string and numeric keys correctly.

Okay, I need to implement the groupBy function in TypeScript. Let's see what the requirements are.

The function is generic, taking items of type T and a key function that returns a type K, which can be a string or a number. The output is a record where each key maps to an array of items that share that key, maintaining their original order.

First, I should think about how to structure this. I'll start by initializing an empty object to hold the groups. Then, I'll iterate over each item in the items array. For each item, I'll apply the key function to get the key. If the key doesn't exist in the result object, I'll create a new array for it. Then, I'll push the item into the corresponding array.

Wait, but in TypeScript, objects can't have keys of type string or number directly as their own properties. Oh, right, but when we use the bracket notation, it should work because the key is either a string or a number, which can be coerced into a string for object keys.

So, the steps are:

1. Initialize an empty object, let's call it result.
2. Loop through each item in the items array.
3. For each item, compute the key using keyFn.
4. Check if the key exists in result. If not, initialize it as an empty array.
5. Push the current item into the array corresponding to the key.
6. After processing all items, return the result object.

Now, thinking about the TypeScript types. The function is generic, so T and K are parameters. The keyFn is a function that takes T and returns K. The result is a Record<K, T[]>, which means each key is of type K, and the value is an array of T.

Wait, but in TypeScript, Record expects the keys to be strings. Oh, but K can be a string or a number. So when K is a number, the Record will have keys as strings because object keys are always strings. But the function's return type is Record<K, T[]>, which is allowed because K is either string or number, and in both cases, the object can hold those keys.

Wait, no. Because in TypeScript, when K is a number, the Record will have keys of type number, but in reality, object keys are strings. So there might be some type issues here. Hmm, but the function's return type is specified as Record<K, T[]>, so the user is responsible for ensuring that K is compatible with object keys. Since K is constrained to string | number, that should be okay because numbers can be used as keys via string coercion.

So, the code:

function groupBy<T, K extends string | number>(items: T[], keyFn: (item: T) => K): Record<K, T[]> {
  const result: Record<K, T[]> = {};
  for (const item of items) {
    const key = keyFn(item);
    if (!result.hasOwnProperty(key)) {
      result[key] = [];
    }
    result[key].push(item);
  }
  return result;
}

Wait, but in TypeScript, when you use hasOwnProperty with a number key, it's better to convert it to a string. Because, for example, if key is 1, result.hasOwnProperty(1) would check for the property '1' as a string. So that should be fine.

Testing the examples:

First example: groupBy([1,2,3,4], n => n%2 ===0 ? "even" : "odd") should return { odd: [1,3], even: [2,4] }.

In the code, for each number, the key is computed. For 1, key is 'odd', so result['odd'] is created if not exists, then 1 is pushed. Similarly for others.

Second example: groupBy([], ...) returns empty object.

Third example: groupBy(["a", "bb", "ccc", "dd"], s => s.length) should return {1: ["a"], 2: ["bb", "dd"], 3: ["ccc"]}. So the keys are numbers, but in the object, they are stored as string representations. But the return type is Record<number, T[]>, so the keys are numbers, but in the object, they are strings. But when you access them via the key, TypeScript will coerce the number to a string, so it should work.

Wait, but in the function, when K is a number, the result is of type Record<K, T[]>, which is equivalent to { [key: K]: T[] }, but in reality, object keys are strings. So when K is a number, the compiler allows it, but when you access the property, it's treated as a string. So the function should work correctly.

Another thing to consider: the order of the items in each group should be the same as their order in the original array. The code does this because it processes items in order and appends to the arrays in the order they appear.

What about edge cases? Like when the key function returns a mix of string and number keys. But since K is constrained to string | number, the function should handle that.

I think this implementation should work. Now, I'll write the code accordingly.