feat: update pipe.ts to use unlimited vardic types (#4484)

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

.gitignore

@@ -7,6 +7,7 @@ dist/
 dist-test/
 build/
 lib*/
+coverage/
 !demos/storyboard/lib-umd/
 types/
 types-3.4/

packages/dataflow/.vscode/launch.json

@@ -18,7 +18,7 @@
             "request": "launch",
             "runtimeArgs": [
                 "run-script",
-                "test-node"
+                "test-vitest"
             ],
             "runtimeExecutable": "npm",
             "skipFiles": [
@@ -29,6 +29,25 @@
                 "!**/node_modules/**"
             ],
         },
+        {
+            "name": "test-node-pipe.spec.ts",
+            "type": "node",
+            "request": "launch",
+            "runtimeArgs": [
+                "run",
+                "test-vitest",
+                "--",
+                "./tests/pipe.spec.ts"
+            ],
+            "runtimeExecutable": "npm",
+            "skipFiles": [
+                "<node_internals>/**"
+            ],
+            "outFiles": [
+                "${workspaceFolder}/**/*.js",
+                "!**/node_modules/**"
+            ]
+        },
         {
             "name": "index.html",
             "request": "launch",

packages/dataflow/package.json

@@ -32,7 +32,10 @@
         "docs": "typedoc --options tdoptions.json .",
         "test-browser": "vitest run --project browser",
         "test-node": "vitest run --project node",
-        "test": "vitest run",
+        "test-types": "npx --yes tsc --project tsconfig.tests.json --noEmit",
+        "test-vitest": "vitest run",
+        "test": "run-s test-types test-vitest",
+        "bench": "vitest bench",
         "coverage": "vitest run --coverage",
         "update": "npx --yes npm-check-updates -u -t minor",
         "update-major": "npx --yes npm-check-updates -u"

packages/dataflow/src/utils/pipe.ts

@@ -1,15 +1,15 @@
 import { describe, it, expect } from "vitest";
-import { concat } from "@hpcc-js/dataflow";
+import { concat } from "../src/index.ts";
 
 describe("concat", () => {
-    it("generator", () => {
+    it("should concatenate arrays when used as curried activity", () => {
         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", () => {
+    it("should concatenate arrays when executed immediately", () => {
         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]);

packages/dataflow/tests/chain.spec.ts

@@ -1,10 +1,10 @@
 import { describe, it, expect } from "vitest";
-import { pipe, filter, count, scalar, sensor } from "@hpcc-js/dataflow";
+import { pipe, filter, count, scalar, sensor } from "../src/index.ts";
 import { population } from "./data.spec.ts";;
 
 describe("count", () => {
 
-    it("Population", () => {
+    it("should track count through pipeline with filters", () => {
         const s1 = count();
         const s2 = count();
         const p1 = pipe(
@@ -18,7 +18,7 @@ describe("count", () => {
         expect(data.length).to.equal(699);
     });
 
-    it("scalarActivity", () => {
+    it("should count items when used as scalar activity", () => {
         const countActivity = scalar(count());
         expect(countActivity([5, 1, 2, -3, 4])).to.equal(5);
     });

packages/dataflow/tests/concat.spec.ts

@@ -1,14 +1,20 @@
 import { describe, it, expect } from "vitest";
-import { deviation, scalar } from "@hpcc-js/dataflow";
+import { deviation, scalar } from "../src/index.ts";
 
 describe("deviation", () => {
-    it("scalarActivity", () => {
+    it("should calculate standard deviation when used as scalar activity", () => {
         const calcDeviation = scalar(deviation());
         expect(calcDeviation([5, 1, 2, 3, 4])).to.equal(Math.sqrt(2.5));
     });
 
-    it("empty array", () => {
+    it("should return undefined for empty array", () => {
         const deviationActivity = scalar(deviation());
         expect(deviationActivity([])).to.be.undefined;
     });
+
+    it("with accessor callback", () => {
+        const data = [{ value: 5 }, { value: 1 }, { value: 2 }, { value: 3 }, { value: 4 }];
+        const calcDeviation = scalar(deviation((d: { value: number }) => d.value));
+        expect(calcDeviation(data)).to.equal(Math.sqrt(2.5));
+    });
 });

packages/dataflow/tests/count.spec.ts

@@ -1,9 +1,9 @@
 import { describe, it, expect } from "vitest";
-import { distribution, scalar } from "@hpcc-js/dataflow";
+import { distribution, scalar } from "../src/index.ts";
 
 describe("distribution", () => {
 
-    it("scalarActivity", () => {
+    it("should calculate full distribution statistics", () => {
         const calcDistribution = scalar(distribution());
         expect(calcDistribution([5, 1, 2, 3, 4])).to.deep.equal({
             min: 1,
@@ -14,8 +14,20 @@ describe("distribution", () => {
         });
     });
 
-    it("empty array", () => {
+    it("should return undefined for empty array", () => {
         const a1 = scalar(distribution());
         expect(a1([])).to.be.undefined;
     });
+
+    it("with accessor callback", () => {
+        const data = [{ value: 5 }, { value: 1 }, { value: 2 }, { value: 3 }, { value: 4 }];
+        const calcDistribution = scalar(distribution((d: { value: number }) => d.value));
+        expect(calcDistribution(data)).to.deep.equal({
+            min: 1,
+            mean: 3,
+            max: 5,
+            deviation: Math.sqrt(2.5),
+            variance: 2.5
+        });
+    });
 });

packages/dataflow/tests/deviation.spec.ts

@@ -1,13 +1,13 @@
 import { describe, it, expect } from "vitest";
-import { each } from "@hpcc-js/dataflow";
+import { each } from "../src/index.ts";
 import { population } from "./data.spec.ts";;
 
 describe("each", () => {
-    it("generator", () => {
+    it("should execute callback for each item when used as curried activity", () => {
         [...each((row, i) => expect(row).to.equal(population[i]))(population)];
     });
 
-    it("scalarActivity", () => {
+    it("should execute callback for each item when executed immediately", () => {
         [...each(population, (row, i) => expect(row).to.equal(population[i]))];
     });
 });