@nachoggodino/cello 0.1.0

package/dist/evaluator/evaluate.js

@@ -0,0 +1,129 @@
+import { buildWorkbookRefIndex, translateFormulaForEngine } from "./formula.js";
+import { deepClone, workbookHasFormulas } from "../shared/utils.js";
+let hyperFormulaCtor = null;
+export async function evaluate(ast, options = {}) {
+    const output = deepClone(ast);
+    if (!workbookHasFormulas(output)) {
+        return output;
+    }
+    if (!(await loadHyperFormula(output))) {
+        return output;
+    }
+    const ctor = hyperFormulaCtor;
+    if (!ctor) {
+        output.diagnostics.push({
+            level: "error",
+            message: "HyperFormula failed to initialize."
+        });
+        return output;
+    }
+    try {
+        const refIndex = buildWorkbookRefIndex(output);
+        const sheetsData = buildSheetsData(output, refIndex);
+        const hf = ctor.buildFromSheets(sheetsData, { licenseKey: "gpl-v3" });
+        applyComputedValues(output, hf);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        output.diagnostics.push({
+            level: "error",
+            message: `Formula evaluation failed: ${message}`
+        });
+        if (options.strict) {
+            throw err;
+        }
+    }
+    return output;
+}
+async function loadHyperFormula(output) {
+    try {
+        if (!hyperFormulaCtor) {
+            const module = await import("hyperformula");
+            const maybeCtor = module.HyperFormula;
+            if (!isHyperFormulaCtor(maybeCtor)) {
+                throw new Error("Invalid HyperFormula module export.");
+            }
+            hyperFormulaCtor = maybeCtor;
+        }
+        return true;
+    }
+    catch {
+        output.diagnostics.push({
+            level: "warning",
+            message: "HyperFormula is not available. Formula cells were not evaluated."
+        });
+        return false;
+    }
+}
+function isHyperFormulaCtor(value) {
+    return ((typeof value === "object" || typeof value === "function") &&
+        value !== null &&
+        "buildFromSheets" in value &&
+        typeof value.buildFromSheets === "function");
+}
+function buildSheetsData(workbook, refIndex) {
+    return Object.fromEntries(workbook.sheets.map((sheet) => [sheet.name, buildSheetMatrix(sheet, workbook, refIndex)]));
+}
+function buildSheetMatrix(sheet, workbook, refIndex) {
+    const matrix = createEmptyMatrix(sheet.rows.length, sheet.columns.length);
+    for (const row of sheet.rows) {
+        const matrixRow = matrix[row.index - 1];
+        if (!matrixRow) {
+            continue;
+        }
+        for (const cell of row.cells) {
+            if (cell.kind === "merge-left" || cell.kind === "merge-up") {
+                continue;
+            }
+            matrixRow[cell.col - 1] = toHyperFormulaValue(cell, sheet.name, refIndex, workbook);
+        }
+    }
+    return matrix;
+}
+function createEmptyMatrix(rowCount, colCount) {
+    return Array.from({ length: rowCount }, () => Array.from({ length: colCount }, () => null));
+}
+function applyComputedValues(workbook, hf) {
+    for (const sheet of workbook.sheets) {
+        const sheetId = hf.getSheetId(sheet.name);
+        if (sheetId === undefined || sheetId === null) {
+            continue;
+        }
+        for (const row of sheet.rows) {
+            for (const cell of row.cells) {
+                if (cell.kind !== "formula") {
+                    continue;
+                }
+                const evaluated = hf.getCellValue({ sheet: sheetId, row: row.index - 1, col: cell.col - 1 });
+                cell.computed = normalizeValue(evaluated, cell.formula);
+            }
+        }
+    }
+}
+function toHyperFormulaValue(cell, sheetName, refIndex, output) {
+    if (cell.kind === "formula" && cell.formula) {
+        return translateFormulaForEngine(cell.formula, sheetName, refIndex, output.diagnostics, cell.row);
+    }
+    return cell.value;
+}
+function normalizeValue(value, formula) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "number" || typeof value === "boolean" || typeof value === "string") {
+        return value;
+    }
+    if (isDetailedCellError(value)) {
+        if (isFormulaParseError(value) && formula) {
+            return formula;
+        }
+        return value.value;
+    }
+    return String(value);
+}
+function isDetailedCellError(value) {
+    return typeof value === "object" && value !== null && "value" in value && typeof value.value === "string";
+}
+function isFormulaParseError(value) {
+    return value.type === "ERROR" && typeof value.message === "string" && value.message.includes("Parsing error");
+}

package/dist/evaluator/formula.d.ts

@@ -0,0 +1,13 @@
+import type { Diagnostic, WorkbookAst } from "../shared/types.js";
+interface SheetRefIndex {
+    firstDataRow: number;
+    lastDataRow: number;
+    columnsByName: Map<string, number>;
+}
+interface WorkbookRefIndex {
+    firstSheetName: string | undefined;
+    bySheetName: Map<string, SheetRefIndex>;
+}
+export declare function buildWorkbookRefIndex(workbook: WorkbookAst): WorkbookRefIndex;
+export declare function translateFormulaForEngine(formula: string, sheetName: string, index: WorkbookRefIndex, diagnostics: Diagnostic[], currentRow?: number): string;
+export {};

package/dist/evaluator/formula.js

@@ -0,0 +1,141 @@
+import { columnLetter } from "../shared/utils.js";
+export function buildWorkbookRefIndex(workbook) {
+    const bySheetName = new Map();
+    for (const sheet of workbook.sheets) {
+        bySheetName.set(sheet.name, buildSheetRefIndex(sheet));
+    }
+    return {
+        firstSheetName: workbook.sheets[0]?.name,
+        bySheetName
+    };
+}
+export function translateFormulaForEngine(formula, sheetName, index, diagnostics, currentRow) {
+    let translated = normalizeFunctionAliases(formula);
+    translated = translated.replace(/!!([A-Za-z_][A-Za-z0-9_]*(?:\[(?:\d+:\d+|\*)\])?|[A-Za-z]+\d+)/g, (_m, token) => {
+        if (!index.firstSheetName) {
+            return `!!${token}`;
+        }
+        return `${index.firstSheetName}!${token}`;
+    });
+    translated = translated.replace(/([A-Za-z_][A-Za-z0-9_]*)!([A-Za-z_][A-Za-z0-9_]*)(?:\[(?:(\d+):(\d+)|(\*))\])?/g, (m, targetSheet, token, start, end, fullSpan) => {
+        if (isA1Ref(token)) {
+            return m;
+        }
+        const target = index.bySheetName.get(targetSheet);
+        if (!target) {
+            return m;
+        }
+        const col = target.columnsByName.get(token.toLowerCase());
+        if (!col) {
+            return m;
+        }
+        if (fullSpan) {
+            return toFullColumnRange(targetSheet, col, target, m, sheetName, diagnostics, token);
+        }
+        if (start && end) {
+            return `${targetSheet}!${columnLetter(col)}${start}:${columnLetter(col)}${end}`;
+        }
+        return toFullColumnRange(targetSheet, col, target, m, sheetName, diagnostics, token);
+    });
+    translated = translated.replace(/([A-Za-z_][A-Za-z0-9_]*)(?:\[(?:(\d+):(\d+)|(\*))\])?/g, (m, token, start, end, fullSpan, offset, source) => {
+        const prev = offset > 0 ? (source[offset - 1] ?? "") : "";
+        const next = source[offset + m.length] ?? "";
+        const prevOk = prev === "" || /[^\w.]/.test(prev);
+        const nextOk = next === "" || /[^\w]/.test(next);
+        if (!prevOk || !nextOk || prev === "!" || prev === '"' || next === "(" || isA1Ref(token) || isKeyword(token)) {
+            return m;
+        }
+        const currentSheet = index.bySheetName.get(sheetName);
+        if (!currentSheet) {
+            return m;
+        }
+        const col = currentSheet.columnsByName.get(token.toLowerCase());
+        if (!col) {
+            return m;
+        }
+        if (fullSpan) {
+            return toFullColumnRange(undefined, col, currentSheet, m, sheetName, diagnostics, token);
+        }
+        if (start && end) {
+            return `${columnLetter(col)}${start}:${columnLetter(col)}${end}`;
+        }
+        if (isAggregateReferenceContext(source, offset, token)) {
+            if (currentRow && currentRow > currentSheet.firstDataRow) {
+                return `${columnLetter(col)}${currentSheet.firstDataRow}:${columnLetter(col)}${currentRow - 1}`;
+            }
+            return toFullColumnRange(undefined, col, currentSheet, m, sheetName, diagnostics, token);
+        }
+        if (!currentRow) {
+            return m;
+        }
+        return `${columnLetter(col)}${currentRow}`;
+    });
+    return translated;
+}
+function normalizeFunctionAliases(formula) {
+    return formula.replace(/\bAVG\s*\(/gi, "AVERAGE(");
+}
+function toFullColumnRange(targetSheet, col, target, fallback, sheetName, diagnostics, token) {
+    if (target.firstDataRow === 0 || target.lastDataRow === 0) {
+        diagnostics.push({
+            level: "warning",
+            sheet: sheetName,
+            message: `Named reference "${targetSheet ? `${targetSheet}!` : ""}${token}" has no data rows to resolve.`
+        });
+        return fallback;
+    }
+    const range = `${columnLetter(col)}${target.firstDataRow}:${columnLetter(col)}${target.lastDataRow}`;
+    return targetSheet ? `${targetSheet}!${range}` : range;
+}
+function isAggregateReferenceContext(source, offset, token) {
+    const aggregateFunctions = new Set(["SUM", "AVG", "AVERAGE", "MIN", "MAX", "COUNT", "COUNTA", "PRODUCT"]);
+    let depth = 0;
+    for (let i = offset - 1; i >= 0; i -= 1) {
+        const ch = source[i] ?? "";
+        if (ch === ")") {
+            depth += 1;
+            continue;
+        }
+        if (ch === "(") {
+            if (depth > 0) {
+                depth -= 1;
+                continue;
+            }
+            let end = i - 1;
+            while (end >= 0 && /\s/.test(source[end] ?? "")) {
+                end -= 1;
+            }
+            let start = end;
+            while (start >= 0 && /[A-Za-z_]/.test(source[start] ?? "")) {
+                start -= 1;
+            }
+            const fn = source.slice(start + 1, end + 1).toUpperCase();
+            if (!aggregateFunctions.has(fn)) {
+                return false;
+            }
+            const between = source.slice(i + 1, offset).trim();
+            const after = source.slice(offset + token.length).trimStart();
+            return (between === "" || between === ",") && (after === "" || after.startsWith(")") || after.startsWith(","));
+        }
+    }
+    return false;
+}
+function buildSheetRefIndex(sheet) {
+    const dataRows = sheet.rows.filter((row) => row.kind === "data").map((row) => row.index);
+    const firstDataRow = dataRows[0] ?? 0;
+    const lastDataRow = dataRows[dataRows.length - 1] ?? 0;
+    const columnsByName = new Map();
+    for (const column of sheet.columns) {
+        if (column.name && column.name.trim().length > 0) {
+            columnsByName.set(column.name.toLowerCase(), column.index);
+        }
+    }
+    return { firstDataRow, lastDataRow, columnsByName };
+}
+function isKeyword(token) {
+    const upper = token.toUpperCase();
+    return upper === "TRUE" || upper === "FALSE";
+}
+function isA1Ref(token) {
+    return /^\$?[A-Za-z]{1,3}\$?\d+$/.test(token);
+}

package/dist/formatter/format.d.ts

@@ -0,0 +1 @@
+export declare function format(text: string): string;

package/dist/formatter/format.js

@@ -0,0 +1,112 @@
+import { parseSheetFormat, parseTrailingModifiers } from "../shared/utils.js";
+export function format(text) {
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    const output = [];
+    let activeSheetFormat = "cello";
+    let block = [];
+    const flushBlock = () => {
+        if (block.length === 0) {
+            return;
+        }
+        output.push(...formatBlock(block));
+        block = [];
+    };
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("//") || trimmed.length === 0) {
+            flushBlock();
+            output.push(line);
+            continue;
+        }
+        const sheetMatch = trimmed.match(/^@sheet\s+(.+?)(?:\s+\[(.+)\])?$/);
+        if (sheetMatch) {
+            flushBlock();
+            activeSheetFormat = parseSheetFormat(sheetMatch[2]?.trim()).kind === "cello" ? "cello" : "other";
+            output.push(line);
+            continue;
+        }
+        if (activeSheetFormat !== "cello") {
+            flushBlock();
+            output.push(line);
+            continue;
+        }
+        const parsed = parseFormatRow(line);
+        if (parsed) {
+            block.push(parsed);
+            continue;
+        }
+        flushBlock();
+        output.push(line);
+    }
+    flushBlock();
+    return output.join("\n");
+}
+function parseFormatRow(line) {
+    const leading = "";
+    const content = line.trimStart();
+    if (/^@header(?:\s|$)/.test(content)) {
+        return parseDirectiveRow(leading, content, "@header");
+    }
+    if (/^@defaults(?:\s|$)/.test(content)) {
+        return parseDirectiveRow(leading, content, "@defaults");
+    }
+    const firstPipe = content.indexOf("|");
+    if (firstPipe < 0) {
+        return null;
+    }
+    const prefix = content.slice(0, firstPipe).trim();
+    const body = content.slice(firstPipe);
+    const cells = splitPipeCells(body);
+    if (prefix.length === 0) {
+        return { leading, prefix: "", cells };
+    }
+    const parsed = parseTrailingModifiers(prefix);
+    if (parsed.base.length === 0) {
+        return { leading, prefix, cells };
+    }
+    return null;
+}
+function parseDirectiveRow(leading, content, directive) {
+    const body = content.slice(directive.length).trim();
+    if (!body.includes("|")) {
+        return null;
+    }
+    return {
+        leading,
+        prefix: directive,
+        cells: splitPipeCells(body)
+    };
+}
+function splitPipeCells(line) {
+    const tokens = line.split("|").map((token) => token.trim());
+    return tokens
+        .filter((_, index) => !(index === 0 && tokens[0] === ""))
+        .filter((_, index, all) => !(index === all.length - 1 && all[index] === ""));
+}
+function formatBlock(rows) {
+    const prefixWidth = rows.reduce((max, row) => Math.max(max, row.prefix.length), 0);
+    const columnCount = rows.reduce((max, row) => Math.max(max, row.cells.length), 0);
+    const columnWidths = new Array(columnCount).fill(0);
+    for (const row of rows) {
+        for (let index = 0; index < columnCount; index += 1) {
+            const cell = row.cells[index] ?? "";
+            if (cell.length > (columnWidths[index] ?? 0)) {
+                columnWidths[index] = cell.length;
+            }
+        }
+    }
+    return rows.map((row) => formatRow(row, prefixWidth, columnWidths));
+}
+function formatRow(row, prefixWidth, columnWidths) {
+    const formattedPrefix = row.prefix.length > 0
+        ? `${row.prefix}${" ".repeat(prefixWidth - row.prefix.length + 1)}`
+        : prefixWidth > 0
+            ? " ".repeat(prefixWidth + 1)
+            : "";
+    let formatted = `${row.leading}${formattedPrefix}|`;
+    for (let index = 0; index < columnWidths.length; index += 1) {
+        const cell = row.cells[index] ?? "";
+        formatted += ` ${cell.padEnd(columnWidths[index] ?? 0)} |`;
+    }
+    return formatted;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { parse } from "./parser/parse.js";
+export { evaluate } from "./evaluator/evaluate.js";
+export { format } from "./formatter/format.js";
+export { render } from "./renderer/render.js";
+export { serialize } from "./serializer/serialize.js";
+export { validate } from "./validator/validate.js";
+export type { CellKind, CellNode, ColumnNode, Diagnostic, EvaluateOptions, InferredType, Modifier, ParseOptions, RenderOptions, RowKind, RowNode, SheetFormat, SheetNode, WorkbookAst } from "./shared/types.js";
+export type { ValidateOptions, ValidateResult } from "./validator/validate.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { parse } from "./parser/parse.js";
+export { evaluate } from "./evaluator/evaluate.js";
+export { format } from "./formatter/format.js";
+export { render } from "./renderer/render.js";
+export { serialize } from "./serializer/serialize.js";
+export { validate } from "./validator/validate.js";

package/dist/parser/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ParseOptions, WorkbookAst } from "../shared/types.js";
+export declare function parse(text: string, options?: ParseOptions): WorkbookAst;