npm - @nachoggodino/cello - Versions diffs - 0.1.0 - Mend

@nachoggodino/cello 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/BYLAWS.md +446 -0
package/CHANGELOG.md +11 -0
package/LICENSE +12 -0
package/README.md +211 -0
package/dist/cli/cli.d.ts +16 -0
package/dist/cli/cli.js +360 -0
package/dist/cli/serve.d.ts +15 -0
package/dist/cli/serve.js +226 -0
package/dist/evaluator/evaluate.d.ts +2 -0
package/dist/evaluator/evaluate.js +129 -0
package/dist/evaluator/formula.d.ts +13 -0
package/dist/evaluator/formula.js +141 -0
package/dist/formatter/format.d.ts +1 -0
package/dist/formatter/format.js +112 -0
package/dist/index.d.ts +8 -0
package/dist/index.js +6 -0
package/dist/parser/parse.d.ts +2 -0
package/dist/parser/parse.js +552 -0
package/dist/renderer/render.d.ts +2 -0
package/dist/renderer/render.js +295 -0
package/dist/serializer/serialize.d.ts +2 -0
package/dist/serializer/serialize.js +104 -0
package/dist/shared/types.d.ts +88 -0
package/dist/shared/types.js +1 -0
package/dist/shared/utils.d.ts +16 -0
package/dist/shared/utils.js +142 -0
package/dist/validator/validate.d.ts +8 -0
package/dist/validator/validate.js +10 -0
package/dist/version.d.ts +1 -0
package/dist/version.js +1 -0
package/docs/ARCHITECTURE.md +43 -0
package/docs/CLI.md +58 -0
package/docs/COMPLIANCE.md +82 -0
package/docs/ERROR_MODEL.md +25 -0
package/docs/FORMULA_SUPPORT.md +33 -0
package/docs/SPEC.md +723 -0
package/docs/SYNTAX_HIGHLIGHTING.md +91 -0
package/examples/advanced_kpi.cel +42 -0
package/examples/basic.cel +8 -0
package/examples/feature_showcase.cel +37 -0
package/package.json +96 -0
package/syntaxes/cel.language-configuration.json +31 -0
package/syntaxes/cel.tmLanguage.json +250 -0

package/dist/renderer/render.js ADDED Viewed

@@ -0,0 +1,295 @@
+import { evaluate } from "../evaluator/evaluate.js";
+import { parse } from "../parser/parse.js";
+import { columnLetter, escapeHtml, workbookHasFormulas } from "../shared/utils.js";
+export async function render(input, options = {}) {
+    const parseOptions = {
+        ...(options.strict === undefined ? {} : { strict: options.strict }),
+        ...(options.baseDir === undefined ? {} : { baseDir: options.baseDir }),
+        ...(options.readExternalSource === undefined ? {} : { readExternalSource: options.readExternalSource })
+    };
+    const parsed = typeof input === "string" ? parse(input, parseOptions) : input;
+    const shouldEvaluate = options.evaluate !== false && workbookHasFormulas(parsed);
+    const evaluated = shouldEvaluate ? await evaluate(parsed, parseOptions) : parsed;
+    const workbookHtml = renderWorkbook(renderTabs(evaluated), renderSheets(evaluated));
+    return options.format === "fragment"
+        ? renderFragment(workbookHtml, options.interactive !== false)
+        : renderDocument(options.title ?? "Cello Workbook", workbookHtml, options.interactive !== false);
+}
+function renderDocument(title, workbookHtml, interactive) {
+    return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>${escapeHtml(title)}</title>
+  ${renderStyles()}
+</head>
+<body>
+  ${workbookHtml}
+  ${interactive ? renderScript() : ""}
+</body>
+</html>`;
+}
+function renderFragment(workbookHtml, interactive) {
+    return `${renderStyles()}
+  ${workbookHtml}
+  ${interactive ? renderScript() : ""}`;
+}
+function renderStyles() {
+    return `<style>
+    .cello-workbook {
+      font-family: Inter, Segoe UI, Arial, sans-serif;
+      color: #111827;
+      --cello-tone-ok-color: #166534;
+      --cello-tone-ok-background: #dcfce7;
+      --cello-tone-warn-color: #9a3412;
+      --cello-tone-warn-background: #ffedd5;
+      --cello-tone-error-color: #991b1b;
+      --cello-tone-error-background: #fee2e2;
+      --cello-tone-info-color: #1d4ed8;
+      --cello-tone-info-background: #dbeafe;
+      --cello-tone-muted-color: #475569;
+      --cello-tone-muted-background: #e2e8f0;
+      --cello-tone-accent-color: #6d28d9;
+      --cello-tone-accent-background: #ede9fe;
+    }
+    .cello-tabs { display: flex; gap: 8px; overflow-x: auto; margin-bottom: 12px; }
+    .cello-tab { border: 1px solid #d1d5db; background: #ffffff; padding: 6px 10px; border-radius: 6px; cursor: pointer; }
+    .cello-tab.active { background: #111827; color: #ffffff; border-color: #111827; }
+    .cello-sheet { display: none; }
+    .cello-sheet.active { display: block; }
+    table { border-collapse: collapse; width: max-content; max-width: none; }
+    th, td { border: 1px solid #e5e7eb; padding: 8px; text-align: left; vertical-align: top; white-space: nowrap; }
+    th[colspan], th[rowspan], td[colspan], td[rowspan] { text-align: center; vertical-align: middle; }
+    th { background: #f3f4f6; font-weight: 600; }
+    .cello-corner-index, .cello-column-index, .cello-row-index { background: #f9fafb; color: #6b7280; font-size: 0.75rem; font-weight: 600; text-align: center; }
+    .cello-corner-index, .cello-row-index { min-width: 36px; }
+    .cello-bold { font-weight: 700; }
+    .cello-italic { font-style: italic; }
+    .cello-h1 { font-size: 1.25rem; font-weight: 700; }
+    .cello-h2 { font-size: 1.1rem; font-weight: 700; }
+    .cello-tone-ok { color: var(--cello-tone-ok-color); background: var(--cello-tone-ok-background); }
+    .cello-tone-warn { color: var(--cello-tone-warn-color); background: var(--cello-tone-warn-background); }
+    .cello-tone-error { color: var(--cello-tone-error-color); background: var(--cello-tone-error-background); }
+    .cello-tone-info { color: var(--cello-tone-info-color); background: var(--cello-tone-info-background); }
+    .cello-tone-muted { color: var(--cello-tone-muted-color); background: var(--cello-tone-muted-background); }
+    .cello-tone-accent { color: var(--cello-tone-accent-color); background: var(--cello-tone-accent-background); }
+  </style>`;
+}
+function renderWorkbook(tabs, sheetsHtml) {
+    return `<div class="cello-workbook">
+    <div class="cello-tabs">${tabs}</div>
+    ${sheetsHtml}
+  </div>`;
+}
+function renderScript() {
+    return `<script>
+    (() => {
+    const currentScript = document.currentScript;
+    const root = currentScript?.previousElementSibling;
+    if (!(root instanceof HTMLElement) || !root.classList.contains("cello-workbook")) {
+      return;
+    }
+    const tabs = Array.from(root.querySelectorAll(".cello-tab"));
+    const sheets = Array.from(root.querySelectorAll(".cello-sheet"));
+    const activeSheetStorageKey = "cello:active-sheet:" + window.location.pathname;
+    function readStoredSheet() {
+      try {
+        return window.localStorage.getItem(activeSheetStorageKey);
+      } catch {
+        return null;
+      }
+    }
+    function writeStoredSheet(id) {
+      try {
+        window.localStorage.setItem(activeSheetStorageKey, id);
+      } catch {}
+    }
+    function activateSheet(id) {
+      const nextTab = tabs.find((tab) => tab.getAttribute("data-sheet") === id) ?? tabs[0];
+      if (!nextTab) {
+        return;
+      }
+      const nextId = nextTab.getAttribute("data-sheet");
+      tabs.forEach((tab) => tab.classList.toggle("active", tab === nextTab));
+      sheets.forEach((sheet) => sheet.classList.toggle("active", sheet.getAttribute("data-sheet") === nextId));
+      if (nextId) {
+        writeStoredSheet(nextId);
+      }
+    }
+    tabs.forEach((tab) => {
+      tab.addEventListener("click", () => {
+        activateSheet(tab.getAttribute("data-sheet"));
+      });
+    });
+    activateSheet(readStoredSheet());
+    })();
+  </script>`;
+}
+function renderTabs(workbook) {
+    return workbook.sheets
+        .map((sheet, idx) => `<button class="cello-tab ${idx === 0 ? "active" : ""}" data-sheet="${escapeHtml(sheet.name)}">${escapeHtml(sheet.name)}</button>`)
+        .join("");
+}
+function renderSheets(workbook) {
+    return workbook.sheets
+        .map((sheet, idx) => `<section class="cello-sheet ${idx === 0 ? "active" : ""}" data-sheet="${escapeHtml(sheet.name)}"><table>${renderColumnIndexRow(sheet)}<tbody>${sheet.rows
+        .map((row) => renderRow(row, sheet))
+        .join("")}</tbody></table></section>`)
+        .join("");
+}
+function renderColumnIndexRow(sheet) {
+    const columns = Array.from({ length: getSheetColumnCount(sheet) }, (_, idx) => `<th class="cello-column-index">${columnLetter(idx + 1)}</th>`).join("");
+    return `<thead><tr><th class="cello-corner-index"></th>${columns}</tr></thead>`;
+}
+function renderRow(row, sheet) {
+    const header = row.kind === "header";
+    const cells = row.cells.filter(isRenderableCell).map((cell) => renderCell(cell, header, collectModifiers(cell, row, sheet))).join("");
+    return `<tr><th class="cello-row-index" scope="row">${row.index}</th>${cells}</tr>`;
+}
+function renderCell(cell, header, modifiers) {
+    const tag = header ? "th" : "td";
+    const formatted = formatInline(formatDisplayValue(renderCellValue(cell), modifiers));
+    const attrs = buildCellAttributes(cell, modifiers);
+    return `<${tag} ${attrs}>${formatted}</${tag}>`;
+}
+function renderCellValue(cell) {
+    if (cell.computed !== undefined) {
+        return cell.computed;
+    }
+    if (cell.kind === "formula" && cell.formula) {
+        return cell.formula;
+    }
+    return cell.value;
+}
+function collectModifiers(cell, row, sheet) {
+    const columnModifiers = row.kind === "header" ? [] : (sheet.columns[cell.col - 1]?.modifiers ?? []);
+    return [...columnModifiers, ...row.modifiers, ...cell.modifiers];
+}
+function buildCellAttributes(cell, modifiers) {
+    const className = buildClassAttribute(modifiers);
+    const style = buildStyleAttribute(modifiers);
+    return [
+        cell.colspan > 1 ? `colspan="${cell.colspan}"` : "",
+        cell.rowspan > 1 ? `rowspan="${cell.rowspan}"` : "",
+        className,
+        style
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+function formatInline(raw) {
+    if (raw.startsWith("## ")) {
+        return `<span class="cello-h1">${escapeHtml(raw.slice(3))}</span>`;
+    }
+    if (raw.startsWith("# ")) {
+        return `<span class="cello-h2">${escapeHtml(raw.slice(2))}</span>`;
+    }
+    let out = escapeHtml(raw);
+    out = out.replace(/\*([^*]+)\*/g, "<span class=\"cello-bold\">$1</span>");
+    out = out.replace(/_([^_]+)_/g, "<span class=\"cello-italic\">$1</span>");
+    out = out.replace(/~~([^~]+)~~/g, "<del>$1</del>");
+    return out;
+}
+function buildStyleAttribute(modifiers) {
+    const style = modifiers.map(toStyleRule).filter(Boolean).join(";");
+    return style ? `style="${style}"` : "";
+}
+function buildClassAttribute(modifiers) {
+    const classes = modifiers.map(toClassName).filter(Boolean);
+    return classes.length > 0 ? `class="${classes.join(" ")}"` : "";
+}
+function formatDisplayValue(value, modifiers) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return String(value);
+    }
+    const format = collectNumericDisplayFormat(modifiers);
+    if (!format) {
+        return String(value);
+    }
+    const scaled = format.percent ? value * 100 : value;
+    const numberText = format.decimals === undefined ? String(scaled) : scaled.toFixed(format.decimals);
+    return `${format.currency ?? ""}${numberText}${format.percent ? "%" : ""}`;
+}
+function collectNumericDisplayFormat(modifiers) {
+    const format = { percent: false };
+    let found = false;
+    for (const mod of modifiers) {
+        if (isCurrencyModifier(mod.key)) {
+            format.currency = mod.key;
+            found = true;
+            continue;
+        }
+        if (mod.key === "%") {
+            format.percent = true;
+            found = true;
+            continue;
+        }
+        const decimals = parseDecimalsModifier(mod.key);
+        if (decimals !== undefined) {
+            format.decimals = decimals;
+            found = true;
+        }
+    }
+    return found ? format : undefined;
+}
+function isCurrencyModifier(key) {
+    return key === "€" || key === "$" || key === "£";
+}
+function parseDecimalsModifier(key) {
+    const match = /^(\d+)d$/.exec(key);
+    if (!match) {
+        return undefined;
+    }
+    const decimals = Number(match[1]);
+    return Number.isSafeInteger(decimals) ? decimals : undefined;
+}
+function isRenderableCell(cell) {
+    return cell.kind !== "merge-left" && cell.kind !== "merge-up";
+}
+function getSheetColumnCount(sheet) {
+    const maxRenderedColumn = Math.max(0, ...sheet.rows.flatMap((row) => row.cells
+        .filter(isRenderableCell)
+        .map((cell) => cell.col + Math.max(cell.colspan, 1) - 1)));
+    return Math.max(sheet.columns.length, maxRenderedColumn);
+}
+function toStyleRule(mod) {
+    if (mod.key === "bold") {
+        return "font-weight:700";
+    }
+    if (mod.key === "italic") {
+        return "font-style:italic";
+    }
+    if (mod.key === "bg" && mod.value) {
+        return `background:${mod.value}`;
+    }
+    if (mod.key === "bgfg" && mod.value) {
+        const [background = "", foreground = ""] = mod.value.split(":");
+        return [background ? `background:${background}` : "", foreground ? `color:${foreground}` : ""].filter(Boolean).join(";");
+    }
+    if (mod.key.startsWith("#")) {
+        return `color:${mod.key}`;
+    }
+    if (mod.key === "color" && mod.value) {
+        return `color:${mod.value}`;
+    }
+    if (mod.key === "tone") {
+        return "";
+    }
+    if (isNamedColorModifier(mod.key)) {
+        return `color:${mod.key}`;
+    }
+    return "";
+}
+function toClassName(mod) {
+    if (mod.key !== "tone" || !mod.value) {
+        return "";
+    }
+    return isToneName(mod.value) ? `cello-tone-${mod.value}` : "";
+}
+function isNamedColorModifier(key) {
+    return /^[a-z]+$/.test(key) && !["bold", "default", "italic", "hidden"].includes(key);
+}
+function isToneName(value) {
+    return ["ok", "warn", "error", "info", "muted", "accent"].includes(value);
+}

package/dist/serializer/serialize.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { WorkbookAst } from "../shared/types.js";
2	+ export declare function serialize(ast: WorkbookAst): string;

package/dist/serializer/serialize.js ADDED Viewed

@@ -0,0 +1,104 @@
+export function serialize(ast) {
+    const chunks = [];
+    for (const [sheetIndex, sheet] of ast.sheets.entries()) {
+        if (sheetIndex > 0) {
+            chunks.push("");
+        }
+        chunks.push(`@sheet ${sheet.name}${formatToToken(sheet.format)}`);
+        for (const row of sheet.rows) {
+            chunks.push(stringifyRow(row));
+            if (row.kind === "header") {
+                const defaultsRow = stringifyDefaultsRow(sheet, row);
+                if (defaultsRow) {
+                    chunks.push(defaultsRow);
+                }
+            }
+        }
+    }
+    return chunks.join("\n");
+}
+function stringifyRow(row) {
+    if (row.kind === "header") {
+        return stringifyHeaderRow(row);
+    }
+    return stringifyDataRow(row);
+}
+function stringifyHeaderRow(row) {
+    const cells = row.cells
+        .filter((c) => c.kind !== "merge-left" && c.kind !== "merge-up")
+        .map((c) => `${stringifyCellBase(c)}${stringifyModifiers(c.modifiers.filter((modifier) => modifier.key !== "default"))}`)
+        .join(" | ");
+    return `@header | ${cells} |`;
+}
+function stringifyDataRow(row) {
+    const cells = row.cells.map((cell) => stringifyCell(cell)).join(" | ");
+    const rowPrefix = row.modifiers.length > 0 ? `${stringifyModifiers(row.modifiers)} ` : "";
+    return `${rowPrefix}| ${cells} |`;
+}
+function stringifyDefaultsRow(sheet, row) {
+    const cells = sheet.columns.map((column) => {
+        const columnDefault = findDefaultModifier(column.modifiers);
+        if (!columnDefault) {
+            return "";
+        }
+        return columnDefault.value ?? "";
+    });
+    if (!cells.some((cell) => cell.length > 0)) {
+        return undefined;
+    }
+    return `@defaults | ${cells.join(" | ")} |`;
+}
+function findDefaultModifier(modifiers) {
+    return modifiers.find((modifier) => modifier.key === "default");
+}
+function formatToToken(format) {
+    if (format.kind === "cello") {
+        return "";
+    }
+    if (format.kind === "markdown") {
+        return " [markdown]";
+    }
+    if (format.kind === "json") {
+        return format.path ? ` [json:${format.path}]` : " [json]";
+    }
+    const delimiter = format.alias ? format.alias : format.delimiter === "\t" ? "\\t" : format.delimiter;
+    const suffix = format.noHeader ? ":noheader" : "";
+    return ` [${delimiter}${suffix}]`;
+}
+function stringifyCell(cell) {
+    if (cell.kind === "merge-left") {
+        return "<";
+    }
+    if (cell.kind === "merge-up") {
+        return "^";
+    }
+    const base = stringifyCellBase(cell);
+    return `${base}${stringifyModifiers(cell.modifiers)}`;
+}
+function stringifyCellBase(cell) {
+    if (cell.kind === "formula" && cell.formula) {
+        return cell.formula;
+    }
+    return stringifyScalar(cell.value);
+}
+function stringifyModifiers(modifiers) {
+    if (modifiers.length === 0) {
+        return "";
+    }
+    return modifiers.map((m) => `[${m.raw}]`).join("");
+}
+function stringifyScalar(value) {
+    if (value === null || value === undefined) {
+        return "";
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    if (typeof value === "number") {
+        return String(value);
+    }
+    if (typeof value === "boolean") {
+        return value ? "TRUE" : "FALSE";
+    }
+    return String(value);
+}

package/dist/shared/types.d.ts ADDED Viewed

@@ -0,0 +1,88 @@
+export type CelloVersion = "1.0";
+export type SheetFormat = {
+    kind: "cello";
+} | {
+    kind: "delimited";
+    delimiter: string;
+    noHeader: boolean;
+    alias?: "csv" | "tsv" | "excel";
+} | {
+    kind: "markdown";
+} | {
+    kind: "json";
+    path?: string;
+};
+export type RowKind = "header" | "data";
+export type CellKind = "value" | "formula" | "merge-left" | "merge-up" | "empty";
+export type InferredType = "number" | "date" | "boolean" | "text" | "empty";
+export interface Modifier {
+    raw: string;
+    key: string;
+    value?: string;
+}
+export interface CellNode {
+    row: number;
+    col: number;
+    raw: string;
+    kind: CellKind;
+    inferredType: InferredType;
+    value: string | number | boolean | null;
+    formula?: string;
+    modifiers: Modifier[];
+    computed?: string | number | boolean | null;
+    colspan: number;
+    rowspan: number;
+}
+export interface RowNode {
+    index: number;
+    kind: RowKind;
+    sourceLine: number;
+    modifiers: Modifier[];
+    cells: CellNode[];
+}
+export interface ColumnNode {
+    index: number;
+    letter: string;
+    name?: string;
+    modifiers: Modifier[];
+    hidden: boolean;
+}
+export interface SheetNode {
+    name: string;
+    format: SheetFormat;
+    rows: RowNode[];
+    columns: ColumnNode[];
+}
+export type DiagnosticLevel = "warning" | "error";
+export interface Diagnostic {
+    level: DiagnosticLevel;
+    message: string;
+    line?: number;
+    sheet?: string;
+}
+export interface WorkbookAst {
+    version: CelloVersion;
+    sheets: SheetNode[];
+    diagnostics: Diagnostic[];
+}
+export interface ParseOptions {
+    strict?: boolean;
+    anonymousSheetName?: string;
+    baseDir?: string;
+    readExternalSource?: (path: string, context: {
+        baseDir: string;
+        resolvedPath: string;
+    }) => string;
+}
+export interface EvaluateOptions {
+    strict?: boolean;
+}
+export interface RenderOptions {
+    strict?: boolean;
+    title?: string;
+    baseDir?: string;
+    readExternalSource?: ParseOptions["readExternalSource"];
+    evaluate?: boolean;
+    format?: "document" | "fragment";
+    interactive?: boolean;
+}

package/dist/shared/types.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/shared/utils.d.ts ADDED Viewed

@@ -0,0 +1,16 @@
+import type { Modifier, SheetFormat, WorkbookAst } from "./types.js";
+export declare function columnLetter(index: number): string;
+export declare function deepClone<T>(value: T): T;
+export declare function escapeHtml(value: string): string;
+export declare function parseTrailingModifiers(value: string): {
+    base: string;
+    modifiers: Modifier[];
+};
+export declare function parseModifier(raw: string): Modifier;
+export declare function inferType(value: string): {
+    inferredType: "number" | "date" | "boolean" | "text" | "empty";
+    parsed: string | number | boolean | null;
+};
+export declare function parseSheetFormat(rawFormat?: string): SheetFormat;
+export declare function splitDelimitedLine(line: string, delimiter: string): string[];
+export declare function workbookHasFormulas(workbook: WorkbookAst): boolean;

package/dist/shared/utils.js ADDED Viewed

@@ -0,0 +1,142 @@
+export function columnLetter(index) {
+    let n = index;
+    let out = "";
+    while (n > 0) {
+        const rem = (n - 1) % 26;
+        out = String.fromCharCode(65 + rem) + out;
+        n = Math.floor((n - 1) / 26);
+    }
+    return out || "A";
+}
+export function deepClone(value) {
+    if (typeof structuredClone === "function") {
+        return structuredClone(value);
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+export function escapeHtml(value) {
+    return value
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+export function parseTrailingModifiers(value) {
+    let rest = value.trimEnd();
+    const modifiers = [];
+    while (rest.endsWith("]")) {
+        const open = rest.lastIndexOf("[");
+        if (open < 0) {
+            break;
+        }
+        const rawContent = rest.slice(open + 1, -1);
+        if (rawContent.includes("[") || rawContent.includes("]")) {
+            break;
+        }
+        modifiers.unshift(parseModifier(rawContent));
+        rest = rest.slice(0, open).trimEnd();
+    }
+    return { base: rest.trim(), modifiers };
+}
+export function parseModifier(raw) {
+    if (raw.startsWith("#bg:")) {
+        const [background = "", foreground = ""] = raw
+            .slice(4)
+            .split(":")
+            .map((part) => part.trim());
+        return { raw, key: "bgfg", value: `${background}:${foreground}` };
+    }
+    if (raw.includes(":")) {
+        const [key, ...rest] = raw.split(":");
+        return { raw, key: (key ?? "").trim().toLowerCase(), value: rest.join(":").trim() };
+    }
+    return { raw, key: raw.trim().toLowerCase() };
+}
+export function inferType(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return { inferredType: "empty", parsed: null };
+    }
+    if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+        return { inferredType: "text", parsed: trimmed.slice(1, -1) };
+    }
+    if (trimmed === "TRUE") {
+        return { inferredType: "boolean", parsed: true };
+    }
+    if (trimmed === "FALSE") {
+        return { inferredType: "boolean", parsed: false };
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+        return { inferredType: "date", parsed: trimmed };
+    }
+    const maybeNumber = Number(trimmed);
+    if (!Number.isNaN(maybeNumber) && Number.isFinite(maybeNumber)) {
+        return { inferredType: "number", parsed: maybeNumber };
+    }
+    return { inferredType: "text", parsed: trimmed };
+}
+export function parseSheetFormat(rawFormat) {
+    if (!rawFormat || rawFormat.trim().length === 0) {
+        return { kind: "cello" };
+    }
+    const token = rawFormat.trim();
+    const lower = token.toLowerCase();
+    if (lower === "markdown") {
+        return { kind: "markdown" };
+    }
+    if (lower.startsWith("json")) {
+        const parts = token.split(":");
+        if (parts.length > 1) {
+            return { kind: "json", path: parts.slice(1).join(":") };
+        }
+        return { kind: "json" };
+    }
+    for (const [alias, delimiter] of [
+        ["csv", ","],
+        ["tsv", "\t"],
+        ["excel", ";"]
+    ]) {
+        if (lower.startsWith(alias)) {
+            return { kind: "delimited", delimiter, noHeader: lower.includes("noheader"), alias };
+        }
+    }
+    const [formatHead, ...flags] = token.split(":");
+    const noHeader = flags.some((f) => f.trim().toLowerCase() === "noheader");
+    if (formatHead === "\\t") {
+        return { kind: "delimited", delimiter: "\t", noHeader };
+    }
+    if (formatHead && formatHead.length === 1) {
+        return { kind: "delimited", delimiter: formatHead, noHeader };
+    }
+    return { kind: "cello" };
+}
+export function splitDelimitedLine(line, delimiter) {
+    const output = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (ch === '"') {
+            if (inQuotes && i + 1 < line.length && line[i + 1] === '"') {
+                current += '"';
+                i += 1;
+            }
+            else {
+                inQuotes = !inQuotes;
+            }
+            continue;
+        }
+        if (!inQuotes && ch === delimiter) {
+            output.push(current);
+            current = "";
+            continue;
+        }
+        current += ch;
+    }
+    output.push(current);
+    return output;
+}
+export function workbookHasFormulas(workbook) {
+    return workbook.sheets.some((sheet) => sheet.rows.some((row) => row.cells.some((cell) => cell.kind === "formula")));
+}

package/dist/validator/validate.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { Diagnostic, EvaluateOptions, ParseOptions } from "../shared/types.js";
+export interface ValidateOptions extends ParseOptions, EvaluateOptions {
+}
+export interface ValidateResult {
+    valid: boolean;
+    diagnostics: Diagnostic[];
+}
+export declare function validate(text: string, options?: ValidateOptions): Promise<ValidateResult>;

package/dist/validator/validate.js ADDED Viewed

@@ -0,0 +1,10 @@
+import { evaluate } from "../evaluator/evaluate.js";
+import { parse } from "../parser/parse.js";
+export async function validate(text, options = {}) {
+    const ast = parse(text, options);
+    const evaluated = await evaluate(ast, options);
+    return {
+        valid: evaluated.diagnostics.length === 0,
+        diagnostics: evaluated.diagnostics
+    };
+}

package/dist/version.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export declare const VERSION = "0.1.0";

package/dist/version.js ADDED Viewed

	@@ -0,0 +1 @@
1	+ export const VERSION = "0.1.0";