@oml/markdown 0.9.0 → 0.11.0

package/src/renderers/graph-renderer.ts

@@ -1,7 +1,8 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
-import { CanvasMarkdownBlockRenderer } from './renderer.js';
+import { CanvasMarkdownBlockRenderer, displayLabelFromIri } from './renderer.js';
 import type { MdBlockExecutionResult } from './types.js';
+import { isIriValue, shortLabelFromIri } from './wikilink-utils.js';
 
 // --- CSS variable constants for base styles (auto-update on VS Code theme) ---
 const CSS_NODE_FILL    = 'var(--vscode-button-secondaryBackground, var(--vscode-button-background, #5a5a8a))';
@@ -1637,15 +1638,10 @@ function shortLabel(value: string): string {
     if (value.startsWith('_:')) {
         return value;
     }
-    const hash = value.lastIndexOf('#');
-    if (hash >= 0 && hash < value.length - 1) {
-        return value.slice(hash + 1);
+    if (isIriValue(value)) {
+        return shortLabelFromIri(value);
     }
-    const slash = value.lastIndexOf('/');
-    if (slash >= 0 && slash < value.length - 1) {
-        return value.slice(slash + 1);
-    }
-    return value;
+    return displayLabelFromIri(value);
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {

package/src/renderers/renderer.ts

@@ -7,6 +7,72 @@ export interface MarkdownBlockRenderer {
     render(result: MdBlockExecutionResult): HTMLElement;
 }
 
+let iriLabelSnapshot: ReadonlyMap<string, string> | undefined;
+
+export function setIriLabelSnapshot(snapshot?: ReadonlyMap<string, string> | Record<string, string>): void {
+    if (!snapshot) {
+        iriLabelSnapshot = undefined;
+        return;
+    }
+    if (snapshot instanceof Map) {
+        iriLabelSnapshot = snapshot;
+        return;
+    }
+    iriLabelSnapshot = new Map(
+        Object.entries(snapshot).map(([iri, label]) => [normalizeIriLabelKey(iri), String(label)] as const)
+    );
+}
+
+export function runWithIriLabelSnapshot<T>(
+    snapshot: ReadonlyMap<string, string> | Record<string, string> | undefined,
+    action: () => T
+): T {
+    const previous = iriLabelSnapshot;
+    setIriLabelSnapshot(snapshot);
+    try {
+        return action();
+    } finally {
+        iriLabelSnapshot = previous;
+    }
+}
+
+export function displayLabelFromIri(iri: string): string {
+    const normalized = normalizeIriLabelKey(iri);
+    if (!normalized) {
+        return iri;
+    }
+
+    const labeled = iriLabelSnapshot?.get(normalized);
+    if (typeof labeled === 'string' && labeled.length > 0) {
+        return labeled;
+    }
+
+    const fragmentIndex = normalized.lastIndexOf('#');
+    if (fragmentIndex >= 0 && fragmentIndex < normalized.length - 1) {
+        return decodeIriLabelSegment(normalized.slice(fragmentIndex + 1));
+    }
+
+    const withoutQuery = normalized.split('?')[0]?.replace(/\/+$/, '') ?? normalized;
+    const slashIndex = withoutQuery.lastIndexOf('/');
+    if (slashIndex >= 0 && slashIndex < withoutQuery.length - 1) {
+        return decodeIriLabelSegment(withoutQuery.slice(slashIndex + 1));
+    }
+
+    return normalized;
+}
+
+function normalizeIriLabelKey(iri: string): string {
+    return String(iri ?? '').trim().replace(/^<|>$/g, '');
+}
+
+function decodeIriLabelSegment(value: string): string {
+    try {
+        return decodeURIComponent(value);
+    } catch {
+        return value;
+    }
+}
+
 export type TableBlockKind = 'table' | 'table-editor' | 'matrix' | 'tree';
 export type CanvasBlockKind = 'graph' | 'diagram';
 

package/src/renderers/table-renderer.ts

@@ -18,7 +18,6 @@ type TableEditorActionContext = {
         datatypeIri?: string;
         classIri?: string;
         nodeKind?: string;
-        enumValues?: string[];
         editor?: 'multiline';
     }>;
     blockSource?: string;
@@ -28,6 +27,14 @@ type TableEditorActionContext = {
     pointerY?: number;
 };
 
+type TableRootWithAiContext = HTMLDivElement & {
+    __omlAiContext?: {
+        columns: string[];
+        rows: Array<{ iri: string; cells: string[] }>;
+        blockSource?: string;
+    };
+};
+
 export class TableMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
     protected readonly tableKinds: ReadonlyArray<TableBlockKind> = ['table'];
 
@@ -93,7 +100,7 @@ export class TableMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
         options: Record<string, unknown> | undefined,
         blockSource?: string
     ): HTMLElement {
-        const root = document.createElement('div');
+        const root = document.createElement('div') as TableRootWithAiContext;
         root.className = 'table-root graph-root';
         const isTree = this.tableKinds.includes('tree');
         const allRowsWithIndex = rows.map((cells, index) => ({ index, cells }));
@@ -115,6 +122,16 @@ export class TableMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
             ...row,
             cells: visibleColumnIndexes.map((columnIndex) => row.cells[columnIndex] ?? ''),
         }));
+        root.__omlAiContext = {
+            columns: visibleColumns.slice(),
+            rows: rowsWithIndex
+                .map((row) => ({
+                    iri: (row.cells[0] ?? '').trim(),
+                    cells: row.cells.slice(),
+                }))
+                .filter((row) => row.iri.length > 0),
+            blockSource,
+        };
         const columnContexts = createColumnContexts(visibleColumns, rowsWithIndex);
         const treeModel = isTree
             ? this.createTreeModel(columns, allRowsWithIndex, visibleColumnIndexes, options)
@@ -219,10 +236,16 @@ export class TableMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
                 return;
             }
             const filtered = this.applyFiltersAndSorting(columns, sourceRows, state);
-            this.requestCsvDownload(visibleColumns, filtered.map((entry) => entry.cells));
+            const csvExport = this.transformCsvDownloadData(visibleColumns, filtered.map((entry) => entry.cells));
+            this.requestCsvDownload(csvExport.columns, csvExport.rows);
         });
         controlsRight.appendChild(downloadButton);
 
+        const uploadButton = this.createUploadCsvButton(visibleColumns, rowsWithIndex, isTree, blockSource);
+        if (uploadButton) {
+            controlsRight.appendChild(uploadButton);
+        }
+
         controls.appendChild(controlsLeft);
         controls.appendChild(controlsRight);
         root.appendChild(controls);
@@ -958,6 +981,19 @@ export class TableMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
         return value;
     }
 
+    protected createUploadCsvButton(
+        _columns: string[],
+        _rows: Array<{ index: number; cells: string[] }>,
+        _isTree: boolean,
+        _blockSource: string | undefined
+    ): HTMLElement | undefined {
+        return undefined;
+    }
+
+    protected transformCsvDownloadData(columns: string[], rows: string[][]): { columns: string[]; rows: string[][] } {
+        return { columns, rows };
+    }
+
     private requestCsvDownload(columns: string[], rows: string[][]): void {
         if (columns.length === 0) {
             return;

package/src/renderers/text-renderer.ts

@@ -2,7 +2,7 @@
 
 import { QueryMarkdownBlockRenderer } from './renderer.js';
 import type { MdBlockExecutionResult } from './types.js';
-import MarkdownIt from 'markdown-it';
+import { appendInlineValue } from './wikilink-utils.js';
 
 type TextStyleSelectorKind = 'paragraph';
 type TextStyleTarget = 'value';
@@ -23,11 +23,6 @@ type TextSelectorContext = {
 };
 
 export class TextMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
-    private readonly markdown = new MarkdownIt({
-        html: false,
-        linkify: true,
-    });
-
     canRender(result: MdBlockExecutionResult): boolean {
         return result.status === 'ok'
             && result.kind === 'text'
@@ -51,7 +46,7 @@ export class TextMarkdownBlockRenderer extends QueryMarkdownBlockRenderer {
             const paragraph = document.createElement('p');
             const valueSpan = document.createElement('span');
             valueSpan.className = 'oml-md-result-text-value';
-            valueSpan.innerHTML = this.markdown.renderInline(row[0] ?? '');
+            appendInlineValue(valueSpan, row[0] ?? '');
             paragraph.appendChild(valueSpan);
 
             const context = createParagraphSelectorContext(index, row[0] ?? '', payload.columns, row);

package/src/renderers/wikilink-utils.ts

@@ -1,5 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
+import { displayLabelFromIri } from './renderer.js';
+
 export function appendInlineValue(container: HTMLElement, value: string): void {
     const wikilinkPattern = /\[\[([^\]]+)\]\]/g;
     let cursor = 0;
@@ -44,7 +46,7 @@ export function appendTokenizedValueParts(container: HTMLElement, raw: string, p
         if (isIriValue(token)) {
             fragment.appendChild(createWikiLinkElement(token, shortLabelFromIri(token)));
         } else {
-            fragment.textContent = token;
+            appendInlineValue(fragment, token);
         }
         container.appendChild(fragment);
     }
@@ -58,15 +60,7 @@ export function splitTokenizedValueParts(raw: string): string[] {
 }
 
 export function shortLabelFromIri(iri: string): string {
-    const hash = iri.lastIndexOf('#');
-    if (hash >= 0 && hash < iri.length - 1) {
-        return iri.slice(hash + 1);
-    }
-    const slash = iri.lastIndexOf('/');
-    if (slash >= 0 && slash < iri.length - 1) {
-        return iri.slice(slash + 1);
-    }
-    return iri;
+    return displayLabelFromIri(iri);
 }
 
 export function isIriValue(value: string): boolean {

package/src/static/browser-runtime.ts

@@ -1,6 +1,7 @@
 // Copyright (c) 2026 Modelware. All rights reserved.
 
 import { createMarkdownRendererRegistry } from '../renderers/registry.js';
+import { setIriLabelSnapshot } from '../renderers/renderer.js';
 
 const SUPPORTED = new Set(['table', 'tree', 'graph', 'chart', 'diagram', 'list', 'text', 'matrix', 'table-editor']);
 
@@ -203,6 +204,8 @@ async function applyExecutionResults(): Promise<void> {
     const wikilinkIndex = parseJsonNode<Record<string, string>>('oml-md-wikilink-index', {});
     const iriAliasIndex = parseJsonNode<Record<string, string>>('oml-md-wikilink-iri-aliases', {});
     const wikilinkConfig = parseJsonNode<WikilinkConfig>('oml-md-wikilink-config', { linkingEnabled: false });
+    const memberLabelSnapshot = parseJsonNode<Record<string, string>>('oml-md-member-labels', {});
+    setIriLabelSnapshot(memberLabelSnapshot);
     const linkingEnabled = Boolean(wikilinkConfig?.linkingEnabled);
     // Resolve wikilinks in regular markdown content (outside code-block panels).
     applyWikilinks(document, wikilinkIndex, iriAliasIndex, linkingEnabled);