@hpcc-js/dataflow 9.6.7 → 9.6.9

package/src/activities/concat.ts

@@ -1,14 +1,14 @@
-import { Source, IterableActivity } from "./activity.ts";
-
-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.ts";
+
+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.ts";
-
-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.ts";
+
+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.ts";
-
-//  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.ts";
+
+//  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.ts";
-
-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.ts";
+
+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.ts";
-
-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.ts";
+
+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.ts";
-
-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.ts";
+
+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);
+}

package/src/activities/histogram.ts

@@ -1,99 +1,99 @@
-import { IterableActivity, Source, isSource } from "./activity.ts";
-import { extent } from "../observers/extent.ts";
-import { scalar } from "../observers/observer.ts";
-
-export type HistogramFn<T> = (row: T) => number;
-export type HistogramRow<T> = { from: number, to: number, value: T[] };
-export type OptionA = { buckets: number };
-/** 
- * Histogram options specifying the minimum value and bucket range (size).
- * @property min - The minimum value for the first bucket's lower bound
- * @property range - The size/width of each bucket (distance between bucket boundaries)
- */
-export type OptionB = { min: number, range: number };
-export type Options = OptionA | OptionB;
-
-function isOptionA(_: Options): _ is OptionA {
-    return (_ as OptionA).buckets !== undefined;
-}
-
-function histogramGen<T = any>(callbackFn: HistogramFn<T>, options: Options): IterableActivity<T, HistogramRow<T>> {
-    return function* (_source: Source<T>) {
-        let min: number;
-        let bucketSize: number;
-
-        let source;
-        if (isOptionA(options)) {
-            source = Array.isArray(_source) ? _source : [..._source];
-            const minMax = scalar(extent(callbackFn))(source);
-            if (minMax === undefined || minMax[0] === undefined || minMax[1] === undefined) {
-                // For empty sources with buckets option, generate empty buckets with NaN bounds
-                const buckets = options.buckets;
-                for (let i = 0; i < buckets; ++i) {
-                    yield {
-                        from: NaN,
-                        to: NaN,
-                        value: []
-                    };
-                }
-                return;
-            }
-            min = minMax[0];
-            const max = minMax[1];
-            const buckets = options.buckets;
-            bucketSize = (max - min) / buckets;
-        } else {
-            source = _source;
-            min = options.min;
-            bucketSize = options.range;
-        }
-
-        const histogram: { [key: number]: T[] } = {};
-
-        let maxBucketID = 0;
-        let hasData = false;
-        for (const row of source) {
-            hasData = true;
-            const value = callbackFn(row);
-            const bucketID = Math.floor((value - min) / bucketSize);
-            if (maxBucketID < bucketID) {
-                maxBucketID = bucketID;
-            }
-            if (histogram[bucketID] === undefined) {
-                histogram[bucketID] = [];
-            }
-            histogram[bucketID].push(row);
-        }
-
-        // If no data, return empty for OptionB (min/range)
-        if (!hasData) {
-            return;
-        }
-
-        const lastBucket = histogram[maxBucketID];
-        const from = min + maxBucketID * bucketSize;
-
-        for (let i = 0; i <= maxBucketID; ++i) {
-            //  If all items in the last bucket match the "to" of the previous bucket, put them in there...
-            if (i === maxBucketID - 1 && lastBucket.every(row => from === callbackFn(row))) {
-                yield {
-                    from: min + i * bucketSize,
-                    to: min + (i + 1) * bucketSize,
-                    value: [...(histogram[i] || []), ...lastBucket]
-                };
-                break;
-            }
-            yield {
-                from: min + i * bucketSize,
-                to: min + (i + 1) * bucketSize,
-                value: histogram[i] || []
-            };
-        }
-    };
-}
-
-export function histogram<T>(histogramByFn: HistogramFn<T>, options: Options): IterableActivity<T, HistogramRow<T>>;
-export function histogram<T>(source: Source<T>, histogramByFn: HistogramFn<T>, options: Options): IterableIterator<HistogramRow<T>>;
-export function histogram<T>(s_or_hf: Source<T> | HistogramFn<T>, hf_or_b: HistogramFn<T> | Options, options?: Options): IterableActivity<T, HistogramRow<T>> | IterableIterator<HistogramRow<T>> {
-    return isSource(s_or_hf) ? histogramGen<T>(hf_or_b as HistogramFn<T>, options!)(s_or_hf) : histogramGen<T>(s_or_hf as HistogramFn<T>, hf_or_b as Options);
-}
+import { IterableActivity, Source, isSource } from "./activity.ts";
+import { extent } from "../observers/extent.ts";
+import { scalar } from "../observers/observer.ts";
+
+export type HistogramFn<T> = (row: T) => number;
+export type HistogramRow<T> = { from: number, to: number, value: T[] };
+export type OptionA = { buckets: number };
+/** 
+ * Histogram options specifying the minimum value and bucket range (size).
+ * @property min - The minimum value for the first bucket's lower bound
+ * @property range - The size/width of each bucket (distance between bucket boundaries)
+ */
+export type OptionB = { min: number, range: number };
+export type Options = OptionA | OptionB;
+
+function isOptionA(_: Options): _ is OptionA {
+    return (_ as OptionA).buckets !== undefined;
+}
+
+function histogramGen<T = any>(callbackFn: HistogramFn<T>, options: Options): IterableActivity<T, HistogramRow<T>> {
+    return function* (_source: Source<T>) {
+        let min: number;
+        let bucketSize: number;
+
+        let source;
+        if (isOptionA(options)) {
+            source = Array.isArray(_source) ? _source : [..._source];
+            const minMax = scalar(extent(callbackFn))(source);
+            if (minMax === undefined || minMax[0] === undefined || minMax[1] === undefined) {
+                // For empty sources with buckets option, generate empty buckets with NaN bounds
+                const buckets = options.buckets;
+                for (let i = 0; i < buckets; ++i) {
+                    yield {
+                        from: NaN,
+                        to: NaN,
+                        value: []
+                    };
+                }
+                return;
+            }
+            min = minMax[0];
+            const max = minMax[1];
+            const buckets = options.buckets;
+            bucketSize = (max - min) / buckets;
+        } else {
+            source = _source;
+            min = options.min;
+            bucketSize = options.range;
+        }
+
+        const histogram: { [key: number]: T[] } = {};
+
+        let maxBucketID = 0;
+        let hasData = false;
+        for (const row of source) {
+            hasData = true;
+            const value = callbackFn(row);
+            const bucketID = Math.floor((value - min) / bucketSize);
+            if (maxBucketID < bucketID) {
+                maxBucketID = bucketID;
+            }
+            if (histogram[bucketID] === undefined) {
+                histogram[bucketID] = [];
+            }
+            histogram[bucketID].push(row);
+        }
+
+        // If no data, return empty for OptionB (min/range)
+        if (!hasData) {
+            return;
+        }
+
+        const lastBucket = histogram[maxBucketID];
+        const from = min + maxBucketID * bucketSize;
+
+        for (let i = 0; i <= maxBucketID; ++i) {
+            //  If all items in the last bucket match the "to" of the previous bucket, put them in there...
+            if (i === maxBucketID - 1 && lastBucket.every(row => from === callbackFn(row))) {
+                yield {
+                    from: min + i * bucketSize,
+                    to: min + (i + 1) * bucketSize,
+                    value: [...(histogram[i] || []), ...lastBucket]
+                };
+                break;
+            }
+            yield {
+                from: min + i * bucketSize,
+                to: min + (i + 1) * bucketSize,
+                value: histogram[i] || []
+            };
+        }
+    };
+}
+
+export function histogram<T>(histogramByFn: HistogramFn<T>, options: Options): IterableActivity<T, HistogramRow<T>>;
+export function histogram<T>(source: Source<T>, histogramByFn: HistogramFn<T>, options: Options): IterableIterator<HistogramRow<T>>;
+export function histogram<T>(s_or_hf: Source<T> | HistogramFn<T>, hf_or_b: HistogramFn<T> | Options, options?: Options): IterableActivity<T, HistogramRow<T>> | IterableIterator<HistogramRow<T>> {
+    return isSource(s_or_hf) ? histogramGen<T>(hf_or_b as HistogramFn<T>, options!)(s_or_hf) : histogramGen<T>(s_or_hf as HistogramFn<T>, hf_or_b as Options);
+}

package/src/activities/join.ts

@@ -1,19 +1,19 @@
-import { IterableActivity, Source, isSource } from "./activity.ts";
-
-export type JoinCallback<T, U, V> = (rowT: T, rowU: U, index: number) => V;
-
-function joinGen<T = any, U = any, V = any>(_sourceU: Source<U>, callbackFn: JoinCallback<T, U, V>): IterableActivity<T, V> {
-    const sourceB = Array.isArray(_sourceU) ? _sourceU[Symbol.iterator]() : _sourceU;
-    return function* (sourceT: Source<T>) {
-        let i = -1;
-        for (const item of sourceT) {
-            yield callbackFn(item, sourceB.next().value, ++i);
-        }
-    };
-}
-
-export function join<T, U, V>(sourceU: Source<U>, callbackFn: JoinCallback<T, U, V>): IterableActivity<T, V>;
-export function join<T, U, V>(sourceU: Source<U>, callbackFn: JoinCallback<T, U, V>): IterableIterator<V>;
-export function join<T, U, V>(sT_or_sU: Source<T> | Source<U>, sU_or_cb: Source<U> | JoinCallback<T, U, V>, callbackFn?: JoinCallback<T, U, V>): IterableActivity<T, V> | IterableIterator<V> {
-    return isSource(sU_or_cb) ? joinGen(sU_or_cb, callbackFn!)(sT_or_sU as Source<T>) : joinGen(sT_or_sU as Source<U>, sU_or_cb);
-}
+import { IterableActivity, Source, isSource } from "./activity.ts";
+
+export type JoinCallback<T, U, V> = (rowT: T, rowU: U, index: number) => V;
+
+function joinGen<T = any, U = any, V = any>(_sourceU: Source<U>, callbackFn: JoinCallback<T, U, V>): IterableActivity<T, V> {
+    const sourceB = Array.isArray(_sourceU) ? _sourceU[Symbol.iterator]() : _sourceU;
+    return function* (sourceT: Source<T>) {
+        let i = -1;
+        for (const item of sourceT) {
+            yield callbackFn(item, sourceB.next().value, ++i);
+        }
+    };
+}
+
+export function join<T, U, V>(sourceU: Source<U>, callbackFn: JoinCallback<T, U, V>): IterableActivity<T, V>;
+export function join<T, U, V>(sourceU: Source<U>, callbackFn: JoinCallback<T, U, V>): IterableIterator<V>;
+export function join<T, U, V>(sT_or_sU: Source<T> | Source<U>, sU_or_cb: Source<U> | JoinCallback<T, U, V>, callbackFn?: JoinCallback<T, U, V>): IterableActivity<T, V> | IterableIterator<V> {
+    return isSource(sU_or_cb) ? joinGen(sU_or_cb, callbackFn!)(sT_or_sU as Source<T>) : joinGen(sT_or_sU as Source<U>, sU_or_cb);
+}

package/src/activities/map.ts

@@ -1,18 +1,18 @@
-import { IterableActivity, Source, isSource } from "./activity.ts";
-
-export type MapCallback<T, U> = (row: T, index: number) => U;
-
-function mapGen<T = any, U = any>(callbackFn: MapCallback<T, U>): IterableActivity<T, U> {
-    return function* (source: Source<T>) {
-        let i = -1;
-        for (const item of source) {
-            yield callbackFn(item, ++i);
-        }
-    };
-}
-
-export function map<T, U>(callbackFn: MapCallback<T, U>): IterableActivity<T, U>;
-export function map<T, U>(source: Source<T>, callbackFn: MapCallback<T, U>): IterableIterator<U>;
-export function map<T, U>(s_or_cb: Source<T> | MapCallback<T, U>, callbackFn?: MapCallback<T, U>): IterableActivity<T, U> | IterableIterator<U> {
-    return isSource(s_or_cb) ? mapGen(callbackFn!)(s_or_cb) : mapGen(s_or_cb);
-}
+import { IterableActivity, Source, isSource } from "./activity.ts";
+
+export type MapCallback<T, U> = (row: T, index: number) => U;
+
+function mapGen<T = any, U = any>(callbackFn: MapCallback<T, U>): IterableActivity<T, U> {
+    return function* (source: Source<T>) {
+        let i = -1;
+        for (const item of source) {
+            yield callbackFn(item, ++i);
+        }
+    };
+}
+
+export function map<T, U>(callbackFn: MapCallback<T, U>): IterableActivity<T, U>;
+export function map<T, U>(source: Source<T>, callbackFn: MapCallback<T, U>): IterableIterator<U>;
+export function map<T, U>(s_or_cb: Source<T> | MapCallback<T, U>, callbackFn?: MapCallback<T, U>): IterableActivity<T, U> | IterableIterator<U> {
+    return isSource(s_or_cb) ? mapGen(callbackFn!)(s_or_cb) : mapGen(s_or_cb);
+}

package/src/activities/normalize.ts

@@ -1,21 +1,21 @@
-import { Source, IterableActivity, isSource } from "./activity.ts";
-import { extent } from "../observers/extent.ts";
-import { scalar } from "../observers/observer.ts";
-import { map } from "./map.ts";
-
-function normalizeGen(): IterableActivity<number> {
-    const calcExtent = scalar(extent());
-    return function* (_source: Source<number>) {
-        const source = Array.isArray(_source) ? _source : [..._source];
-        const range = calcExtent(source);
-        const divisor = (range[1] - range[0]) || 1;
-        const normalizeMap = map((row: number) => (row - range[0]) / divisor);
-        return yield* normalizeMap(source);
-    };
-}
-
-export function normalize(): IterableActivity<number>;
-export function normalize(source: Source<number>): IterableIterator<number>;
-export function normalize(s_or_undef?: Source<number>): IterableActivity<number> | IterableIterator<number> {
-    return isSource(s_or_undef) ? normalizeGen()(s_or_undef) : normalizeGen();
-}
+import { Source, IterableActivity, isSource } from "./activity.ts";
+import { extent } from "../observers/extent.ts";
+import { scalar } from "../observers/observer.ts";
+import { map } from "./map.ts";
+
+function normalizeGen(): IterableActivity<number> {
+    const calcExtent = scalar(extent());
+    return function* (_source: Source<number>) {
+        const source = Array.isArray(_source) ? _source : [..._source];
+        const range = calcExtent(source);
+        const divisor = (range[1] - range[0]) || 1;
+        const normalizeMap = map((row: number) => (row - range[0]) / divisor);
+        return yield* normalizeMap(source);
+    };
+}
+
+export function normalize(): IterableActivity<number>;
+export function normalize(source: Source<number>): IterableIterator<number>;
+export function normalize(s_or_undef?: Source<number>): IterableActivity<number> | IterableIterator<number> {
+    return isSource(s_or_undef) ? normalizeGen()(s_or_undef) : normalizeGen();
+}

package/src/activities/skip.ts

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

package/src/activities/sort.ts

@@ -1,16 +1,16 @@
-import { IterableActivity, Source, isSource } from "./activity.ts";
-
-export type SortCallback<T> = (a: T, b: T) => number;
-
-function sortGen<T = any>(compareFn?: SortCallback<T>): IterableActivity<T> {
-    return function* (source: Source<T>) {
-        yield* (Array.isArray(source) ? source : [...source]).sort(compareFn);
-    };
-}
-
-export function sort<T = any>(callbackFn: SortCallback<T>): IterableActivity<T>;
-export function sort<T = any>(source: Source<T>, callbackFn: SortCallback<T>): IterableIterator<T>;
-export function sort<T = any>(s_or_cb: Source<T> | SortCallback<T>, callbackFn?: SortCallback<T>): IterableActivity<T> | IterableIterator<T> {
-    return isSource(s_or_cb) ? sortGen(callbackFn!)(s_or_cb) : sortGen(s_or_cb);
-}
-
+import { IterableActivity, Source, isSource } from "./activity.ts";
+
+export type SortCallback<T> = (a: T, b: T) => number;
+
+function sortGen<T = any>(compareFn?: SortCallback<T>): IterableActivity<T> {
+    return function* (source: Source<T>) {
+        yield* (Array.isArray(source) ? source : [...source]).sort(compareFn);
+    };
+}
+
+export function sort<T = any>(callbackFn: SortCallback<T>): IterableActivity<T>;
+export function sort<T = any>(source: Source<T>, callbackFn: SortCallback<T>): IterableIterator<T>;
+export function sort<T = any>(s_or_cb: Source<T> | SortCallback<T>, callbackFn?: SortCallback<T>): IterableActivity<T> | IterableIterator<T> {
+    return isSource(s_or_cb) ? sortGen(callbackFn!)(s_or_cb) : sortGen(s_or_cb);
+}
+