@oml/markdown 0.11.0 → 0.13.0

package/src/renderers/matrix-renderer.ts

@@ -1,8 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
 import { QueryMarkdownBlockRenderer } from './renderer.js';
-import type { MdBlockExecutionResult } from './types.js';
-import { appendTokenizedValueParts, createWikiLinkElement, isIriValue, shortLabelFromIri } from './wikilink-utils.js';
+import type { MdBlockExecutionResult, MdTableCell, MdTableCellValue } from './types.js';
 
 type MatrixStyleRuleKind = 'row' | 'column' | 'cell' | 'header';
 type MatrixStyleRuleTarget = 'cell' | 'value';
@@ -44,13 +43,15 @@ type MatrixSelectorContext =
     | { kind: 'header'; context: MatrixHeaderContext };
 
 type MatrixCellRecord = {
-    values: string[];
+    cell: MdTableCell;
 };
 
 type MatrixModel = {
     rowKeys: string[];
     columnKeys: string[];
     cells: Map<string, MatrixCellRecord>;
+    rowHeaders: Map<string, MdTableCell>;
+    columnHeaders: Map<string, MdTableCell>;
 };
 
 export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
@@ -79,7 +80,7 @@ export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
 
         const stylesheet = compileMatrixStylesheet(result.options);
         const rowColumnLabel = extractRowColumnLabel(result.options);
-        const model = this.buildMatrixModel(payloadRows, rowIndex, columnIndex, valueIndex);
+        const model = this.buildMatrixModel(payloadRows, result.payload?.rowsTyped ?? [], rowIndex, columnIndex, valueIndex);
         container.appendChild(this.renderMatrix(model, stylesheet, rowColumnLabel));
         return container;
     }
@@ -167,7 +168,8 @@ export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
             for (const [columnIndex, columnName] of visibleColumns.entries()) {
                 const th = document.createElement('div');
                 th.className = 'table-header-cell';
-                const label = this.renderHeaderLabel(columnName);
+                const label = this.renderCellValue(columnName, model.columnHeaders.get(columnName));
+                label.style.fontWeight = '400';
                 th.appendChild(label);
                 this.applyStylesheet(th, undefined, stylesheet, [
                     { kind: 'column', context: { index: columnIndex, name: columnName } }
@@ -183,7 +185,7 @@ export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
 
                 const rowHeaderCell = document.createElement('div');
                 rowHeaderCell.className = 'table-cell';
-                const rowHeaderValue = this.renderValueParts([rowName]);
+                const rowHeaderValue = this.renderCellValue(rowName, model.rowHeaders.get(rowName));
                 rowHeaderCell.appendChild(rowHeaderValue);
                 const rowContext: MatrixRowContext = { index: rowCounter, name: rowName };
                 this.applyStylesheet(rowHeaderCell, rowHeaderValue, stylesheet, [
@@ -195,13 +197,13 @@ export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
                 for (const [columnIndex, columnName] of visibleColumns.entries()) {
                     const key = buildMatrixKey(rowName, columnName);
                     const record = model.cells.get(key);
-                    const values = record?.values ?? [];
-                    const displayValue = values.join(' ');
+                    const recordCell = record?.cell;
+                    const displayValue = this.formatCellDisplayText(recordCell?.value ?? '', recordCell);
                     const columnContext: MatrixColumnContext = { index: columnIndex, name: columnName };
 
                     const td = document.createElement('div');
                     td.className = 'table-cell';
-                    const valueElement = this.renderValueParts(values);
+                    const valueElement = this.renderCellValue(recordCell?.value ?? '', recordCell);
                     td.appendChild(valueElement);
 
                     const cellContext: MatrixCellContext = {
@@ -241,61 +243,49 @@ export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
         return columns.join(' ');
     }
 
-    private buildMatrixModel(rows: string[][], rowIndex: number, columnIndex: number, valueIndex: number): MatrixModel {
+    private buildMatrixModel(
+        rows: string[][],
+        rowsTyped: MdTableCell[][],
+        rowIndex: number,
+        columnIndex: number,
+        valueIndex: number
+    ): MatrixModel {
         const rowKeys: string[] = [];
         const columnKeys: string[] = [];
         const seenRows = new Set<string>();
         const seenColumns = new Set<string>();
         const cells = new Map<string, MatrixCellRecord>();
+        const rowHeaders = new Map<string, MdTableCell>();
+        const columnHeaders = new Map<string, MdTableCell>();
 
-        for (const row of rows) {
+        for (let index = 0; index < rows.length; index += 1) {
+            const row = rows[index];
+            const typedRow = rowsTyped[index] ?? [];
             const rowKey = row[rowIndex] ?? '';
             const columnKey = row[columnIndex] ?? '';
-            const value = row[valueIndex] ?? '';
+            const rowCell = typedRow[rowIndex] ?? literalCell(rowKey);
+            const columnCell = typedRow[columnIndex] ?? literalCell(columnKey);
+            const valueCell = typedRow[valueIndex] ?? literalCell(row[valueIndex] ?? '');
             if (!rowKey || !columnKey) {
                 continue;
             }
             if (!seenRows.has(rowKey)) {
                 seenRows.add(rowKey);
                 rowKeys.push(rowKey);
+                rowHeaders.set(rowKey, rowCell);
             }
             if (!seenColumns.has(columnKey)) {
                 seenColumns.add(columnKey);
                 columnKeys.push(columnKey);
+                columnHeaders.set(columnKey, columnCell);
             }
             const key = buildMatrixKey(rowKey, columnKey);
-            const record = cells.get(key) ?? { values: [] };
-            record.values.push(value);
+            const record = cells.get(key) ?? { cell: { ...valueCell, values: valueCell.values.slice() } };
+            mergeCellValues(record.cell, valueCell.values);
             cells.set(key, record);
         }
 
-        return { rowKeys, columnKeys, cells };
-    }
-
-    private renderValueParts(values: string[]): HTMLElement {
-        const value = document.createElement('span');
-        value.className = 'table-value';
-        const normalized = values.filter((entry) => entry.length > 0);
-        if (normalized.length === 0) {
-            value.textContent = '';
-            return value;
-        }
-        for (const rawPart of normalized) {
-            appendTokenizedValueParts(value, rawPart, 'table-value-part');
-        }
-        return value;
-    }
-
-    private renderHeaderLabel(raw: string): HTMLElement {
-        const label = document.createElement('span');
-        label.className = 'table-header-label';
-        label.style.fontWeight = '400';
-        if (!isIriValue(raw)) {
-            label.textContent = raw;
-            return label;
-        }
-        label.appendChild(createWikiLinkElement(raw, shortLabelFromIri(raw)));
-        return label;
+        return { rowKeys, columnKeys, cells, rowHeaders, columnHeaders };
     }
 
     private applyStylesheet(
@@ -365,7 +355,7 @@ export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
                 if (!record) {
                     continue;
                 }
-                const cellText = record.values.join(' ').toLowerCase();
+                const cellText = this.formatCellDisplayText(record.cell.value, record.cell).toLowerCase();
                 if (cellText.includes(search)) {
                     matchedRows.add(rowName);
                     matchedColumns.add(columnName);
@@ -400,10 +390,11 @@ export class MatrixMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
         const lines: string[] = [];
         lines.push([escapeCell(rowColumnLabel), ...visibleColumns.map(escapeCell)].join(','));
         for (const rowName of visibleRows) {
-            const row: string[] = [escapeCell(rowName)];
+            const rowHeader = model.rowHeaders.get(rowName);
+            const row: string[] = [escapeCell(this.formatCellDisplayText(rowHeader?.value ?? rowName, rowHeader))];
             for (const columnName of visibleColumns) {
                 const record = model.cells.get(buildMatrixKey(rowName, columnName));
-                row.push(escapeCell((record?.values ?? []).join(' ')));
+                row.push(escapeCell(this.formatCellDisplayText(record?.cell.value ?? '', record?.cell)));
             }
             lines.push(row.join(','));
         }
@@ -424,6 +415,28 @@ function buildMatrixKey(rowKey: string, columnKey: string): string {
     return `${rowKey}\u0000${columnKey}`;
 }
 
+function literalCell(value: string): MdTableCell {
+    return { kind: 'literal', value, values: [{ kind: 'literal', value }] };
+}
+
+function mergeCellValues(target: MdTableCell, additions: ReadonlyArray<MdTableCellValue>): void {
+    const existing = new Set(target.values.map((value) => `${value.kind}\u0000${value.value}`));
+    for (const value of additions) {
+        const key = `${value.kind}\u0000${value.value}`;
+        if (existing.has(key)) {
+            continue;
+        }
+        existing.add(key);
+        target.values.push(value);
+    }
+    target.value = target.values.map((value) => {
+        if (value.kind === 'bnode') {
+            return `_:${value.value}`;
+        }
+        return value.value;
+    }).join(', ');
+}
+
 function createDownloadButton(): HTMLButtonElement {
     const downloadButton = document.createElement('button');
     downloadButton.className = 'tree-download-btn';

package/src/renderers/renderer.ts

@@ -1,6 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import type { MdBlockExecutionResult } from './types.js';
+import type { MdBlockExecutionResult, MdTableCell, MdTableCellValue } from './types.js';
+import { appendInlineValue, createWikiLinkElement, isUrlValue, shortLabelFromIri } from './wikilink-utils.js';
 
 export interface MarkdownBlockRenderer {
     canRender(result: MdBlockExecutionResult): boolean;
@@ -119,6 +120,43 @@ export abstract class BaseMarkdownBlockRenderer implements MarkdownBlockRenderer
 }
 
 export abstract class QueryMarkdownBlockRenderer extends BaseMarkdownBlockRenderer {
+    protected renderCellValue(raw: string, typedValue?: MdTableCell): HTMLElement {
+        const value = document.createElement('span');
+        value.className = 'table-value';
+        const entries = typedValue?.values ?? [];
+        if (entries.length > 0) {
+            entries.forEach((entry, index) => {
+                if (index > 0) {
+                    value.appendChild(document.createTextNode(' '));
+                }
+                value.appendChild(this.renderValueToken(entry));
+            });
+            return value;
+        }
+        const display = this.formatCellDisplayText(raw, typedValue);
+        const fragment = document.createElement('span');
+        fragment.className = 'table-value-part';
+        fragment.dataset.value = display;
+        appendInlineValue(fragment, display);
+        value.appendChild(fragment);
+        return value;
+    }
+
+    protected formatCellDisplayText(raw: string, typedValue?: MdTableCell): string {
+        if (typedValue?.values?.length) {
+            return typedValue.values.map((entry) => {
+                if (entry.kind === 'iri') {
+                    return shortLabelFromIri(entry.value);
+                }
+                if (entry.kind === 'bnode') {
+                    return `_:${entry.value}`;
+                }
+                return entry.value;
+            }).join(' ');
+        }
+        return raw;
+    }
+
     protected getBlockSource(result: MdBlockExecutionResult): string | undefined {
         return result.blockSource;
     }
@@ -130,6 +168,33 @@ export abstract class QueryMarkdownBlockRenderer extends BaseMarkdownBlockRender
     protected getBlockRange(result: MdBlockExecutionResult): { start?: number; end?: number } {
         return { start: result.blockLineStart, end: result.blockLineEnd };
     }
+
+    private renderValueToken(entry: MdTableCellValue): HTMLElement {
+        const fragment = document.createElement('span');
+        fragment.className = 'table-value-part';
+        fragment.dataset.value = entry.value;
+        if (entry.kind === 'iri') {
+            if (isBuiltInOntologyIri(entry.value)) {
+                appendInlineValue(fragment, shortLabelFromIri(entry.value));
+            } else {
+                fragment.appendChild(createWikiLinkElement(entry.value, shortLabelFromIri(entry.value)));
+            }
+            return fragment;
+        }
+        if (entry.kind === 'bnode') {
+            appendInlineValue(fragment, `_:${entry.value}`);
+            return fragment;
+        }
+        if (isUrlValue(entry.value)) {
+            const link = document.createElement('a');
+            link.href = entry.value;
+            link.textContent = entry.value;
+            fragment.appendChild(link);
+            return fragment;
+        }
+        appendInlineValue(fragment, entry.value);
+        return fragment;
+    }
 }
 
 export abstract class CanvasMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
@@ -148,3 +213,42 @@ export abstract class CanvasMarkdownBlockRenderer extends QueryMarkdownBlockRend
         return container;
     }
 }
+
+const BUILT_IN_ONTOLOGY_IRIS = new Set([
+    'http://opencaesar.io/oml',
+    'http://www.w3.org/2001/XMLSchema',
+    'http://www.w3.org/1999/02/22-rdf-syntax-ns',
+    'http://www.w3.org/2000/01/rdf-schema',
+    'http://www.w3.org/2002/07/owl',
+    'http://www.w3.org/2003/11/swrl',
+    'http://www.w3.org/2003/11/swrlb',
+]);
+
+function ontologyLookupKeyFromIri(value: string): string | undefined {
+    const iri = String(value ?? '').trim().replace(/^<|>$/g, '');
+    if (!iri || !/^[A-Za-z][A-Za-z0-9+.-]*:[^\s]+$/.test(iri)) {
+        return undefined;
+    }
+    const hashIndex = iri.indexOf('#');
+    if (hashIndex >= 0) {
+        return normalizeOntologyLookupKey(iri.slice(0, hashIndex + 1));
+    }
+    const schemeIndex = iri.indexOf('://');
+    const slashIndex = iri.lastIndexOf('/');
+    if (slashIndex > schemeIndex + 2) {
+        return normalizeOntologyLookupKey(iri.slice(0, slashIndex + 1));
+    }
+    return normalizeOntologyLookupKey(iri);
+}
+
+function normalizeOntologyLookupKey(value: string): string {
+    return value.trim().replace(/^<|>$/g, '').replace(/[\/#]+$/, '');
+}
+
+function isBuiltInOntologyIri(iri: string): boolean {
+    const key = ontologyLookupKeyFromIri(iri);
+    if (!key) {
+        return false;
+    }
+    return BUILT_IN_ONTOLOGY_IRIS.has(normalizeOntologyLookupKey(key));
+}