@bilig/formula 0.1.2 → 0.1.3

package/dist/js-evaluator.js

@@ -3,6 +3,8 @@ import { indexToColumn, parseCellAddress, parseRangeAddress } from "./addressing
 import { getBuiltin, hasBuiltin } from "./builtins.js";
 import { getLookupBuiltin } from "./builtins/lookup.js";
 import { evaluateGroupBy, evaluatePivotBy } from "./group-pivot-evaluator.js";
+import { evaluateArraySpecialCall } from "./js-evaluator-array-special-calls.js";
+import { evaluateContextSpecialCall } from "./js-evaluator-context-special-calls.js";
 import { isArrayValue, scalarFromEvaluationResult, } from "./runtime-values.js";
 import { rewriteSpecialCall } from "./special-call-rewrites.js";
 function emptyValue() {
@@ -540,29 +542,6 @@ function coerceOptionalTrimModeArgument(value, fallback) {
 function isCellValueError(value) {
     return typeof value === "object" && value !== null && "tag" in value;
 }
-function indexOfWithMatchMode(text, delimiter, startIndex, matchMode) {
-    if (matchMode === 1) {
-        return text.toLowerCase().indexOf(delimiter.toLowerCase(), startIndex);
-    }
-    return text.indexOf(delimiter, startIndex);
-}
-function splitTextByDelimiter(text, delimiter, matchMode) {
-    if (delimiter === "") {
-        return [text];
-    }
-    const parts = [];
-    let cursor = 0;
-    while (cursor <= text.length) {
-        const found = indexOfWithMatchMode(text, delimiter, cursor, matchMode);
-        if (found === -1) {
-            parts.push(text.slice(cursor));
-            break;
-        }
-        parts.push(text.slice(cursor, found));
-        cursor = found + delimiter.length;
-    }
-    return parts;
-}
 function makeArrayStack(rows, cols, values) {
     return { kind: "array", rows, cols, values };
 }
@@ -628,9 +607,6 @@ function aggregateRangeSubset(functionArg, subset, context, totalSet) {
     const result = builtin(...subset);
     return isArrayValue(result) ? scalarFromEvaluationResult(result) : result;
 }
-function isTrimRangeEmptyCell(value) {
-    return value.tag === ValueTag.Empty;
-}
 function applyLambda(lambdaValue, args, context) {
     if (lambdaValue.kind !== "lambda") {
         return stackScalar(lambdaValue.kind === "scalar" && lambdaValue.value.tag === ValueTag.Error
@@ -649,67 +625,6 @@ function applyLambda(lambdaValue, args, context) {
 }
 function evaluateSpecialCall(callee, rawArgs, context, argRefs = []) {
     switch (callee) {
-        case "ROW": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const row = referenceRowNumber(argRefs[0], context);
-            return stackScalar(row === undefined ? error(ErrorCode.Value) : numberValue(row));
-        }
-        case "COLUMN": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const column = referenceColumnNumber(argRefs[0], context);
-            return stackScalar(column === undefined ? error(ErrorCode.Value) : numberValue(column));
-        }
-        case "ISOMITTED": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            return stackScalar({ tag: ValueTag.Boolean, value: rawArgs[0]?.kind === "omitted" });
-        }
-        case "FORMULATEXT": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const address = referenceTopLeftAddress(argRefs[0]);
-            const sheetName = referenceSheetName(argRefs[0], context);
-            if (!address || !sheetName) {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            const formula = context.resolveFormula?.(sheetName, address);
-            return stackScalar(formula
-                ? stringValue(formula.startsWith("=") ? formula : `=${formula}`)
-                : error(ErrorCode.NA));
-        }
-        case "FORMULA": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const address = referenceTopLeftAddress(argRefs[0]);
-            const sheetName = referenceSheetName(argRefs[0], context);
-            if (!address || !sheetName) {
-                return stackScalar(error(ErrorCode.Ref));
-            }
-            const formula = context.resolveFormula?.(sheetName, address);
-            return stackScalar(formula
-                ? stringValue(formula.startsWith("=") ? formula : `=${formula}`)
-                : error(ErrorCode.NA));
-        }
-        case "PHONETIC": {
-            if (rawArgs.length !== 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const target = rawArgs[0];
-            if (target.kind === "scalar") {
-                return stackScalar(stringValue(toStringValue(target.value)));
-            }
-            if (target.kind === "range") {
-                return stackScalar(stringValue(toStringValue(target.values[0] ?? emptyValue())));
-            }
-            return stackScalar(error(ErrorCode.Value));
-        }
         case "GETPIVOTDATA": {
             if (rawArgs.length < 2 || (rawArgs.length - 2) % 2 !== 0) {
                 return stackScalar(error(ErrorCode.Value));
@@ -840,106 +755,6 @@ function evaluateSpecialCall(callee, rawArgs, context, argRefs = []) {
             };
             return stackScalar(context.resolveMultipleOperations?.(request) ?? error(ErrorCode.Ref));
         }
-        case "CHOOSE": {
-            if (rawArgs.length < 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const indexValue = isSingleCellValue(rawArgs[0]);
-            const choice = indexValue ? toNumber(indexValue) : undefined;
-            if (choice === undefined || !Number.isFinite(choice)) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const truncated = Math.trunc(choice);
-            if (truncated < 1 || truncated >= rawArgs.length) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            return cloneStackValue(rawArgs[truncated]);
-        }
-        case "SHEET": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            if (rawArgs.length === 0) {
-                const index = sheetIndexByName(context.sheetName, context);
-                return stackScalar(index === undefined ? error(ErrorCode.NA) : numberValue(index));
-            }
-            if (argRefs[0]) {
-                const index = sheetIndexByName(referenceSheetName(argRefs[0], context) ?? context.sheetName, context);
-                return stackScalar(index === undefined ? error(ErrorCode.NA) : numberValue(index));
-            }
-            const scalar = isSingleCellValue(rawArgs[0]);
-            if (scalar?.tag !== ValueTag.String) {
-                return stackScalar(error(ErrorCode.NA));
-            }
-            const index = sheetIndexByName(scalar.value, context);
-            return stackScalar(index === undefined ? error(ErrorCode.NA) : numberValue(index));
-        }
-        case "SHEETS": {
-            if (rawArgs.length > 1) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            if (rawArgs.length === 0) {
-                return stackScalar(numberValue(sheetNames(context).length));
-            }
-            if (argRefs[0]) {
-                return stackScalar(numberValue(1));
-            }
-            const scalar = isSingleCellValue(rawArgs[0]);
-            if (scalar?.tag !== ValueTag.String) {
-                return stackScalar(error(ErrorCode.NA));
-            }
-            return stackScalar(sheetIndexByName(scalar.value, context) === undefined
-                ? error(ErrorCode.NA)
-                : numberValue(1));
-        }
-        case "CELL": {
-            if (rawArgs.length < 1 || rawArgs.length > 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const infoType = isSingleCellValue(rawArgs[0]);
-            if (infoType?.tag !== ValueTag.String) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const ref = rawArgs.length === 2 ? argRefs[1] : currentCellReference(context);
-            if (!ref) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const normalizedInfoType = infoType.value.trim().toLowerCase();
-            switch (normalizedInfoType) {
-                case "address": {
-                    const address = absoluteAddress(ref, context);
-                    return stackScalar(address ? stringValue(address) : error(ErrorCode.Value));
-                }
-                case "row": {
-                    const row = referenceRowNumber(ref, context);
-                    return stackScalar(row === undefined ? error(ErrorCode.Value) : numberValue(row));
-                }
-                case "col": {
-                    const column = referenceColumnNumber(ref, context);
-                    return stackScalar(column === undefined ? error(ErrorCode.Value) : numberValue(column));
-                }
-                case "contents": {
-                    const address = referenceTopLeftAddress(ref);
-                    const sheetName = referenceSheetName(ref, context);
-                    if (!address || !sheetName) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    return stackScalar(context.resolveCell(sheetName, address));
-                }
-                case "type": {
-                    const address = referenceTopLeftAddress(ref);
-                    const sheetName = referenceSheetName(ref, context);
-                    if (!address || !sheetName) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    return stackScalar(stringValue(cellTypeCode(context.resolveCell(sheetName, address))));
-                }
-                case "filename":
-                    return stackScalar(stringValue(""));
-                default:
-                    return stackScalar(error(ErrorCode.Value));
-            }
-        }
         case "INDIRECT": {
             if (rawArgs.length < 1 || rawArgs.length > 2) {
                 return stackScalar(error(ErrorCode.Value));
@@ -989,312 +804,47 @@ function evaluateSpecialCall(callee, rawArgs, context, argRefs = []) {
             const resolvedName = context.resolveName?.(normalizedRefText);
             return stackScalar(resolvedName ?? error(ErrorCode.Ref));
         }
-        case "EXPAND": {
-            if (rawArgs.length < 2 || rawArgs.length > 4) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const source = toRangeLike(rawArgs[0]);
-            const rows = coerceOptionalPositiveIntegerArgument(rawArgs[1], source.rows);
-            const cols = coerceOptionalPositiveIntegerArgument(rawArgs[2], source.cols);
-            if (isCellValueError(rows)) {
-                return stackScalar(rows);
-            }
-            if (isCellValueError(cols)) {
-                return stackScalar(cols);
-            }
-            const padArgument = rawArgs[3];
-            const padValue = padArgument === undefined
-                ? error(ErrorCode.NA)
-                : (() => {
-                    const scalar = isSingleCellValue(padArgument);
-                    return scalar ?? error(ErrorCode.Value);
-                })();
-            if (padValue.tag === ValueTag.Error && padArgument !== undefined) {
-                const scalar = isSingleCellValue(padArgument);
-                if (!scalar) {
-                    return stackScalar(error(ErrorCode.Value));
-                }
-            }
-            if (rows < source.rows || cols < source.cols) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const values = [];
-            for (let row = 0; row < rows; row += 1) {
-                for (let col = 0; col < cols; col += 1) {
-                    values.push(row < source.rows && col < source.cols ? getRangeCell(source, row, col) : padValue);
-                }
-            }
-            return makeArrayStack(rows, cols, values);
-        }
-        case "TEXTSPLIT": {
-            if (rawArgs.length < 2 || rawArgs.length > 6) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const text = coerceScalarTextArgument(rawArgs[0]);
-            const columnDelimiter = coerceScalarTextArgument(rawArgs[1]);
-            const rowDelimiter = rawArgs[2] === undefined ? undefined : coerceScalarTextArgument(rawArgs[2]);
-            const ignoreEmpty = coerceOptionalBooleanArgument(rawArgs[3], false);
-            const matchMode = coerceOptionalMatchModeArgument(rawArgs[4], 0);
-            if (isCellValueError(text)) {
-                return stackScalar(text);
-            }
-            if (isCellValueError(columnDelimiter)) {
-                return stackScalar(columnDelimiter);
-            }
-            if (rowDelimiter !== undefined && isCellValueError(rowDelimiter)) {
-                return stackScalar(rowDelimiter);
-            }
-            if (isCellValueError(ignoreEmpty)) {
-                return stackScalar(ignoreEmpty);
-            }
-            if (isCellValueError(matchMode)) {
-                return stackScalar(matchMode);
-            }
-            if (columnDelimiter === "" && rowDelimiter === undefined) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const padArgument = rawArgs[5];
-            const padValue = padArgument === undefined
-                ? error(ErrorCode.NA)
-                : (() => {
-                    const scalar = isSingleCellValue(padArgument);
-                    return scalar ?? error(ErrorCode.Value);
-                })();
-            if (padArgument !== undefined && !isSingleCellValue(padArgument)) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const rowSlices = rowDelimiter === undefined || rowDelimiter === ""
-                ? [text]
-                : splitTextByDelimiter(text, rowDelimiter, matchMode);
-            const matrix = rowSlices.map((rowSlice) => {
-                const parts = columnDelimiter === ""
-                    ? [rowSlice]
-                    : splitTextByDelimiter(rowSlice, columnDelimiter, matchMode);
-                const filtered = ignoreEmpty ? parts.filter((part) => part !== "") : parts;
-                return filtered.length === 0 ? [] : filtered;
-            });
-            const rows = Math.max(matrix.length, 1);
-            const cols = Math.max(1, ...matrix.map((row) => row.length));
-            const values = [];
-            for (let rowIndex = 0; rowIndex < rows; rowIndex += 1) {
-                const row = matrix[rowIndex] ?? [];
-                for (let colIndex = 0; colIndex < cols; colIndex += 1) {
-                    values.push(colIndex < row.length ? stringValue(row[colIndex]) : padValue);
-                }
-            }
-            return makeArrayStack(rows, cols, values);
-        }
-        case "TRIMRANGE": {
-            if (rawArgs.length < 1 || rawArgs.length > 3) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const source = toRangeLike(rawArgs[0]);
-            const trimRows = coerceOptionalTrimModeArgument(rawArgs[1], 3);
-            const trimCols = coerceOptionalTrimModeArgument(rawArgs[2], 3);
-            if (isCellValueError(trimRows)) {
-                return stackScalar(trimRows);
-            }
-            if (isCellValueError(trimCols)) {
-                return stackScalar(trimCols);
-            }
-            let startRow = 0;
-            let endRow = source.rows - 1;
-            let startCol = 0;
-            let endCol = source.cols - 1;
-            const trimLeadingRows = trimRows === 1 || trimRows === 3;
-            const trimTrailingRows = trimRows === 2 || trimRows === 3;
-            const trimLeadingCols = trimCols === 1 || trimCols === 3;
-            const trimTrailingCols = trimCols === 2 || trimCols === 3;
-            if (trimLeadingRows) {
-                while (startRow <= endRow) {
-                    let hasNonEmpty = false;
-                    for (let col = 0; col < source.cols; col += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, startRow, col))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    startRow += 1;
-                }
-            }
-            if (trimTrailingRows) {
-                while (endRow >= startRow) {
-                    let hasNonEmpty = false;
-                    for (let col = 0; col < source.cols; col += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, endRow, col))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    endRow -= 1;
-                }
-            }
-            if (startRow > endRow) {
-                return makeArrayStack(1, 1, [emptyValue()]);
-            }
-            if (trimLeadingCols) {
-                while (startCol <= endCol) {
-                    let hasNonEmpty = false;
-                    for (let row = startRow; row <= endRow; row += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, row, startCol))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    startCol += 1;
-                }
-            }
-            if (trimTrailingCols) {
-                while (endCol >= startCol) {
-                    let hasNonEmpty = false;
-                    for (let row = startRow; row <= endRow; row += 1) {
-                        if (!isTrimRangeEmptyCell(getRangeCell(source, row, endCol))) {
-                            hasNonEmpty = true;
-                            break;
-                        }
-                    }
-                    if (hasNonEmpty) {
-                        break;
-                    }
-                    endCol -= 1;
-                }
-            }
-            if (startCol > endCol) {
-                return makeArrayStack(1, 1, [emptyValue()]);
-            }
-            const rows = endRow - startRow + 1;
-            const cols = endCol - startCol + 1;
-            const values = [];
-            for (let row = startRow; row <= endRow; row += 1) {
-                for (let col = startCol; col <= endCol; col += 1) {
-                    values.push(getRangeCell(source, row, col));
-                }
-            }
-            return makeArrayStack(rows, cols, values);
-        }
-        case "MAKEARRAY": {
-            if (rawArgs.length !== 3) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const rows = toPositiveInteger(rawArgs[0]);
-            const cols = toPositiveInteger(rawArgs[1]);
-            if (rows === undefined || cols === undefined) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const lambda = rawArgs[2];
-            const values = [];
-            for (let row = 1; row <= rows; row += 1) {
-                for (let col = 1; col <= cols; col += 1) {
-                    const result = applyLambda(lambda, [
-                        stackScalar({ tag: ValueTag.Number, value: row }),
-                        stackScalar({ tag: ValueTag.Number, value: col }),
-                    ], context);
-                    const scalar = isSingleCellValue(result);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    values.push(scalar);
-                }
-            }
-            return { kind: "array", rows, cols, values };
-        }
-        case "MAP": {
-            if (rawArgs.length < 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const lambda = rawArgs[rawArgs.length - 1];
-            const inputs = rawArgs.slice(0, -1);
-            const shape = getBroadcastShape(inputs);
-            if (!shape) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const ranges = inputs.map(toRangeLike);
-            const values = [];
-            for (let row = 0; row < shape.rows; row += 1) {
-                for (let col = 0; col < shape.cols; col += 1) {
-                    const lambdaArgs = ranges.map((range) => stackScalar(getRangeCell(range, Math.min(row, range.rows - 1), Math.min(col, range.cols - 1))));
-                    const result = applyLambda(lambda, lambdaArgs, context);
-                    const scalar = isSingleCellValue(result);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    values.push(scalar);
-                }
-            }
-            return { kind: "array", rows: shape.rows, cols: shape.cols, values };
-        }
-        case "BYROW":
-        case "BYCOL": {
-            if (rawArgs.length !== 2) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const source = toRangeLike(rawArgs[0]);
-            const lambda = rawArgs[1];
-            const values = [];
-            if (callee === "BYROW") {
-                for (let row = 0; row < source.rows; row += 1) {
-                    const rowValues = [];
-                    for (let col = 0; col < source.cols; col += 1) {
-                        rowValues.push(getRangeCell(source, row, col));
-                    }
-                    const result = applyLambda(lambda, [{ kind: "range", values: rowValues, rows: 1, cols: source.cols, refKind: "cells" }], context);
-                    const scalar = isSingleCellValue(result);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    values.push(scalar);
-                }
-                return { kind: "array", rows: source.rows, cols: 1, values };
-            }
-            for (let col = 0; col < source.cols; col += 1) {
-                const colValues = [];
-                for (let row = 0; row < source.rows; row += 1) {
-                    colValues.push(getRangeCell(source, row, col));
-                }
-                const result = applyLambda(lambda, [{ kind: "range", values: colValues, rows: source.rows, cols: 1, refKind: "cells" }], context);
-                const scalar = isSingleCellValue(result);
-                if (!scalar) {
-                    return stackScalar(error(ErrorCode.Value));
-                }
-                values.push(scalar);
-            }
-            return { kind: "array", rows: 1, cols: source.cols, values };
-        }
-        case "REDUCE":
-        case "SCAN": {
-            if (rawArgs.length !== 2 && rawArgs.length !== 3) {
-                return stackScalar(error(ErrorCode.Value));
-            }
-            const hasInitial = rawArgs.length === 3;
-            let accumulator = hasInitial ? cloneStackValue(rawArgs[0]) : stackScalar(emptyValue());
-            const source = toRangeLike(rawArgs[hasInitial ? 1 : 0]);
-            const lambda = rawArgs[hasInitial ? 2 : 1];
-            const scanValues = [];
-            for (const cell of source.values) {
-                accumulator = applyLambda(lambda, [accumulator, stackScalar(cell)], context);
-                if (callee === "SCAN") {
-                    const scalar = isSingleCellValue(accumulator);
-                    if (!scalar) {
-                        return stackScalar(error(ErrorCode.Value));
-                    }
-                    scanValues.push(scalar);
-                }
-            }
-            return callee === "SCAN"
-                ? { kind: "array", rows: source.rows, cols: source.cols, values: scanValues }
-                : accumulator;
-        }
         default:
-            return undefined;
+            return (evaluateContextSpecialCall(callee, rawArgs, context, argRefs, {
+                error,
+                emptyValue,
+                numberValue,
+                stringValue,
+                stackScalar,
+                cloneStackValue,
+                toNumber,
+                toStringValue,
+                isSingleCellValue,
+                currentCellReference,
+                referenceSheetName,
+                referenceTopLeftAddress,
+                referenceRowNumber,
+                referenceColumnNumber,
+                absoluteAddress,
+                cellTypeCode,
+                sheetNames,
+                sheetIndexByName,
+            }) ??
+                evaluateArraySpecialCall(callee, rawArgs, context, {
+                    error,
+                    emptyValue,
+                    numberValue,
+                    stringValue,
+                    stackScalar,
+                    toRangeLike,
+                    getRangeCell,
+                    getBroadcastShape,
+                    makeArrayStack,
+                    applyLambda,
+                    toPositiveInteger,
+                    coerceScalarTextArgument,
+                    coerceOptionalBooleanArgument,
+                    coerceOptionalMatchModeArgument,
+                    coerceOptionalPositiveIntegerArgument,
+                    coerceOptionalTrimModeArgument,
+                    isCellValueError,
+                    isSingleCellValue,
+                }));
     }
 }
 function lowerNode(node, plan) {