df-script 1.4.0

package/dist/columnExpressions/mixins/StringExpr.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringExpr = exports.StringExprNamespace = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+class StringExprNamespace {
+    expr;
+    constructor(expr) {
+        this.expr = expr;
+    }
+    _deriveString(fn) {
+        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneUnary)((v) => fn(String(v))));
+    }
+    concat(other) {
+        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneBinary)(this.expr, other, (v, o) => String(v) + String(o)));
+    }
+    contains(pattern) {
+        if (pattern == null) {
+            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
+        }
+        return this._deriveString((str) => {
+            return pattern instanceof RegExp ? pattern.test(str) : str.includes(pattern);
+        });
+    }
+    count_matches(pattern) {
+        if (pattern == null) {
+            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
+        }
+        return this._deriveString((str) => {
+            if (pattern instanceof RegExp) {
+                const regex = pattern.global
+                    ? pattern
+                    : new RegExp(pattern.source, pattern.flags + "g");
+                const matches = str.match(regex);
+                return matches ? matches.length : 0;
+            }
+            else {
+                let count = 0;
+                let pos = str.indexOf(pattern);
+                while (pos !== -1) {
+                    count++;
+                    pos = str.indexOf(pattern, pos + pattern.length);
+                }
+                return count;
+            }
+        });
+    }
+    decode_uri_component() {
+        return this._deriveString((str) => {
+            try {
+                return decodeURIComponent(str);
+            }
+            catch {
+                return str;
+            }
+        });
+    }
+    encode_uri_component() {
+        return this._deriveString((str) => {
+            try {
+                return encodeURIComponent(str);
+            }
+            catch {
+                return str;
+            }
+        });
+    }
+    ends_with(suffix) {
+        return this._deriveString((str) => str.endsWith(suffix));
+    }
+    explode() {
+        return this._deriveString((str) => str.split(""));
+    }
+    extract(pattern, group = 0) {
+        if (pattern == null) {
+            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
+        }
+        return this._deriveString((str) => {
+            const match = str.match(pattern);
+            if (!match)
+                return null;
+            return match[group] !== undefined ? match[group] : null;
+        });
+    }
+    len() {
+        return this.len_chars();
+    }
+    len_bytes() {
+        return this._deriveString((str) => new TextEncoder().encode(str).length);
+    }
+    len_chars() {
+        return this._deriveString((str) => str.length);
+    }
+    lower() {
+        return this._deriveString((str) => str.toLowerCase());
+    }
+    lpad(width, fill = " ") {
+        return this._deriveString((str) => str.padStart(width, fill));
+    }
+    pad_end(width, fill = " ") {
+        return this.rpad(width, fill);
+    }
+    pad_start(width, fill = " ") {
+        return this.lpad(width, fill);
+    }
+    replace(pattern, replacement) {
+        if (pattern == null) {
+            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
+        }
+        return this._deriveString((str) => str.replace(pattern, replacement));
+    }
+    replace_all(pattern, replacement) {
+        if (pattern == null) {
+            return (0, ExprBase_1.derive)(this.expr, (vArray) => new Array(vArray.length).fill(null));
+        }
+        return this._deriveString((str) => {
+            if (pattern instanceof RegExp) {
+                const regex = pattern.global
+                    ? pattern
+                    : new RegExp(pattern.source, pattern.flags + "g");
+                return str.replace(regex, replacement);
+            }
+            return str.replaceAll(pattern, replacement);
+        });
+    }
+    reverse() {
+        return this._deriveString((str) => str.split("").reverse().join(""));
+    }
+    rpad(width, fill = " ") {
+        return this._deriveString((str) => str.padEnd(width, fill));
+    }
+    slice(offset, length) {
+        return this._deriveString((str) => {
+            const start = offset < 0 ? str.length + offset : offset;
+            const end = length !== undefined ? start + length : undefined;
+            return str.slice(start, end);
+        });
+    }
+    slice_str(offset, length) {
+        return this.slice(offset, length);
+    }
+    split(delimiter) {
+        return this._deriveString((str) => str.split(delimiter));
+    }
+    starts_with(prefix) {
+        return this._deriveString((str) => str.startsWith(prefix));
+    }
+    strip_chars(characters, options) {
+        return this._deriveString((str) => (0, utils_1.stripChars)(str, characters, { mode: "both", ...options }));
+    }
+    strip_chars_end(characters, options) {
+        return this._deriveString((str) => (0, utils_1.stripChars)(str, characters, { mode: "end", ...options }));
+    }
+    strip_chars_start(characters, options) {
+        return this._deriveString((str) => (0, utils_1.stripChars)(str, characters, { mode: "start", ...options }));
+    }
+    strip_prefix(prefix) {
+        return this._deriveString((str) => {
+            return (0, utils_1.stripChars)(str, prefix, {
+                mode: "start",
+                maxScanStart: 1,
+                maxMatchesStart: 1,
+                returnStringOnNull: true,
+                stringOptions: { literal: true }
+            });
+        });
+    }
+    strip_suffix(suffix) {
+        return this._deriveString((str) => {
+            return (0, utils_1.stripChars)(str, suffix, {
+                mode: "end",
+                maxScanEnd: 1,
+                maxMatchesEnd: 1,
+                returnStringOnNull: true,
+                stringOptions: { literal: true }
+            });
+        });
+    }
+    strptime(format, strict = true) {
+        return this._deriveString((str) => (0, utils_1.strptime)(str, format, strict));
+    }
+    to_date() {
+        return this._deriveString((str) => {
+            const d = (0, utils_1.toValidDate)(str);
+            if (!d)
+                return null;
+            const copy = new Date(d);
+            copy.setUTCHours(0, 0, 0, 0);
+            return copy;
+        });
+    }
+    to_datetime() {
+        return this._deriveString(utils_1.toValidDate);
+    }
+    to_decimal(precision, scale) {
+        return this._deriveString((str) => (0, utils_1.toValidDecimal)(str, { precision, scale }));
+    }
+    to_integer() {
+        return this._deriveString((str) => (0, utils_1.toValidInt)(str));
+    }
+    to_lowercase() {
+        return this.lower();
+    }
+    to_time() {
+        return this._deriveString((str) => {
+            const d = (0, utils_1.toValidDate)(str);
+            if (d)
+                return d.toISOString().split("T")[1].slice(0, 12);
+            const trimmed = str.trim();
+            if (utils_1.TIME_PREFIX_REGEX.test(trimmed)) {
+                const td = new Date(`1970-01-01T${trimmed}${utils_1.ZONE_OFFSET_REGEX.test(trimmed) ? "" : "Z"}`);
+                if ((0, utils_1.isValidDateObj)(td)) {
+                    return td.toISOString().split("T")[1].slice(0, 12);
+                }
+            }
+            return null;
+        });
+    }
+    to_titlecase() {
+        return this._deriveString((str) => str.replace(/\b\w/g, c => c.toUpperCase()));
+    }
+    to_uppercase() {
+        return this.upper();
+    }
+    trim() {
+        return this.strip_chars();
+    }
+    trim_end() {
+        return this.strip_chars_end();
+    }
+    trim_start() {
+        return this.strip_chars_start();
+    }
+    upper() {
+        return this._deriveString((str) => str.toUpperCase());
+    }
+    zfill(width) {
+        return this._deriveString((str) => str.padStart(width, "0"));
+    }
+}
+exports.StringExprNamespace = StringExprNamespace;
+const StringExpr = (Base) => {
+    return class extends Base {
+        get str() {
+            return new StringExprNamespace(this);
+        }
+    };
+};
+exports.StringExpr = StringExpr;

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

@@ -0,0 +1,69 @@
+import type { TimeUnit } from "../../types";
+import type { ExprConstructor } from "../types";
+export declare class DateTimeExprNamespace {
+    expr: any;
+    constructor(expr: any);
+    _deriveDate(fn: (d: Date) => any): any;
+    _deriveDuration(fn: (v: number) => number): any;
+    century(): any;
+    date(): any;
+    datetime(): any;
+    day(): any;
+    epoch(unit?: TimeUnit): any;
+    hour(): any;
+    is_leap_year(): any;
+    microsecond(): any;
+    millennium(): any;
+    millisecond(): any;
+    minute(): any;
+    month(): any;
+    month_end(): any;
+    month_start(): any;
+    nanosecond(): any;
+    ordinal_day(): any;
+    quarter(): any;
+    second(): any;
+    strftime(format: string, locale?: string): any;
+    time(): any;
+    timestamp(unit?: TimeUnit): any;
+    to_string(format: string, locale?: string): any;
+    total_days(): any;
+    total_hours(): any;
+    total_microseconds(): any;
+    total_milliseconds(): any;
+    total_minutes(): any;
+    total_nanoseconds(): any;
+    total_seconds(): any;
+    week(): any;
+    weekday(): any;
+    year(): any;
+}
+export declare const TemporalExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        get dt(): DateTimeExprNamespace;
+        ops: import("../../types").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../../types").AggFn<any> | null;
+        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;

package/dist/columnExpressions/mixins/TemporalExpr.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemporalExpr = exports.DateTimeExprNamespace = void 0;
+const ExprBase_1 = require("../ExprBase");
+const utils_1 = require("../../utils");
+class DateTimeExprNamespace {
+    expr;
+    constructor(expr) {
+        this.expr = expr;
+    }
+    _deriveDate(fn) {
+        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneUnary)((v) => {
+            const d = (0, utils_1.toValidDate)(v);
+            return d ? fn(d) : null;
+        }));
+    }
+    _deriveDuration(fn) {
+        return (0, ExprBase_1.derive)(this.expr, (0, ExprBase_1.kleeneUnary)((v) => {
+            return typeof v === "number" ? fn(v) : null;
+        }));
+    }
+    century() {
+        return this._deriveDate(utils_1.getCentury);
+    }
+    date() {
+        return this._deriveDate((d) => new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate())));
+    }
+    datetime() {
+        return this._deriveDate((d) => d);
+    }
+    day() {
+        return this._deriveDate((d) => d.getUTCDate());
+    }
+    epoch(unit = "ms") {
+        return this._deriveDate((d) => (0, utils_1.toEpoch)(d, unit));
+    }
+    hour() {
+        return this._deriveDate((d) => d.getUTCHours());
+    }
+    is_leap_year() {
+        return this._deriveDate(utils_1.isLeapYear);
+    }
+    microsecond() {
+        return this._deriveDate((d) => d.getUTCMilliseconds() * utils_1.US_PER_MS);
+    }
+    millennium() {
+        return this._deriveDate(utils_1.getMillennium);
+    }
+    millisecond() {
+        return this._deriveDate((d) => d.getUTCMilliseconds());
+    }
+    minute() {
+        return this._deriveDate((d) => d.getUTCMinutes());
+    }
+    month() {
+        return this._deriveDate((d) => d.getUTCMonth() + 1);
+    }
+    month_end() {
+        return this._deriveDate((d) => (0, utils_1.getMonthOffset)(d, 1, 0));
+    }
+    month_start() {
+        return this._deriveDate((d) => (0, utils_1.getMonthOffset)(d, 0, 1));
+    }
+    nanosecond() {
+        return this._deriveDate((d) => d.getUTCMilliseconds() * utils_1.NS_PER_MS);
+    }
+    ordinal_day() {
+        return this._deriveDate(utils_1.getOrdinalDay);
+    }
+    quarter() {
+        return this._deriveDate(utils_1.getQuarter);
+    }
+    second() {
+        return this._deriveDate((d) => d.getUTCSeconds());
+    }
+    strftime(format, locale) {
+        return this._deriveDate((d) => (0, utils_1.strftime)(d, format, locale));
+    }
+    time() {
+        return this._deriveDate((d) => d.toISOString().split("T")[1].slice(0, 12));
+    }
+    timestamp(unit = "ms") {
+        return this.epoch(unit);
+    }
+    to_string(format, locale) {
+        return this.strftime(format, locale);
+    }
+    total_days() {
+        return this._deriveDuration((v) => v / utils_1.MS_PER_DAY);
+    }
+    total_hours() {
+        return this._deriveDuration((v) => v / utils_1.MS_PER_HOUR);
+    }
+    total_microseconds() {
+        return this._deriveDuration((v) => v * utils_1.US_PER_MS);
+    }
+    total_milliseconds() {
+        return this._deriveDuration((v) => v);
+    }
+    total_minutes() {
+        return this._deriveDuration((v) => v / utils_1.MS_PER_MINUTE);
+    }
+    total_nanoseconds() {
+        return this._deriveDuration((v) => v * utils_1.NS_PER_MS);
+    }
+    total_seconds() {
+        return this._deriveDuration((v) => v / utils_1.MS_PER_SECOND);
+    }
+    week() {
+        return this._deriveDate(utils_1.getISOWeek);
+    }
+    weekday() {
+        return this._deriveDate((d) => d.getUTCDay() || 7);
+    }
+    year() {
+        return this._deriveDate((d) => d.getUTCFullYear());
+    }
+}
+exports.DateTimeExprNamespace = DateTimeExprNamespace;
+const TemporalExpr = (Base) => {
+    return class extends Base {
+        get dt() {
+            return new DateTimeExprNamespace(this);
+        }
+    };
+};
+exports.TemporalExpr = TemporalExpr;

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

@@ -0,0 +1,50 @@
+import type { IExpr } from "../../types";
+import type { ExprConstructor } from "../types";
+export declare const WindowExpr: <TBase extends ExprConstructor>(Base: TBase) => {
+    new (...args: any[]): {
+        partitionBy: (string | 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 | IExpr | (string | 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("../../types").OpFn[];
+        colName?: string;
+        outputName?: string;
+        isLiteral?: boolean;
+        literalValue?: any;
+        aggFn?: import("../../types").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("../../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;