@hpcc-js/dataflow 8.0.1 → 8.1.1

package/src/__tests__/concat.ts

@@ -1,18 +1,18 @@
-import { expect } from "chai";
-import { concat } from "../index";
-
-describe("concat", () => {
-    it("generator", () => {
-        expect([...concat([])([])]).to.deep.equal([]);
-        expect([...concat([1, 2, 3])([])]).to.deep.equal([1, 2, 3]);
-        expect([...concat<number>([])([1, 2, 3])]).to.deep.equal([1, 2, 3]);
-        expect([...concat([4, 5, 6])([1, 2, 3])]).to.deep.equal([1, 2, 3, 4, 5, 6]);
-    });
-
-    it("scalarActivity", () => {
-        expect([...concat([], [])]).to.deep.equal([]);
-        expect([...concat([], [1, 2, 3])]).to.deep.equal([1, 2, 3]);
-        expect([...concat([1, 2, 3], [])]).to.deep.equal([1, 2, 3]);
-        expect([...concat([1, 2, 3], [4, 5, 6])]).to.deep.equal([1, 2, 3, 4, 5, 6]);
-    });
-});
+import { expect } from "chai";
+import { concat } from "../index";
+
+describe("concat", () => {
+    it("generator", () => {
+        expect([...concat([])([])]).to.deep.equal([]);
+        expect([...concat([1, 2, 3])([])]).to.deep.equal([1, 2, 3]);
+        expect([...concat<number>([])([1, 2, 3])]).to.deep.equal([1, 2, 3]);
+        expect([...concat([4, 5, 6])([1, 2, 3])]).to.deep.equal([1, 2, 3, 4, 5, 6]);
+    });
+
+    it("scalarActivity", () => {
+        expect([...concat([], [])]).to.deep.equal([]);
+        expect([...concat([], [1, 2, 3])]).to.deep.equal([1, 2, 3]);
+        expect([...concat([1, 2, 3], [])]).to.deep.equal([1, 2, 3]);
+        expect([...concat([1, 2, 3], [4, 5, 6])]).to.deep.equal([1, 2, 3, 4, 5, 6]);
+    });
+});

package/src/__tests__/count.ts

@@ -1,25 +1,25 @@
-import { expect } from "chai";
-import { pipe, filter, count, scalar, sensor } from "../index";
-import { population } from "./data";
-
-describe("count", () => {
-
-    it("Population", () => {
-        const s1 = count();
-        const s2 = count();
-        const p1 = pipe(
-            sensor(s1),
-            filter(r => r.age > 30),
-            sensor(s2),
-        );
-        const data = [...p1(population)];
-        expect(s1.peek()).to.equal(1000);
-        expect(s2.peek()).to.equal(699);
-        expect(data.length).to.equal(699);
-    });
-
-    it("scalarActivity", () => {
-        const countActivity = scalar(count());
-        expect(countActivity([5, 1, 2, -3, 4])).to.equal(5);
-    });
-});
+import { expect } from "chai";
+import { pipe, filter, count, scalar, sensor } from "../index";
+import { population } from "./data";
+
+describe("count", () => {
+
+    it("Population", () => {
+        const s1 = count();
+        const s2 = count();
+        const p1 = pipe(
+            sensor(s1),
+            filter(r => r.age > 30),
+            sensor(s2),
+        );
+        const data = [...p1(population)];
+        expect(s1.peek()).to.equal(1000);
+        expect(s2.peek()).to.equal(699);
+        expect(data.length).to.equal(699);
+    });
+
+    it("scalarActivity", () => {
+        const countActivity = scalar(count());
+        expect(countActivity([5, 1, 2, -3, 4])).to.equal(5);
+    });
+});

package/src/__tests__/data.ts

@@ -1,64 +1,64 @@
-import * as faker from "faker";
-import { expect } from "chai";
-
-faker.seed(123);
-
-export function person() {
-    return {
-        "fname": faker.name.firstName(),
-        "lname": faker.name.lastName(),
-        "age": faker.random.number(50) + 16,
-        "job": faker.name.jobType(),
-        "username": faker.internet.userName(),
-        "email": faker.internet.email(),
-        "address": {
-            "street": faker.address.streetName(),
-            "suite": faker.address.secondaryAddress(),
-            "city": faker.address.city(),
-            "zipcode": faker.address.zipCode(),
-            "state": faker.address.stateAbbr(),
-            "geo": {
-                "lat": faker.address.latitude(),
-                "lng": faker.address.longitude()
-            }
-        },
-        "phone": faker.phone.phoneNumber(),
-        "website": faker.internet.domainName(),
-        "company": {
-            "name": faker.company.companyName(),
-            "catchPhrase": faker.company.catchPhrase(),
-            "bs": faker.company.bs()
-        }
-    };
-}
-export type Person = ReturnType<typeof person>;
-
-export function* people(total = 1000) {
-    for (let i = 0; i < total; ++i) {
-        yield person();
-    }
-}
-
-function personLite() {
-    return {
-        "fname": faker.name.firstName(),
-        "lname": faker.name.lastName(),
-        "zipcode": faker.address.zipCode(),
-        "state": faker.address.stateAbbr()
-    };
-}
-export type PersonLite = ReturnType<typeof person>;
-
-export function* peopleLite(total = 1000) {
-    for (let i = 0; i < total; ++i) {
-        yield personLite();
-    }
-}
-
-export const population: Person[] = [...people()];
-
-describe("data", () => {
-    it("generate", () => {
-        expect(population).to.have.lengthOf(1000);
-    });
-});
+import * as faker from "faker";
+import { expect } from "chai";
+
+faker.seed(123);
+
+export function person() {
+    return {
+        "fname": faker.name.firstName(),
+        "lname": faker.name.lastName(),
+        "age": faker.random.number(50) + 16,
+        "job": faker.name.jobType(),
+        "username": faker.internet.userName(),
+        "email": faker.internet.email(),
+        "address": {
+            "street": faker.address.streetName(),
+            "suite": faker.address.secondaryAddress(),
+            "city": faker.address.city(),
+            "zipcode": faker.address.zipCode(),
+            "state": faker.address.stateAbbr(),
+            "geo": {
+                "lat": faker.address.latitude(),
+                "lng": faker.address.longitude()
+            }
+        },
+        "phone": faker.phone.phoneNumber(),
+        "website": faker.internet.domainName(),
+        "company": {
+            "name": faker.company.companyName(),
+            "catchPhrase": faker.company.catchPhrase(),
+            "bs": faker.company.bs()
+        }
+    };
+}
+export type Person = ReturnType<typeof person>;
+
+export function* people(total = 1000) {
+    for (let i = 0; i < total; ++i) {
+        yield person();
+    }
+}
+
+function personLite() {
+    return {
+        "fname": faker.name.firstName(),
+        "lname": faker.name.lastName(),
+        "zipcode": faker.address.zipCode(),
+        "state": faker.address.stateAbbr()
+    };
+}
+export type PersonLite = ReturnType<typeof person>;
+
+export function* peopleLite(total = 1000) {
+    for (let i = 0; i < total; ++i) {
+        yield personLite();
+    }
+}
+
+export const population: Person[] = [...people()];
+
+describe("data", () => {
+    it("generate", () => {
+        expect(population).to.have.lengthOf(1000);
+    });
+});

package/src/__tests__/deviation.ts

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

package/src/__tests__/distribution.ts

@@ -1,21 +1,21 @@
-import { expect } from "chai";
-import { distribution, scalar } from "../index";
-
-describe("distribution", () => {
-
-    it("scalarActivity", () => {
-        const calcDistribution = scalar(distribution());
-        expect(calcDistribution([5, 1, 2, 3, 4])).to.deep.equal({
-            min: 1,
-            mean: 3,
-            max: 5,
-            deviation: Math.sqrt(2.5),
-            variance: 2.5
-        });
-    });
-
-    it("empty array", () => {
-        const a1 = scalar(distribution());
-        expect(a1([])).to.be.undefined;
-    });
-});
+import { expect } from "chai";
+import { distribution, scalar } from "../index";
+
+describe("distribution", () => {
+
+    it("scalarActivity", () => {
+        const calcDistribution = scalar(distribution());
+        expect(calcDistribution([5, 1, 2, 3, 4])).to.deep.equal({
+            min: 1,
+            mean: 3,
+            max: 5,
+            deviation: Math.sqrt(2.5),
+            variance: 2.5
+        });
+    });
+
+    it("empty array", () => {
+        const a1 = scalar(distribution());
+        expect(a1([])).to.be.undefined;
+    });
+});

package/src/__tests__/each.ts

@@ -1,13 +1,13 @@
-import { expect } from "chai";
-import { each } from "../index";
-import { population } from "./data";
-
-describe("each", () => {
-    it("generator", () => {
-        [...each((row, i) => expect(row).to.equal(population[i]))(population)];
-    });
-
-    it("scalarActivity", () => {
-        [...each(population, (row, i) => expect(row).to.equal(population[i]))];
-    });
-});
+import { expect } from "chai";
+import { each } from "../index";
+import { population } from "./data";
+
+describe("each", () => {
+    it("generator", () => {
+        [...each((row, i) => expect(row).to.equal(population[i]))(population)];
+    });
+
+    it("scalarActivity", () => {
+        [...each(population, (row, i) => expect(row).to.equal(population[i]))];
+    });
+});

package/src/__tests__/entries.ts

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

package/src/__tests__/extent.ts

@@ -1,25 +1,25 @@
-import { expect } from "chai";
-import { pipe, filter, extent, scalar, sensor } from "../index";
-import { population } from "./data";
-
-describe("max", () => {
-
-    it("Population", () => {
-        const s1 = extent(r => r.age);
-        const s2 = extent(r => r.age);
-        const p1 = pipe(
-            sensor(s1),
-            filter(r => r.age > 30),
-            sensor(s2),
-        );
-        const data = [...p1(population)];
-        expect(data.length).to.equal(699);
-        expect(s1.peek()).to.deep.equal([16, 66]);
-        expect(s2.peek()).to.deep.equal([31, 66]);
-    });
-
-    it("scalarActivity", () => {
-        const extentActivity = scalar(extent());
-        expect(extentActivity([5, 1, 2, -3, 4])).to.deep.equal([-3, 5]);
-    });
-});
+import { expect } from "chai";
+import { pipe, filter, extent, scalar, sensor } from "../index";
+import { population } from "./data";
+
+describe("max", () => {
+
+    it("Population", () => {
+        const s1 = extent(r => r.age);
+        const s2 = extent(r => r.age);
+        const p1 = pipe(
+            sensor(s1),
+            filter(r => r.age > 30),
+            sensor(s2),
+        );
+        const data = [...p1(population)];
+        expect(data.length).to.equal(699);
+        expect(s1.peek()).to.deep.equal([16, 66]);
+        expect(s2.peek()).to.deep.equal([31, 66]);
+    });
+
+    it("scalarActivity", () => {
+        const extentActivity = scalar(extent());
+        expect(extentActivity([5, 1, 2, -3, 4])).to.deep.equal([-3, 5]);
+    });
+});

package/src/__tests__/filter.ts

@@ -1,16 +1,16 @@
-import { expect } from "chai";
-import { filter } from "../index";
-import { population } from "./data";
-
-const testFilter = row => row.address.state === "FL";
-const expected = population.filter(testFilter);
-
-describe("filter", () => {
-    it("generator", () => {
-        expect([...filter(testFilter)(population)]).to.deep.equal(expected);
-    });
-
-    it("scalarActivity", () => {
-        expect([...filter(population, testFilter)]).to.deep.equal(expected);
-    });
-});
+import { expect } from "chai";
+import { filter } from "../index";
+import { population } from "./data";
+
+const testFilter = row => row.address.state === "FL";
+const expected = population.filter(testFilter);
+
+describe("filter", () => {
+    it("generator", () => {
+        expect([...filter(testFilter)(population)]).to.deep.equal(expected);
+    });
+
+    it("scalarActivity", () => {
+        expect([...filter(population, testFilter)]).to.deep.equal(expected);
+    });
+});

package/src/__tests__/first.ts

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

package/src/__tests__/generate.ts

@@ -1,9 +1,9 @@
-import { expect } from "chai";
-import { generate } from "../index";
-
-describe("generate", () => {
-    it("basic", () => {
-        expect([...generate(Math.random, 22)]).to.be.lengthOf(22);
-    });
-
-});
+import { expect } from "chai";
+import { generate } from "../index";
+
+describe("generate", () => {
+    it("basic", () => {
+        expect([...generate(Math.random, 22)]).to.be.lengthOf(22);
+    });
+
+});

package/src/__tests__/group.ts

@@ -1,19 +1,19 @@
-import { expect } from "chai";
-import { group } from "../index";
-import { Person, population } from "./data";
-
-describe("group", () => {
-    it("generator", () => {
-        const gb = [...group<Person>(row => row.address.state)(population)];
-        expect(gb).to.have.length;
-        expect(gb[0].key).to.exist;
-        expect(gb[0].value).to.have.length;
-    });
-
-    it("scalarActivity", () => {
-        const gb = [...group(population, row => row.address.state)];
-        expect(gb).to.have.length;
-        expect(gb[0].key).to.exist;
-        expect(gb[0].value).to.have.length;
-    });
-});
+import { expect } from "chai";
+import { group } from "../index";
+import { Person, population } from "./data";
+
+describe("group", () => {
+    it("generator", () => {
+        const gb = [...group<Person>(row => row.address.state)(population)];
+        expect(gb).to.have.length;
+        expect(gb[0].key).to.exist;
+        expect(gb[0].value).to.have.length;
+    });
+
+    it("scalarActivity", () => {
+        const gb = [...group(population, row => row.address.state)];
+        expect(gb).to.have.length;
+        expect(gb[0].key).to.exist;
+        expect(gb[0].value).to.have.length;
+    });
+});

package/src/__tests__/histogram.ts

@@ -1,47 +1,47 @@
-import { expect } from "chai";
-import { histogram } from "../index";
-import { people, Person, population } from "./data";
-
-describe("histogram", () => {
-    it("generator", () => {
-        const h = [...histogram<Person>(row => row.age, { buckets: 10 })(population)];
-        expect(h).to.have.length;
-        expect(h.length).to.equal(10);
-        expect(h[0].from).to.exist;
-        expect(h[0].to).to.exist;
-        expect(h[0].value).to.have.length;
-
-        const h2 = [...histogram<Person>(row => row.age, { min: 15, range: 5 })(population)];
-        expect(h2).to.have.length;
-        expect(h2.length).to.equal(11);
-    });
-
-    it("generator 2", () => {
-        const h = [...histogram<Person>(row => row.age, { buckets: 10 })(people())];
-        expect(h).to.have.length;
-        expect(h.length).to.equal(10);
-        expect(h[0].from).to.exist;
-        expect(h[0].to).to.exist;
-        expect(h[0].value).to.have.length;
-
-        const h2 = [...histogram<Person>(row => row.age, { min: 15, range: 5 })(people())];
-        expect(h2).to.have.length;
-        expect(h2.length).to.equal(11);
-    });
-
-    it("scalarActivity", () => {
-        const h = [...histogram(population, row => row.age, { buckets: 10 })];
-        expect(h).to.have.length;
-        expect(h[0].from).to.exist;
-        expect(h[0].to).to.exist;
-        expect(h[0].value).to.have.length;
-    });
-
-    it("readme", () => {
-        const data = [1, 12, 13, 13, 3, 14, 19, 6];
-        const h = [...histogram(data, n => n, { buckets: 3 })];
-        expect(h).to.have.length;
-        const h2 = [...histogram(data, n => n, { min: 0, range: 5 })];
-        expect(h2).to.have.length;
-    });
-});
+import { expect } from "chai";
+import { histogram } from "../index";
+import { people, Person, population } from "./data";
+
+describe("histogram", () => {
+    it("generator", () => {
+        const h = [...histogram<Person>(row => row.age, { buckets: 10 })(population)];
+        expect(h).to.have.length;
+        expect(h.length).to.equal(10);
+        expect(h[0].from).to.exist;
+        expect(h[0].to).to.exist;
+        expect(h[0].value).to.have.length;
+
+        const h2 = [...histogram<Person>(row => row.age, { min: 15, range: 5 })(population)];
+        expect(h2).to.have.length;
+        expect(h2.length).to.equal(11);
+    });
+
+    it("generator 2", () => {
+        const h = [...histogram<Person>(row => row.age, { buckets: 10 })(people())];
+        expect(h).to.have.length;
+        expect(h.length).to.equal(10);
+        expect(h[0].from).to.exist;
+        expect(h[0].to).to.exist;
+        expect(h[0].value).to.have.length;
+
+        const h2 = [...histogram<Person>(row => row.age, { min: 15, range: 5 })(people())];
+        expect(h2).to.have.length;
+        expect(h2.length).to.equal(11);
+    });
+
+    it("scalarActivity", () => {
+        const h = [...histogram(population, row => row.age, { buckets: 10 })];
+        expect(h).to.have.length;
+        expect(h[0].from).to.exist;
+        expect(h[0].to).to.exist;
+        expect(h[0].value).to.have.length;
+    });
+
+    it("readme", () => {
+        const data = [1, 12, 13, 13, 3, 14, 19, 6];
+        const h = [...histogram(data, n => n, { buckets: 3 })];
+        expect(h).to.have.length;
+        const h2 = [...histogram(data, n => n, { min: 0, range: 5 })];
+        expect(h2).to.have.length;
+    });
+});

package/src/__tests__/map.ts

@@ -1,16 +1,16 @@
-import { expect } from "chai";
-import { map } from "../index";
-import { population } from "./data";
-
-const testMap = row => ({ ...row.address });
-const expected = population.map(testMap);
-
-describe("map", () => {
-    it("generator", () => {
-        expect([...map(testMap)(population)]).to.deep.equal(expected);
-    });
-
-    it("scalarActivity", () => {
-        expect([...map(population, testMap)]).to.deep.equal(expected);
-    });
-});
+import { expect } from "chai";
+import { map } from "../index";
+import { population } from "./data";
+
+const testMap = row => ({ ...row.address });
+const expected = population.map(testMap);
+
+describe("map", () => {
+    it("generator", () => {
+        expect([...map(testMap)(population)]).to.deep.equal(expected);
+    });
+
+    it("scalarActivity", () => {
+        expect([...map(population, testMap)]).to.deep.equal(expected);
+    });
+});