@hpcc-js/dataflow 9.1.0 → 9.2.1

package/src/__tests__/readme.ts

@@ -1,113 +1,113 @@
-import { expect } from "chai";
-
-import { count, filter, first, generate, map, max, pipe, sensor } from "../index";
-
-describe("readme", () => {
-
-    it("quick example", () => {
-
-        const c1 = count();
-        const c2 = count();
-        const c3 = count();
-        const m1 = max(row => row.value);
-
-        const p1 = pipe(
-            sensor(c1),                         //  Keep running count of input
-            filter(n => n <= 0.5),              //  Filter out numbers > 0.5  
-            sensor(c2),                         //  Keep running count of filtered rows
-            map((n, idx) =>                     //  Convert to JSON Object 
-                ({ index: idx, value: n })),
-            filter(row => row.index % 2 === 0), //  Filter even row indecies 
-            sensor(c3),                         //  Keep running count of final rows
-            sensor(m1),                         //  Track largest value
-            first(3)                            //  Take first 3 rows
-        );
-
-        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}`);
-        // [1] => Counts: undefined, undefined, undefined
-        const outIterable = p1(generate(Math.random, 1000));
-        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}`);
-        // [2] => Counts: undefined, undefined, undefined
-        console.info(JSON.stringify([...outIterable]));
-        // [3] => [{"index":0,"value":0.19075931906641008},{"index":2,"value":0.4873469062925415},{"index":4,"value":0.4412516774100035}]
-        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
-        // [4] => Counts: 6, 5, 3, 0.4873469062925415
-
-        const outArray = [...p1([0.7, 0.5, 0.4, 0.8, 0.3, 1])];
-        console.info(JSON.stringify(outArray));
-        // [5] => [{"index":0,"value":0.5},{"index":2,"value":0.3}]
-        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
-        // [6] => Counts:  6, 3, 2, 0.5
-
-        expect(outArray.length).to.equal(2);
-
-        for (const row of p1(generate(Math.random, 1000000))) {
-            console.info(`${row.index}: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
-        }
-    });
-
-    it("interesting example", () => {
-        const c1 = count();
-        const c2 = count();
-        const c3 = count();
-        const m1 = max(row => row.value);
-
-        const p1 = pipe(
-            sensor(c1),                         //  Keep running count of input
-            filter(n => n <= 0.5),              //  Filter out numbers > 0.5  
-            sensor(c2),                         //  Keep running count of filtered rows
-            map((n, idx) =>                     //  Convert to JSON Object 
-                ({ index: idx, value: n })),
-            filter(row => row.index % 2 === 0), //  Filter even row indecies 
-            sensor(c3),                         //  Keep running count of final rows
-            sensor(m1),                         //  Track largest value
-        );
-
-        for (const row of p1(generate(Math.random, 1000000))) {
-            if (row.index % 100000 === 0) {
-                console.info(`${row.index}: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
-            }
-        }
-    });
-});
-
-/*
-const process3 = pipe(
-    filter(n => n <= 0.5),
-    map((n, idx) => ({ index: idx, value: n })),
-    filter(row => row.index % 2 === 0),
-    sort((l, r) => l.value - r.value),
-    first(3)
-);
-console.log(...process3([]));
-
-// Iterable output
-pipe([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-    filter(n => n <= 5),
-    map((n, idx) => ({ index: idx, value: n })),
-    filter(row => row.index % 2 === 0),
-    sort((l, r) => l.value - r.value),
-    first(3)
-);  // => { index: 0, value: 0 }, { index: 2, value: 2 }, { index: 4, value: 4 }
-
-const process = pipe(
-    filter(n => n <= 5),
-    map((n, idx) => ({ index: idx, value: n })),
-    filter(row => row.index % 2 === 0),
-    sort((l, r) => l.value - r.value),
-    first(3)
-);
-console.log([...process([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])]); // => { index: 0, value: 0 }, { index: 2, value: 2 }, { index: 4, value: 4 }
-
-// Scalar output
-pipe([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-    process,
-    scalar(max(row => row.value))
-);  // => 4
-
-const process_2 = pipe(
-    process,
-    scalar(min(row => row.value))
-);
-console.log(process_2([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));  // => 0
-*/
+import { expect } from "chai";
+
+import { count, filter, first, generate, map, max, pipe, sensor } from "../index";
+
+describe("readme", () => {
+
+    it("quick example", () => {
+
+        const c1 = count();
+        const c2 = count();
+        const c3 = count();
+        const m1 = max(row => row.value);
+
+        const p1 = pipe(
+            sensor(c1),                         //  Keep running count of input
+            filter(n => n <= 0.5),              //  Filter out numbers > 0.5  
+            sensor(c2),                         //  Keep running count of filtered rows
+            map((n, idx) =>                     //  Convert to JSON Object 
+                ({ index: idx, value: n })),
+            filter(row => row.index % 2 === 0), //  Filter even row indecies 
+            sensor(c3),                         //  Keep running count of final rows
+            sensor(m1),                         //  Track largest value
+            first(3)                            //  Take first 3 rows
+        );
+
+        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}`);
+        // [1] => Counts: undefined, undefined, undefined
+        const outIterable = p1(generate(Math.random, 1000));
+        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}`);
+        // [2] => Counts: undefined, undefined, undefined
+        console.info(JSON.stringify([...outIterable]));
+        // [3] => [{"index":0,"value":0.19075931906641008},{"index":2,"value":0.4873469062925415},{"index":4,"value":0.4412516774100035}]
+        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
+        // [4] => Counts: 6, 5, 3, 0.4873469062925415
+
+        const outArray = [...p1([0.7, 0.5, 0.4, 0.8, 0.3, 1])];
+        console.info(JSON.stringify(outArray));
+        // [5] => [{"index":0,"value":0.5},{"index":2,"value":0.3}]
+        console.info(`Counts: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
+        // [6] => Counts:  6, 3, 2, 0.5
+
+        expect(outArray.length).to.equal(2);
+
+        for (const row of p1(generate(Math.random, 1000000))) {
+            console.info(`${row.index}: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
+        }
+    });
+
+    it("interesting example", () => {
+        const c1 = count();
+        const c2 = count();
+        const c3 = count();
+        const m1 = max(row => row.value);
+
+        const p1 = pipe(
+            sensor(c1),                         //  Keep running count of input
+            filter(n => n <= 0.5),              //  Filter out numbers > 0.5  
+            sensor(c2),                         //  Keep running count of filtered rows
+            map((n, idx) =>                     //  Convert to JSON Object 
+                ({ index: idx, value: n })),
+            filter(row => row.index % 2 === 0), //  Filter even row indecies 
+            sensor(c3),                         //  Keep running count of final rows
+            sensor(m1),                         //  Track largest value
+        );
+
+        for (const row of p1(generate(Math.random, 1000000))) {
+            if (row.index % 100000 === 0) {
+                console.info(`${row.index}: ${c1.peek()}, ${c2.peek()}, ${c3.peek()}, ${m1.peek()}`);
+            }
+        }
+    });
+});
+
+/*
+const process3 = pipe(
+    filter(n => n <= 0.5),
+    map((n, idx) => ({ index: idx, value: n })),
+    filter(row => row.index % 2 === 0),
+    sort((l, r) => l.value - r.value),
+    first(3)
+);
+console.log(...process3([]));
+
+// Iterable output
+pipe([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    filter(n => n <= 5),
+    map((n, idx) => ({ index: idx, value: n })),
+    filter(row => row.index % 2 === 0),
+    sort((l, r) => l.value - r.value),
+    first(3)
+);  // => { index: 0, value: 0 }, { index: 2, value: 2 }, { index: 4, value: 4 }
+
+const process = pipe(
+    filter(n => n <= 5),
+    map((n, idx) => ({ index: idx, value: n })),
+    filter(row => row.index % 2 === 0),
+    sort((l, r) => l.value - r.value),
+    first(3)
+);
+console.log([...process([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])]); // => { index: 0, value: 0 }, { index: 2, value: 2 }, { index: 4, value: 4 }
+
+// Scalar output
+pipe([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+    process,
+    scalar(max(row => row.value))
+);  // => 4
+
+const process_2 = pipe(
+    process,
+    scalar(min(row => row.value))
+);
+console.log(process_2([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));  // => 0
+*/

package/src/__tests__/reduce.ts

@@ -1,17 +1,17 @@
-import { expect } from "chai";
-import { reduce, scalar } from "../index";
-
-const data = [1, 2, 3, 4, 5];
-const reduceFunc = (prev, row) => prev + row;
-const expectedA = data.reduce(reduceFunc);
-const expectedB = data.reduce(reduceFunc, 10);
-
-describe("reduce", () => {
-
-    it("scalarActivity", () => {
-        const calcReduce = scalar(reduce(reduceFunc));
-        const calcReduce2 = scalar(reduce(reduceFunc, 10));
-        expect(calcReduce(data)).to.equal(expectedA);
-        expect(calcReduce2(data)).to.equal(expectedB);
-    });
-});
+import { expect } from "chai";
+import { reduce, scalar } from "../index";
+
+const data = [1, 2, 3, 4, 5];
+const reduceFunc = (prev, row) => prev + row;
+const expectedA = data.reduce(reduceFunc);
+const expectedB = data.reduce(reduceFunc, 10);
+
+describe("reduce", () => {
+
+    it("scalarActivity", () => {
+        const calcReduce = scalar(reduce(reduceFunc));
+        const calcReduce2 = scalar(reduce(reduceFunc, 10));
+        expect(calcReduce(data)).to.equal(expectedA);
+        expect(calcReduce2(data)).to.equal(expectedB);
+    });
+});

package/src/__tests__/skip.ts

@@ -1,15 +1,15 @@
-import { expect } from "chai";
-import { skip } from "../index";
-
-describe("skip", () => {
-    it("generator", () => {
-        expect([...skip(2)([])]).to.deep.equal([]);
-        expect([...skip(2)(["a", "b", "c"])]).to.deep.equal(["c"]);
-    });
-
-    it("scalarActivity", () => {
-        expect([...skip([], 22)]).to.deep.equal([]);
-        expect([...skip(["a", "b", "c"], 2)]).to.deep.equal(["c"]);
-        expect([...skip(["a", "b", "c"], 22)]).to.deep.equal([]);
-    });
-});
+import { expect } from "chai";
+import { skip } from "../index";
+
+describe("skip", () => {
+    it("generator", () => {
+        expect([...skip(2)([])]).to.deep.equal([]);
+        expect([...skip(2)(["a", "b", "c"])]).to.deep.equal(["c"]);
+    });
+
+    it("scalarActivity", () => {
+        expect([...skip([], 22)]).to.deep.equal([]);
+        expect([...skip(["a", "b", "c"], 2)]).to.deep.equal(["c"]);
+        expect([...skip(["a", "b", "c"], 22)]).to.deep.equal([]);
+    });
+});

package/src/__tests__/sort.ts

@@ -1,21 +1,21 @@
-import { expect } from "chai";
-import { sort } from "../index";
-import { Person, population } from "./data";
-
-function sortFunc(l: Person, r: Person): number {
-    const retVal = l.lname.localeCompare(r.lname);
-    if (retVal === 0) return l.fname.localeCompare(r.fname);
-    return retVal;
-}
-
-const expected = [...population].sort(sortFunc);
-
-describe("sort", () => {
-    it("generator", () => {
-        expect([...sort(sortFunc)(population)]).to.deep.equal(expected);
-    });
-
-    it("scalarActivity", () => {
-        expect([...sort(population, sortFunc)]).to.deep.equal(expected);
-    });
-});
+import { expect } from "chai";
+import { sort } from "../index";
+import { Person, population } from "./data";
+
+function sortFunc(l: Person, r: Person): number {
+    const retVal = l.lname.localeCompare(r.lname);
+    if (retVal === 0) return l.fname.localeCompare(r.fname);
+    return retVal;
+}
+
+const expected = [...population].sort(sortFunc);
+
+describe("sort", () => {
+    it("generator", () => {
+        expect([...sort(sortFunc)(population)]).to.deep.equal(expected);
+    });
+
+    it("scalarActivity", () => {
+        expect([...sort(population, sortFunc)]).to.deep.equal(expected);
+    });
+});

package/src/__tests__/variance.ts

@@ -1,14 +1,14 @@
-import { expect } from "chai";
-import { variance, scalar } from "../index";
-
-describe("variance", () => {
-    it("scalarActivity", () => {
-        const calcVariance = scalar(variance());
-        expect(calcVariance([5, 1, 2, 3, 4])).to.equal(2.5);
-    });
-
-    it("empty array", () => {
-        const varianceActivity = scalar(variance());
-        expect(varianceActivity([])).to.be.undefined;
-    });
-});
+import { expect } from "chai";
+import { variance, scalar } from "../index";
+
+describe("variance", () => {
+    it("scalarActivity", () => {
+        const calcVariance = scalar(variance());
+        expect(calcVariance([5, 1, 2, 3, 4])).to.equal(2.5);
+    });
+
+    it("empty array", () => {
+        const varianceActivity = scalar(variance());
+        expect(varianceActivity([])).to.be.undefined;
+    });
+});

package/src/activities/activity.ts

@@ -1,8 +1,8 @@
-export type Source<T> = IterableIterator<T> | T[];
-export type IterableActivity<T, U = T> = (source: Source<T>) => IterableIterator<U>;
-export type ScalarActivity<T, U = T> = (source: Source<T>) => U;
-export type Activity<T, U = T> = IterableActivity<T, U> | ScalarActivity<T, U>;
-
-export function isSource<T>(source: Source<T> | any): source is Source<T> {
-    return source && (typeof source[Symbol.iterator] === "function" || Array.isArray(source));
-}
+export type Source<T> = IterableIterator<T> | T[];
+export type IterableActivity<T, U = T> = (source: Source<T>) => IterableIterator<U>;
+export type ScalarActivity<T, U = T> = (source: Source<T>) => U;
+export type Activity<T, U = T> = IterableActivity<T, U> | ScalarActivity<T, U>;
+
+export function isSource<T>(source: Source<T> | any): source is Source<T> {
+    return source && (typeof source[Symbol.iterator] === "function" || Array.isArray(source));
+}

package/src/activities/concat.ts

@@ -1,14 +1,14 @@
-import { Source, IterableActivity } from "./activity";
-
-function concatGen<T = any>(concatSource: Source<T>): IterableActivity<T> {
-    return function* (source: Source<T>) {
-        yield* source;
-        yield* concatSource;
-    };
-}
-
-export function concat<T = any>(concatSource: Source<T>): IterableActivity<T, T>;
-export function concat<T>(source: Source<T>, concatSource: Source<T>): IterableIterator<T>;
-export function concat<T = any>(s_or_n: Source<T>, concatSource?: Source<T>): IterableActivity<T, T> | IterableIterator<T> {
-    return concatSource !== undefined ? concatGen<T>(concatSource!)(s_or_n) : concatGen<T>(s_or_n);
-}
+import { Source, IterableActivity } from "./activity";
+
+function concatGen<T = any>(concatSource: Source<T>): IterableActivity<T> {
+    return function* (source: Source<T>) {
+        yield* source;
+        yield* concatSource;
+    };
+}
+
+export function concat<T = any>(concatSource: Source<T>): IterableActivity<T, T>;
+export function concat<T>(source: Source<T>, concatSource: Source<T>): IterableIterator<T>;
+export function concat<T = any>(s_or_n: Source<T>, concatSource?: Source<T>): IterableActivity<T, T> | IterableIterator<T> {
+    return concatSource !== undefined ? concatGen<T>(concatSource!)(s_or_n) : concatGen<T>(s_or_n);
+}

package/src/activities/each.ts

@@ -1,19 +1,19 @@
-import { IterableActivity, Source, isSource } from "./activity";
-
-export type EachCallback<T> = (value: T, index: number) => void;
-
-function eachGen<T = any>(callbackFn: EachCallback<T>): IterableActivity<T> {
-    return function* (source: Source<T>) {
-        let i = -1;
-        for (const item of source) {
-            callbackFn(item, ++i);
-            yield item;
-        }
-    };
-}
-
-export function each<T = any>(callbackFn: EachCallback<T>): IterableActivity<T>;
-export function each<T>(source: Source<T>, callbackFn: EachCallback<T>): IterableIterator<T>;
-export function each<T>(s_or_cb: Source<T> | EachCallback<T>, callbackFn?: EachCallback<T>): IterableActivity<T> | IterableIterator<T> {
-    return isSource(s_or_cb) ? eachGen(callbackFn!)(s_or_cb) : eachGen(s_or_cb);
-}
+import { IterableActivity, Source, isSource } from "./activity";
+
+export type EachCallback<T> = (value: T, index: number) => void;
+
+function eachGen<T = any>(callbackFn: EachCallback<T>): IterableActivity<T> {
+    return function* (source: Source<T>) {
+        let i = -1;
+        for (const item of source) {
+            callbackFn(item, ++i);
+            yield item;
+        }
+    };
+}
+
+export function each<T = any>(callbackFn: EachCallback<T>): IterableActivity<T>;
+export function each<T>(source: Source<T>, callbackFn: EachCallback<T>): IterableIterator<T>;
+export function each<T>(s_or_cb: Source<T> | EachCallback<T>, callbackFn?: EachCallback<T>): IterableActivity<T> | IterableIterator<T> {
+    return isSource(s_or_cb) ? eachGen(callbackFn!)(s_or_cb) : eachGen(s_or_cb);
+}

package/src/activities/entries.ts

@@ -1,17 +1,17 @@
-import { IterableActivity, Source } from "./activity";
-
-//  Array.entries
-function entriesGen<T = any>(): IterableActivity<T, [number, T]> {
-    return function* (source: Source<T>) {
-        let i = -1;
-        for (const item of source) {
-            yield [++i, item];
-        }
-    };
-}
-
-export function entries<T = any>(): IterableActivity<T, [number, T]>;
-export function entries<T>(source: Source<T>): IterableIterator<[number, T]>;
-export function entries<T>(source?: Source<T>): IterableActivity<T, [number, T]> | IterableIterator<[number, T]> {
-    return source ? entriesGen<T>()(source) : entriesGen<T>();
-}
+import { IterableActivity, Source } from "./activity";
+
+//  Array.entries
+function entriesGen<T = any>(): IterableActivity<T, [number, T]> {
+    return function* (source: Source<T>) {
+        let i = -1;
+        for (const item of source) {
+            yield [++i, item];
+        }
+    };
+}
+
+export function entries<T = any>(): IterableActivity<T, [number, T]>;
+export function entries<T>(source: Source<T>): IterableIterator<[number, T]>;
+export function entries<T>(source?: Source<T>): IterableActivity<T, [number, T]> | IterableIterator<[number, T]> {
+    return source ? entriesGen<T>()(source) : entriesGen<T>();
+}

package/src/activities/filter.ts

@@ -1,20 +1,20 @@
-import { IterableActivity, Source, isSource } from "./activity";
-
-export type FilterCallback<T> = (value: T, index: number) => boolean;
-
-function filterGen<T = any>(callbackFn: FilterCallback<T>): IterableActivity<T> {
-    return function* (source: Source<T>) {
-        let i = -1;
-        for (const item of source) {
-            if (callbackFn(item, ++i)) {
-                yield item;
-            }
-        }
-    };
-}
-
-export function filter<T = any>(callbackFn: FilterCallback<T>): IterableActivity<T>;
-export function filter<T>(source: Source<T>, callbackFn: FilterCallback<T>): IterableIterator<T>;
-export function filter<T>(s_or_cb: Source<T> | FilterCallback<T>, callbackFn?: FilterCallback<T>): IterableActivity<T> | IterableIterator<T> {
-    return isSource(s_or_cb) ? filterGen(callbackFn!)(s_or_cb) : filterGen(s_or_cb);
-}
+import { IterableActivity, Source, isSource } from "./activity";
+
+export type FilterCallback<T> = (value: T, index: number) => boolean;
+
+function filterGen<T = any>(callbackFn: FilterCallback<T>): IterableActivity<T> {
+    return function* (source: Source<T>) {
+        let i = -1;
+        for (const item of source) {
+            if (callbackFn(item, ++i)) {
+                yield item;
+            }
+        }
+    };
+}
+
+export function filter<T = any>(callbackFn: FilterCallback<T>): IterableActivity<T>;
+export function filter<T>(source: Source<T>, callbackFn: FilterCallback<T>): IterableIterator<T>;
+export function filter<T>(s_or_cb: Source<T> | FilterCallback<T>, callbackFn?: FilterCallback<T>): IterableActivity<T> | IterableIterator<T> {
+    return isSource(s_or_cb) ? filterGen(callbackFn!)(s_or_cb) : filterGen(s_or_cb);
+}

package/src/activities/first.ts

@@ -1,20 +1,20 @@
-import { IterableActivity, isSource, Source } from "./activity";
-
-function firstGen<T = any>(n: number): IterableActivity<T, T> {
-    return function* (source: Source<T>) {
-        let i = 0;
-        for (const item of source) {
-            yield item;
-            if (++i >= n) {
-                break;
-            }
-        }
-    };
-}
-
-export function first<T = any>(n: number): IterableActivity<T, T>;
-export function first<T>(source: Source<T>, n: number): IterableIterator<T>;
-export function first<T = any>(s_or_n: Source<T> | number, n?: number): IterableActivity<T, T> | IterableIterator<T> {
-    if (!isSource(s_or_n)) return firstGen<T>(s_or_n);
-    return firstGen<T>(n!)(s_or_n);
-}
+import { IterableActivity, isSource, Source } from "./activity";
+
+function firstGen<T = any>(n: number): IterableActivity<T, T> {
+    return function* (source: Source<T>) {
+        let i = 0;
+        for (const item of source) {
+            yield item;
+            if (++i >= n) {
+                break;
+            }
+        }
+    };
+}
+
+export function first<T = any>(n: number): IterableActivity<T, T>;
+export function first<T>(source: Source<T>, n: number): IterableIterator<T>;
+export function first<T = any>(s_or_n: Source<T> | number, n?: number): IterableActivity<T, T> | IterableIterator<T> {
+    if (!isSource(s_or_n)) return firstGen<T>(s_or_n);
+    return firstGen<T>(n!)(s_or_n);
+}

package/src/activities/group.ts

@@ -1,27 +1,27 @@
-import { IterableActivity, Source, isSource } from "./activity";
-
-export type GroupFn<T> = (row: T, index: number) => number | string;
-export type GroupRow<T> = { key: string, value: T[] };
-
-function groupGen<T = any>(groupFn: GroupFn<T>): IterableActivity<T, GroupRow<T>> {
-    return function* (source: Source<T>) {
-        let i = -1;
-        const group: { [key: string]: T[] } = {};
-        for (const row of source) {
-            const key = groupFn(row, ++i);
-            if (!group[key]) {
-                group[key] = [];
-            }
-            group[key].push(row);
-        }
-        for (const key in group) {
-            yield { key, value: group[key] };
-        }
-    };
-}
-
-export function group<T>(groupByFn: GroupFn<T>): IterableActivity<T, GroupRow<T>>;
-export function group<T>(source: Source<T>, groupByFn: GroupFn<T>): IterableIterator<GroupRow<T>>;
-export function group<T>(s_or_gbf: Source<T> | GroupFn<T>, groupByFn?: GroupFn<T>): IterableActivity<T, GroupRow<T>> | IterableIterator<GroupRow<T>> {
-    return isSource(s_or_gbf) ? groupGen<T>(groupByFn!)(s_or_gbf) : groupGen<T>(s_or_gbf);
-}
+import { IterableActivity, Source, isSource } from "./activity";
+
+export type GroupFn<T> = (row: T, index: number) => number | string;
+export type GroupRow<T> = { key: string, value: T[] };
+
+function groupGen<T = any>(groupFn: GroupFn<T>): IterableActivity<T, GroupRow<T>> {
+    return function* (source: Source<T>) {
+        let i = -1;
+        const group: { [key: string]: T[] } = {};
+        for (const row of source) {
+            const key = groupFn(row, ++i);
+            if (!group[key]) {
+                group[key] = [];
+            }
+            group[key].push(row);
+        }
+        for (const key in group) {
+            yield { key, value: group[key] };
+        }
+    };
+}
+
+export function group<T>(groupByFn: GroupFn<T>): IterableActivity<T, GroupRow<T>>;
+export function group<T>(source: Source<T>, groupByFn: GroupFn<T>): IterableIterator<GroupRow<T>>;
+export function group<T>(s_or_gbf: Source<T> | GroupFn<T>, groupByFn?: GroupFn<T>): IterableActivity<T, GroupRow<T>> | IterableIterator<GroupRow<T>> {
+    return isSource(s_or_gbf) ? groupGen<T>(groupByFn!)(s_or_gbf) : groupGen<T>(s_or_gbf);
+}