df-script 1.4.0 → 1.5.0

package/dist/columnExpressions/index.js

@@ -14,9 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveColumnSelectors = resolveColumnSelectors;
-const ColumnExpr_1 = require("./ColumnExpr");
-const constants_1 = require("./constants");
 __exportStar(require("./constants"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./ExprBase"), exports);
@@ -28,54 +25,14 @@ __exportStar(require("./mixins/AggregationExpr"), exports);
 __exportStar(require("./mixins/WindowExpr"), exports);
 __exportStar(require("./mixins/TemporalExpr"), exports);
 __exportStar(require("./mixins/ListExpr"), exports);
+__exportStar(require("./mixins/StructExpr"), exports);
 __exportStar(require("./ColumnExpr"), exports);
 __exportStar(require("./functions/lit"), exports);
 __exportStar(require("./functions/all"), exports);
 __exportStar(require("./functions/exclude"), exports);
 __exportStar(require("./functions/coalesce"), exports);
 __exportStar(require("./functions/when"), exports);
-function resolveColumnSelectors(exprs, allKeys, keysToExcludeFromAll) {
-    const expanded = [];
-    const excludeSet = keysToExcludeFromAll ? new Set(keysToExcludeFromAll) : new Set();
-    for (const expr of exprs) {
-        if (typeof expr === "string") {
-            expanded.push(new ColumnExpr_1.ColumnExpr(expr));
-        }
-        else if (expr instanceof ColumnExpr_1.ColumnExpr && expr.colName === constants_1.ALL_COLUMNS_MARKER) {
-            const excluded = new Set(expr.excludedCols);
-            for (const key of allKeys) {
-                if (!excludeSet.has(key) && !excluded.has(key)) {
-                    const concrete = new ColumnExpr_1.ColumnExpr(key);
-                    concrete.ops = [...expr.ops];
-                    concrete.aggFn = expr.aggFn;
-                    concrete.partitionOpsIndex = expr.partitionOpsIndex;
-                    concrete.groupingOpsIndex = expr.groupingOpsIndex;
-                    concrete.partitionBy = expr.partitionBy;
-                    if (expr.evaluateWindow) {
-                        concrete.evaluateWindow = expr.evaluateWindow;
-                    }
-                    if (expr.outputName && expr.outputName !== constants_1.ALL_COLUMNS_MARKER) {
-                        concrete.outputName = expr.outputName;
-                    }
-                    expanded.push(concrete);
-                }
-            }
-        }
-        else if (expr && typeof expr === 'object' && 'evaluate' in expr && !expr.colName) {
-            for (const key of allKeys) {
-                if (!excludeSet.has(key)) {
-                    const concrete = new ColumnExpr_1.ColumnExpr(key);
-                    concrete.ops = [...expr.ops];
-                    concrete.aggFn = expr.aggFn;
-                    concrete.groupingOpsIndex = expr.groupingOpsIndex;
-                    concrete.partitionOpsIndex = expr.partitionOpsIndex;
-                    expanded.push(concrete);
-                }
-            }
-        }
-        else {
-            expanded.push(expr);
-        }
-    }
-    return expanded;
-}
+__exportStar(require("./functions/implode"), exports);
+__exportStar(require("./functions/seq_range"), exports);
+__exportStar(require("./functions/element"), exports);
+__exportStar(require("./utils"), exports);

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

@@ -1,50 +1,25 @@
-import type { AggFn } from "../../types";
-import type { ExprConstructor } from "../types";
-export declare const AggregationExpr: <TBase extends ExprConstructor>(Base: TBase) => {
-    new (...args: any[]): {
-        aggFn: AggFn<any> | null;
-        _deriveAgg(fn: AggFn<any>): /*elided*/ any;
-        all(): /*elided*/ any;
-        all_null(): /*elided*/ any;
-        any(): /*elided*/ any;
-        any_null(): /*elided*/ any;
-        avg(): /*elided*/ any;
-        count(options?: {
-            includeNulls?: boolean;
-        }): /*elided*/ any;
-        first(): /*elided*/ any;
-        last(): /*elided*/ any;
-        max(): /*elided*/ any;
-        mean(): /*elided*/ any;
-        median(): /*elided*/ any;
-        min(): /*elided*/ any;
-        mode(): /*elided*/ any;
-        n_unique(): /*elided*/ any;
-        quantile(q: number): /*elided*/ any;
-        std(): /*elided*/ any;
-        sum(): /*elided*/ any;
-        ops: import("../../types").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("../../types").IExpr)[] | null;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        isWindow?: boolean;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*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;
-    };
-} & TBase;
+import type { AggFn, UniqueListStatsOptions } from "../../types";
+import { ExprBase } from "../ExprBase";
+export declare class AggregationExpr extends ExprBase {
+    _deriveAgg(fn: AggFn<any>): this;
+    all(): this;
+    all_null(): this;
+    any(): this;
+    any_null(): this;
+    avg(): this;
+    count(options?: {
+        includeNulls?: boolean;
+    }): this;
+    first(): this;
+    implode(): this;
+    last(): this;
+    max(): this;
+    mean(): this;
+    median(): this;
+    min(): this;
+    mode(): this;
+    n_unique(options?: UniqueListStatsOptions): this;
+    quantile(q: number): this;
+    std(): this;
+    sum(): this;
+}

package/dist/columnExpressions/mixins/AggregationExpr.js

@@ -4,169 +4,73 @@ exports.AggregationExpr = void 0;
 const ExprBase_1 = require("../ExprBase");
 const exceptions_1 = require("../../exceptions");
 const utils_1 = require("../../utils");
-const AggregationExpr = (Base) => {
-    return class extends Base {
-        aggFn = this.aggFn || null;
-        _deriveAgg(fn) {
-            const newInst = (0, ExprBase_1.derive)(this);
-            newInst.aggFn = fn;
-            newInst.groupingOpsIndex = this.ops.length;
-            newInst.partitionOpsIndex = this.ops.length;
-            return newInst;
-        }
-        all() {
-            return this._deriveAgg(v => {
-                for (let i = 0; i < v.length; i++) {
-                    if (!v[i])
-                        return false;
-                }
-                return true;
-            });
-        }
-        all_null() {
-            return this._deriveAgg(v => {
-                for (let i = 0; i < v.length; i++) {
-                    if (v[i] != null)
-                        return false;
-                }
-                return true;
-            });
-        }
-        any() {
-            return this._deriveAgg(v => {
-                for (let i = 0; i < v.length; i++) {
-                    if (v[i])
-                        return true;
-                }
-                return false;
-            });
-        }
-        any_null() {
-            return this._deriveAgg(v => {
-                for (let i = 0; i < v.length; i++) {
-                    if (v[i] == null)
-                        return true;
-                }
-                return false;
-            });
-        }
-        avg() {
-            return this._deriveAgg(v => (0, utils_1.getListStats)(v).mean);
-        }
-        count(options = {}) {
-            if (options.includeNulls)
-                return this._deriveAgg(v => v.length);
-            return this._deriveAgg(v => (0, utils_1.getListStats)(v).count);
-        }
-        first() {
-            return this._deriveAgg(v => v[0] ?? null);
-        }
-        last() {
-            return this._deriveAgg(v => v[v.length - 1] ?? null);
-        }
-        max() {
-            return this._deriveAgg(v => (0, utils_1.getListStats)(v).max);
-        }
-        mean() {
-            return this.avg();
-        }
-        median() {
-            return this._deriveAgg(v => {
-                if (!(0, utils_1.isArrayOfType)(v, "number", { allowNulls: true }))
-                    return null;
-                const len = v.length;
-                const nums = [];
-                for (let i = 0; i < len; i++) {
-                    const val = v[i];
-                    if (val != null) {
-                        nums.push(val);
-                    }
-                }
-                const numsLen = nums.length;
-                if (numsLen === 0)
-                    return null;
-                nums.sort((a, b) => a - b);
-                const mid = Math.floor(numsLen / 2);
-                return numsLen % 2 !== 0
-                    ? nums[mid]
-                    : (nums[mid - 1] + nums[mid]) / 2;
-            });
-        }
-        min() {
-            return this._deriveAgg(v => (0, utils_1.getListStats)(v).min);
-        }
-        mode() {
-            return this._deriveAgg(v => {
-                if (!(0, utils_1.isArrayOrTypedArray)(v))
-                    return null;
-                const len = v.length;
-                const counts = new Map();
-                let maxCount = 0;
-                for (let i = 0; i < len; i++) {
-                    const val = v[i];
-                    if (val == null)
-                        continue;
-                    const c = (counts.get(val) ?? 0) + 1;
-                    counts.set(val, c);
-                    if (c > maxCount)
-                        maxCount = c;
-                }
-                if (maxCount === 0)
-                    return null;
-                const modes = [];
-                for (const [val, c] of counts.entries()) {
-                    if (c === maxCount) {
-                        modes.push(val);
-                    }
-                }
-                if (modes.length === 0)
-                    return null;
-                modes.sort((a, b) => {
-                    if (a == null && b == null)
-                        return 0;
-                    if (a == null)
-                        return 1;
-                    if (b == null)
-                        return -1;
-                    if (a < b)
-                        return -1;
-                    if (a > b)
-                        return 1;
-                    return 0;
-                });
-                return modes[0];
-            });
-        }
-        n_unique() {
-            return this._deriveAgg(v => new Set(v).size);
-        }
-        quantile(q) {
-            if (q < 0 || q > 1)
-                throw new exceptions_1.ComputeError("Quantile q must be between 0 and 1");
-            return this._deriveAgg(v => {
-                const f = [];
-                for (let i = 0; i < v.length; i++) {
-                    if (v[i] != null)
-                        f.push(v[i]);
-                }
-                const fLen = f.length;
-                if (!fLen)
-                    return null;
-                f.sort((a, b) => a - b);
-                const idx = (fLen - 1) * q;
-                const low = Math.floor(idx);
-                const high = Math.ceil(idx);
-                if (low === high)
-                    return f[low];
-                return f[low] + (idx - low) * (f[high] - f[low]);
-            });
-        }
-        std() {
-            return this._deriveAgg(v => (0, utils_1.getListStats)(v).std);
-        }
-        sum() {
-            return this._deriveAgg(v => (0, utils_1.getListStats)(v).sum);
-        }
-    };
-};
+class AggregationExpr extends ExprBase_1.ExprBase {
+    _deriveAgg(fn) {
+        const newInst = (0, ExprBase_1.derive)(this);
+        newInst.aggFn = fn;
+        newInst.groupingOpsIndex = this.ops.length;
+        newInst.partitionOpsIndex = this.ops.length;
+        return newInst;
+    }
+    all() {
+        return this._deriveAgg(v => (0, utils_1.isArrayOfType)(v, (x) => !!x, { mode: "every" }));
+    }
+    all_null() {
+        return this._deriveAgg(v => (0, utils_1.isArrayOfType)(v, "nullish", { mode: "every" }));
+    }
+    any() {
+        return this._deriveAgg(v => (0, utils_1.isArrayOfType)(v, (x) => !!x, { mode: "some" }));
+    }
+    any_null() {
+        return this._deriveAgg(v => (0, utils_1.isArrayOfType)(v, "nullish", { mode: "some" }));
+    }
+    avg() {
+        return this._deriveAgg(v => (0, utils_1.getListStats)(v).mean);
+    }
+    count(options = {}) {
+        if (options.includeNulls)
+            return this._deriveAgg(v => v.length);
+        return this._deriveAgg(v => (0, utils_1.getListStats)(v).count);
+    }
+    first() {
+        return this._deriveAgg(v => v[0] ?? null);
+    }
+    implode() {
+        return this._deriveAgg(v => v);
+    }
+    last() {
+        return this._deriveAgg(v => v[v.length - 1] ?? null);
+    }
+    max() {
+        return this._deriveAgg(v => (0, utils_1.getListStats)(v).max);
+    }
+    mean() {
+        return this.avg();
+    }
+    median() {
+        return this._deriveAgg(v => (0, utils_1.computeMedian)(v));
+    }
+    min() {
+        return this._deriveAgg(v => (0, utils_1.getListStats)(v).min);
+    }
+    mode() {
+        return this._deriveAgg(v => (0, utils_1.computeMode)(v));
+    }
+    n_unique(options = {}) {
+        return this._deriveAgg(v => {
+            return (0, utils_1.getUniqueListStats)(v, options).count;
+        });
+    }
+    quantile(q) {
+        if (q < 0 || q > 1)
+            throw new exceptions_1.ComputeError("Quantile q must be between 0 and 1");
+        return this._deriveAgg(v => (0, utils_1.computeQuantile)(v, q));
+    }
+    std() {
+        return this._deriveAgg(v => (0, utils_1.getListStats)(v).std);
+    }
+    sum() {
+        return this._deriveAgg(v => (0, utils_1.getListStats)(v).sum);
+    }
+}
 exports.AggregationExpr = AggregationExpr;

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

@@ -1,67 +1,42 @@
 import type { IExpr } from "../../types";
-import type { ExprConstructor, RandomOptions } from "../types";
-export declare const ArithmeticExpr: <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;
-        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: any): /*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;
-    };
-} & TBase;
+import type { RandomOptions } from "../types";
+import { ExprBase } from "../ExprBase";
+export declare class ArithmeticExpr extends ExprBase {
+    abs(): this;
+    acos(): this;
+    acosh(): this;
+    add(val: number | IExpr | null): this;
+    asin(): this;
+    asinh(): this;
+    atan(): this;
+    atanh(): this;
+    cbrt(): this;
+    ceil(): this;
+    clip(lower?: number | null, upper?: number | null): this;
+    cos(): this;
+    cosh(): this;
+    degrees(): this;
+    div(val: number | IExpr | null): this;
+    exp(): this;
+    expm1(): this;
+    floor(): this;
+    floordiv(val: number | IExpr | null): this;
+    hypot(val: number | IExpr | null): this;
+    log(base?: number): this;
+    log1p(): this;
+    mod(val: number | IExpr | null): this;
+    mul(val: number | IExpr | null): this;
+    negate(): this;
+    pow(val: number | IExpr | null): this;
+    radians(): this;
+    rand(seed?: number, { min, max, integer }?: RandomOptions): this;
+    round(decimals?: number): this;
+    sign(): this;
+    sin(): this;
+    sinh(): this;
+    sqrt(): this;
+    sub(val: number | IExpr | null): this;
+    tan(): this;
+    tanh(): this;
+    trunc(): this;
+}