df-script 1.5.0 → 1.7.0

package/dist/columnExpressions/mixins/ListExpr.js

@@ -1,224 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ListExpr = exports.ListExprNamespace = void 0;
-const ExprBase_1 = require("../ExprBase");
-const utils_1 = require("../utils");
-const utils_2 = require("../../utils");
-const exceptions_1 = require("../../exceptions");
-const constants_1 = require("../constants");
-class ListExprNamespace {
-    expr;
-    constructor(expr) {
-        this.expr = expr;
-    }
-    _deriveList(fn) {
-        return (0, ExprBase_1.derive)(this.expr, (0, utils_1.kleeneUnary)((v) => {
-            return (0, utils_2.isArrayOrTypedArray)(v) ? fn(v) : null;
-        }));
-    }
-    all() {
-        return this._deriveList((arr) => (0, utils_2.isArrayOfType)(arr, (x) => !!x, { mode: "every" }));
-    }
-    any() {
-        return this._deriveList((arr) => (0, utils_2.isArrayOfType)(arr, (x) => !!x, { mode: "some" }));
-    }
-    contains(item) {
-        return this._deriveList((arr) => arr.includes(item));
-    }
-    contains_all(items) {
-        return this._deriveList((arr) => (0, utils_2.isArrayOfType)(items, (x) => arr.includes(x), { mode: "every" }));
-    }
-    contains_any(items) {
-        return this._deriveList((arr) => (0, utils_2.isArrayOfType)(items, (x) => arr.includes(x), { mode: "some" }));
-    }
-    count_matches(item) {
-        return this._deriveList((arr) => {
-            let count = 0;
-            const len = arr.length;
-            for (let i = 0; i < len; i++) {
-                if (arr[i] === item) {
-                    count++;
-                }
-            }
-            return count;
-        });
-    }
-    drop_nulls() {
-        return this._deriveList((arr) => {
-            const len = arr.length;
-            const result = [];
-            for (let i = 0; i < len; i++) {
-                if (arr[i] != null)
-                    result.push(arr[i]);
-            }
-            return result;
-        });
-    }
-    explode({ empty_as_null = true, keep_nulls = true } = {}) {
-        return (0, ExprBase_1.derive)(this.expr, (vArray) => {
-            const height = vArray.length;
-            let newHeight = 0;
-            for (let i = 0; i < height; i++) {
-                const val = vArray[i];
-                if ((0, utils_2.isArrayOrTypedArray)(val)) {
-                    newHeight += val.length || (empty_as_null ? 1 : 0);
-                    continue;
-                }
-                if (val != null) {
-                    newHeight += 1;
-                    continue;
-                }
-                if (keep_nulls) {
-                    newHeight += 1;
-                }
-            }
-            const res = new Array(newHeight);
-            const rowMap = new Int32Array(newHeight);
-            let idx = 0;
-            for (let i = 0; i < height; i++) {
-                const val = vArray[i];
-                if ((0, utils_2.isArrayOrTypedArray)(val)) {
-                    const len = val.length;
-                    if (len > 0) {
-                        for (let j = 0; j < len; j++) {
-                            rowMap[idx] = i;
-                            res[idx++] = val[j];
-                        }
-                        continue;
-                    }
-                    if (empty_as_null) {
-                        rowMap[idx] = i;
-                        res[idx++] = null;
-                    }
-                    continue;
-                }
-                if (val != null) {
-                    rowMap[idx] = i;
-                    res[idx++] = val;
-                    continue;
-                }
-                if (keep_nulls) {
-                    rowMap[idx] = i;
-                    res[idx++] = null;
-                }
-            }
-            res.rowMap = rowMap;
-            return res;
-        });
-    }
-    first(null_on_oob = true) {
-        return this.get(0, null_on_oob);
-    }
-    gather(indices, null_on_oob = true) {
-        return this._deriveList((arr) => {
-            const len = arr.length;
-            const idxs = (0, utils_2.isArrayOrTypedArray)(indices) ? indices : [indices];
-            const numIndices = idxs.length;
-            const res = new Array(numIndices);
-            for (let i = 0; i < numIndices; i++) {
-                const index = idxs[i];
-                const val = arr.at(index);
-                if (val === undefined && !null_on_oob) {
-                    throw new exceptions_1.ComputeError(`Index ${index} is out of bounds for list of length ${len}`);
-                }
-                res[i] = val ?? null;
-            }
-            return res;
-        });
-    }
-    gather_every(options = {}) {
-        return this._deriveList((arr) => (0, utils_2.stepSliceList)(arr, options));
-    }
-    get(index, null_on_oob = true) {
-        return this._deriveList((arr) => {
-            const val = arr.at(index);
-            if (val === undefined && !null_on_oob) {
-                throw new exceptions_1.ComputeError(`Index ${index} is out of bounds for list of length ${arr.length}`);
-            }
-            return val ?? null;
-        });
-    }
-    join(separator = ",", options = {}) {
-        return this._deriveList((arr) => (0, utils_2.joinList)(arr, separator, options));
-    }
-    last(null_on_oob = true) {
-        return this.get(-1, null_on_oob);
-    }
-    len() {
-        return this.lengths();
-    }
-    lengths() {
-        return this._deriveList((arr) => arr.length);
-    }
-    max() {
-        return this._deriveList((arr) => (0, utils_2.getListStats)(arr).max);
-    }
-    mean() {
-        return this._deriveList((arr) => (0, utils_2.getListStats)(arr).mean);
-    }
-    median() {
-        return this._deriveList((arr) => (0, utils_2.computeMedian)(arr));
-    }
-    min() {
-        return this._deriveList((arr) => (0, utils_2.getListStats)(arr).min);
-    }
-    mode() {
-        return this._deriveList((arr) => (0, utils_2.computeMode)(arr));
-    }
-    n_unique(options = {}) {
-        return this._deriveList((arr) => (0, utils_2.getUniqueListStats)(arr, options).count);
-    }
-    reverse() {
-        return this._deriveList((arr) => arr.slice().reverse());
-    }
-    slice(offset, length) {
-        return this._deriveList((arr) => {
-            const len = arr.length;
-            const start = offset < 0 ? Math.max(0, len + offset) : offset;
-            const end = length !== undefined ? start + length : len;
-            return arr.slice(start, end);
-        });
-    }
-    sort(descending = false) {
-        return this._deriveList((arr) => (0, utils_2.sortList)(arr, descending));
-    }
-    sum() {
-        return this._deriveList((arr) => (0, utils_2.getListStats)(arr).sum);
-    }
-    unique(options = {}) {
-        return this._deriveList((arr) => (0, utils_2.getUniqueListStats)(arr, options).values);
-    }
-    eval(expr) {
-        return (0, ExprBase_1.derive)(this.expr, (vArray, columns) => {
-            const height = vArray.length;
-            const result = new Array(height);
-            for (let i = 0; i < height; i++) {
-                const val = vArray[i];
-                if (!(0, utils_2.isArrayOrTypedArray)(val)) {
-                    result[i] = null;
-                    continue;
-                }
-                const subHeight = val.length;
-                const subColumns = { ...columns, [constants_1.ELEMENT_MARKER]: val };
-                const isGlobalAgg = expr.aggFn != null && (expr.partitionBy == null || expr.partitionBy.length === 0);
-                if (isGlobalAgg) {
-                    const preOpsIdx = expr.groupingOpsIndex !== undefined ? expr.groupingOpsIndex : expr.ops.length;
-                    const preVal = expr.evaluatePre(preOpsIdx, subColumns, subHeight);
-                    const aggVal = expr.aggFn(Array.from(preVal));
-                    result[i] = expr.evaluatePost(preOpsIdx, [aggVal], subColumns);
-                }
-                else {
-                    result[i] = (0, utils_1.evaluateExpression)(expr, subColumns, subHeight);
-                }
-            }
-            return result;
-        });
-    }
-}
-exports.ListExprNamespace = ListExprNamespace;
-class ListExpr extends ExprBase_1.ExprBase {
-    get list() {
-        return new ListExprNamespace(this);
-    }
-}
-exports.ListExpr = ListExpr;

package/dist/columnExpressions/mixins/LogicalExpr.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogicalExpr = void 0;
-const ExprBase_1 = require("../ExprBase");
-const utils_1 = require("../utils");
-const utils_2 = require("../../utils");
-class LogicalExpr extends ExprBase_1.ExprBase {
-    and(other) {
-        return (0, ExprBase_1.derive)(this, (vArray, columns) => {
-            const height = vArray.length;
-            const otherVal = this._resolve(other, columns, height);
-            const isOtherArray = (0, utils_2.isArrayOrTypedArray)(otherVal);
-            const result = new Array(height);
-            for (let i = 0; i < height; i++) {
-                const v = vArray[i];
-                const w = isOtherArray ? otherVal[i] : otherVal;
-                if (v === false || w === false)
-                    result[i] = false;
-                else if (v == null || w == null)
-                    result[i] = null;
-                else
-                    result[i] = true;
-            }
-            return result;
-        });
-    }
-    not() {
-        return (0, ExprBase_1.derive)(this, (0, utils_1.kleeneUnary)((v) => !v));
-    }
-    or(other) {
-        return (0, ExprBase_1.derive)(this, (vArray, columns) => {
-            const height = vArray.length;
-            const otherVal = this._resolve(other, columns, height);
-            const isOtherArray = (0, utils_2.isArrayOrTypedArray)(otherVal);
-            const result = new Array(height);
-            for (let i = 0; i < height; i++) {
-                const v = vArray[i];
-                const w = isOtherArray ? otherVal[i] : otherVal;
-                if (v === true || w === true)
-                    result[i] = true;
-                else if (v == null || w == null)
-                    result[i] = null;
-                else
-                    result[i] = false;
-            }
-            return result;
-        });
-    }
-    xor(other) {
-        return (0, ExprBase_1.derive)(this, (0, utils_1.kleeneBinary)(this, other, (v, w) => !!v !== !!w));
-    }
-}
-exports.LogicalExpr = LogicalExpr;

package/dist/columnExpressions/mixins/ManipulationExpr.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ManipulationExpr = void 0;
-const ExprBase_1 = require("../ExprBase");
-const utils_1 = require("../../utils");
-class ManipulationExpr extends ExprBase_1.ExprBase {
-    fill_null({ value = undefined, strategy = undefined, limit = undefined } = {}) {
-        return (0, ExprBase_1.derive)(this, (vArray, columns) => {
-            const height = vArray.length;
-            const result = Array.from(vArray);
-            if (strategy !== undefined) {
-                if (strategy === "zero" || strategy === "one" || strategy === "min" || strategy === "max" || strategy === "mean") {
-                    let fillVal;
-                    if (strategy === "zero") {
-                        fillVal = 0;
-                    }
-                    else if (strategy === "one") {
-                        fillVal = 1;
-                    }
-                    else {
-                        const stats = (0, utils_1.getListStats)(vArray);
-                        fillVal = stats[strategy];
-                    }
-                    (0, utils_1.fillSequence)(result, fillVal, {
-                        mode: "constant",
-                        condition: (v) => v == null
-                    });
-                }
-                else if (strategy === "forward" || strategy === "backward") {
-                    const isForward = strategy === "forward";
-                    let lastVal = null;
-                    let consecCount = 0;
-                    (0, utils_1.fillSequence)(result, null, {
-                        mode: "independent",
-                        reverse: !isForward,
-                        step: ({ originalValue }) => {
-                            if (originalValue != null) {
-                                lastVal = originalValue;
-                                consecCount = 0;
-                                return originalValue;
-                            }
-                            if (lastVal !== null && (limit === undefined || consecCount < limit)) {
-                                consecCount++;
-                                return lastVal;
-                            }
-                            return null;
-                        }
-                    });
-                }
-                else {
-                    throw new Error(`Unsupported fill_null strategy: "${strategy}"`);
-                }
-            }
-            else {
-                const resolved = this._resolve(value, columns, height);
-                const isArr = (0, utils_1.isArrayOrTypedArray)(resolved);
-                (0, utils_1.fillSequence)(result, null, {
-                    mode: "independent",
-                    step: ({ index, originalValue }) => originalValue == null ? (isArr ? resolved[index] : resolved) : originalValue
-                });
-            }
-            return result;
-        });
-    }
-    reverse() {
-        return (0, ExprBase_1.derive)(this, (vArray) => {
-            return vArray.slice().reverse();
-        });
-    }
-}
-exports.ManipulationExpr = ManipulationExpr;

package/dist/columnExpressions/mixins/NumericExpr.d.ts

@@ -1,92 +0,0 @@
-import type { IExpr } from "../../types";
-import type { ExprConstructor, RandomOptions } from "../types";
-export declare const NumericExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        abs(): /*elided*/ any;
-        acos(): /*elided*/ any;
-        acosh(): /*elided*/ any;
-        add(val: number | IExpr | null): /*elided*/ any;
-        asin(): /*elided*/ any;
-        asinh(): /*elided*/ any;
-        atan(): /*elided*/ any;
-        atanh(): /*elided*/ any;
-        cbrt(): /*elided*/ any;
-        ceil(): /*elided*/ any;
-        clip(lower?: number | null, upper?: number | null): /*elided*/ any;
-        cos(): /*elided*/ any;
-        cosh(): /*elided*/ any;
-        degrees(): /*elided*/ any;
-        div(val: number | IExpr | null): /*elided*/ any;
-        exp(): /*elided*/ any;
-        expm1(): /*elided*/ any;
-        floor(): /*elided*/ any;
-        floordiv(val: number | IExpr | null): /*elided*/ any;
-        hypot(val: number | IExpr | null): /*elided*/ any;
-        log(base?: number): /*elided*/ any;
-        log1p(): /*elided*/ any;
-        mod(val: number | IExpr | null): /*elided*/ any;
-        mul(val: number | IExpr | null): /*elided*/ any;
-        negate(): /*elided*/ any;
-        pow(val: number | IExpr | null): /*elided*/ any;
-        radians(): /*elided*/ any;
-        rand(seed?: number, { min, max, integer }?: RandomOptions): /*elided*/ any;
-        round(decimals?: number): /*elided*/ any;
-        sign(): /*elided*/ any;
-        sin(): /*elided*/ any;
-        sinh(): /*elided*/ any;
-        sqrt(): /*elided*/ any;
-        sub(val: number | IExpr | null): /*elided*/ any;
-        tan(): /*elided*/ any;
-        tanh(): /*elided*/ any;
-        trunc(): /*elided*/ any;
-        avg(): /*elided*/ any;
-        mean(): /*elided*/ any;
-        sum(): /*elided*/ any;
-        std(): /*elided*/ any;
-        min(): /*elided*/ any;
-        max(): /*elided*/ any;
-        median(): /*elided*/ any;
-        quantile(q: number): /*elided*/ any;
-        count(options?: {
-            includeNulls?: boolean;
-        }): /*elided*/ any;
-        cum_max(reverse?: boolean): /*elided*/ any;
-        cum_min(reverse?: boolean): /*elided*/ any;
-        cum_prod(reverse?: boolean): /*elided*/ any;
-        cum_sum(reverse?: boolean): /*elided*/ any;
-        rolling_max(windowSize: number): /*elided*/ any;
-        rolling_mean(windowSize: number): /*elided*/ any;
-        rolling_median(windowSize: number): /*elided*/ any;
-        rolling_min(windowSize: number): /*elided*/ any;
-        rolling_quantile(quantile: number, windowSize: number): /*elided*/ any;
-        rolling_std(windowSize: number): /*elided*/ any;
-        rolling_sum(windowSize: number): /*elided*/ any;
-        ops: import("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("../../types").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: import("../../types").RegisteredDataType): /*elided*/ any;
-        _resolve(val: any, columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData | any;
-        evaluate(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePreGrouping(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
-        evaluatePrePartition(columns: import("../../types").ColumnDict, height: number): import("../../types").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("../../types").ColumnDict): import("../../types").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-        _window(evaluateWindow: (this: IExpr, groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any): /*elided*/ any;
-        _rolling(windowSize: number, aggFn: (vals: any[]) => any): /*elided*/ any;
-        _deriveAgg(fn: import("../../types").AggFn<any>): /*elided*/ any;
-    };
-} & TBase;