A simple aggregation function for handling lists of data.

get-aggregation.ts

type KeyGenerator<ItemProps> = (item: ItemProps) => string;
type Reducer<AggregatedProps, ItemProps> = (
  aggregation: AggregatedProps,
  item: ItemProps,
  idx: number,
) => AggregatedProps;
type Aggregation<AggregatedProps> = {
  key: string;
  items: ItemProps[];
  values: AggregatedProps;
};
type AggregationMapping<AggregatedProps> = {
  [key: string]: Aggregation;
};

const getAggregation = <ItemProps, AggregatedProps>(
  list: ItemProps[],
  keyGenerator: KeyGenerator<ItemProps>,
  reducer: Reducer<AggregatedProps, ItemProps>,
): Aggregation[] => {
  const aggregationMapping: AggregationMapping<AggregatedProps> = {};

  list.forEach((item, idx) => {
    const key = keyGenerator(item);
    const aggregation = aggregationMapping[key] || {
      key,
      items: [],
      values: {},
    };
    
    aggregationMapping[key] = {
      ...aggregation,
      items: [...aggregation.items, item],
      values: reducer(aggregation.values, item, idx),
    };
  });

  return Object.values(aggregationMapping);
};