@nachoggodino/cello 0.1.0

package/dist/parser/parse.js

@@ -0,0 +1,552 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { columnLetter, inferType, parseSheetFormat, parseTrailingModifiers, splitDelimitedLine } from "../shared/utils.js";
+const DEFAULT_ANON_SHEET_NAME = "Sheet1";
+export function parse(text, options = {}) {
+    const workbook = {
+        version: "1.0",
+        sheets: [],
+        diagnostics: []
+    };
+    const state = {
+        currentSheet: null,
+        currentHeaders: [],
+        previousRowByColumn: new Map(),
+        jsonBufferBySheet: new Map(),
+        consumedDelimitedHeaderBySheet: new Set()
+    };
+    const sourceLines = text.replace(/\r\n/g, "\n").split("\n");
+    const runtime = {
+        workbook,
+        options,
+        state,
+        injectedLines: [],
+        ensureSheet: () => ensureSheet(workbook, state, options),
+        pushDiagnostic: (d) => pushDiagnostic(workbook, options, d)
+    };
+    let lineNumber = 0;
+    let sourceIndex = 0;
+    while (runtime.injectedLines.length > 0 || sourceIndex < sourceLines.length) {
+        const fromInjected = runtime.injectedLines.length > 0;
+        const rawLine = fromInjected
+            ? (runtime.injectedLines.shift() ?? "")
+            : (sourceLines[sourceIndex] ?? "");
+        if (!fromInjected && sourceIndex < sourceLines.length) {
+            sourceIndex += 1;
+        }
+        lineNumber += 1;
+        const trimmed = rawLine.trim();
+        if (trimmed.startsWith("//")) {
+            continue;
+        }
+        if (tryHandleSheetDeclaration(runtime, trimmed, lineNumber)) {
+            continue;
+        }
+        if (trimmed.length === 0) {
+            resetRowTracking(runtime.state);
+            continue;
+        }
+        const sheet = runtime.ensureSheet();
+        if (sheet.format.kind === "json") {
+            bufferJsonLine(runtime.state, sheet.name, rawLine);
+            continue;
+        }
+        if (tryHandleExternalSource(runtime, sheet, trimmed, lineNumber)) {
+            continue;
+        }
+        if (sheet.format.kind === "cello" && tryHandleHeaderDirective(runtime, sheet, rawLine, trimmed, lineNumber)) {
+            continue;
+        }
+        if (sheet.format.kind === "cello" && tryHandleDefaultsDirective(runtime, sheet, rawLine, trimmed, lineNumber)) {
+            continue;
+        }
+        if (sheet.format.kind === "delimited") {
+            handleDelimitedLine(runtime.state, sheet, rawLine, lineNumber);
+            continue;
+        }
+        if (sheet.format.kind === "markdown") {
+            handleMarkdownLine(runtime.state, sheet, trimmed, lineNumber);
+            continue;
+        }
+        if (!rawLine.includes("|")) {
+            runtime.pushDiagnostic({
+                level: "warning",
+                line: lineNumber,
+                sheet: sheet.name,
+                message: `Skipped non-row line: ${trimmed}`
+            });
+            continue;
+        }
+        handleNativeLine(runtime, sheet, rawLine, lineNumber);
+    }
+    finalizeJsonSheets(runtime);
+    return workbook;
+}
+function ensureSheet(workbook, state, options) {
+    if (!state.currentSheet) {
+        state.currentSheet = createSheet(options.anonymousSheetName ?? DEFAULT_ANON_SHEET_NAME, undefined);
+        workbook.sheets.push(state.currentSheet);
+        resetSheetTracking(state);
+    }
+    return state.currentSheet;
+}
+function pushDiagnostic(workbook, options, diagnostic) {
+    workbook.diagnostics.push(diagnostic);
+    if (options.strict && diagnostic.level === "error") {
+        throw new Error(`Parse error: ${diagnostic.message}${diagnostic.line ? ` (line ${diagnostic.line})` : ""}`);
+    }
+}
+function resetSheetTracking(state) {
+    state.currentHeaders = [];
+    resetRowTracking(state);
+}
+function resetRowTracking(state) {
+    state.previousRowByColumn = new Map();
+}
+function tryHandleSheetDeclaration(runtime, trimmed, lineNumber) {
+    const sheetMatch = trimmed.match(/^@sheet\s+(.+?)(?:\s+\[(.+)\])?$/);
+    if (!sheetMatch) {
+        return false;
+    }
+    const rawName = sheetMatch[1];
+    const rawFormat = sheetMatch[2];
+    if (!rawName) {
+        runtime.pushDiagnostic({ level: "warning", line: lineNumber, message: "Invalid @sheet declaration." });
+        return true;
+    }
+    const nextSheet = createSheet(rawName.trim(), rawFormat?.trim());
+    runtime.workbook.sheets.push(nextSheet);
+    runtime.state.currentSheet = nextSheet;
+    resetSheetTracking(runtime.state);
+    return true;
+}
+function tryHandleExternalSource(runtime, sheet, trimmed, lineNumber) {
+    const externalSourceMatch = trimmed.match(/^->\s+(.+)$/);
+    if (!externalSourceMatch) {
+        return false;
+    }
+    if (sheet.rows.length > 0) {
+        runtime.pushDiagnostic({
+            level: "warning",
+            line: lineNumber,
+            sheet: sheet.name,
+            message: "External sheet source (-> path) must appear before any rows in a sheet."
+        });
+        return true;
+    }
+    const rawPath = (externalSourceMatch[1] ?? "").trim();
+    const baseDir = runtime.options.baseDir ?? getDefaultBaseDir();
+    const filePath = resolve(baseDir, rawPath);
+    try {
+        const externalText = readExternalSource(runtime.options, rawPath, baseDir, filePath).replace(/\r\n/g, "\n");
+        const externalLines = externalText.split("\n");
+        runtime.injectedLines = externalLines.concat(runtime.injectedLines);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        runtime.pushDiagnostic({
+            level: "warning",
+            line: lineNumber,
+            sheet: sheet.name,
+            message: `Failed to load external sheet source "${rawPath}": ${message}`
+        });
+    }
+    return true;
+}
+function getDefaultBaseDir() {
+    return typeof process !== "undefined" && typeof process.cwd === "function" ? process.cwd() : ".";
+}
+function readExternalSource(options, rawPath, baseDir, resolvedPath) {
+    return options.readExternalSource
+        ? options.readExternalSource(rawPath, { baseDir, resolvedPath })
+        : readFileSync(resolvedPath, "utf8");
+}
+function bufferJsonLine(state, sheetName, rawLine) {
+    const current = state.jsonBufferBySheet.get(sheetName) ?? [];
+    current.push(rawLine);
+    state.jsonBufferBySheet.set(sheetName, current);
+}
+function finalizeJsonSheets(runtime) {
+    for (const sheet of runtime.workbook.sheets) {
+        if (sheet.format.kind !== "json") {
+            continue;
+        }
+        const raw = (runtime.state.jsonBufferBySheet.get(sheet.name) ?? []).join("\n").trim();
+        if (raw.length === 0) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (!Array.isArray(parsed) || (parsed[0] && typeof parsed[0] !== "object")) {
+                throw new Error("JSON sheet expects an array of flat objects.");
+            }
+            const first = parsed[0];
+            const headers = Object.keys(first ?? {}).map((name) => ({ name, modifiers: [] }));
+            if (headers.length > 0) {
+                applyHeaders(runtime.state, sheet, headers, 0);
+            }
+            let previousRowByColumn = mapLatestVisibleCells(sheet.rows[sheet.rows.length - 1] ?? {
+                index: 0,
+                kind: "data",
+                sourceLine: 0,
+                modifiers: [],
+                cells: []
+            });
+            for (const obj of parsed) {
+                const cells = headers.map((h) => stringifyJsonValue(obj[h.name]));
+                previousRowByColumn = appendDataRow(sheet, cells, 0, previousRowByColumn, headers);
+            }
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            runtime.workbook.diagnostics.push({
+                level: "warning",
+                sheet: sheet.name,
+                message: `JSON parse failed. Falling back to single text row: ${message}`
+            });
+            const row = parseDataCells([raw], {
+                rowIndex: sheet.rows.length + 1,
+                lineNumber: 0,
+                rowModifiers: [],
+                previousRowByColumn: new Map(),
+                currentHeaders: []
+            });
+            sheet.rows.push(row);
+            registerColumns(sheet, row.cells, []);
+        }
+    }
+}
+function createSheet(name, rawFormat) {
+    return {
+        name,
+        format: parseSheetFormat(rawFormat),
+        rows: [],
+        columns: []
+    };
+}
+function tryHandleHeaderDirective(runtime, sheet, rawLine, trimmed, lineNumber) {
+    if (!/^@header(?:\s|$)/.test(trimmed)) {
+        return false;
+    }
+    const markerStart = rawLine.indexOf("@header");
+    const body = rawLine.slice(markerStart + "@header".length).trim();
+    if (!body.includes("|")) {
+        runtime.pushDiagnostic({
+            level: "warning",
+            line: lineNumber,
+            sheet: sheet.name,
+            message: "@header must be followed by a pipe-separated row."
+        });
+        return true;
+    }
+    applyHeaders(runtime.state, sheet, parseHeadersFromLine(body), lineNumber);
+    return true;
+}
+function parseHeadersFromLine(line) {
+    return splitNativeCells(line).map((token) => {
+        const parsed = parseTrailingModifiers(token.trim());
+        return { name: parsed.base, modifiers: parsed.modifiers.filter((modifier) => modifier.key !== "default") };
+    });
+}
+function applyHeaders(state, sheet, headers, lineNumber) {
+    pushHeaderRow(sheet, headers, lineNumber);
+    state.currentHeaders = headers;
+    applyHeadersToColumns(sheet, headers);
+}
+function tryHandleDefaultsDirective(runtime, sheet, rawLine, trimmed, lineNumber) {
+    if (!/^@defaults(?:\s|$)/.test(trimmed)) {
+        return false;
+    }
+    const markerStart = rawLine.indexOf("@defaults");
+    const body = rawLine.slice(markerStart + "@defaults".length).trim();
+    if (!body.includes("|")) {
+        runtime.pushDiagnostic({
+            level: "warning",
+            line: lineNumber,
+            sheet: sheet.name,
+            message: "@defaults must be followed by a pipe-separated row."
+        });
+        return true;
+    }
+    applyDefaults(runtime.state, sheet, splitNativeCells(body));
+    return true;
+}
+function applyDefaults(state, sheet, defaults) {
+    const maxColumns = Math.max(defaults.length, state.currentHeaders.length);
+    const nextHeaders = [];
+    for (let idx = 0; idx < maxColumns; idx += 1) {
+        const header = state.currentHeaders[idx] ?? { name: "", modifiers: [] };
+        const rawDefault = defaults[idx]?.trim() ?? "";
+        const modifiers = rawDefault.length > 0
+            ? upsertDefaultModifier(header.modifiers, rawDefault)
+            : header.modifiers;
+        nextHeaders[idx] = { name: header.name, modifiers };
+    }
+    state.currentHeaders = nextHeaders;
+    applyHeadersToColumns(sheet, nextHeaders);
+}
+function upsertDefaultModifier(modifiers, formula) {
+    const normalized = formula.startsWith("=") ? formula : `=${formula}`;
+    const defaultModifier = {
+        raw: `default:${normalized}`,
+        key: "default",
+        value: normalized
+    };
+    return [...modifiers.filter((modifier) => modifier.key !== "default"), defaultModifier];
+}
+function pushHeaderRow(sheet, headers, lineNumber) {
+    const index = sheet.rows.length + 1;
+    sheet.rows.push({
+        index,
+        kind: "header",
+        sourceLine: lineNumber,
+        modifiers: [],
+        cells: headers.map((header, col) => createValueCell(index, col + 1, header.name, header.modifiers, "text"))
+    });
+}
+function splitNativeCells(line) {
+    const tokens = line.split("|").map((t) => t.trim());
+    return trimPipeEdgeTokens(tokens);
+}
+function splitNativeRow(line) {
+    const firstPipe = line.indexOf("|");
+    if (firstPipe === -1) {
+        return { rowModifiers: [], cells: [line] };
+    }
+    const rowPrefix = line.slice(0, firstPipe).trim();
+    const body = line.slice(firstPipe);
+    const cells = splitNativeCells(body);
+    if (rowPrefix.length === 0) {
+        return { rowModifiers: [], cells };
+    }
+    const parsed = parseTrailingModifiers(rowPrefix);
+    if (parsed.base.length === 0) {
+        return { rowModifiers: parsed.modifiers, cells };
+    }
+    return { rowModifiers: [], unsupportedPrefix: rowPrefix, cells };
+}
+function handleNativeLine(runtime, sheet, rawLine, lineNumber) {
+    const { rowModifiers, unsupportedPrefix, cells } = splitNativeRow(rawLine);
+    if (unsupportedPrefix) {
+        runtime.pushDiagnostic({
+            level: "warning",
+            line: lineNumber,
+            sheet: sheet.name,
+            message: `Ignored unsupported row prefix "${unsupportedPrefix}". Row references are not supported.`
+        });
+    }
+    runtime.state.previousRowByColumn = appendDataRow(sheet, cells, lineNumber, runtime.state.previousRowByColumn, runtime.state.currentHeaders, rowModifiers);
+}
+function handleDelimitedLine(state, sheet, rawLine, lineNumber) {
+    const parts = splitDelimitedLine(rawLine, sheet.format.delimiter).map((v) => v.trim());
+    const headerConsumedKey = sheet.name;
+    if (!sheet.format.noHeader && !state.consumedDelimitedHeaderBySheet.has(headerConsumedKey)) {
+        applyHeaders(state, sheet, toHeaderDefs(parts), lineNumber);
+        state.consumedDelimitedHeaderBySheet.add(headerConsumedKey);
+        return;
+    }
+    state.previousRowByColumn = appendDataRow(sheet, parts, lineNumber, state.previousRowByColumn, state.currentHeaders);
+}
+function handleMarkdownLine(state, sheet, trimmed, lineNumber) {
+    if (isMarkdownSeparator(trimmed) || !trimmed.includes("|")) {
+        return;
+    }
+    const parts = parseMarkdownLine(trimmed);
+    if (state.currentHeaders.length === 0) {
+        applyHeaders(state, sheet, toHeaderDefs(parts), lineNumber);
+        return;
+    }
+    state.previousRowByColumn = appendDataRow(sheet, parts, lineNumber, state.previousRowByColumn, state.currentHeaders);
+}
+function parseDataCells(cells, context) {
+    const parsedCells = [];
+    const currentByColumn = new Map();
+    const maxColumn = Math.max(cells.length, getLastDefaultColumnIndex(context.currentHeaders));
+    for (let idx = 0; idx < maxColumn; idx += 1) {
+        const col = idx + 1;
+        const token = cells[idx]?.trim() ?? "";
+        const defaultFormula = getColumnDefaultFormula(context.currentHeaders[idx]);
+        if (token === "<") {
+            const left = currentByColumn.get(col - 1);
+            if (left) {
+                left.colspan += 1;
+            }
+            parsedCells.push(createMergeCell(context.rowIndex, col, "merge-left"));
+            if (left) {
+                currentByColumn.set(col, left);
+            }
+            continue;
+        }
+        if (token === "^") {
+            const above = context.previousRowByColumn.get(col);
+            if (above) {
+                above.rowspan += 1;
+            }
+            parsedCells.push(createMergeCell(context.rowIndex, col, "merge-up"));
+            if (above) {
+                currentByColumn.set(col, above);
+            }
+            continue;
+        }
+        if (token.length === 0 && defaultFormula) {
+            const formulaCell = createFormulaCell(context.rowIndex, col, defaultFormula);
+            parsedCells.push(formulaCell);
+            currentByColumn.set(col, formulaCell);
+            continue;
+        }
+        if (token.startsWith("=")) {
+            const formulaCell = createFormulaCell(context.rowIndex, col, token);
+            parsedCells.push(formulaCell);
+            currentByColumn.set(col, formulaCell);
+            continue;
+        }
+        const extracted = parseTrailingModifiers(token);
+        const inferred = inferType(extracted.base);
+        const cell = createValueCell(context.rowIndex, col, inferred.parsed, extracted.modifiers, inferred.inferredType, token);
+        parsedCells.push(cell);
+        currentByColumn.set(col, cell);
+    }
+    return createDataRow(context.rowIndex, context.lineNumber, parsedCells, context.rowModifiers);
+}
+function appendDataRow(sheet, cells, lineNumber, previousRowByColumn, currentHeaders, rowModifiers = []) {
+    const row = parseDataCells(cells, {
+        rowIndex: sheet.rows.length + 1,
+        lineNumber,
+        rowModifiers,
+        previousRowByColumn,
+        currentHeaders
+    });
+    sheet.rows.push(row);
+    registerColumns(sheet, row.cells, currentHeaders);
+    return mapLatestVisibleCells(row);
+}
+function registerColumns(sheet, cells, currentHeaders) {
+    const maxCol = cells.length;
+    for (let col = 1; col <= maxCol; col += 1) {
+        if (sheet.columns[col - 1]) {
+            continue;
+        }
+        const header = currentHeaders[col - 1];
+        sheet.columns[col - 1] = createColumnNode(col, header);
+    }
+}
+function applyHeadersToColumns(sheet, headers) {
+    for (let i = 0; i < headers.length; i += 1) {
+        const header = headers[i];
+        if (!header) {
+            continue;
+        }
+        sheet.columns[i] = createColumnNode(i + 1, header);
+    }
+}
+function mapLatestVisibleCells(row) {
+    const map = new Map();
+    for (const cell of row.cells) {
+        if (cell.kind === "merge-left" || cell.kind === "merge-up") {
+            continue;
+        }
+        map.set(cell.col, cell);
+    }
+    return map;
+}
+function isMarkdownSeparator(trimmed) {
+    const collapsed = trimmed.replaceAll(" ", "");
+    return /^(\|)?[:\-|]+(\|)?$/.test(collapsed);
+}
+function parseMarkdownLine(trimmed) {
+    const parts = trimmed.split("|").map((p) => p.trim());
+    return trimPipeEdgeTokens(parts);
+}
+function trimPipeEdgeTokens(tokens) {
+    return tokens
+        .filter((_, idx) => !(idx === 0 && tokens[0] === ""))
+        .filter((_, idx, arr) => !(idx === arr.length - 1 && arr[idx] === ""));
+}
+function toHeaderDefs(values) {
+    return values.map((name) => ({ name, modifiers: [] }));
+}
+function getLastDefaultColumnIndex(headers) {
+    for (let idx = headers.length - 1; idx >= 0; idx -= 1) {
+        if (getColumnDefaultFormula(headers[idx])) {
+            return idx + 1;
+        }
+    }
+    return 0;
+}
+function getColumnDefaultFormula(header) {
+    const formula = header?.modifiers.find((modifier) => modifier.key === "default")?.value?.trim();
+    if (!formula) {
+        return undefined;
+    }
+    return formula.startsWith("=") ? formula : `=${formula}`;
+}
+function createColumnNode(index, header) {
+    return {
+        index,
+        letter: columnLetter(index),
+        ...(header?.name ? { name: header.name } : {}),
+        modifiers: header?.modifiers ?? [],
+        hidden: Boolean(header?.modifiers.some((m) => m.key === "hidden"))
+    };
+}
+function createDataRow(index, sourceLine, cells, modifiers) {
+    return {
+        index,
+        kind: "data",
+        sourceLine,
+        modifiers,
+        cells
+    };
+}
+function createValueCell(row, col, value, modifiers, inferredType, raw = value === null ? "" : String(value)) {
+    return {
+        row,
+        col,
+        raw,
+        kind: inferredType === "empty" ? "empty" : "value",
+        inferredType,
+        value,
+        modifiers,
+        colspan: 1,
+        rowspan: 1
+    };
+}
+function createFormulaCell(row, col, formula) {
+    return {
+        row,
+        col,
+        raw: formula,
+        kind: "formula",
+        inferredType: "text",
+        value: formula,
+        formula,
+        modifiers: [],
+        colspan: 1,
+        rowspan: 1
+    };
+}
+function createMergeCell(row, col, kind) {
+    return {
+        row,
+        col,
+        raw: kind === "merge-left" ? "<" : "^",
+        kind,
+        inferredType: "empty",
+        value: null,
+        modifiers: [],
+        colspan: 0,
+        rowspan: 0
+    };
+}
+function stringifyJsonValue(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+    }
+    return JSON.stringify(value);
+}

package/dist/renderer/render.d.ts

@@ -0,0 +1,2 @@
+import type { RenderOptions, WorkbookAst } from "../shared/types.js";
+export declare function render(input: string | WorkbookAst, options?: RenderOptions): Promise<string>;