I implemented a custom groupBy function using TypeScript.

export interface Group {
  key: any;
  items: any[];
}

export interface GroupBy {
  keys: string[];
  thenby?: GroupBy;
}

export const groupBy = (array: any[], grouping: GroupBy): Group[] => {
  const keys = grouping.keys;
  const groups = array.reduce((groups, item) => {
    const group = groups.find(g => keys.every(key => item[key] === g.key[key]));
    const data = Object.getOwnPropertyNames(item)
      .filter(prop => !keys.find(key => key === prop))
      .reduce((o, key) => ({ ...o, [key]: item[key] }), {});
    return group
      ? groups.map(g => (g === group ? { ...g, items: [...g.items, data] } : g))
      : [
          ...groups,
          {
            key: keys.reduce((o, key) => ({ ...o, [key]: item[key] }), {}),
            items: [data]
          }
        ];
  }, []);
  return grouping.thenby ? groups.map(g => ({ ...g, items: groupBy(g.items, grouping.thenby) })) : groups;
};

A live demo showcasing this functionality can be found on StackBlitz here:

https://stackblitz.com/edit/typescript-ezydzv

For those looking to streamline their data manipulation process, consider utilizing the groupBy function found within the comprehensive manipula package. This tool not only implements various C# LINQ methods but also maintains the familiar syntax for seamless integration.

Below are two possible solutions:

function Categorize1(arr, category) {
    var group = {};

    arr.forEach(item => group[item[category]] = (group[item[category]] || 0) + 1);

    return group;
}

function Categorize2(arr, category) {
    return arr.reduce((group, item) => {
        group[item[category]] = (group[item[category]] || 0) + 1;

        return count;
    }, {});
}

var items = [
    { itemType: 'shirt' },
    { itemType: 'pants' },
    { itemType: 'shirt' },
    { itemType: 'shoes' },
    { itemType: 'hat' },
    { itemType: 'shirt' },
    { itemType: 'shirt' },
    { itemType: 'shoes' },
    { itemType: 'pants' },
    { itemType: 'pants' },
    { itemType: 'shirt' },
    { itemType: 'hat' },
    { itemType: 'shirt' },
    { itemType: 'hat' },
    { itemType: 'pants' }
];

console.log(Categorize1(items, 'itemType'));
console.log(Categorize2(items, 'itemType'));

When using LINQ-Group-By, the result is similar to a dictionary where the group item serves as the key and the element array is the object within a list.

Replicating this functionality in JavaScript is quite simple.
Here's the TypeScript code for reference:

// Source: https://stackoverflow.com/questions/20310369/declare-a-delegate-type-in-typescript
// type Predicate<T, TKey> = (item: T) => TKey;

interface Predicate<T, TKey> 
{
    (item: T): TKey;
}

function LinqGroupBy<TSource, TKey>(source: TSource[], keySelector: Predicate<TSource, TKey>)
    : { [key: string]: TSource[] }
{
    if (source == null)
        throw new Error("ArgumentNullException: Source");
    if (keySelector == null)
        throw new Error("ArgumentNullException: keySelector");

    let dict: { [key: string]: TSource[]} = {};

    for (let i = 0; i < source.length; ++i)
    {
        let key: string = String(keySelector(source[i]));

        if (!dict.hasOwnProperty(key))
        {
            dict[key] = [];
        }

        dict[key].push(source[i]);
    }

    return dict;
}

This TypeScript code can be transpiled down to:

function LinqGroupBy(source, keySelector) 
{
    if (source == null)
        throw new Error("ArgumentNullException: Source");
    if (keySelector == null)
        throw new Error("ArgumentNullException: keySelector");
    var dict = {};
    for (var i = 0; i < source.length; ++i) 
    {
        var key = String(keySelector(source[i]));
        if (!dict.hasOwnProperty(key)) 
        {
            dict[key] = [];
        }
        dict[key].push(source[i]);
    }
    return dict;
}

Although the conversion to JavaScript may be a bit tricky given the nature of objects in the language, it generally functions effectively.

Although this may be an old post, I wanted to share my unique implementation which was mainly inspired by @Stefan.

Instead of simply returning { [key: string]: TSource[] }, my version provides a return of { [key: string]: { key: TKey; value: TSource[] } }

This approach proved valuable in my specific scenario where the key is not just a simple string.

interface Predicate<T, TKey> {
  (item: T): TKey;
}

const customizedGroupBy = <TSource, TKey>(
  source: TSource[],
  keySelector: Predicate<TSource, TKey>
): { [key: string]: { key: TKey; value: TSource[] } } => {
  if (source === null) throw new Error("ArgumentNullException: Source");
  if (keySelector === null) throw new Error("ArgumentNullException: keySelector");

  const dictionary: { [key: string]: { key: TKey; value: TSource[] } } = {};

  for (let i = 0; i < source.length; ++i) {
    const keyValue = keySelector(source[i]);
    let customKey = String(JSON.stringify(keyValue));

    if (!dictionary.hasOwnProperty(customKey)) {
        dictionary[customKey] = {
            key: keyValue,
            value: [],
        };
    }

    dictionary[customKey].value.push(source[i]);
  }

  return dictionary;
};