df-script 1.4.0

package/dist/dataframe/dataframe.js

@@ -0,0 +1,749 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFrame = void 0;
+const columnExpressions_1 = require("../columnExpressions");
+const grouped_1 = require("./grouped/grouped");
+const datatypes_1 = require("../datatypes");
+const utils_1 = require("../utils");
+const exceptions_1 = require("../exceptions");
+const concat_1 = require("../functions/concat");
+const constants_1 = require("./constants");
+const utils_2 = require("./utils");
+class DataFrame {
+    _columns;
+    _height;
+    _schema = {};
+    constructor(data, schema, height) {
+        if (Array.isArray(data)) {
+            const { columns, height: h } = (0, utils_2.rowsToColumns)(data);
+            this._columns = columns;
+            this._height = h;
+            schema ? this.applySchema(schema) : this.inferSchema();
+            return;
+        }
+        if ((0, utils_1.isObj)(data)) {
+            let firstLength = -1;
+            for (const [key, col] of Object.entries(data)) {
+                const colLen = (0, utils_1.isArrayOrTypedArray)(col) ? col.length : 0;
+                if (firstLength === -1) {
+                    firstLength = colLen;
+                }
+                else if (colLen !== firstLength) {
+                    throw new exceptions_1.DataFrameError(`Column height mismatch: Column "${key}" has length ${colLen}, but previous columns have length ${firstLength}`);
+                }
+            }
+            this._columns = data;
+            this._height = height !== undefined ? height : (firstLength === -1 ? 0 : firstLength);
+            schema ? this.applySchema(schema) : this.inferSchema();
+            return;
+        }
+        this._columns = {};
+        this._height = 0;
+        schema ? this.applySchema(schema) : (this._schema = {});
+    }
+    inferSchema() {
+        const schema = {};
+        const keys = Object.keys(this._columns);
+        for (const key of keys) {
+            schema[key] = (0, utils_2.inferColumnType)(this._columns[key]);
+        }
+        this._schema = schema;
+    }
+    applySchema(schema) {
+        this._schema = schema;
+        const keys = Object.keys(schema);
+        const newColumns = {};
+        for (const key of keys) {
+            const type = schema[key];
+            const oldCol = this._columns[key];
+            let newCol = type.allocate ? type.allocate(this._height) : new Array(this._height).fill(null);
+            if (!oldCol) {
+                if (this._height > 0 && (0, utils_1.isTypedArray)(newCol)) {
+                    newCol = new Array(this._height).fill(null);
+                }
+                newColumns[key] = newCol;
+                continue;
+            }
+            let hasNulls = false;
+            const coercedVals = new Array(this._height);
+            for (let i = 0; i < this._height; i++) {
+                const coerced = type.coerce(oldCol[i]);
+                coercedVals[i] = coerced;
+                if (coerced == null) {
+                    hasNulls = true;
+                }
+            }
+            if (hasNulls && (0, utils_1.isTypedArray)(newCol)) {
+                newCol = new Array(this._height);
+            }
+            for (let i = 0; i < this._height; i++) {
+                newCol[i] = coercedVals[i];
+            }
+            newColumns[key] = newCol;
+        }
+        this._columns = newColumns;
+    }
+    getSchema() {
+        return this._schema;
+    }
+    to_dicts() {
+        return (0, utils_2.columnsToRows)(this._columns, this._height);
+    }
+    to_dict() {
+        return { ...this._columns };
+    }
+    get columns() {
+        return Object.keys(this._columns);
+    }
+    concat(items, options = {}) {
+        const arrayItems = (0, utils_1.isArrayOfType)(items, DataFrame, { mode: "every", allowEmpty: false })
+            ? items
+            : [items];
+        return (0, concat_1.concat)([this, ...arrayItems], options);
+    }
+    drop(...args) {
+        const columnsToDrop = new Set(args.flat());
+        const newColumns = {};
+        const outSchema = {};
+        for (const key of Object.keys(this._columns)) {
+            if (!columnsToDrop.has(key)) {
+                newColumns[key] = this._columns[key];
+                outSchema[key] = this._schema[key];
+            }
+        }
+        return new DataFrame(newColumns, outSchema, this._height);
+    }
+    get dtypes() {
+        const keys = Object.keys(this._columns);
+        const len = keys.length;
+        const result = new Array(len);
+        for (let i = 0; i < len; i++) {
+            result[i] = this._schema[keys[i]];
+        }
+        return result;
+    }
+    filter(...exprs) {
+        if (this._height === 0)
+            return new DataFrame({}, this._schema, 0);
+        const height = this._height;
+        const keys = Object.keys(this._columns);
+        const numKeys = keys.length;
+        const evaluatedExprs = [];
+        const funcPredicates = [];
+        for (const expr of exprs) {
+            if (typeof expr === "function") {
+                funcPredicates.push(expr);
+            }
+            else {
+                evaluatedExprs.push(expr.evaluate(this._columns, height));
+            }
+        }
+        const matchingIndices = [];
+        let currentIndex = 0;
+        let rowObj = null;
+        if (funcPredicates.length > 0) {
+            const columns = this._columns;
+            rowObj = {};
+            for (let k = 0; k < numKeys; k++) {
+                const key = keys[k];
+                const col = columns[key];
+                Object.defineProperty(rowObj, key, {
+                    get() {
+                        const val = col[currentIndex];
+                        return val === undefined ? null : val;
+                    },
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+        }
+        for (let i = 0; i < height; i++) {
+            let keep = true;
+            for (let j = 0; j < evaluatedExprs.length; j++) {
+                if (!evaluatedExprs[j][i]) {
+                    keep = false;
+                    break;
+                }
+            }
+            if (!keep)
+                continue;
+            if (rowObj) {
+                currentIndex = i;
+                for (let j = 0; j < funcPredicates.length; j++) {
+                    if (!funcPredicates[j](rowObj)) {
+                        keep = false;
+                        break;
+                    }
+                }
+            }
+            if (!keep)
+                continue;
+            matchingIndices.push(i);
+        }
+        const newColumns = (0, utils_2.gatherColumnsByIndices)(this._columns, matchingIndices);
+        const newHeight = matchingIndices.length;
+        return new DataFrame(newColumns, this._schema, newHeight);
+    }
+    groupby(keys) {
+        const keysArr = (0, utils_1.toValidArray)(keys);
+        const groups = new Map();
+        const len = this._height;
+        const keysLen = keysArr.length;
+        const keysStr = new Array(keysLen);
+        for (let i = 0; i < keysLen; i++) {
+            keysStr[i] = String(keysArr[i]);
+        }
+        for (let j = 0; j < keysStr.length; j++) {
+            (0, exceptions_1.assertColumnExists)(keysStr[j], this._columns, "Grouping key");
+        }
+        const singleKey = keysLen === 1 ? keysStr[0] : null;
+        const col = singleKey ? this._columns[singleKey] : null;
+        for (let i = 0; i < len; i++) {
+            let hash;
+            if (singleKey) {
+                const val = col[i];
+                hash = val == null ? "" : String(val);
+            }
+            else {
+                const vals = new Array(keysLen);
+                for (let j = 0; j < keysLen; j++) {
+                    const val = this._columns[keysStr[j]][i];
+                    vals[j] = val == null ? "" : String(val);
+                }
+                hash = vals.join(constants_1.KEY_SEPARATOR);
+            }
+            let group = groups.get(hash);
+            if (group === undefined) {
+                groups.set(hash, group = []);
+            }
+            group.push(i);
+        }
+        const allKeys = Object.keys(this._columns);
+        return new grouped_1.GroupedData(groups, keysArr, allKeys, this._columns, this._height, this._schema);
+    }
+    head(n = 10) {
+        return this.limit(n, { offset: 0, from: "start" });
+    }
+    get height() {
+        return this._height;
+    }
+    hstack(other, options = {}) {
+        return this.concat(other, { how: "horizontal", horizontal: options });
+    }
+    join(config) {
+        const { other, on, how = "inner", suffixes = ["", "_right"] } = config;
+        const joinKeys = (0, utils_1.toValidArray)(on);
+        for (const key of joinKeys) {
+            const keyStr = String(key);
+            (0, exceptions_1.assertColumnExists)(keyStr, this._columns, "Join key", " in the left DataFrame.");
+            (0, exceptions_1.assertColumnExists)(keyStr, other._columns, "Join key", " in the right DataFrame.");
+        }
+        const [leftSuffix, rightSuffix] = suffixes;
+        const leftKeys = Object.keys(this._columns);
+        const rightKeys = Object.keys(other._columns);
+        const joinKeySet = new Set(joinKeys);
+        const leftLen = leftKeys.length;
+        const rightLen = rightKeys.length;
+        const getColumnHashAt = (columns, idx) => {
+            const len = joinKeys.length;
+            if (len === 1) {
+                const val = columns[joinKeys[0]][idx];
+                return val == null ? null : String(val);
+            }
+            const vals = new Array(len);
+            for (let i = 0; i < len; i++) {
+                const val = columns[joinKeys[i]][idx];
+                if (val == null)
+                    return null;
+                vals[i] = String(val);
+            }
+            return vals.join(constants_1.KEY_SEPARATOR);
+        };
+        const rightHash = new Map();
+        const rightHeight = other._height;
+        const rightCols = other._columns;
+        for (let i = 0; i < rightHeight; i++) {
+            const hash = getColumnHashAt(rightCols, i);
+            if (hash === null)
+                continue;
+            let list = rightHash.get(hash);
+            if (list === undefined) {
+                list = [];
+                rightHash.set(hash, list);
+            }
+            list.push(i);
+        }
+        const leftHeight = this._height;
+        const leftCols = this._columns;
+        const leftIndices = [];
+        const rightIndices = [];
+        const trackRight = how === "outer" || how === "right";
+        const matchedRightIndices = trackRight ? new Set() : null;
+        for (let i = 0; i < leftHeight; i++) {
+            const hash = getColumnHashAt(leftCols, i);
+            const matches = hash === null ? undefined : rightHash.get(hash);
+            if (matches === undefined) {
+                if (how === "left" || how === "outer") {
+                    leftIndices.push(i);
+                    rightIndices.push(null);
+                }
+            }
+            else {
+                for (let m = 0; m < matches.length; m++) {
+                    const rIdx = matches[m];
+                    if (trackRight) {
+                        matchedRightIndices.add(rIdx);
+                    }
+                    leftIndices.push(i);
+                    rightIndices.push(rIdx);
+                }
+            }
+        }
+        if (trackRight) {
+            for (let j = 0; j < rightHeight; j++) {
+                if (!matchedRightIndices.has(j)) {
+                    leftIndices.push(-1);
+                    rightIndices.push(j);
+                }
+            }
+        }
+        const outHeight = leftIndices.length;
+        const newColumns = {};
+        const outSchema = {};
+        for (let i = 0; i < leftLen; i++) {
+            const k = leftKeys[i];
+            const mappedName = (k in other._columns && !joinKeySet.has(k)) ? `${k}${leftSuffix}` : k;
+            const leftCol = this._columns[k];
+            const isJoinKey = joinKeySet.has(k);
+            const outCol = new Array(outHeight);
+            if (isJoinKey) {
+                const rightCol = other._columns[k];
+                for (let r = 0; r < outHeight; r++) {
+                    const leftIdx = leftIndices[r];
+                    if (leftIdx !== -1) {
+                        outCol[r] = leftCol[leftIdx];
+                    }
+                    else {
+                        const rightIdx = rightIndices[r];
+                        outCol[r] = rightIdx !== null ? rightCol[rightIdx] : null;
+                    }
+                }
+            }
+            else {
+                for (let r = 0; r < outHeight; r++) {
+                    const leftIdx = leftIndices[r];
+                    outCol[r] = leftIdx !== -1 ? leftCol[leftIdx] : null;
+                }
+            }
+            newColumns[mappedName] = outCol;
+            if (this._schema[k]) {
+                outSchema[mappedName] = this._schema[k];
+            }
+        }
+        for (let i = 0; i < rightLen; i++) {
+            const k = rightKeys[i];
+            if (!joinKeySet.has(k)) {
+                const mappedName = k in this._columns ? `${k}${rightSuffix}` : k;
+                const rightCol = other._columns[k];
+                const outCol = new Array(outHeight);
+                for (let r = 0; r < outHeight; r++) {
+                    const rightIdx = rightIndices[r];
+                    outCol[r] = rightIdx !== null ? rightCol[rightIdx] : null;
+                }
+                newColumns[mappedName] = outCol;
+                if (other._schema[k]) {
+                    outSchema[mappedName] = other._schema[k];
+                }
+            }
+        }
+        return new DataFrame(newColumns, outSchema, outHeight);
+    }
+    limit(n, options = {}) {
+        const { offset = 0, from = "start" } = options;
+        const len = this._height;
+        const safeN = isNaN(n) ? 0 : Math.max(Math.floor(n), 0);
+        const safeOffset = isNaN(offset) ? 0 : Math.max(Math.floor(offset), 0);
+        if (safeN === 0 || len === 0 || safeOffset >= len) {
+            const newColumns = {};
+            const outSchema = {};
+            for (const key of Object.keys(this._columns)) {
+                newColumns[key] = [];
+                outSchema[key] = this._schema[key];
+            }
+            return new DataFrame(newColumns, outSchema, 0);
+        }
+        let actualStart = 0;
+        let actualEnd = 0;
+        if (from === "end") {
+            actualEnd = Math.max(len - safeOffset, 0);
+            actualStart = Math.max(actualEnd - safeN, 0);
+        }
+        else {
+            actualEnd = Math.min(safeOffset + safeN, len);
+            actualStart = safeOffset;
+        }
+        const newHeight = Math.max(actualEnd - actualStart, 0);
+        const newColumns = {};
+        for (const key of Object.keys(this._columns)) {
+            newColumns[key] = this._columns[key].slice(actualStart, actualEnd);
+        }
+        return new DataFrame(newColumns, this._schema, newHeight);
+    }
+    pivot(config) {
+        if (this._height === 0)
+            return new DataFrame({}, {}, 0);
+        const { index, columns, values } = config;
+        const indexArr = (0, utils_1.toValidArray)(index);
+        const indexLen = indexArr.length;
+        const indexStr = new Array(indexLen);
+        for (let i = 0; i < indexLen; i++) {
+            indexStr[i] = String(indexArr[i]);
+        }
+        const colKey = String(columns);
+        const valKey = String(values);
+        for (const idxKey of indexStr) {
+            (0, exceptions_1.assertColumnExists)(idxKey, this._columns, "Pivot index key", " in the DataFrame.");
+        }
+        (0, exceptions_1.assertColumnExists)(colKey, this._columns, "Pivot column key");
+        (0, exceptions_1.assertColumnExists)(valKey, this._columns, "Pivot values key", " in the DataFrame.");
+        const groups = new Map();
+        const colNames = new Set();
+        const height = this._height;
+        const pivotCol = this._columns[colKey];
+        const valCol = this._columns[valKey];
+        for (let i = 0; i < height; i++) {
+            const vals = new Array(indexLen);
+            for (let j = 0; j < indexLen; j++) {
+                const val = this._columns[indexStr[j]][i];
+                vals[j] = val == null ? "" : String(val);
+            }
+            const rowKey = vals.join(constants_1.KEY_SEPARATOR);
+            const pivotColName = String(pivotCol[i]);
+            colNames.add(pivotColName);
+            let group = groups.get(rowKey);
+            if (group === undefined) {
+                group = { firstIdx: i, indices: [] };
+                groups.set(rowKey, group);
+            }
+            group.indices.push(i);
+        }
+        const outHeight = groups.size;
+        const newColumns = {};
+        const outSchema = {};
+        for (let j = 0; j < indexLen; j++) {
+            const k = indexStr[j];
+            newColumns[k] = new Array(outHeight);
+            if (this._schema[k]) {
+                outSchema[k] = this._schema[k];
+            }
+        }
+        const allCols = Array.from(colNames);
+        const valType = this._schema[valKey] || datatypes_1.DataTypeRegistry.Utf8;
+        for (let j = 0; j < allCols.length; j++) {
+            const colName = allCols[j];
+            newColumns[colName] = new Array(outHeight).fill(null);
+            outSchema[colName] = valType;
+        }
+        let groupIdx = 0;
+        for (const group of groups.values()) {
+            const firstIdx = group.firstIdx;
+            for (let j = 0; j < indexLen; j++) {
+                const k = indexStr[j];
+                newColumns[k][groupIdx] = this._columns[k][firstIdx];
+            }
+            const indices = group.indices;
+            for (let k = 0; k < indices.length; k++) {
+                const idx = indices[k];
+                const pivotColName = String(pivotCol[idx]);
+                newColumns[pivotColName][groupIdx] = valCol[idx];
+            }
+            groupIdx++;
+        }
+        return new DataFrame(newColumns, outSchema, outHeight);
+    }
+    rename(mapping) {
+        const renameMapping = mapping || {};
+        const newColumns = {};
+        const outSchema = {};
+        const originalKeys = Object.keys(this._columns);
+        for (const key of originalKeys) {
+            const newKey = renameMapping[key] || key;
+            newColumns[newKey] = this._columns[key];
+            outSchema[newKey] = this._schema[key];
+        }
+        const finalKeys = Object.keys(newColumns);
+        if (finalKeys.length < originalKeys.length) {
+            throw new exceptions_1.DataFrameError("Rename collision: Multiple columns mapped to the same output name.");
+        }
+        return new DataFrame(newColumns, outSchema, this._height);
+    }
+    reverse() {
+        if (this._height === 0)
+            return this;
+        const newColumns = {};
+        const keys = Object.keys(this._columns);
+        const len = keys.length;
+        for (let i = 0; i < len; i++) {
+            const key = keys[i];
+            newColumns[key] = this._columns[key].slice().reverse();
+        }
+        return new DataFrame(newColumns, this._schema, this._height);
+    }
+    get schema() {
+        return this._schema;
+    }
+    select(...args) {
+        const exprs = this._normalizeArgs(args);
+        const allKeys = Object.keys(this._columns);
+        const expandedExprs = (0, columnExpressions_1.resolveColumnSelectors)(exprs, allKeys);
+        const newColumns = {};
+        const outSchema = {};
+        for (const expr of expandedExprs) {
+            const targetKey = expr.outputName || expr.colName || columnExpressions_1.ALL_COLUMNS_MARKER;
+            if (targetKey in newColumns) {
+                throw new exceptions_1.DataFrameError(`Duplicate column selection: "${targetKey}" is selected multiple times.`);
+            }
+            newColumns[targetKey] = expr.isWindow
+                ? (0, utils_2.resolveWindowExpr)(expr, this._columns, this._height)
+                : expr.evaluate(this._columns, this._height);
+            const originalKey = expr.colName || targetKey;
+            const isPureColSelector = expr instanceof columnExpressions_1.ColumnExpr && expr.ops.length === 0 && !expr.isWindow && !expr.aggFn;
+            outSchema[targetKey] = (isPureColSelector && this._schema[originalKey])
+                ? this._schema[originalKey]
+                : (0, utils_2.inferColumnType)(newColumns[targetKey]);
+        }
+        return new DataFrame(newColumns, outSchema, this._height);
+    }
+    get shape() {
+        return [this.height, this.width];
+    }
+    slice(start, end) {
+        const total = this._height;
+        const actualStart = start < 0 ? Math.max(total + start, 0) : Math.min(start, total);
+        const actualEnd = end === undefined
+            ? total
+            : (end < 0 ? Math.max(total + end, 0) : Math.min(end, total));
+        const n = Math.max(actualEnd - actualStart, 0);
+        return this.limit(n, { offset: actualStart });
+    }
+    sort(config) {
+        if (!config || !config.by || this._height === 0)
+            return this;
+        const { by, descending = false, nullsLast = true, custom } = config;
+        const sortKeys = (0, utils_1.toValidArray)(by);
+        for (let i = 0; i < sortKeys.length; i++) {
+            const keyOrExpr = sortKeys[i];
+            if (typeof keyOrExpr === "string") {
+                (0, exceptions_1.assertColumnExists)(keyOrExpr, this._columns, "Sort key");
+            }
+        }
+        const descArray = Array.isArray(descending)
+            ? descending
+            : new Array(sortKeys.length).fill(descending);
+        const sortKeysLen = sortKeys.length;
+        const plan = new Array(sortKeysLen);
+        for (let i = 0; i < sortKeysLen; i++) {
+            const keyOrExpr = sortKeys[i];
+            const isDesc = descArray[i] ? -1 : 1;
+            const customComp = (custom && typeof keyOrExpr === "string") ? custom[keyOrExpr] : null;
+            const values = keyOrExpr?.evaluate
+                ? keyOrExpr.evaluate(this._columns, this._height)
+                : (this._columns[keyOrExpr] || new Array(this._height).fill(null));
+            plan[i] = {
+                values,
+                isDesc,
+                customComp
+            };
+        }
+        const planLen = plan.length;
+        const nullMultiplier = nullsLast ? 1 : -1;
+        const indices = new Array(this._height);
+        for (let i = 0; i < this._height; i++) {
+            indices[i] = i;
+        }
+        indices.sort((idxA, idxB) => {
+            for (let i = 0; i < planLen; i++) {
+                const { values, isDesc, customComp } = plan[i];
+                const vA = values[idxA];
+                const vB = values[idxB];
+                if (customComp) {
+                    const res = customComp(vA, vB);
+                    if (res !== 0)
+                        return res * isDesc;
+                    continue;
+                }
+                if (vA == null || vB == null) {
+                    if (vA === vB)
+                        continue;
+                    return (vA == null ? 1 : -1) * nullMultiplier;
+                }
+                if (vA === vB)
+                    continue;
+                const res = vA < vB ? -1 : 1;
+                return res * isDesc;
+            }
+            return 0;
+        });
+        const newColumns = (0, utils_2.gatherColumnsByIndices)(this._columns, indices);
+        return new DataFrame(newColumns, this._schema, this._height);
+    }
+    tail(n = 10) {
+        return this.limit(n, { offset: 0, from: 'end' });
+    }
+    to_list(nameOrExpr) {
+        if (this._height === 0)
+            return [];
+        const isExpr = nameOrExpr && typeof nameOrExpr !== "string" && "evaluate" in nameOrExpr;
+        let colData;
+        if (isExpr) {
+            const expr = nameOrExpr;
+            colData = expr.evaluate(this._columns, this._height);
+        }
+        else {
+            const key = nameOrExpr;
+            if (key == null) {
+                return new Array(this._height).fill(null);
+            }
+            (0, exceptions_1.assertColumnExists)(key, this._columns, "Column");
+            colData = this._columns[key];
+        }
+        return Array.isArray(colData) ? colData : Array.from(colData);
+    }
+    unique(columns) {
+        if (this._height === 0)
+            return new DataFrame({}, this._schema, 0);
+        const colsArr = (0, utils_1.toValidArray)(columns);
+        const colsStr = colsArr.length === 0
+            ? Object.keys(this._columns)
+            : colsArr.map(String);
+        for (const colKey of colsStr) {
+            (0, exceptions_1.assertColumnExists)(colKey, this._columns, "Unique column key");
+        }
+        const seen = new Set();
+        const matchingIndices = [];
+        const colsLen = colsStr.length;
+        const height = this._height;
+        const singleCol = colsLen === 1 ? this._columns[colsStr[0]] : null;
+        for (let i = 0; i < height; i++) {
+            let hash;
+            if (singleCol) {
+                const val = singleCol[i];
+                hash = val == null ? "" : String(val);
+            }
+            else {
+                const vals = new Array(colsLen);
+                for (let j = 0; j < colsLen; j++) {
+                    const val = this._columns[colsStr[j]][i];
+                    vals[j] = val == null ? "" : String(val);
+                }
+                hash = vals.join(constants_1.KEY_SEPARATOR);
+            }
+            if (!seen.has(hash)) {
+                seen.add(hash);
+                matchingIndices.push(i);
+            }
+        }
+        const newColumns = (0, utils_2.gatherColumnsByIndices)(this._columns, matchingIndices);
+        const newHeight = matchingIndices.length;
+        return new DataFrame(newColumns, this._schema, newHeight);
+    }
+    unpivot(config) {
+        const { idVars, valueVars, varName = "variable", valueName = "value" } = config;
+        const idVarsStr = (0, utils_1.toValidArray)(idVars).map(String);
+        const valueVarsStr = (0, utils_1.toValidArray)(valueVars).map(String);
+        const idVarsLen = idVarsStr.length;
+        const valueVarsLen = valueVarsStr.length;
+        for (const idKey of idVarsStr) {
+            (0, exceptions_1.assertColumnExists)(idKey, this._columns, "Unpivot id variable key");
+        }
+        for (const vKey of valueVarsStr) {
+            (0, exceptions_1.assertColumnExists)(vKey, this._columns, "Unpivot value variable key");
+        }
+        const newHeight = this._height * valueVarsLen;
+        const newColumns = {};
+        for (let k = 0; k < idVarsLen; k++) {
+            newColumns[idVarsStr[k]] = new Array(newHeight);
+        }
+        newColumns[varName] = new Array(newHeight);
+        newColumns[valueName] = new Array(newHeight);
+        let outIdx = 0;
+        for (let i = 0; i < this._height; i++) {
+            for (let j = 0; j < valueVarsLen; j++) {
+                const vVar = valueVarsStr[j];
+                for (let k = 0; k < idVarsLen; k++) {
+                    const idKey = idVarsStr[k];
+                    newColumns[idKey][outIdx] = this._columns[idKey][i];
+                }
+                newColumns[varName][outIdx] = vVar;
+                newColumns[valueName][outIdx] = this._columns[vVar][i];
+                outIdx++;
+            }
+        }
+        const outSchema = {};
+        for (const key of idVarsStr) {
+            outSchema[key] = this._schema[key];
+        }
+        outSchema[varName] = datatypes_1.DataTypeRegistry.Utf8;
+        outSchema[valueName] = (0, utils_2.inferColumnType)(newColumns[valueName]);
+        return new DataFrame(newColumns, outSchema, newHeight);
+    }
+    vstack(other) {
+        return this.concat(other, { how: "vertical" });
+    }
+    get width() {
+        return Object.keys(this._columns).length;
+    }
+    _normalizeArgs(args) {
+        const flatArgs = args.flat();
+        const exprs = [];
+        for (const arg of flatArgs) {
+            if (typeof arg === "string") {
+                exprs.push(new columnExpressions_1.ColumnExpr(arg));
+            }
+            else if ((0, utils_1.isObj)(arg) && 'evaluate' in arg) {
+                exprs.push(arg);
+            }
+            else if ((0, utils_1.isObj)(arg)) {
+                for (const [key, val] of Object.entries(arg)) {
+                    if ((0, utils_1.isObj)(val) && 'evaluate' in val) {
+                        exprs.push(val.alias(key));
+                    }
+                    else {
+                        const staticExpr = new columnExpressions_1.ColumnExpr(key);
+                        staticExpr.evaluate = (_cols, h) => new Array(h).fill(val);
+                        exprs.push(staticExpr);
+                    }
+                }
+            }
+        }
+        return exprs;
+    }
+    with_columns(...args) {
+        const exprs = this._normalizeArgs(args);
+        const allKeys = Object.keys(this._columns);
+        const expandedExprs = (0, columnExpressions_1.resolveColumnSelectors)(exprs, allKeys);
+        const numEntries = expandedExprs.length;
+        const newColumns = { ...this._columns };
+        const outSchema = { ...this._schema };
+        for (let j = 0; j < numEntries; j++) {
+            const expr = expandedExprs[j];
+            const name = expr.outputName || expr.colName || columnExpressions_1.ALL_COLUMNS_MARKER;
+            if (expr.isWindow) {
+                newColumns[name] = (0, utils_2.resolveWindowExpr)(expr, this._columns, this._height);
+            }
+            else {
+                newColumns[name] = expr.evaluate(this._columns, this._height);
+            }
+            const originalKey = expr.colName || name;
+            const isPureColSelector = expr instanceof columnExpressions_1.ColumnExpr && expr.ops.length === 0 && !expr.isWindow && !expr.aggFn;
+            if (isPureColSelector && this._schema[originalKey]) {
+                outSchema[name] = this._schema[originalKey];
+            }
+            else {
+                outSchema[name] = (0, utils_2.inferColumnType)(newColumns[name]);
+            }
+        }
+        return new DataFrame(newColumns, outSchema, this._height);
+    }
+}
+exports.DataFrame = DataFrame;