@geml/geml 1.5.0 → 1.6.0

package/dist/table.js

@@ -127,22 +127,34 @@ function lexExpr(s) {
 // Display format: a `[printf]` spec bound to a column/cell name (§6).
 //   `FY [%.1f]` → name "FY", fmt "%.1f";  `YoY [%.1f%%]` → "%.1f%%"
 // ---------------------------------------------------------------------------
+// The bracket suffix has to contain a `%` to be a format (§6). Without that
+// test, a column whose own name is bracketed — `[Data] = …` — parses as an
+// empty name plus the format `Data`, and the formula silently targets nothing.
 function splitName(lhs) {
-    const m = /^(.*?)\s*\[([^\]]*)\]\s*$/.exec(lhs.trim());
+    const m = /^(.*?)\s*\[([^\]]*%[^\]]*)\]\s*$/.exec(lhs.trim());
     let name = (m ? m[1] : lhs).trim();
     if (name.startsWith('"') && name.endsWith('"'))
         name = name.slice(1, -1);
     return m ? { name, fmt: m[2] } : { name };
 }
+// A result IEEE-754 produces but a table cannot hold (§6): `x / 0` is ±∞, `0 / 0`
+// is NaN. The cell keeps no value and displays `-`, which is what a reader sees;
+// naming the cause is the difference between "this row had no data" and "this
+// row divided by zero", so it is said out loud like a substituted cell is.
+const nanMsg = (where, v) => `${where}: ${Number.isNaN(v) ? "result is not a number (0/0)" : "division by zero"}; the cell holds no value and shows \`-\``;
 // Default rendering for an unformatted computed number: drop IEEE-754 display
 // noise (0.1+0.2 → "0.3", sum of 1-dp inputs → "263.6") without altering the
 // stored numeric value.
 function defaultNum(v) {
+    if (!isFinite(v))
+        return "-";
     return String(parseFloat(v.toPrecision(12)));
 }
 // Minimal printf for a single numeric value: handles %f/%e/%d/%g with optional
 // precision, and `%%` as a literal percent. Width/flags are not padded.
 function applyFormat(fmt, v) {
+    if (!isFinite(v))
+        return "-";
     return fmt.replace(/%%|%[-+ 0]*\d*(?:\.\d+)?[fFeEgGd]/g, (m) => {
         if (m === "%%")
             return "%";
@@ -232,16 +244,6 @@ function evalExpr(toks, row, col, agg) {
     return v;
 }
 // ---------------------------------------------------------------------------
-// Spans
-// ---------------------------------------------------------------------------
-// Parse `r2c1:2x1` → target cell (1-based row/col over body) + size.
-function parseSpan(s) {
-    const m = /^r(\d+)c(\d+):(\d+)x(\d+)$/.exec(s.trim());
-    if (!m)
-        return null;
-    return { row: +m[1], col: +m[2], rows: +m[3], cols: +m[4] };
-}
-// ---------------------------------------------------------------------------
 // Public entry
 // ---------------------------------------------------------------------------
 export function parseTable(body, attrs, line, sink) {
@@ -310,19 +312,47 @@ export function parseTable(body, attrs, line, sink) {
         const v = model.rows[row]?.[ci]?.value;
         return typeof v === "number" ? v : null;
     };
+    // A cell a formula reads but cannot read as a number (`x`, `N/A`, `TBD`, an
+    // empty cell) counts as 0, so one dirty row does not void the whole column.
+    // But counting it silently is how a table quietly reports the wrong total, so
+    // say which cell was substituted. One warning per cell, not per mention: a
+    // formula naming the same column twice describes one substitution.
+    const substituted = new Set();
     const colResolve = (name, row) => {
         const ci = colIndex(name);
-        return ci < 0 ? null : cellNum(ci, row);
+        if (ci < 0)
+            return null;
+        const n = cellNum(ci, row);
+        if (n !== null)
+            return n;
+        const key = `${ci}\0${row}`;
+        if (!substituted.has(key)) {
+            substituted.add(key);
+            const text = model.rows[row]?.[ci]?.text ?? "";
+            diagnostics.push({
+                severity: "warning",
+                code: "compute-non-numeric-cell",
+                message: `column \`${name}\` row ${row + 1} is not a number (${text === "" ? "empty" : `\`${text}\``}); counted as 0`,
+            });
+        }
+        return 0;
     };
     const computeAgg = (fn, ci) => {
+        if (fn === "count") {
+            let c = 0;
+            for (let r = 0; r < model.rows.length; r++) {
+                const text = model.rows[r]?.[ci]?.text;
+                if (text !== undefined && text !== "")
+                    c++;
+            }
+            return c;
+        }
         const vals = [];
         for (let r = 0; r < model.rows.length; r++) {
             const v = cellNum(ci, r);
             if (v !== null)
                 vals.push(v);
         }
-        if (fn === "count")
-            return vals.length;
         if (vals.length === 0)
             return 0;
         if (fn === "sum")
@@ -398,13 +428,14 @@ export function parseTable(body, attrs, line, sink) {
             try {
                 const v = evalExpr(toks, r, colResolve, aggResolve);
                 const cell = ensureCell(model.rows[r], ci);
-                if (Number.isFinite(v)) {
-                    const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                cell.text = text;
+                cell.computed = true;
+                cell.inlines = [{ type: "text", value: text }];
+                if (Number.isFinite(v))
                     cell.value = v;
-                    cell.text = text;
-                    cell.computed = true;
-                    cell.inlines = [{ type: "text", value: text }];
-                }
+                else
+                    diagnostics.push({ severity: "warning", code: "compute-not-a-number", message: nanMsg(`compute \`${name}\` row ${r + 1}`, v) });
             }
             catch (e) {
                 diagnostics.push({ severity: "error", code: "compute-error", message: `compute \`${name}\`: ${e.message}` });
@@ -458,10 +489,12 @@ export function parseTable(body, attrs, line, sink) {
             }
             try {
                 const v = evalExpr(toks, 0, noRow, aggResolve);
-                if (Number.isFinite(v)) {
-                    const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
-                    summary[ci] = { text, inlines: [{ type: "text", value: text }], value: v, computed: true };
-                }
+                const text = fmt ? applyFormat(fmt, v) : defaultNum(v);
+                summary[ci] = { text, inlines: [{ type: "text", value: text }], computed: true };
+                if (Number.isFinite(v))
+                    summary[ci].value = v;
+                else
+                    diagnostics.push({ severity: "warning", code: "compute-not-a-number", message: nanMsg(`summary \`${name}\``, v) });
             }
             catch (e) {
                 const msg = /unknown column `(.+)`/.exec(e.message);
@@ -471,32 +504,6 @@ export function parseTable(body, attrs, line, sink) {
         }
         model.summary = summary;
     }
-    // Spans: `span="r2c1:2x1"` (one or many: span, span2, …).
-    const spanDecls = Object.entries(attrs)
-        .filter(([k]) => k === "span" || /^span\d+$/.test(k))
-        .map(([, v]) => v)
-        .filter((v) => typeof v === "string");
-    for (const sd of spanDecls) {
-        const sp = parseSpan(sd);
-        if (!sp) {
-            diagnostics.push({ severity: "error", code: "bad-span", message: `bad span \`${sd}\` (want \`rNcM:RxC\`)` });
-            continue;
-        }
-        const cell = model.rows[sp.row - 1]?.[sp.col - 1];
-        if (!cell) {
-            diagnostics.push({ severity: "warning", code: "span-outside-table", message: `span \`${sd}\` targets a cell outside the table` });
-            continue;
-        }
-        // A span can never extend past the grid: clamp its extent to the rows/cols
-        // actually available from the target cell. Without this, `span="r1c1:9e6x9e6"`
-        // makes the renderer's O(rows×cols) coverage sweep hang (DoS). Every row has
-        // exactly `columns.length` cells (built above), so the column bound is exact.
-        const maxRows = model.rows.length - (sp.row - 1);
-        const maxCols = columns.length - (sp.col - 1);
-        const rows = Math.max(1, Math.min(sp.rows, maxRows));
-        const cols = Math.max(1, Math.min(sp.cols, maxCols));
-        cell.span = { rows, cols };
-    }
     return { model, diagnostics };
 }
 function ensureCell(row, ci) {

package/dist/to-md.js

@@ -125,7 +125,10 @@ function typedToMd(b, notes) {
         return "";
     }
     if (b.mode === "flow") {
-        // Footnote definition: a `note.footnote` carrying its ref as the id.
+        // A note the author marked `.footnote` projects to a Markdown footnote
+        // definition. The parser no longer synthesizes this class — the `[^id]: text`
+        // definition line was withdrawn from §5.2 — but an author still writes it,
+        // and it is the only way this projection can be produced.
         if (b.type === "note" && b.classes.includes("footnote") && b.id) {
             const text = (b.children ?? []).map((c) => block(c, notes)).join(" ").replace(/\n+/g, " ").trim();
             return `[^${b.id}]: ${text}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geml/geml",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "mcpName": "io.github.geml-spec/geml",
   "publishConfig": {
     "access": "public"