@hpcc-js/dataflow 9.2.0 → 9.2.1

package/dist/index.js

@@ -1,2 +1,558 @@
-function c(e){return e&&(typeof e[Symbol.iterator]=="function"||Array.isArray(e))}function x(e){return function*(t){yield*t,yield*e}}function $(e,t){return t!==void 0?x(t)(e):x(e)}function U(e){return function*(t){let r=-1;for(let i of t)e(i,++r),yield i}}function d(e,t){return c(e)?U(t)(e):U(e)}function S(){return function*(e){let t=-1;for(let r of e)yield[++t,r]}}function ie(e){return e?S()(e):S()}function k(e){return function*(t){let r=-1;for(let i of t)e(i,++r)&&(yield i)}}function ae(e,t){return c(e)?k(t)(e):k(e)}function O(e){return function*(t){let r=0;for(let i of t)if(yield i,++r>=e)break}}function ye(e,t){return c(e)?O(t)(e):O(e)}function h(e){return function*(t){let r=-1,i={};for(let n of t){let o=e(n,++r);i[o]||(i[o]=[]),i[o].push(n)}for(let n in i)yield{key:n,value:i[n]}}}function Ae(e,t){return c(e)?h(t)(e):h(e)}function I(e,t){let r=e();return{observe:(i,n)=>{r.observe(t(i,n),n)},peek:r.peek}}function Ue(e){return d((t,r)=>e.observe(t,r))}function de(e){return function*(t){let r=-1;for(let i of t)e.observe(i,++r);yield e.peek()}}function T(e){return function(t){let r=-1;for(let i of t)e.observe(i,++r);return e.peek()}}function F(){let e;return{observe:(t,r)=>{(r===0||e<t)&&(e=t)},peek:()=>e}}function v(e){return e?I(F,e):F()}function g(){let e;return{observe:(t,r)=>{(r===0||e>t)&&(e=t)},peek:()=>e}}function p(e){return e?I(g,e):g()}function w(){let e=p(),t=v();return{observe:(r,i)=>{e.observe(r,i),t.observe(r,i)},peek:()=>[e.peek(),t.peek()]}}function s(e){return e?I(w,e):w()}function P(e){return e.buckets!==void 0}function C(e,t){return function*(r){let i,n,o;if(P(t)){o=Array.isArray(r)?r:[...r];let a=T(s(e))(o);if(a===void 0)return;i=a[0];let y=a[1],l=t.buckets;n=(y-i)/l}else o=r,i=t.min,n=t.range;let u={},b=0;for(let a of o){let y=e(a),l=Math.floor((y-i)/n);b<l&&(b=l),u[l]===void 0&&(u[l]=[]),u[l].push(a)}let f=u[b],N=i+b*n;for(let a=0;a<=b;++a){if(a===b-1&&f.every(y=>N===e(y))){yield{from:i+a*n,to:i+(a+1)*n,value:[...u[a]||[],...f]};break}yield{from:i+a*n,to:i+(a+1)*n,value:u[a]||[]}}}}function je(e,t,r){return c(e)?C(t,r)(e):C(e,t)}function M(e,t){let r=Array.isArray(e)?e[Symbol.iterator]():e;return function*(i){let n=-1;for(let o of i)yield t(o,r.next().value,++n)}}function Xe(e,t,r){return c(t)?M(t,r)(e):M(e,t)}function G(e){return function*(t){let r=-1;for(let i of t)yield e(i,++r)}}function V(e,t){return c(e)?G(t)(e):G(e)}function R(){let e=T(s());return function*(t){let r=Array.isArray(t)?t:[...t],i=e(r),n=i[1]-i[0]||1;return yield*V(u=>(u-i[0])/n)(r)}}function ct(e){return c(e)?R()(e):R()}function D(e){return function*(t){let r=-1;for(let i of t)++r>=e&&(yield i)}}function lt(e,t){return c(e)?D(t)(e):D(e)}function H(e){return function*(t){yield*(Array.isArray(t)?t:[...t]).sort(e)}}function st(e,t){return c(e)?H(t)(e):H(e)}function At(){let e;return{observe:(t,r)=>{r===0&&(e=0),++e},peek:()=>e}}function E(){let e,t,r;return{observe:(i,n)=>{n===0&&(e=0,t=0,r=0);let o=i-t;t+=o/++e,r+=o*(i-t)},peek:()=>e>1?r/(e-1):void 0}}function m(e){return e?I(E,e):E()}function B(){let e=m();return{observe:(t,r)=>{e.observe(t,r)},peek:()=>{let t=e.peek();return t!==void 0?Math.sqrt(t):t}}}function gt(e){return e?I(B,e):B()}function Q(){let e,t;return{observe:(r,i)=>{i===0?e=r:e+=r,t=i},peek:()=>e/(t+1)}}function z(e){return e?I(Q,e):Q()}function q(){let e=p(),t=v(),r=z(),i=m();return{observe:(n,o)=>{e.observe(n,o),t.observe(n,o),r.observe(n,o),i.observe(n,o)},peek:()=>{let n=e.peek();if(n===void 0)return;let o=i.peek();return{min:n,max:t.peek(),mean:r.peek(),variance:o,deviation:o!==void 0?Math.sqrt(o):void 0}}}}function Qt(e){return e?I(q,e):q()}function J(){let e;return{observe:(t,r)=>{r===0&&(e=[]),e.push(t)},peek:()=>{let t=e.sort((i,n)=>i-n),r=t.length/2;return t.length%2===0?(t[r-1]+t[r])/2:t[Math.floor(r)]}}}function A(e){return e?I(J,e):J()}function j(){let e;return{observe:(t,r)=>{r===0&&(e=[]),e.push(t)},peek:()=>{let t=e.sort((u,b)=>u-b),r=t.length/2,i,n,o;if(!(t.length<2))return t.length%2===0?(i=(t[r-1]+t[r])/2,n=t.slice(0,r),o=t.slice(r)):(i=t[Math.floor(r)],n=t.slice(0,Math.floor(r)),o=t.slice(Math.ceil(r))),[t[0],T(A())(n),i,T(A())(o),t[t.length-1]]}}}function Yt(e){return e?I(j,e):j()}function W(e,t){let r;return{observe:(i,n)=>{n===0?r=t===void 0?i:e(t,i,n):r=e(r,i,n)},peek:()=>r}}function $t(e,t){return W(e,t)}function*_t(e,t){let r=-1;for(;t===void 0||++r<t;)yield e()}var X=function*(){}.constructor;function K(...e){return e[e.length-1]instanceof X?function*(t){let r=t;for(let i of e)r=i(r);yield*r}:function(t){let r=t;for(let i of e)r=i(r);return r}}function Y(e,...t){return c(e)?K(...t)(e):K(e,...t)}var or=Y;export{I as Accessor,de as activity,or as chain,$ as concat,At as count,gt as deviation,Qt as distribution,d as each,ie as entries,s as extent,ae as filter,ye as first,_t as generate,Ae as group,je as histogram,c as isSource,Xe as join,V as map,v as max,z as mean,A as median,p as min,ct as normalize,Y as pipe,Yt as quartile,$t as reduce,T as scalar,Ue as sensor,lt as skip,st as sort,m as variance};
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@hpcc-js/dataflow"] = {}));
+})(this, (function (exports) { 'use strict';
+
+    function isSource(source) {
+        return source && (typeof source[Symbol.iterator] === "function" || Array.isArray(source));
+    }
+
+    function concatGen(concatSource) {
+        return function* (source) {
+            yield* source;
+            yield* concatSource;
+        };
+    }
+    function concat(s_or_n, concatSource) {
+        return concatSource !== undefined ? concatGen(concatSource)(s_or_n) : concatGen(s_or_n);
+    }
+
+    function eachGen(callbackFn) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                callbackFn(item, ++i);
+                yield item;
+            }
+        };
+    }
+    function each(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? eachGen(callbackFn)(s_or_cb) : eachGen(s_or_cb);
+    }
+
+    //  Array.entries
+    function entriesGen() {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                yield [++i, item];
+            }
+        };
+    }
+    function entries(source) {
+        return source ? entriesGen()(source) : entriesGen();
+    }
+
+    function filterGen(callbackFn) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                if (callbackFn(item, ++i)) {
+                    yield item;
+                }
+            }
+        };
+    }
+    function filter(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? filterGen(callbackFn)(s_or_cb) : filterGen(s_or_cb);
+    }
+
+    function firstGen(n) {
+        return function* (source) {
+            let i = 0;
+            for (const item of source) {
+                yield item;
+                if (++i >= n) {
+                    break;
+                }
+            }
+        };
+    }
+    function first(s_or_n, n) {
+        if (!isSource(s_or_n))
+            return firstGen(s_or_n);
+        return firstGen(n)(s_or_n);
+    }
+
+    function groupGen(groupFn) {
+        return function* (source) {
+            let i = -1;
+            const group = {};
+            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] };
+            }
+        };
+    }
+    function group(s_or_gbf, groupByFn) {
+        return isSource(s_or_gbf) ? groupGen(groupByFn)(s_or_gbf) : groupGen(s_or_gbf);
+    }
+
+    function Accessor(fof, accesor) {
+        const s = fof();
+        return {
+            observe: (_, i) => {
+                s.observe(accesor(_, i), i);
+            },
+            peek: s.peek
+        };
+    }
+    //  This is an pass through activity so a FlowObserver can be inserted into a pipeline ---
+    function sensor(s) {
+        return each((r, i) => s.observe(r, i));
+    }
+    //  This converts a FlowObserver to an Activity ---
+    function activity(s) {
+        return function* (source) {
+            let i = -1;
+            for (const row of source) {
+                s.observe(row, ++i);
+            }
+            yield s.peek();
+        };
+    }
+    //  This converts a FlowObserver to an ScalarActivity ---
+    function scalar(s) {
+        return function (source) {
+            let i = -1;
+            for (const row of source) {
+                s.observe(row, ++i);
+            }
+            return s.peek();
+        };
+    }
+
+    function _max() {
+        let max;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    max = value;
+                }
+                else if (max < value) {
+                    max = value;
+                }
+            },
+            peek: () => max
+        };
+    }
+    function max(callbackFn) {
+        return callbackFn ? Accessor(_max, callbackFn) : _max();
+    }
+
+    function _min() {
+        let min;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    min = value;
+                }
+                else if (min > value) {
+                    min = value;
+                }
+            },
+            peek: () => min
+        };
+    }
+    function min(callbackFn) {
+        return callbackFn ? Accessor(_min, callbackFn) : _min();
+    }
+
+    function _extent() {
+        const minFO = min();
+        const maxFO = max();
+        return {
+            observe: (value, idx) => {
+                minFO.observe(value, idx);
+                maxFO.observe(value, idx);
+            },
+            peek: () => [minFO.peek(), maxFO.peek()]
+        };
+    }
+    function extent(callbackFn) {
+        return callbackFn ? Accessor(_extent, callbackFn) : _extent();
+    }
+
+    function isOptionA(_) {
+        return _.buckets !== undefined;
+    }
+    function histogramGen(callbackFn, options) {
+        return function* (_source) {
+            let min;
+            let bucketSize;
+            let source;
+            if (isOptionA(options)) {
+                source = Array.isArray(_source) ? _source : [..._source];
+                const minMax = scalar(extent(callbackFn))(source);
+                if (minMax === undefined) {
+                    return undefined;
+                }
+                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 = {};
+            let maxBucketID = 0;
+            for (const row of source) {
+                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);
+            }
+            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] || []
+                };
+            }
+        };
+    }
+    function histogram(s_or_hf, hf_or_b, options) {
+        return isSource(s_or_hf) ? histogramGen(hf_or_b, options)(s_or_hf) : histogramGen(s_or_hf, hf_or_b);
+    }
+
+    function joinGen(_sourceU, callbackFn) {
+        const sourceB = Array.isArray(_sourceU) ? _sourceU[Symbol.iterator]() : _sourceU;
+        return function* (sourceT) {
+            let i = -1;
+            for (const item of sourceT) {
+                yield callbackFn(item, sourceB.next().value, ++i);
+            }
+        };
+    }
+    function join(sT_or_sU, sU_or_cb, callbackFn) {
+        return isSource(sU_or_cb) ? joinGen(sU_or_cb, callbackFn)(sT_or_sU) : joinGen(sT_or_sU, sU_or_cb);
+    }
+
+    function mapGen(callbackFn) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                yield callbackFn(item, ++i);
+            }
+        };
+    }
+    function map(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? mapGen(callbackFn)(s_or_cb) : mapGen(s_or_cb);
+    }
+
+    function normalizeGen() {
+        const calcExtent = scalar(extent());
+        return function* (_source) {
+            const source = Array.isArray(_source) ? _source : [..._source];
+            const range = calcExtent(source);
+            const divisor = (range[1] - range[0]) || 1;
+            const normalizeMap = map((row) => (row - range[0]) / divisor);
+            return yield* normalizeMap(source);
+        };
+    }
+    function normalize(s_or_undef) {
+        return isSource(s_or_undef) ? normalizeGen()(s_or_undef) : normalizeGen();
+    }
+
+    function skipGen(n) {
+        return function* (source) {
+            let i = -1;
+            for (const item of source) {
+                if (++i >= n) {
+                    yield item;
+                }
+            }
+        };
+    }
+    function skip(s_or_n, n) {
+        return isSource(s_or_n) ? skipGen(n)(s_or_n) : skipGen(s_or_n);
+    }
+
+    function sortGen(compareFn) {
+        return function* (source) {
+            yield* (Array.isArray(source) ? source : [...source]).sort(compareFn);
+        };
+    }
+    function sort(s_or_cb, callbackFn) {
+        return isSource(s_or_cb) ? sortGen(callbackFn)(s_or_cb) : sortGen(s_or_cb);
+    }
+
+    function count() {
+        let count;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    count = 0;
+                }
+                ++count;
+            },
+            peek: () => count
+        };
+    }
+
+    function _variance() {
+        let count;
+        let mean;
+        let sum;
+        return {
+            observe: (value, idx) => {
+                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
+        };
+    }
+    function variance(callbackFn) {
+        return callbackFn ? Accessor(_variance, callbackFn) : _variance();
+    }
+
+    function _deviation() {
+        const v = variance();
+        return {
+            observe: (value, idx) => {
+                v.observe(value, idx);
+            },
+            peek: () => {
+                const variance = v.peek();
+                return variance !== undefined ? Math.sqrt(variance) : variance;
+            }
+        };
+    }
+    function deviation(callbackFn) {
+        return callbackFn ? Accessor(_deviation, callbackFn) : _deviation();
+    }
+
+    function _mean() {
+        let total;
+        let count;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    total = value;
+                }
+                else {
+                    total += value;
+                }
+                count = idx;
+            },
+            peek: () => total / (count + 1)
+        };
+    }
+    function mean(callbackFn) {
+        return callbackFn ? Accessor(_mean, callbackFn) : _mean();
+    }
+
+    function _distribution() {
+        const minFO = min();
+        const maxFO = max();
+        const meanFO = mean();
+        const varianceFO = variance();
+        return {
+            observe: (value, idx) => {
+                minFO.observe(value, idx);
+                maxFO.observe(value, idx);
+                meanFO.observe(value, idx);
+                varianceFO.observe(value, idx);
+            },
+            peek: () => {
+                const minResult = minFO.peek();
+                if (minResult === undefined)
+                    return undefined;
+                const varianceResult = varianceFO.peek();
+                return {
+                    min: minResult,
+                    max: maxFO.peek(),
+                    mean: meanFO.peek(),
+                    variance: varianceResult,
+                    deviation: varianceResult !== undefined ? Math.sqrt(varianceResult) : undefined
+                };
+            }
+        };
+    }
+    function distribution(callbackFn) {
+        return callbackFn ? Accessor(_distribution, callbackFn) : _distribution();
+    }
+
+    function _median() {
+        let values;
+        return {
+            observe: (value, idx) => {
+                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)];
+                }
+            }
+        };
+    }
+    function median(callbackFn) {
+        return callbackFn ? Accessor(_median, callbackFn) : _median();
+    }
+
+    function _quartile() {
+        let values;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    values = [];
+                }
+                values.push(value);
+            },
+            peek: () => {
+                const sorted = values.sort((l, r) => l - r);
+                const mid = sorted.length / 2;
+                let medianVal;
+                let lower;
+                let upper;
+                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]];
+            }
+        };
+    }
+    function quartile(callbackFn) {
+        return callbackFn ? Accessor(_quartile, callbackFn) : _quartile();
+    }
+
+    function _reduce(callback, initialValue) {
+        let reduced;
+        return {
+            observe: (value, idx) => {
+                if (idx === 0) {
+                    reduced = initialValue === undefined ? value : callback(initialValue, value, idx);
+                }
+                else {
+                    reduced = callback(reduced, value, idx);
+                }
+            },
+            peek: () => reduced
+        };
+    }
+    function reduce(callbackFn, initialValue) {
+        return _reduce(callbackFn, initialValue);
+    }
+
+    function* generate(generatorFn, maxLen) {
+        let i = -1;
+        while (maxLen === undefined || ++i < maxLen) {
+            yield generatorFn();
+        }
+    }
+
+    const GeneratorFunction = (function* () { }).constructor;
+    function chainGen(...items) {
+        if (items[items.length - 1] instanceof GeneratorFunction) {
+            return function* (source) {
+                // @ts-ignore
+                let tail = source;
+                for (const activity of items) {
+                    // @ts-ignore
+                    tail = activity(tail);
+                }
+                yield* tail;
+            };
+        }
+        else {
+            return function (source) {
+                // @ts-ignore
+                let tail = source;
+                for (const activity of items) {
+                    // @ts-ignore
+                    tail = activity(tail);
+                }
+                return tail;
+            };
+        }
+    }
+    function pipe(s_or_ia, ...items) {
+        return isSource(s_or_ia) ? chainGen(...items)(s_or_ia) : chainGen(s_or_ia, ...items);
+    }
+    //  Maintain backward compatibility
+    const chain = pipe;
+
+    exports.Accessor = Accessor;
+    exports.activity = activity;
+    exports.chain = chain;
+    exports.concat = concat;
+    exports.count = count;
+    exports.deviation = deviation;
+    exports.distribution = distribution;
+    exports.each = each;
+    exports.entries = entries;
+    exports.extent = extent;
+    exports.filter = filter;
+    exports.first = first;
+    exports.generate = generate;
+    exports.group = group;
+    exports.histogram = histogram;
+    exports.isSource = isSource;
+    exports.join = join;
+    exports.map = map;
+    exports.max = max;
+    exports.mean = mean;
+    exports.median = median;
+    exports.min = min;
+    exports.normalize = normalize;
+    exports.pipe = pipe;
+    exports.quartile = quartile;
+    exports.reduce = reduce;
+    exports.scalar = scalar;
+    exports.sensor = sensor;
+    exports.skip = skip;
+    exports.sort = sort;
+    exports.variance = variance;
+
+}));
 //# sourceMappingURL=index.js.map