@podlite/schema 0.0.65 → 0.0.66

package/lib/plugin-data-table.d.ts

@@ -1,2 +1,2 @@
-declare const _default: () => (tree: any) => any;
+declare const _default: (opt?: {}) => (tree: any) => any;
 export default _default;

package/lib/plugin-data-table.js

@@ -65,7 +65,7 @@ function applyRename(rows, rename, hasHeader) {
     }
     return [headerRow, ...rows.slice(1)];
 }
-function processDataTable(node, tree) {
+function processDataTable(node, tree, report) {
     const attrs = (0, config_1.default)(node, {});
     const srcRaw = attrs.getFirstValue('src');
     const mimeAttr = attrs.getFirstValue('mime-type');
@@ -91,7 +91,7 @@ function processDataTable(node, tree) {
         if (scheme === 'data') {
             const dataBlock = (0, plugin_tables_1.findDataBlockByKey)(tree, target);
             if (!dataBlock) {
-                console.warn(`[data-table] no =data block found for data:${target} — rendered as empty`);
+                report('table-source-unreadable', `no =data block found for data:${target}, table rendered as empty`, node);
                 return { ...node, name: 'table', content: [] };
             }
             if (mimeAttr) {
@@ -99,7 +99,7 @@ function processDataTable(node, tree) {
             }
             const dataMime = (0, config_1.default)(dataBlock, {}).getFirstValue('mime-type');
             if (!dataMime) {
-                console.warn(`[data-table] =data block ${target} has no :mime-type — rendered as empty`);
+                report('table-source-unreadable', `=data block ${target} has no :mime-type, table rendered as empty`, node);
                 return { ...node, name: 'table', content: [] };
             }
             const parsed = (0, plugin_tables_1.parseMimeType)(dataMime);
@@ -123,12 +123,12 @@ function processDataTable(node, tree) {
     const isCsv = mimeType === 'text/csv';
     const isTsv = mimeType === 'text/tab-separated-values';
     if (!isCsv && !isTsv) {
-        console.warn(`[data-table] unsupported mime-type ${mimeType} — rendered as empty`);
+        report('table-source-unreadable', `unsupported mime-type ${mimeType}, table rendered as empty`, node);
         return { ...node, name: 'table', content: [] };
     }
     let rows = isCsv ? (0, plugin_tables_1.parseCsv)(csvText) : (0, plugin_tables_1.parseTsv)(csvText);
     if (rows.length === 0) {
-        console.warn(`[data-table] ${isCsv ? 'CSV' : 'TSV'} parse produced no rows — rendered as empty`);
+        report('table-source-unreadable', `${isCsv ? 'CSV' : 'TSV'} source has no rows, table rendered as empty`, node);
         return { ...node, name: 'table', content: [] };
     }
     if (columns) {
@@ -142,16 +142,17 @@ function processDataTable(node, tree) {
         name: 'table',
         content: (0, plugin_tables_1.csvToTableContent)(rows, hasHeader, attrs.getAllValues('allow')),
     };
-    return (0, plugin_tables_1.normalizeCellCounts)(filledNode, 'data-table');
+    return (0, plugin_tables_1.normalizeCellCounts)(filledNode, 'data-table', report);
 }
-exports.default = () => tree => {
+exports.default = (opt = {}) => tree => {
+    const report = (0, plugin_tables_1.makeTableReport)(opt);
     const transformer = (0, makeTransformer_1.default)({
         'data-table': node => {
             try {
-                return processDataTable(node, tree);
+                return processDataTable(node, tree, report);
             }
             catch (err) {
-                console.warn(`[data-table] ${err.message}`);
+                report('table-source-unreadable', err.message, node);
                 return { ...node, name: 'table', content: [] };
             }
         },

package/lib/plugin-formatting-codes.js

@@ -41,49 +41,85 @@ const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
 const makeTransformer_2 = require("./helpers/makeTransformer");
 const config_1 = __importDefault(require("./helpers/config"));
 const parseAttributes_1 = require("./helpers/parseAttributes");
+// `=config C<> :allow<I>` names a markup code, not a block: the trailing angles
+// are the marker, and what it declares belongs to the code they name
+const codeConfigOwner = (name) => typeof name === 'string' && /^[A-Z]<>$/.test(name) ? name[0] : null;
+const collectAllowedIn = (content, inherited) => {
+    if (!Array.isArray(content))
+        return inherited;
+    let map = inherited;
+    for (const child of content) {
+        if (!child || typeof child !== 'object')
+            continue;
+        const node = child;
+        if (node.type !== 'config')
+            continue;
+        const owner = codeConfigOwner(node.name);
+        if (!owner)
+            continue;
+        if (map === inherited)
+            map = { ...inherited };
+        map[owner] = (0, config_1.default)(node, {}).getAllValues('allow');
+    }
+    return map;
+};
 const middle = () => tree => {
     const transformerBlocks = (0, makeTransformer_1.default)({
         ':para': (n, ctx, visiter) => {
+            const allowedIn = ctx.allowedIn;
             return (0, makeTransformer_1.default)({
                 ':text': (n, ctx) => {
-                    return fcparser.parse(n.value, { parseAttributes: parseAttributes_1.parseAttributes });
+                    return fcparser.parse(n.value, { allowedIn, parseAttributes: parseAttributes_1.parseAttributes });
                 },
                 ':verbatim': (n, ctx) => {
-                    return fcparser.parse(n.value, { parseAttributes: parseAttributes_1.parseAttributes });
+                    return fcparser.parse(n.value, { allowedIn, parseAttributes: parseAttributes_1.parseAttributes });
                 },
             })(n, { ...ctx });
             return n;
         },
         ':block': (n, ctx, visiter) => {
+            // a block is a lexical scope: a code configured inside it stays inside
+            const allowedIn = collectAllowedIn('content' in n ? n.content : undefined, ctx.allowedIn || {});
             // only =pod may have childs blocks
             if ('name' in n && n.name === 'pod')
                 return {
                     ...n,
-                    content: visiter(n.content, ctx, visiter),
+                    content: visiter(n.content, { ...ctx, allowedIn }, visiter),
                 };
             const conf = (0, config_1.default)(n, ctx);
             const name = 'name' in n ? n.name : '';
             // Blocks whose content is verbatim by default — fcode parsing only
             // kicks in when :allow opts in (per spec, "Formatting within code blocks").
             const isVerbatimDefault = ['code', 'data', 'markdown', 'picture', 'formula'].includes(name);
-            const allowValues = conf.getAllValues('allow');
             if ((0, makeTransformer_2.isNamedBlock)(name))
                 return n;
+            // A table owns rows, and the text sits in the cells, so :allow written on
+            // the table reaches them. The nearest declaration wins: cell, row, table.
+            const inheritsAllow = name === 'row' || name === 'cell';
+            const declared = conf.exists('allow')
+                ? conf.getAllValues('allow')
+                : inheritsAllow
+                    ? ctx.allowFromTable
+                    : undefined;
+            const allowValues = declared || [];
+            const passesAllow = name === 'table' || name === 'row' ? declared : ctx.allowFromTable;
             if (isVerbatimDefault && allowValues.length === 0)
                 return n;
-            // a cell built from data carries its own set; declared empty means no code acts
-            if (name === 'cell' && conf.exists('allow') && allowValues.length === 0)
-                return n;
-            const allowed = allowValues.sort();
+            // declared empty means no code acts on this text; nested blocks still get
+            // their turn, since a cell may declare a set of its own
+            const literal = inheritsAllow && declared !== undefined && declared.length === 0;
+            const allowed = [...allowValues].sort();
+            const inner = { ...ctx, allowedIn, allowFromTable: passesAllow };
             const transformer = (0, makeTransformer_1.default)({
-                ':verbatim': (n, ctx) => fcparser.parse(n.value, { allowed, parseAttributes: parseAttributes_1.parseAttributes }),
-                ':text': (n, ctx) => fcparser.parse(n.value, { allowed, parseAttributes: parseAttributes_1.parseAttributes }),
-                ':block': (n, ctx) => transformerBlocks(n, { ...ctx }),
+                ':verbatim': (node, ctx) => literal ? node : fcparser.parse(node.value, { allowed, allowedIn, parseAttributes: parseAttributes_1.parseAttributes }),
+                ':text': (node, ctx) => literal ? node : fcparser.parse(node.value, { allowed, allowedIn, parseAttributes: parseAttributes_1.parseAttributes }),
+                ':block': (node, ctx) => transformerBlocks(node, { ...ctx, allowedIn, allowFromTable: passesAllow }),
             });
-            return { ...n, content: transformer(n.content, { ...ctx }) };
+            return { ...n, content: transformer(n.content, inner) };
         },
     });
-    return transformerBlocks(tree, {});
+    // a document needs no enclosing block, so the top level is a scope of its own
+    return transformerBlocks(tree, { allowedIn: collectAllowedIn(tree, {}) });
 };
 exports.default = middle;
 //# sourceMappingURL=plugin-formatting-codes.js.map

package/lib/plugin-tables.d.ts

@@ -7,6 +7,8 @@ export declare function parseMimeType(raw: any): {
 export declare function findDataBlockByKey(tree: any, key: any): any;
 export declare function extractDataText(dataNode: any): any;
 export declare function csvToTableContent(csvRows: any, hasHeader?: boolean, allow?: string[]): any;
-export declare function normalizeCellCounts(tableNode: any, source?: string): any;
-declare const _default: () => (tree: any) => any;
+export type TableReport = (code: string, message: string, node: any) => void;
+export declare function makeTableReport(opt: any): TableReport;
+export declare function normalizeCellCounts(tableNode: any, source?: string, report?: TableReport): any;
+declare const _default: (opt?: {}) => (tree: any) => any;
 export default _default;

package/lib/plugin-tables.js

@@ -9,6 +9,7 @@ exports.parseMimeType = parseMimeType;
 exports.findDataBlockByKey = findDataBlockByKey;
 exports.extractDataText = extractDataText;
 exports.csvToTableContent = csvToTableContent;
+exports.makeTableReport = makeTableReport;
 exports.normalizeCellCounts = normalizeCellCounts;
 /**
  * Plugin for fill term's for defn. From S26:
@@ -216,16 +217,27 @@ function csvToTableContent(csvRows, hasHeader = false, allow = []) {
         return buildRowBlock(cells, hasHeader && i === 0);
     });
 }
-// ─── Error recovery (design notes Rules 2-4) ───────────────────────────────
+function makeTableReport(opt) {
+    const diagnostics = opt && Array.isArray(opt.diagnostics) ? opt.diagnostics : null;
+    return (code, message, node) => {
+        const location = node && node.location;
+        if (!diagnostics || !location)
+            return;
+        const seen = diagnostics.some(d => d.message === message && d.location.start.offset === location.start.offset);
+        if (!seen)
+            diagnostics.push({ severity: 'warning', code, message, location });
+    };
+}
+const noReport = () => { };
 // Rule 2 — table-level cell count validation. Pad short rows with empty
-// cells; truncate long rows. Emit a warning whenever a row is changed.
+// cells; truncate long rows. Report whenever a row is changed.
 // Expected count is taken from the `:header` row if present, otherwise from
 // the row with the maximum cell count.
 //
 // Skipped when any cell uses `:colspan` or `:rowspan`: a spanning cell
 // occupies multiple columns, so naive cell counting would misreport row
 // width and drop legitimate spanned cells.
-function normalizeCellCounts(tableNode, source = 'table') {
+function normalizeCellCounts(tableNode, source = 'table', report = noReport) {
     if (!tableNode || !Array.isArray(tableNode.content))
         return tableNode;
     const rows = tableNode.content.filter(c => c && c.type === 'block' && c.name === 'row');
@@ -252,13 +264,13 @@ function normalizeCellCounts(tableNode, source = 'table') {
             const padding = [];
             for (let i = cells.length; i < expected; i++)
                 padding.push(buildCellBlock(''));
-            console.warn(`[${source}] row has ${cells.length} cells, expected ${expected} — padded with ${padding.length} empty`);
+            report('table-row-cells', `${source} row has ${cells.length} of ${expected} cells, padded with ${padding.length} empty. A row continued on the next line needs a blank line before the next row`, tableNode);
             mutated = true;
             return { ...child, content: [...child.content, ...padding] };
         }
         // cells.length > expected → truncate
         const dropped = cells.length - expected;
-        console.warn(`[${source}] row has ${cells.length} cells, expected ${expected} — truncated ${dropped}`);
+        report('table-row-cells', `${source} row has ${cells.length} of ${expected} cells, dropped ${dropped}`, tableNode);
         mutated = true;
         // Keep non-cell entries (e.g. blanklines) and the first `expected` cells
         let keepCells = expected;
@@ -282,7 +294,7 @@ function normalizeCellCounts(tableNode, source = 'table') {
 // for visible separators (`|` / `+`) surrounded by whitespace; lines without
 // any visible separator fall back to whitespace separation. Warns when more
 // than one separator type is observed within a single table.
-function detectMixedSeparators(lines) {
+function detectMixedSeparators(lines, report = noReport, node = null) {
     const seen = new Set();
     for (const line of lines) {
         if (!line || typeof line !== 'string')
@@ -297,7 +309,7 @@ function detectMixedSeparators(lines) {
             break;
     }
     if (seen.size > 1) {
-        console.warn(`[table] mixed separator types detected: ${Array.from(seen).join(', ')} — recommend a single style`);
+        report('table-mixed-separators', `table mixes separator styles: ${Array.from(seen).join(', ')}. Keep one`, node);
     }
 }
 // Rule 4 — replace =table with =code block. Used when a referenced =data
@@ -448,9 +460,41 @@ const wrapImplicitCells = rowNode => {
     });
     return { ...rowNode, content: wrapped };
 };
+// An abbreviated `=for row` owns its own paragraph, so cells written under it
+// stay at table level and both the row and the cells lose their meaning. They
+// are attached to the row above, and the author is told, per the same recovery
+// contract that pads and truncates rows.
+const attachOrphanCells = (tableNode, report = noReport) => {
+    const content = tableNode.content;
+    if (!Array.isArray(content))
+        return tableNode;
+    if (!content.some(c => c && c.type === 'block' && c.name === 'cell'))
+        return tableNode;
+    const out = [];
+    let openRow = null;
+    for (const child of content) {
+        if (child && child.type === 'block' && child.name === 'row') {
+            openRow = { ...child, content: Array.isArray(child.content) ? [...child.content] : [] };
+            out.push(openRow);
+            continue;
+        }
+        if (child && child.type === 'block' && child.name === 'cell') {
+            if (!openRow) {
+                openRow = { type: 'block', name: 'row', margin: child.margin || '', content: [] };
+                out.push(openRow);
+            }
+            openRow.content.push(child);
+            continue;
+        }
+        out.push(child);
+    }
+    report('table-cell-outside-row', 'a cell written outside a row was attached to the row above it; an abbreviated =for row holds only its own paragraph, so write =begin row and =end row around the cells', tableNode);
+    return { ...tableNode, content: out };
+};
 const isStructured = tableNode => Array.isArray(tableNode.content) &&
     tableNode.content.some(c => c && c.type === 'block' && (c.name === 'row' || c.name === 'cell'));
-exports.default = () => tree => {
+exports.default = (opt = {}) => tree => {
+    const report = makeTableReport(opt);
     const transformer = (0, makeTransformer_1.default)({
         table: (node, ctx, visiter) => {
             // CSV/data source reference (spec §1672):
@@ -461,7 +505,7 @@ exports.default = () => tree => {
                 const dataBlock = findDataBlockByKey(tree, ref.target);
                 if (!dataBlock) {
                     // Rule 4: source not found → empty table (still a =table block)
-                    console.warn(`[table] no =data block found for data:${ref.target} — rendered as empty`);
+                    report('table-source-unreadable', `no =data block found for data:${ref.target}, table rendered as empty`, node);
                     return { ...node, content: [] };
                 }
                 const rawMime = (0, config_1.default)(dataBlock, {}).getFirstValue('mime-type');
@@ -472,22 +516,23 @@ exports.default = () => tree => {
                     const text = extractDataText(dataBlock);
                     const rows = isCsv ? parseCsv(text) : parseTsv(text);
                     if (rows.length === 0) {
-                        console.warn(`[table] ${isCsv ? 'CSV' : 'TSV'} parse produced no rows for data:${ref.target} — rendered as empty`);
+                        report('table-source-unreadable', `${isCsv ? 'CSV' : 'TSV'} source data:${ref.target} has no rows, table rendered as empty`, node);
                         return { ...node, content: [] };
                     }
                     const hasHeader = mimeParams.header === 'present';
                     const allow = (0, config_1.default)(node, {}).getAllValues('allow');
                     const filledNode = { ...node, content: csvToTableContent(rows, hasHeader, allow) };
-                    return normalizeCellCounts(filledNode, `table data:${ref.target}`);
+                    return normalizeCellCounts(filledNode, `table data:${ref.target}`, report);
                 }
                 // Rule 4: source not tabular → render as code block so content remains visible
-                console.warn(`[table] =data :key<${ref.target}> has non-tabular mime-type ${rawMime || '(none)'} — rendered as =code`);
+                report('table-source-unreadable', `=data :key<${ref.target}> has non-tabular mime-type ${rawMime || '(none)'}, rendered as =code`, node);
                 return buildCodeFromDataBlock(node, dataBlock);
             }
             // structured mode: transform row children (wrap implicit cells), then
             // apply Rule 2 cell count normalization.
             if (isStructured(node)) {
-                const transformedContent = (node.content || []).map(c => {
+                const attached = attachOrphanCells(node, report);
+                const transformedContent = (attached.content || []).map(c => {
                     if (c && c.name === 'row')
                         return wrapImplicitCells(c);
                     return c;
@@ -495,7 +540,7 @@ exports.default = () => tree => {
                 // a matched rule replaces the node without descending, so recurse
                 // here or tables nested inside cells keep their raw text rows
                 const recursed = visiter ? visiter(transformedContent, ctx) : transformedContent;
-                return normalizeCellCounts({ ...node, content: recursed }, 'table');
+                return normalizeCellCounts({ ...attached, content: recursed }, 'table', report);
             }
             let rows = [];
             const collectValues = row => {
@@ -521,7 +566,7 @@ exports.default = () => tree => {
             const lines = flattenDeep(rows.map(splitToLines));
             const separators = flattenDeep(seps.map(splitToLines));
             // Rule 3: warn on mixed separator types within a single table
-            detectMixedSeparators(lines);
+            detectMixedSeparators(lines, report, node);
             // collect text rows
             let textRows = [];
             (0, makeTransformer_1.default)({
@@ -560,7 +605,7 @@ exports.default = () => tree => {
                 },
                 'head:text': head => makeHeaderRow(splitToCells(head.value).map(makeCell)),
             })(node);
-            return normalizeCellCounts(res, 'table');
+            return normalizeCellCounts(res, 'table', report);
         },
     });
     return transformer(tree, {});

package/lib/types.d.ts

@@ -98,6 +98,7 @@ export interface Image {
     type: 'image';
     src: string;
     alt?: string;
+    link?: string;
 }
 export interface Toc {
     type: 'toc';
@@ -139,7 +140,7 @@ export interface RootBlock extends Omit<Block, 'location'> {
 }
 export interface ParseDiagnostic {
     severity: 'warning';
-    code: 'value-unreadable' | 'directive-unreadable';
+    code: 'value-unreadable' | 'directive-unreadable' | 'table-row-cells' | 'table-cell-outside-row' | 'table-mixed-separators' | 'table-source-unreadable';
     message: string;
     location: Location;
 }
@@ -364,7 +365,7 @@ export interface BlockTable extends Omit<Block, 'content'> {
 export interface TableCell {
     name: 'cell';
     type: 'block';
-    content: Array<string>;
+    content: Array<PodNode>;
 }
 export interface TableRow {
     name: 'row';

package/lib/version.d.ts

@@ -1 +1 @@
-export declare const version = "0.0.65";
+export declare const version = "0.0.66";

package/lib/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // generated by scripts/inject-version.mjs — do not edit by hand
-exports.version = '0.0.65';
+exports.version = '0.0.66';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podlite/schema",
-  "version": "0.0.65",
+  "version": "0.0.66",
   "description": "AST tools and schema for Podlite markup language — validate, traverse, and transform document trees",
   "main": "./lib/index.js",
   "sideEffects": false,

package/schema/AstTree.json

@@ -1348,6 +1348,10 @@
                 "code": {
                     "enum": [
                         "directive-unreadable",
+                        "table-cell-outside-row",
+                        "table-mixed-separators",
+                        "table-row-cells",
+                        "table-source-unreadable",
                         "value-unreadable"
                     ],
                     "type": "string"
@@ -1378,6 +1382,9 @@
                 },
                 "alt": {
                     "type": "string"
+                },
+                "link": {
+                    "type": "string"
                 }
             },
             "required": [
@@ -1529,7 +1536,7 @@
                 "content": {
                     "type": "array",
                     "items": {
-                        "type": "string"
+                        "$ref": "#/definitions/PodNode"
                     }
                 }
             },

package/schema/PodliteDocument.json

@@ -1348,6 +1348,10 @@
                 "code": {
                     "enum": [
                         "directive-unreadable",
+                        "table-cell-outside-row",
+                        "table-mixed-separators",
+                        "table-row-cells",
+                        "table-source-unreadable",
                         "value-unreadable"
                     ],
                     "type": "string"
@@ -1378,6 +1382,9 @@
                 },
                 "alt": {
                     "type": "string"
+                },
+                "link": {
+                    "type": "string"
                 }
             },
             "required": [
@@ -1529,7 +1536,7 @@
                 "content": {
                     "type": "array",
                     "items": {
-                        "type": "string"
+                        "$ref": "#/definitions/PodNode"
                     }
                 }
             },