sync

src/collector/impl.ts

@@ -65,6 +65,37 @@ export class ToObjectCollector<TElement, TKey extends PropertyKey, TValue> imple
   }
 }
 
+export class ToObjectListCollector<TElement, TKey extends PropertyKey, TValue> implements Collector<TElement, Record<TKey, TValue[]>, Record<TKey, TValue[]>> {
+  readonly #keySelector: Converter<TElement, TKey>;
+  readonly #valueSelector: Converter<TElement, TValue>;
+
+  constructor(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+    this.#keySelector = keySelector;
+    this.#valueSelector = valueSelector;
+  }
+
+  initialize() {
+    return {} as Record<TKey, TValue[]>;
+  }
+
+  accumulate(accumulator: Record<TKey, TValue[]>, element: TElement) {
+    const key = this.#keySelector(element);
+    const value = this.#valueSelector(element);
+
+    const l = accumulator[key];
+
+    if (l) {
+      l.push(value);
+    } else {
+      accumulator[key] = [value];
+    }
+  }
+
+  finalize(accumulator: Record<TKey, TValue[]>) {
+    return accumulator;
+  }
+}
+
 export class ToMapCollector<TElement, TKey, TValue> implements Collector<TElement, Map<TKey, TValue>, Map<TKey, TValue>> {
   readonly #keySelector: Converter<TElement, TKey>;
   readonly #valueSelector: Converter<TElement, TValue>;
@@ -90,6 +121,37 @@ export class ToMapCollector<TElement, TKey, TValue> implements Collector<TElemen
   }
 }
 
+export class ToMapListCollector<TElement, TKey, TValue> implements Collector<TElement, Map<TKey, TValue[]>, Map<TKey, TValue[]>> {
+  readonly #keySelector: Converter<TElement, TKey>;
+  readonly #valueSelector: Converter<TElement, TValue>;
+
+  constructor(keySelector: Converter<TElement, TKey>, valueSelector: Converter<TElement, TValue>) {
+    this.#keySelector = keySelector;
+    this.#valueSelector = valueSelector;
+  }
+
+  initialize() {
+    return new Map<TKey, TValue[]>();
+  }
+
+  accumulate(accumulator: Map<TKey, TValue[]>, element: TElement) {
+    const key = this.#keySelector(element);
+    const value = this.#valueSelector(element);
+
+    const l = accumulator.get(key);
+
+    if (l) {
+      l.push(value);
+    } else {
+      accumulator.set(key, [value]);
+    }
+  }
+
+  finalize(accumulator: Map<TKey, TValue[]>) {
+    return accumulator;
+  }
+}
+
 export class ToSetCollector<TElement> implements Collector<TElement, Set<TElement>, Set<TElement>> {
   initialize() {
     return new Set<TElement>();
@@ -128,60 +190,60 @@ export class JoinCollector implements Collector<any, any[], string> {
   }
 }
 
-export class SumCollector implements Collector<number, { sum: number }, number> {
+export class SumCollector implements Collector<number, { sum: number; }, number> {
   initialize() {
     return { sum: 0 };
   }
 
-  accumulate(accumulator: { sum: number }, element: number) {
+  accumulate(accumulator: { sum: number; }, element: number) {
     accumulator.sum += element;
   }
 
-  finalize(accumulator: { sum: number }) {
+  finalize(accumulator: { sum: number; }) {
     return accumulator.sum;
   }
 }
 
-export class BigIntSumCollector implements Collector<bigint, { sum: bigint }, bigint> {
+export class BigIntSumCollector implements Collector<bigint, { sum: bigint; }, bigint> {
   initialize() {
     return { sum: 0n, };
   }
 
-  accumulate(accumulator: { sum: bigint }, element: bigint) {
+  accumulate(accumulator: { sum: bigint; }, element: bigint) {
     accumulator.sum += element;
   }
 
-  finalize(accumulator: { sum: bigint }) {
+  finalize(accumulator: { sum: bigint; }) {
     return accumulator.sum;
   }
 }
 
-export class AverageCollector implements Collector<number, { count: number, sum: number }, number> {
+export class AverageCollector implements Collector<number, { count: number, sum: number; }, number> {
   initialize() {
     return { count: 0, sum: 0 };
   }
 
-  accumulate(accumulator: { count: number, sum: number }, element: number) {
+  accumulate(accumulator: { count: number, sum: number; }, element: number) {
     accumulator.count++;
     accumulator.sum += element;
   }
 
-  finalize(accumulator: { count: number, sum: number }) {
+  finalize(accumulator: { count: number, sum: number; }) {
     return accumulator.count === 0 ? 0 : accumulator.sum / accumulator.count;
   }
 }
 
-export class BigIntAverageCollector implements Collector<bigint, { count: number, sum: bigint }, bigint> {
+export class BigIntAverageCollector implements Collector<bigint, { count: number, sum: bigint; }, bigint> {
   initialize() {
     return { count: 0, sum: 0n };
   }
 
-  accumulate(accumulator: { count: number, sum: bigint }, element: bigint) {
+  accumulate(accumulator: { count: number, sum: bigint; }, element: bigint) {
     accumulator.count++;
     accumulator.sum += element;
   }
 
-  finalize(accumulator: { count: number, sum: bigint }) {
+  finalize(accumulator: { count: number, sum: bigint; }) {
     return accumulator.count === 0 ? 0n : accumulator.sum / BigInt(accumulator.count);
   }
 }