@oml/markdown 0.7.0

package/src/renderers/text-renderer.ts

@@ -0,0 +1,252 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { QueryMarkdownBlockRenderer } from './renderer.js';
+import type { MdBlockExecutionResult } from './types.js';
+import MarkdownIt from 'markdown-it';
+
+type TextStyleSelectorKind = 'paragraph';
+type TextStyleTarget = 'value';
+
+type CompiledTextStyleRule = {
+    selectors: Array<{ kind: TextStyleSelectorKind; condition?: string }>;
+    target: TextStyleTarget;
+    style: Record<string, string>;
+};
+
+type TextSelectorContext = {
+    kind: 'paragraph';
+    context: {
+        index: number;
+        value: string;
+        row: { get: (key?: unknown) => { value: string } | undefined };
+    };
+};
+
+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'
+            && result.format === 'table'
+            && !!result.payload;
+    }
+
+    render(result: MdBlockExecutionResult): HTMLElement {
+        const container = this.createResultContainer(result.status);
+        container.classList.add('oml-md-result-plain');
+        const payload = result.payload;
+        if (!payload || payload.rows.length === 0) {
+            container.appendChild(this.createMessageContainer('No results.'));
+            return container;
+        }
+        const stylesheet = compileTextStylesheet(result.options);
+
+        const wrapper = document.createElement('div');
+        wrapper.className = 'oml-md-result-text';
+        payload.rows.forEach((row, index) => {
+            const paragraph = document.createElement('p');
+            const valueSpan = document.createElement('span');
+            valueSpan.className = 'oml-md-result-text-value';
+            valueSpan.innerHTML = this.markdown.renderInline(row[0] ?? '');
+            paragraph.appendChild(valueSpan);
+
+            const context = createParagraphSelectorContext(index, row[0] ?? '', payload.columns, row);
+            for (const rule of stylesheet) {
+                if (!matchesTextRule(rule, [context])) {
+                    continue;
+                }
+                applyTextValueStyles(valueSpan, rule.style);
+            }
+
+            wrapper.appendChild(paragraph);
+        });
+        container.appendChild(wrapper);
+        return container;
+    }
+}
+
+function compileTextStylesheet(options: Record<string, unknown> | undefined): CompiledTextStyleRule[] {
+    const rawStylesheet = options?.stylesheet;
+    if (!Array.isArray(rawStylesheet)) {
+        return [];
+    }
+    const compiled: CompiledTextStyleRule[] = [];
+    for (const rawRule of rawStylesheet) {
+        if (!isRecord(rawRule)) {
+            continue;
+        }
+        const selectors = parseTextSelectors(rawRule.selector);
+        if (selectors.length === 0) {
+            continue;
+        }
+        const style = normalizeStyle(rawRule.style);
+        if (Object.keys(style).length === 0) {
+            continue;
+        }
+        compiled.push({ selectors, target: 'value', style });
+    }
+    return compiled;
+}
+
+function createParagraphSelectorContext(index: number, value: string, columns: string[], row: string[]): TextSelectorContext {
+    return { kind: 'paragraph', context: { index, value, row: createRowAccessor(columns, row) } };
+}
+
+function matchesTextRule(rule: CompiledTextStyleRule, contexts: ReadonlyArray<TextSelectorContext>): boolean {
+    return rule.selectors.some((selector) => {
+        const contextEntry = contexts.find((entry) => entry.kind === selector.kind);
+        if (!contextEntry) {
+            return false;
+        }
+        return evaluateCondition(selector.condition, contextEntry.context);
+    });
+}
+
+function applyTextValueStyles(target: HTMLElement, style: Record<string, string>): void {
+    for (const [property, cssValue] of Object.entries(style)) {
+        target.style.setProperty(property, cssValue);
+    }
+}
+
+function parseTextSelectors(rawSelector: unknown): Array<{ kind: TextStyleSelectorKind; condition?: string }> {
+    if (typeof rawSelector !== 'string') {
+        return [];
+    }
+    const parts = splitSelectors(rawSelector);
+    const selectors: Array<{ kind: TextStyleSelectorKind; condition?: string }> = [];
+    for (const part of parts) {
+        const parsed = parseTextSelector(part);
+        if (parsed) {
+            selectors.push(parsed);
+        }
+    }
+    return selectors;
+}
+
+function splitSelectors(rawSelector: string): string[] {
+    const parts: string[] = [];
+    let current = '';
+    let bracketDepth = 0;
+    let quote: '"' | "'" | undefined;
+    for (let index = 0; index < rawSelector.length; index += 1) {
+        const char = rawSelector[index];
+        if (quote) {
+            current += char;
+            if (char === quote && rawSelector[index - 1] !== '\\') {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (char === '[') {
+            bracketDepth += 1;
+            current += char;
+            continue;
+        }
+        if (char === ']' && bracketDepth > 0) {
+            bracketDepth -= 1;
+            current += char;
+            continue;
+        }
+        if (char === ',' && bracketDepth === 0) {
+            parts.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+
+function parseTextSelector(selector: string): { kind: TextStyleSelectorKind; condition?: string } | undefined {
+    const trimmed = selector.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const bracketStart = trimmed.indexOf('[');
+    if (bracketStart === -1) {
+        return toTextSelector(trimmed, undefined);
+    }
+    if (!trimmed.endsWith(']')) {
+        return undefined;
+    }
+    const kind = trimmed.slice(0, bracketStart).trim();
+    const condition = trimmed.slice(bracketStart + 1, -1).trim();
+    return toTextSelector(kind, condition || undefined);
+}
+
+function toTextSelector(kind: string, condition: string | undefined): { kind: TextStyleSelectorKind; condition?: string } | undefined {
+    const normalized = kind.trim().toLowerCase();
+    if (normalized !== 'paragraph') {
+        return undefined;
+    }
+    return { kind: normalized, condition };
+}
+
+function normalizeStyle(rawStyle: unknown): Record<string, string> {
+    if (!isRecord(rawStyle)) {
+        return {};
+    }
+    const style: Record<string, string> = {};
+    for (const [property, rawValue] of Object.entries(rawStyle)) {
+        if (!property.trim()) {
+            continue;
+        }
+        if (rawValue === undefined || rawValue === null) {
+            continue;
+        }
+        style[property] = String(rawValue);
+    }
+    return style;
+}
+
+function createRowAccessor(columns: string[], row: string[]): { get: (key?: unknown) => { value: string } | undefined } {
+    return {
+        get: (key?: unknown) => {
+            if (typeof key === 'number' && Number.isInteger(key)) {
+                const value = row[key];
+                return value === undefined ? undefined : { value };
+            }
+            if (typeof key === 'string') {
+                const index = columns.indexOf(key);
+                if (index < 0) {
+                    return undefined;
+                }
+                const value = row[index];
+                return value === undefined ? undefined : { value };
+            }
+            return undefined;
+        }
+    };
+}
+
+function evaluateCondition(condition: string | undefined, context: object): boolean {
+    if (!condition) {
+        return true;
+    }
+    try {
+        const scope = Object.assign(Object.create(null), context) as Record<string, unknown>;
+        const keys = Object.keys(scope);
+        const values = keys.map((key) => scope[key]);
+        // eslint-disable-next-line no-new-func
+        const evaluator = new Function(...keys, `"use strict"; return (${condition});`);
+        return Boolean(evaluator(...values));
+    } catch {
+        return false;
+    }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/src/renderers/tree-renderer.ts

@@ -0,0 +1,7 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { TableMarkdownBlockRenderer } from './table-renderer.js';
+
+export class TreeMarkdownBlockRenderer extends TableMarkdownBlockRenderer {
+    protected override readonly tableKinds = ['tree'] as const;
+}

package/src/renderers/types.ts

@@ -0,0 +1,22 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export type MdExecutionStatus = 'ok' | 'error' | 'unimplemented';
+
+export interface MdTablePayload {
+    columns: string[];
+    rows: string[][];
+}
+
+export interface MdBlockExecutionResult {
+    blockId: string;
+    kind: string;
+    status: MdExecutionStatus;
+    format: 'table' | 'message';
+    blockSource?: string;
+    blockMeta?: string;
+    blockLineStart?: number;
+    blockLineEnd?: number;
+    options?: Record<string, unknown>;
+    payload?: MdTablePayload;
+    message?: string;
+}

package/src/renderers/wikilink-utils.ts

@@ -0,0 +1,108 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export function appendInlineValue(container: HTMLElement, value: string): void {
+    const wikilinkPattern = /\[\[([^\]]+)\]\]/g;
+    let cursor = 0;
+    for (const match of value.matchAll(wikilinkPattern)) {
+        const index = match.index ?? 0;
+        if (index > cursor) {
+            appendPlainSegment(container, value.slice(cursor, index));
+        }
+        const iri = (match[1] ?? '').trim();
+        if (iri.length > 0) {
+            container.appendChild(createWikiLinkElement(iri, shortLabelFromIri(iri)));
+        } else {
+            container.appendChild(document.createTextNode(match[0] ?? ''));
+        }
+        cursor = index + (match[0]?.length ?? 0);
+    }
+    if (cursor < value.length) {
+        appendPlainSegment(container, value.slice(cursor));
+    }
+}
+
+export function appendTokenizedValueParts(container: HTMLElement, raw: string, partClass: string): void {
+    const tokens = splitTokenizedValueParts(raw);
+    if (tokens.length === 0) {
+        container.textContent = raw;
+        return;
+    }
+
+    for (const token of tokens) {
+        const fragment = document.createElement('span');
+        fragment.className = partClass;
+
+        const wikilinkIri = parseWikilinkToken(token);
+        if (wikilinkIri) {
+            fragment.dataset.value = wikilinkIri;
+            fragment.appendChild(createWikiLinkElement(wikilinkIri, shortLabelFromIri(wikilinkIri)));
+            container.appendChild(fragment);
+            continue;
+        }
+
+        fragment.dataset.value = token;
+        if (isIriValue(token)) {
+            fragment.appendChild(createWikiLinkElement(token, shortLabelFromIri(token)));
+        } else {
+            fragment.textContent = token;
+        }
+        container.appendChild(fragment);
+    }
+}
+
+export function splitTokenizedValueParts(raw: string): string[] {
+    return raw
+        .split(/\r?\n|,\s*/)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+}
+
+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;
+}
+
+export function isIriValue(value: string): boolean {
+    return /^[a-z][a-z0-9+.-]*:[^\s]+$/i.test(value);
+}
+
+export function createWikiLinkElement(iri: string, label: string): HTMLAnchorElement {
+    const link = document.createElement('a');
+    link.className = 'wikilink';
+    link.href = '#';
+    link.setAttribute('iri', iri);
+    link.title = iri;
+    link.textContent = label;
+    return link;
+}
+
+function appendPlainSegment(container: HTMLElement, value: string): void {
+    const parts = value.split(/([\s,]+)/).filter((part) => part.length > 0);
+    for (const part of parts) {
+        if (/^[\s,]+$/.test(part)) {
+            container.appendChild(document.createTextNode(part));
+            continue;
+        }
+        if (!isIriValue(part)) {
+            container.appendChild(document.createTextNode(part));
+            continue;
+        }
+        container.appendChild(createWikiLinkElement(part, shortLabelFromIri(part)));
+    }
+}
+
+function parseWikilinkToken(value: string): string | undefined {
+    const match = /^\[\[([^\]]+)\]\]$/.exec(value);
+    if (!match) {
+        return undefined;
+    }
+    const iri = (match[1] ?? '').trim();
+    return iri.length > 0 ? iri : undefined;
+}

package/src/static/browser-runtime.ts

@@ -0,0 +1,249 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { createMarkdownRendererRegistry } from '../renderers/registry.js';
+
+const SUPPORTED = new Set(['table', 'tree', 'graph', 'chart', 'diagram', 'list', 'text', 'matrix', 'table-editor']);
+
+type ManifestEntry = { blockId: string; path: string };
+type WikilinkConfig = { linkingEnabled?: boolean };
+
+function parseJsonNode<T>(id: string, fallback: T): T {
+    const node = document.getElementById(id);
+    if (!node) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(node.textContent ?? '') as T;
+    } catch {
+        return fallback;
+    }
+}
+
+function safeDecode(value: string): string {
+    try {
+        return decodeURIComponent(value);
+    } catch {
+        return value;
+    }
+}
+
+function normalizeWikiPathKey(raw: string): string {
+    return String(raw || '')
+        .replace(/\\/g, '/')
+        .replace(/^\/+/, '')
+        .replace(/[/]+/g, '/')
+        .replace(/\.html$/i, '')
+        .replace(/^\.\//, '')
+        .toLowerCase();
+}
+
+function resolveWikiHref(
+    iri: string,
+    wikilinkIndex: Record<string, string>,
+    iriAliasIndex: Record<string, string>
+): string | undefined {
+    const text = String(iri || '').trim();
+    if (!text) {
+        return undefined;
+    }
+    const alias =
+        iriAliasIndex[text]
+        || iriAliasIndex[text.replace(/[.,;:!?]+$/, '')]
+        || iriAliasIndex[safeDecode(text)];
+    if (typeof alias === 'string' && alias.length > 0) {
+        return alias;
+    }
+    const hashIndex = text.indexOf('#');
+    const fragment = hashIndex >= 0 ? text.slice(hashIndex) : '';
+    const iriWithoutFragment = hashIndex >= 0 ? text.slice(0, hashIndex) : text;
+    let parsed: URL;
+    try {
+        parsed = new URL(iriWithoutFragment);
+    } catch {
+        return undefined;
+    }
+    const rawPath = safeDecode((parsed.pathname || '').replace(/^\/+/, ''));
+    const hostPath = `${(parsed.hostname || '').toLowerCase()}/${rawPath}`.replace(/^\/+/, '');
+    const candidates = [normalizeWikiPathKey(hostPath), normalizeWikiPathKey(rawPath)]
+        .filter((candidate, index, all) => candidate && all.indexOf(candidate) === index);
+    for (const candidate of candidates) {
+        const direct = wikilinkIndex[candidate];
+        if (typeof direct === 'string' && direct.length > 0) {
+            return direct + fragment;
+        }
+    }
+    let bestMatch: { key: string; href: string } | undefined;
+    for (const candidate of candidates) {
+        for (const [key, href] of Object.entries(wikilinkIndex)) {
+            if (!candidate.endsWith('/' + key) && candidate !== key && !key.endsWith('/' + candidate)) {
+                continue;
+            }
+            if (!bestMatch || key.length > bestMatch.key.length) {
+                bestMatch = { key, href };
+            }
+        }
+    }
+    if (bestMatch && bestMatch.href.length > 0) {
+        return bestMatch.href + fragment;
+    }
+    if (fragment) {
+        const currentPath = normalizeWikiPathKey((window.location && window.location.pathname) || '');
+        if (currentPath && candidates.some((candidate) => candidate === currentPath)) {
+            return fragment;
+        }
+    }
+    return undefined;
+}
+
+function applyWikilinks(
+    scope: ParentNode,
+    wikilinkIndex: Record<string, string>,
+    iriAliasIndex: Record<string, string>,
+    linkingEnabled: boolean
+): void {
+    const links = Array.from(scope.querySelectorAll<HTMLAnchorElement>('a.wikilink[iri]'));
+    for (const link of links) {
+        const iri = link.getAttribute('iri') || '';
+        const label = link.textContent || iri;
+        if (!linkingEnabled) {
+            const span = document.createElement('span');
+            span.className = 'wikilink';
+            span.setAttribute('iri', iri);
+            span.title = iri;
+            span.textContent = label;
+            link.replaceWith(span);
+            continue;
+        }
+        const href = resolveWikiHref(iri, wikilinkIndex, iriAliasIndex);
+        if (href) {
+            link.href = href;
+            continue;
+        }
+        const span = document.createElement('span');
+        span.className = 'wikilink';
+        span.setAttribute('iri', iri);
+        span.title = iri;
+        span.textContent = label;
+        link.replaceWith(span);
+    }
+}
+
+function installWikilinkObserver(
+    wikilinkIndex: Record<string, string>,
+    iriAliasIndex: Record<string, string>,
+    linkingEnabled: boolean
+): void {
+    const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+            for (const added of Array.from(mutation.addedNodes)) {
+                if (!(added instanceof Element)) {
+                    continue;
+                }
+                if (added.matches('a.wikilink[iri]')) {
+                    applyWikilinks(added.parentElement ?? document, wikilinkIndex, iriAliasIndex, linkingEnabled);
+                    continue;
+                }
+                if (added.querySelector('a.wikilink[iri]')) {
+                    applyWikilinks(added, wikilinkIndex, iriAliasIndex, linkingEnabled);
+                }
+            }
+        }
+    });
+    observer.observe(document.body, { childList: true, subtree: true });
+}
+
+function setupDownloadHandler(): void {
+    window.addEventListener('md-download-file', (event: Event) => {
+        const detail = (event as CustomEvent<{ filename?: string; content?: string }>).detail;
+        if (!detail || typeof detail.filename !== 'string') {
+            return;
+        }
+        const blob = new Blob([detail.content ?? ''], { type: 'text/plain;charset=utf-8' });
+        const anchor = document.createElement('a');
+        const objectUrl = URL.createObjectURL(blob);
+        anchor.href = objectUrl;
+        anchor.download = detail.filename;
+        anchor.style.display = 'none';
+        document.body.appendChild(anchor);
+        anchor.click();
+        anchor.remove();
+        URL.revokeObjectURL(objectUrl);
+    });
+}
+
+function getMdKindFromCodeElement(code: Element): string | undefined {
+    for (const className of Array.from(code.classList)) {
+        if (!className.startsWith('language-')) {
+            continue;
+        }
+        const language = className.slice('language-'.length).toLowerCase();
+        if (SUPPORTED.has(language)) {
+            return language;
+        }
+    }
+    return undefined;
+}
+
+async function loadResult(
+    manifestEntry: ManifestEntry,
+    inlineResults: Record<string, unknown>
+): Promise<unknown> {
+    if (manifestEntry.blockId && Object.prototype.hasOwnProperty.call(inlineResults, manifestEntry.blockId)) {
+        return inlineResults[manifestEntry.blockId];
+    }
+    const response = await fetch(manifestEntry.path);
+    if (!response.ok) {
+        return { status: 'error', message: `Failed to load block result: ${manifestEntry.path}` };
+    }
+    return await response.json();
+}
+
+async function applyExecutionResults(): Promise<void> {
+    const inlineResults = parseJsonNode<Record<string, unknown>>('oml-md-block-inline-results', {});
+    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 linkingEnabled = Boolean(wikilinkConfig?.linkingEnabled);
+    // Resolve wikilinks in regular markdown content (outside code-block panels).
+    applyWikilinks(document, wikilinkIndex, iriAliasIndex, linkingEnabled);
+    // Re-apply wikilinks for dynamic renderer re-renders (tables, filters, paging, etc.).
+    installWikilinkObserver(wikilinkIndex, iriAliasIndex, linkingEnabled);
+
+    const manifest = parseJsonNode<ManifestEntry[]>('oml-md-block-manifest', []);
+    if (!Array.isArray(manifest) || manifest.length === 0) {
+        return;
+    }
+
+    const codeNodes = Array.from(document.querySelectorAll('pre > code'))
+        .filter((code) => getMdKindFromCodeElement(code) !== undefined);
+    if (codeNodes.length === 0) {
+        return;
+    }
+
+    const registry = createMarkdownRendererRegistry();
+    for (let index = 0; index < codeNodes.length && index < manifest.length; index += 1) {
+        const code = codeNodes[index];
+        const pre = code.parentElement;
+        if (!pre) {
+            continue;
+        }
+        try {
+            const result = await loadResult(manifest[index], inlineResults);
+            const panel = registry.render(result as any);
+            // Resolve wikilinks newly introduced by dynamic block renderers.
+            applyWikilinks(panel, wikilinkIndex, iriAliasIndex, linkingEnabled);
+            pre.replaceWith(panel);
+        } catch (error) {
+            const panel = document.createElement('div');
+            panel.className = 'oml-md-result oml-md-result-error';
+            const message = document.createElement('div');
+            message.className = 'oml-md-result-message';
+            message.textContent = `Render error: ${error instanceof Error ? error.message : String(error)}`;
+            panel.appendChild(message);
+            pre.replaceWith(panel);
+        }
+    }
+}
+
+setupDownloadHandler();
+void applyExecutionResults();

package/src/static/index.ts

@@ -0,0 +1,3 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export * from './runtime-assets.js';