df-script 1.4.0 → 1.5.0

package/dist/columnExpressions/ColumnExpr.d.ts

@@ -1,368 +1,30 @@
 import { ExprBase } from "./ExprBase";
-declare const ColumnExpr_base: {
-    new (...args: any[]): {
-        get list(): import("./mixins/ListExpr").ListExprNamespace;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        get dt(): import("./mixins/TemporalExpr").DateTimeExprNamespace;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        and(other: any): /*elided*/ any;
-        not(): /*elided*/ any;
-        or(other: any): /*elided*/ any;
-        xor(other: any): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        get str(): import("./mixins/StringExpr").StringExprNamespace;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        partitionBy: (string | import("..").IExpr)[] | null;
-        _rolling(windowSize: number, aggFn: (vals: any[]) => any): /*elided*/ any;
-        get isWindow(): boolean;
-        cum_count(reverse?: 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;
-        dense_rank(): /*elided*/ any;
-        lag(offset?: number, defaultVal?: any): /*elided*/ any;
-        lead(offset?: number, defaultVal?: any): /*elided*/ any;
-        over(columns: string | import("..").IExpr | (string | import("..").IExpr)[]): /*elided*/ any;
-        rank(): /*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_rank(windowSize: number): /*elided*/ any;
-        rolling_std(windowSize: number): /*elided*/ any;
-        rolling_sum(windowSize: number): /*elided*/ any;
-        row_number(): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        windowOp?: {
-            type: string;
-            [key: string]: any;
-        } | null;
-        alias(name: string): /*elided*/ any;
-        cast(dataType: any): /*elided*/ any;
-        _resolve(val: any, columns: import("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        aggFn: import("..").AggFn<any> | null;
-        _deriveAgg(fn: import("..").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("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        between(lower: any, upper: any, closed?: "both" | "left" | "right" | "none"): /*elided*/ any;
-        eq(val: any): /*elided*/ any;
-        eq_missing(val: any): /*elided*/ any;
-        ge(val: any): /*elided*/ any;
-        gt(val: any): /*elided*/ any;
-        has_nulls(): any;
-        is_close(other: any, options?: {
-            abs_tol?: number;
-            rel_tol?: number;
-            nans_equal?: boolean;
-        }): /*elided*/ any;
-        is_duplicated(): /*elided*/ any;
-        is_empty(options?: {
-            ignoreNulls?: boolean;
-        }): /*elided*/ any;
-        is_finite(): /*elided*/ any;
-        is_first_distinct(): /*elided*/ any;
-        is_in(values: any[] | any): /*elided*/ any;
-        is_infinite(): /*elided*/ any;
-        is_last_distinct(): /*elided*/ any;
-        is_n_distinct(n: number): any;
-        is_nan(): /*elided*/ any;
-        is_not_nan(): /*elided*/ any;
-        is_not_null(): /*elided*/ any;
-        is_null(): /*elided*/ any;
-        is_unique(): /*elided*/ any;
-        le(val: any): /*elided*/ any;
-        lt(val: any): /*elided*/ any;
-        ne(val: any): /*elided*/ any;
-        ne_missing(val: any): /*elided*/ any;
-        not_in(values: any[] | any): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        abs(): /*elided*/ any;
-        acos(): /*elided*/ any;
-        acosh(): /*elided*/ any;
-        add(val: number | import("..").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 | import("..").IExpr | null): /*elided*/ any;
-        exp(): /*elided*/ any;
-        expm1(): /*elided*/ any;
-        floor(): /*elided*/ any;
-        floordiv(val: number | import("..").IExpr | null): /*elided*/ any;
-        hypot(val: number | import("..").IExpr | null): /*elided*/ any;
-        log(base?: number): /*elided*/ any;
-        log1p(): /*elided*/ any;
-        mod(val: number | import("..").IExpr | null): /*elided*/ any;
-        mul(val: number | import("..").IExpr | null): /*elided*/ any;
-        negate(): /*elided*/ any;
-        pow(val: number | import("..").IExpr | null): /*elided*/ any;
-        radians(): /*elided*/ any;
-        rand(seed?: number, { min, max, integer }?: import("./types").RandomOptions): /*elided*/ any;
-        round(decimals?: number): /*elided*/ any;
-        sign(): /*elided*/ any;
-        sin(): /*elided*/ any;
-        sinh(): /*elided*/ any;
-        sqrt(): /*elided*/ any;
-        sub(val: number | import("..").IExpr | null): /*elided*/ any;
-        tan(): /*elided*/ any;
-        tanh(): /*elided*/ any;
-        trunc(): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & {
-    new (...args: any[]): {
-        fill_null(value: any): /*elided*/ any;
-        reverse(): /*elided*/ any;
-        ops: import("..").OpFn[];
-        colName?: string;
-        outputName?: string;
-        isLiteral?: boolean;
-        literalValue?: any;
-        aggFn?: import("..").AggFn<any> | null;
-        groupingOpsIndex?: number;
-        partitionOpsIndex?: number;
-        partitionBy?: (string | import("..").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("..").ColumnDict, height: number): import("..").ColumnData | any;
-        evaluate(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePreGrouping(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostGrouping(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluatePrePartition(columns: import("..").ColumnDict, height: number): import("..").ColumnData;
-        evaluatePostPartition(aggregatedArray: any[], columns: import("..").ColumnDict): import("..").ColumnData;
-        evaluateWindow?(groupPreValues: any[], partitionIndices: number[], currentIndex: number): any;
-        debug(label?: string): /*elided*/ any;
-    };
-} & typeof ExprBase;
-export declare class ColumnExpr<T> extends ColumnExpr_base {
+import { ArithmeticExpr } from "./mixins/ArithmeticExpr";
+import { ComparisonExpr } from "./mixins/ComparisonExpr";
+import { AggregationExpr } from "./mixins/AggregationExpr";
+import { WindowExpr } from "./mixins/WindowExpr";
+import { StringExpr } from "./mixins/StringExpr";
+import { LogicalExpr } from "./mixins/LogicalExpr";
+import { TemporalExpr } from "./mixins/TemporalExpr";
+import { ListExpr } from "./mixins/ListExpr";
+import { StructExpr } from "./mixins/StructExpr";
+import { ManipulationExpr } from "./mixins/ManipulationExpr";
+import { DataType } from "../datatypes";
+import type { IntoExpr, IExpr, DataFrameSchema, ColumnDict } from "../types";
+export declare class ColumnExpr<T> extends ExprBase {
     colName: string;
+    colNames?: string[];
     excludedCols: string[];
-    constructor(colName: keyof T | string);
+    targetType?: any;
+    targetTypes?: any[];
+    static isColExpr(v: unknown): v is ColumnExpr<any>;
+    static toColExpr(col: IntoExpr | IntoExpr[]): ColumnExpr<any>;
+    constructor(colName: keyof T | string | (keyof T | string)[] | DataType | Function | (DataType | Function)[]);
 }
-export {};
+export interface ColumnExpr<T> extends ArithmeticExpr, ComparisonExpr, AggregationExpr, WindowExpr, StringExpr, LogicalExpr, TemporalExpr, ListExpr, StructExpr, ManipulationExpr {
+}
+/**
+ * Resolves column selectors, expanding wildcards, datatypes, and arrays of columns/types
+ * into concrete ColumnExpr instances.
+ */
+export declare function resolveColumnSelectors(exprs: any[], allKeys: string[], keysToExcludeFromAll?: string[], schema?: DataFrameSchema, columns?: ColumnDict): IExpr[];

package/dist/columnExpressions/ColumnExpr.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ColumnExpr = void 0;
+exports.resolveColumnSelectors = resolveColumnSelectors;
 const ExprBase_1 = require("./ExprBase");
 const ArithmeticExpr_1 = require("./mixins/ArithmeticExpr");
 const ComparisonExpr_1 = require("./mixins/ComparisonExpr");
@@ -10,14 +11,209 @@ const StringExpr_1 = require("./mixins/StringExpr");
 const LogicalExpr_1 = require("./mixins/LogicalExpr");
 const TemporalExpr_1 = require("./mixins/TemporalExpr");
 const ListExpr_1 = require("./mixins/ListExpr");
+const StructExpr_1 = require("./mixins/StructExpr");
 const ManipulationExpr_1 = require("./mixins/ManipulationExpr");
-class ColumnExpr extends (0, ListExpr_1.ListExpr)((0, TemporalExpr_1.TemporalExpr)((0, LogicalExpr_1.LogicalExpr)((0, StringExpr_1.StringExpr)((0, WindowExpr_1.WindowExpr)((0, AggregationExpr_1.AggregationExpr)((0, ComparisonExpr_1.ComparisonExpr)((0, ArithmeticExpr_1.ArithmeticExpr)((0, ManipulationExpr_1.ManipulationExpr)(ExprBase_1.ExprBase))))))))) {
+const utils_1 = require("../utils");
+const datatypes_1 = require("../datatypes");
+const constants_1 = require("./constants");
+class ColumnExpr extends ExprBase_1.ExprBase {
     colName;
+    colNames;
     excludedCols = [];
+    targetType;
+    targetTypes;
+    static isColExpr(v) {
+        if (!(0, utils_1.isObj)(v))
+            return false;
+        try {
+            return "evaluate" in v && typeof v.evaluate === "function";
+        }
+        catch {
+            return false;
+        }
+    }
+    static toColExpr(col) {
+        if (col == null) {
+            throw new Error("Column reference cannot be null or undefined.");
+        }
+        return ColumnExpr.isColExpr(col) ? col : new ColumnExpr(col);
+    }
     constructor(colName) {
         super();
-        this.colName = String(colName);
-        this.outputName = this.colName;
+        if (Array.isArray(colName)) {
+            const hasTypes = colName.some(x => x instanceof datatypes_1.DataType || typeof x === "function");
+            if (hasTypes) {
+                this.targetTypes = colName;
+                this.colName = "";
+                this.outputName = "";
+            }
+            else {
+                this.colNames = colName.map(String);
+                this.colName = "";
+                this.outputName = "";
+            }
+        }
+        else if (colName instanceof datatypes_1.DataType || typeof colName === "function") {
+            this.targetType = colName;
+            this.colName = "";
+            this.outputName = "";
+        }
+        else {
+            this.colName = String(colName);
+            this.outputName = this.colName;
+        }
     }
 }
 exports.ColumnExpr = ColumnExpr;
+function applyMixins(derivedCtor, constructors) {
+    for (const baseCtor of constructors) {
+        for (const name of Object.getOwnPropertyNames(baseCtor.prototype)) {
+            if (name !== 'constructor') {
+                Object.defineProperty(derivedCtor.prototype, name, Object.getOwnPropertyDescriptor(baseCtor.prototype, name) || Object.create(null));
+            }
+        }
+    }
+}
+applyMixins(ColumnExpr, [
+    ArithmeticExpr_1.ArithmeticExpr,
+    ComparisonExpr_1.ComparisonExpr,
+    AggregationExpr_1.AggregationExpr,
+    WindowExpr_1.WindowExpr,
+    StringExpr_1.StringExpr,
+    LogicalExpr_1.LogicalExpr,
+    TemporalExpr_1.TemporalExpr,
+    ListExpr_1.ListExpr,
+    StructExpr_1.StructExpr,
+    ManipulationExpr_1.ManipulationExpr
+]);
+/**
+ * Determines which concrete keys a column selector matches.
+ * Returns null if the expression is not a multi-column selector.
+ */
+function getTargetKeys(expr, allKeys, excludeSet, schema) {
+    if (!(expr instanceof ColumnExpr)) {
+        if (expr && typeof expr === "object" && "evaluate" in expr && !expr.colName) {
+            const targets = [];
+            for (let i = 0; i < allKeys.length; i++) {
+                if (!excludeSet.has(allKeys[i])) {
+                    targets.push(allKeys[i]);
+                }
+            }
+            return targets;
+        }
+        return null;
+    }
+    if (expr.colNames && expr.colNames.length > 0) {
+        return expr.colNames;
+    }
+    if (expr.colName === constants_1.ALL_COLUMNS_MARKER) {
+        const excluded = new Set(expr.excludedCols);
+        const targets = [];
+        for (let i = 0; i < allKeys.length; i++) {
+            const key = allKeys[i];
+            if (!excluded.has(key) && !excludeSet.has(key)) {
+                targets.push(key);
+            }
+        }
+        return targets;
+    }
+    if (expr.targetType || (expr.targetTypes && expr.targetTypes.length > 0)) {
+        if (!schema) {
+            throw new Error("Cannot resolve DataType column selector without DataFrame schema.");
+        }
+        const targets = [];
+        for (let i = 0; i < allKeys.length; i++) {
+            const key = allKeys[i];
+            if (excludeSet.has(key)) {
+                continue;
+            }
+            const colType = schema[key];
+            if (!colType) {
+                continue;
+            }
+            if (expr.targetType) {
+                if (colType.matches(expr.targetType)) {
+                    targets.push(key);
+                }
+            }
+            else if (expr.targetTypes) {
+                for (let k = 0; k < expr.targetTypes.length; k++) {
+                    if (colType.matches(expr.targetTypes[k])) {
+                        targets.push(key);
+                        break;
+                    }
+                }
+            }
+        }
+        return targets;
+    }
+    return null;
+}
+/**
+ * Resolves column selectors, expanding wildcards, datatypes, and arrays of columns/types
+ * into concrete ColumnExpr instances.
+ */
+function resolveColumnSelectors(exprs, allKeys, keysToExcludeFromAll, schema, columns) {
+    const expanded = [];
+    const excludeSet = keysToExcludeFromAll ? new Set(keysToExcludeFromAll) : new Set();
+    for (let i = 0; i < exprs.length; i++) {
+        const expr = exprs[i];
+        if (typeof expr === "string") {
+            expanded.push(new ColumnExpr(expr));
+            continue;
+        }
+        // Handle struct unnesting expansion
+        if (expr && typeof expr === "object" && expr.isUnnest) {
+            let fields = [];
+            const colName = expr.colName;
+            if (schema && colName && schema[colName] && schema[colName].name === "Struct") {
+                fields = Object.keys(schema[colName].fields);
+            }
+            if (fields.length === 0 && columns) {
+                const columnsKeys = Object.keys(columns);
+                const firstKey = columnsKeys[0];
+                const height = firstKey ? columns[firstKey].length : 0;
+                const evaluated = expr.baseExpr.evaluate(columns, height);
+                const evalLen = evaluated.length;
+                for (let idx = 0; idx < evalLen; idx++) {
+                    const item = evaluated[idx];
+                    if (item != null && typeof item === "object") {
+                        fields = Object.keys(item);
+                        break;
+                    }
+                }
+            }
+            const fieldsLen = fields.length;
+            if (fieldsLen > 0) {
+                for (let fIdx = 0; fIdx < fieldsLen; fIdx++) {
+                    const fieldName = fields[fIdx];
+                    const fieldExpr = expr.baseExpr.struct.field(fieldName);
+                    expanded.push(fieldExpr);
+                }
+                continue;
+            }
+        }
+        const targets = getTargetKeys(expr, allKeys, excludeSet, schema);
+        if (targets !== null) {
+            for (let j = 0; j < targets.length; j++) {
+                const concrete = new ColumnExpr(targets[j]);
+                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 {
+            expanded.push(expr);
+        }
+    }
+    return expanded;
+}

package/dist/columnExpressions/ExprBase.d.ts

@@ -1,24 +1,21 @@
-import type { IExpr, OpFn, AggFn, ColumnData, ColumnDict } from "../types";
-import type { DataType } from "../datatypes";
-export declare const kleeneUnary: (fn: (v: any) => any) => (vArray: ColumnData) => any[];
-export declare const kleeneBinary: (expr: IExpr, other: any, fn: (v: any, r: any) => any) => (vArray: ColumnData, columns: ColumnDict) => any[];
+import type { IExpr, OpFn, AggFn, ColumnData, ColumnDict, RegisteredDataType } from "../types";
 export declare const derive: <T extends IExpr>(instance: T, nextOp?: OpFn) => T;
 export declare class ExprBase implements IExpr {
     ops: OpFn[];
     outputName: string;
+    isLiteral?: boolean;
+    literalValue?: any;
     aggFn?: AggFn<any> | null;
     groupingOpsIndex?: number;
     partitionOpsIndex?: number;
     partitionBy: (string | IExpr)[] | null;
+    evaluateWindow?: (groupPreValues: any[], partitionIndices: number[], currentIndex: number) => any;
     _resolve(val: any, columns: ColumnDict, height: number): any;
     alias(name: string): this;
-    cast(dataType: DataType): this;
+    cast(dataType: RegisteredDataType): this;
     debug(label?: string): this;
+    private _getInitialValue;
     evaluate(columns: ColumnDict, height: number): ColumnData;
-    private _evaluatePre;
-    private _evaluatePost;
-    evaluatePrePartition(columns: ColumnDict, height: number): ColumnData;
-    evaluatePostPartition(aggregatedArray: any[], columns: ColumnDict): ColumnData;
-    evaluatePreGrouping(columns: ColumnDict, height: number): ColumnData;
-    evaluatePostGrouping(aggregatedArray: any[], columns: ColumnDict): ColumnData;
+    evaluatePre(opsIndex: number | undefined, columns: ColumnDict, height: number): ColumnData;
+    evaluatePost(opsIndex: number | undefined, aggregatedArray: any[], columns: ColumnDict): ColumnData;
 }