@hpcc-js/dataflow 9.2.0 → 9.2.1

package/src/observers/extent.ts

@@ -1,24 +1,24 @@
-import { AccessorT, Observer, Accessor } from "./observer.ts";
-import { max } from "./max.ts";
-import { min } from "./min.ts";
-
-function _extent(): Observer<number, [number, number]> {
-    const minFO = min();
-    const maxFO = max();
-
-    return {
-        observe: (value: number, idx: number) => {
-            minFO.observe(value, idx);
-            maxFO.observe(value, idx);
-        },
-        peek: () => [minFO.peek(), maxFO.peek()]
-    };
-}
-
-export type ExtentAccessor<T> = AccessorT<T, number>;
-
-export function extent(): Observer<number, [number, number]>;
-export function extent<T = any>(callbackFn: ExtentAccessor<T>): Observer<T, [number, number]>;
-export function extent<T = any>(callbackFn?: ExtentAccessor<T>): Observer<number, [number, number]> | Observer<T, [number, number]> {
-    return callbackFn ? Accessor(_extent, callbackFn) : _extent();
-}
+import { AccessorT, Observer, Accessor } from "./observer";
+import { max } from "./max";
+import { min } from "./min";
+
+function _extent(): Observer<number, [number, number]> {
+    const minFO = min();
+    const maxFO = max();
+
+    return {
+        observe: (value: number, idx: number) => {
+            minFO.observe(value, idx);
+            maxFO.observe(value, idx);
+        },
+        peek: () => [minFO.peek(), maxFO.peek()]
+    };
+}
+
+export type ExtentAccessor<T> = AccessorT<T, number>;
+
+export function extent(): Observer<number, [number, number]>;
+export function extent<T = any>(callbackFn: ExtentAccessor<T>): Observer<T, [number, number]>;
+export function extent<T = any>(callbackFn?: ExtentAccessor<T>): Observer<number, [number, number]> | Observer<T, [number, number]> {
+    return callbackFn ? Accessor(_extent, callbackFn) : _extent();
+}

package/src/observers/max.ts

@@ -1,24 +1,24 @@
-import { Observer, Accessor, AccessorT } from "./observer.ts";
-
-function _max(): Observer<number, number> {
-    let max: number;
-
-    return {
-        observe: (value: number, idx: number) => {
-            if (idx === 0) {
-                max = value;
-            } else if (max < value) {
-                max = value;
-            }
-        },
-        peek: () => max
-    };
-}
-
-export type MaxAccessor<T> = AccessorT<T, number>;
-
-export function max(): Observer<number, number>;
-export function max<T = any>(callbackFn: MaxAccessor<T>): Observer<T, number>;
-export function max<T = any>(callbackFn?: MaxAccessor<T>): Observer<number, number> | Observer<T, number> {
-    return callbackFn ? Accessor(_max, callbackFn) : _max();
-}
+import { Observer, Accessor, AccessorT } from "./observer";
+
+function _max(): Observer<number, number> {
+    let max: number;
+
+    return {
+        observe: (value: number, idx: number) => {
+            if (idx === 0) {
+                max = value;
+            } else if (max < value) {
+                max = value;
+            }
+        },
+        peek: () => max
+    };
+}
+
+export type MaxAccessor<T> = AccessorT<T, number>;
+
+export function max(): Observer<number, number>;
+export function max<T = any>(callbackFn: MaxAccessor<T>): Observer<T, number>;
+export function max<T = any>(callbackFn?: MaxAccessor<T>): Observer<number, number> | Observer<T, number> {
+    return callbackFn ? Accessor(_max, callbackFn) : _max();
+}

package/src/observers/mean.ts

@@ -1,26 +1,26 @@
-import { Observer, Accessor } from "./observer.ts";
-
-function _mean(): Observer<number, number> {
-    let total: number;
-    let count: number;
-
-    return {
-        observe: (value: number, idx: number) => {
-            if (idx === 0) {
-                total = value;
-            } else {
-                total += value;
-            }
-            count = idx;
-        },
-        peek: () => total / (count + 1)
-    };
-}
-
-export type MeanAccessor<T> = (row: T, currentIndex: number) => number;
-
-export function mean(): Observer<number, number>;
-export function mean<T = any>(callbackFn: MeanAccessor<T>): Observer<T, number>;
-export function mean<T = any>(callbackFn?: MeanAccessor<T>): Observer<number, number> | Observer<T, number> {
-    return callbackFn ? Accessor(_mean, callbackFn) : _mean();
-}
+import { Observer, Accessor } from "./observer";
+
+function _mean(): Observer<number, number> {
+    let total: number;
+    let count: number;
+
+    return {
+        observe: (value: number, idx: number) => {
+            if (idx === 0) {
+                total = value;
+            } else {
+                total += value;
+            }
+            count = idx;
+        },
+        peek: () => total / (count + 1)
+    };
+}
+
+export type MeanAccessor<T> = (row: T, currentIndex: number) => number;
+
+export function mean(): Observer<number, number>;
+export function mean<T = any>(callbackFn: MeanAccessor<T>): Observer<T, number>;
+export function mean<T = any>(callbackFn?: MeanAccessor<T>): Observer<number, number> | Observer<T, number> {
+    return callbackFn ? Accessor(_mean, callbackFn) : _mean();
+}

package/src/observers/median.ts

@@ -1,31 +1,31 @@
-import { AccessorT, Observer, Accessor } from "./observer.ts";
-
-function _median(): Observer<number, number> {
-    let values: number[];
-
-    return {
-        observe: (value: number, idx: number) => {
-            if (idx === 0) {
-                values = [];
-            }
-            values.push(value);
-        },
-        peek: () => {
-            const sorted = values.sort((l, r) => l - r);
-            const mid = sorted.length / 2;
-            if (sorted.length % 2 === 0) {
-                return (sorted[mid - 1] + sorted[mid]) / 2;
-            } else {
-                return sorted[Math.floor(mid)];
-            }
-        }
-    };
-}
-
-export type MedianAccessor<T> = AccessorT<T, number>;
-
-export function median(): Observer<number, number>;
-export function median<T = any>(callbackFn: MedianAccessor<T>): Observer<T, number>;
-export function median<T = any>(callbackFn?: MedianAccessor<T>): Observer<number, number> | Observer<T, number> {
-    return callbackFn ? Accessor(_median, callbackFn) : _median();
+import { AccessorT, Observer, Accessor } from "./observer";
+
+function _median(): Observer<number, number> {
+    let values: number[];
+
+    return {
+        observe: (value: number, idx: number) => {
+            if (idx === 0) {
+                values = [];
+            }
+            values.push(value);
+        },
+        peek: () => {
+            const sorted = values.sort((l, r) => l - r);
+            const mid = sorted.length / 2;
+            if (sorted.length % 2 === 0) {
+                return (sorted[mid - 1] + sorted[mid]) / 2;
+            } else {
+                return sorted[Math.floor(mid)];
+            }
+        }
+    };
+}
+
+export type MedianAccessor<T> = AccessorT<T, number>;
+
+export function median(): Observer<number, number>;
+export function median<T = any>(callbackFn: MedianAccessor<T>): Observer<T, number>;
+export function median<T = any>(callbackFn?: MedianAccessor<T>): Observer<number, number> | Observer<T, number> {
+    return callbackFn ? Accessor(_median, callbackFn) : _median();
 }

package/src/observers/min.ts

@@ -1,24 +1,24 @@
-import { Observer, Accessor, AccessorT } from "./observer.ts";
-
-function _min(): Observer<number, number> {
-    let min: number;
-
-    return {
-        observe: (value: number, idx: number) => {
-            if (idx === 0) {
-                min = value;
-            } else if (min > value) {
-                min = value;
-            }
-        },
-        peek: () => min
-    };
-}
-
-export type MinAccessor<T> = AccessorT<T, number>;
-
-export function min(): Observer<number, number>;
-export function min<T = any>(callbackFn: MinAccessor<T>): Observer<T, number>;
-export function min<T = any>(callbackFn?: MinAccessor<T>): Observer<number, number> | Observer<T, number> {
-    return callbackFn ? Accessor(_min, callbackFn) : _min();
-}
+import { Observer, Accessor, AccessorT } from "./observer";
+
+function _min(): Observer<number, number> {
+    let min: number;
+
+    return {
+        observe: (value: number, idx: number) => {
+            if (idx === 0) {
+                min = value;
+            } else if (min > value) {
+                min = value;
+            }
+        },
+        peek: () => min
+    };
+}
+
+export type MinAccessor<T> = AccessorT<T, number>;
+
+export function min(): Observer<number, number>;
+export function min<T = any>(callbackFn: MinAccessor<T>): Observer<T, number>;
+export function min<T = any>(callbackFn?: MinAccessor<T>): Observer<number, number> | Observer<T, number> {
+    return callbackFn ? Accessor(_min, callbackFn) : _min();
+}

package/src/observers/observer.ts

@@ -1,52 +1,52 @@
-import { Source } from "../activities/activity.ts";
-import { each } from "../activities/each.ts";
-
-export type AccessorT<T, U> = (row: T, currentIndex: number) => U;
-
-export interface ObserverFactory<T, U> {
-    (): Observer<T, U>;
-}
-
-export interface Observer<T, U> {
-    observe(r: T, idx: number): void;
-    peek(): U;
-}
-
-export function Accessor<T = any, U = any, V = any>(fof: ObserverFactory<V, U>, accesor: AccessorT<T, V>): Observer<T, U> {
-    const s = fof();
-
-    return {
-        observe: (_: T, i: number) => {
-            s.observe(accesor(_, i), i);
-        },
-        peek: s.peek
-    };
-}
-
-//  This is an pass through activity so a FlowObserver can be inserted into a pipeline ---
-export function sensor<T, U = any>(s: Observer<T, U>) {
-    return each((r, i) => s.observe(r, i));
-}
-
-//  This converts a FlowObserver to an Activity ---
-export function activity<T, U>(s: Observer<T, U>) {
-    return function* (source: Source<T>) {
-        let i = -1;
-        for (const row of source) {
-            s.observe(row, ++i);
-        }
-        yield s.peek();
-    };
-}
-
-//  This converts a FlowObserver to an ScalarActivity ---
-export function scalar<T = any, U = any>(s: Observer<T, U>) {
-    return function (source: Source<T>) {
-        let i = -1;
-        for (const row of source) {
-            s.observe(row, ++i);
-        }
-        return s.peek();
-    };
-}
-
+import { Source } from "../activities/activity";
+import { each } from "../activities/each";
+
+export type AccessorT<T, U> = (row: T, currentIndex: number) => U;
+
+export interface ObserverFactory<T, U> {
+    (): Observer<T, U>;
+}
+
+export interface Observer<T, U> {
+    observe(r: T, idx: number): void;
+    peek(): U;
+}
+
+export function Accessor<T = any, U = any, V = any>(fof: ObserverFactory<V, U>, accesor: AccessorT<T, V>): Observer<T, U> {
+    const s = fof();
+
+    return {
+        observe: (_: T, i: number) => {
+            s.observe(accesor(_, i), i);
+        },
+        peek: s.peek
+    };
+}
+
+//  This is an pass through activity so a FlowObserver can be inserted into a pipeline ---
+export function sensor<T, U = any>(s: Observer<T, U>) {
+    return each((r, i) => s.observe(r, i));
+}
+
+//  This converts a FlowObserver to an Activity ---
+export function activity<T, U>(s: Observer<T, U>) {
+    return function* (source: Source<T>) {
+        let i = -1;
+        for (const row of source) {
+            s.observe(row, ++i);
+        }
+        yield s.peek();
+    };
+}
+
+//  This converts a FlowObserver to an ScalarActivity ---
+export function scalar<T = any, U = any>(s: Observer<T, U>) {
+    return function (source: Source<T>) {
+        let i = -1;
+        for (const row of source) {
+            s.observe(row, ++i);
+        }
+        return s.peek();
+    };
+}
+

package/src/observers/quartile.ts

@@ -1,44 +1,44 @@
-import { median } from "./median.ts";
-import { AccessorT, Observer, Accessor, scalar } from "./observer.ts";
-
-export type QuartileAccessor<T> = AccessorT<T, number>;
-
-export type QuartileT = [number, number, number, number, number] | undefined;
-
-function _quartile(): Observer<number, QuartileT> {
-    let values: number[];
-
-    return {
-        observe: (value: number, idx: number) => {
-            if (idx === 0) {
-                values = [];
-            }
-            values.push(value);
-        },
-        peek: () => {
-            const sorted = values.sort((l, r) => l - r);
-            const mid = sorted.length / 2;
-            let medianVal: number;
-            let lower: number[];
-            let upper: number[];
-            if (sorted.length < 2) {
-                return undefined;
-            } else if (sorted.length % 2 === 0) {
-                medianVal = (sorted[mid - 1] + sorted[mid]) / 2;
-                lower = sorted.slice(0, mid);
-                upper = sorted.slice(mid);
-            } else {
-                medianVal = sorted[Math.floor(mid)];
-                lower = sorted.slice(0, Math.floor(mid));
-                upper = sorted.slice(Math.ceil(mid));
-            }
-            return [sorted[0], scalar(median())(lower)!, medianVal, scalar(median())(upper)!, sorted[sorted.length - 1]];
-        }
-    };
-}
-
-export function quartile(): Observer<number, QuartileT>;
-export function quartile<T = any>(callbackFn: QuartileAccessor<T>): Observer<T, QuartileT>;
-export function quartile<T = any>(callbackFn?: QuartileAccessor<T>): Observer<number, QuartileT> | Observer<T, QuartileT> {
-    return callbackFn ? Accessor(_quartile, callbackFn) : _quartile();
+import { median } from "./median";
+import { AccessorT, Observer, Accessor, scalar } from "./observer";
+
+export type QuartileAccessor<T> = AccessorT<T, number>;
+
+export type QuartileT = [number, number, number, number, number] | undefined;
+
+function _quartile(): Observer<number, QuartileT> {
+    let values: number[];
+
+    return {
+        observe: (value: number, idx: number) => {
+            if (idx === 0) {
+                values = [];
+            }
+            values.push(value);
+        },
+        peek: () => {
+            const sorted = values.sort((l, r) => l - r);
+            const mid = sorted.length / 2;
+            let medianVal: number;
+            let lower: number[];
+            let upper: number[];
+            if (sorted.length < 2) {
+                return undefined;
+            } else if (sorted.length % 2 === 0) {
+                medianVal = (sorted[mid - 1] + sorted[mid]) / 2;
+                lower = sorted.slice(0, mid);
+                upper = sorted.slice(mid);
+            } else {
+                medianVal = sorted[Math.floor(mid)];
+                lower = sorted.slice(0, Math.floor(mid));
+                upper = sorted.slice(Math.ceil(mid));
+            }
+            return [sorted[0], scalar(median())(lower)!, medianVal, scalar(median())(upper)!, sorted[sorted.length - 1]];
+        }
+    };
+}
+
+export function quartile(): Observer<number, QuartileT>;
+export function quartile<T = any>(callbackFn: QuartileAccessor<T>): Observer<T, QuartileT>;
+export function quartile<T = any>(callbackFn?: QuartileAccessor<T>): Observer<number, QuartileT> | Observer<T, QuartileT> {
+    return callbackFn ? Accessor(_quartile, callbackFn) : _quartile();
 }

package/src/observers/reduce.ts

@@ -1,22 +1,22 @@
-import { Observer } from "./observer.ts";
-
-export type ReduceCallback<T, U> = (previousValue: U, currentValue: T, currentIndex: number) => U;
-
-function _reduce<T, U>(callback: ReduceCallback<T, U>, initialValue?: U): Observer<T, U> {
-    let reduced: U;
-
-    return {
-        observe: (value: T, idx: number) => {
-            if (idx === 0) {
-                reduced = initialValue === undefined ? (value as unknown as U) : callback(initialValue, value, idx);
-            } else {
-                reduced = callback(reduced, value, idx);
-            }
-        },
-        peek: () => reduced
-    };
-}
-
-export function reduce<T = any, U = any>(callbackFn: ReduceCallback<T, U>, initialValue?: U): Observer<T, U> {
-    return _reduce(callbackFn, initialValue);
-}
+import { Observer } from "./observer";
+
+export type ReduceCallback<T, U> = (previousValue: U, currentValue: T, currentIndex: number) => U;
+
+function _reduce<T, U>(callback: ReduceCallback<T, U>, initialValue?: U): Observer<T, U> {
+    let reduced: U;
+
+    return {
+        observe: (value: T, idx: number) => {
+            if (idx === 0) {
+                reduced = initialValue === undefined ? (value as unknown as U) : callback(initialValue, value, idx);
+            } else {
+                reduced = callback(reduced, value, idx);
+            }
+        },
+        peek: () => reduced
+    };
+}
+
+export function reduce<T = any, U = any>(callbackFn: ReduceCallback<T, U>, initialValue?: U): Observer<T, U> {
+    return _reduce(callbackFn, initialValue);
+}

package/src/observers/variance.ts

@@ -1,29 +1,29 @@
-import { AccessorT, Observer, Accessor } from "./observer.ts";
-
-function _variance(): Observer<number, number | undefined> {
-    let count: number;
-    let mean: number;
-    let sum: number;
-
-    return {
-        observe: (value: number, idx: number) => {
-            if (idx === 0) {
-                count = 0;
-                mean = 0;
-                sum = 0;
-            }
-            const delta = value - mean;
-            mean += delta / ++count;
-            sum += delta * (value - mean);
-        },
-        peek: () => count > 1 ? sum / (count - 1) : undefined
-    };
-}
-
-export type VarianceAccessor<T> = AccessorT<T, number>;
-
-export function variance(): Observer<number, number | undefined>;
-export function variance<T = any>(callbackFn: VarianceAccessor<T>): Observer<T, number | undefined>;
-export function variance<T = any>(callbackFn?: VarianceAccessor<T>): Observer<number, number | undefined> | Observer<T, number | undefined> {
-    return callbackFn ? Accessor(_variance, callbackFn) : _variance();
-}
+import { AccessorT, Observer, Accessor } from "./observer";
+
+function _variance(): Observer<number, number | undefined> {
+    let count: number;
+    let mean: number;
+    let sum: number;
+
+    return {
+        observe: (value: number, idx: number) => {
+            if (idx === 0) {
+                count = 0;
+                mean = 0;
+                sum = 0;
+            }
+            const delta = value - mean;
+            mean += delta / ++count;
+            sum += delta * (value - mean);
+        },
+        peek: () => count > 1 ? sum / (count - 1) : undefined
+    };
+}
+
+export type VarianceAccessor<T> = AccessorT<T, number>;
+
+export function variance(): Observer<number, number | undefined>;
+export function variance<T = any>(callbackFn: VarianceAccessor<T>): Observer<T, number | undefined>;
+export function variance<T = any>(callbackFn?: VarianceAccessor<T>): Observer<number, number | undefined> | Observer<T, number | undefined> {
+    return callbackFn ? Accessor(_variance, callbackFn) : _variance();
+}

package/src/utils/generate.ts

@@ -1,6 +1,6 @@
-export function* generate<U>(generatorFn: () => U, maxLen?: number): IterableIterator<U> {
-    let i = -1;
-    while (maxLen === undefined || ++i < maxLen) {
-        yield generatorFn();
-    }
-}
+export function* generate<U>(generatorFn: () => U, maxLen?: number): IterableIterator<U> {
+    let i = -1;
+    while (maxLen === undefined || ++i < maxLen) {
+        yield generatorFn();
+    }
+}