@oml/markdown 0.7.0

package/src/md/md-runtime.ts

@@ -0,0 +1,191 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import MarkdownIt from 'markdown-it';
+import type { RuleInline } from 'markdown-it/lib/parser_inline.mjs';
+import { extractLeadingFrontMatter, stripLeadingFrontMatter } from './md-frontmatter.js';
+import { MarkdownHandlerRegistry } from './md-registry.js';
+import { parseYamlMap } from './md-yaml.js';
+import type { ParsedCodeBlock, PreparedCodeBlock, PreparedMarkdownDocument } from './md-types.js';
+
+export class MarkdownPreviewRuntime {
+    private readonly renderer: MarkdownIt;
+
+    constructor(private readonly handlers: MarkdownHandlerRegistry) {
+        this.renderer = new MarkdownIt({
+            html: true,
+            linkify: true,
+            typographer: false,
+        });
+        this.renderer.inline.ruler.before('link', 'wiki-link', wikilinkRule);
+    }
+
+    prepare(markdown: string): PreparedMarkdownDocument {
+        const frontMatter = extractLeadingFrontMatter(markdown);
+        const stripped = stripLeadingFrontMatter(markdown);
+        const codeBlocks = this.parseCodeBlocks(stripped);
+        const executableBlocks = this.resolveExecutableBlocks(codeBlocks);
+        const renderedHtml = this.renderer.render(stripped);
+
+        return {
+            markdown: stripped,
+            renderedHtml,
+            frontMatter,
+            contextUri: frontMatter?.contextUri,
+            codeBlocks,
+            executableBlocks
+        };
+    }
+
+    private parseCodeBlocks(markdown: string): ParsedCodeBlock[] {
+        const tokens = this.renderer.parse(markdown, {});
+        const blocks: ParsedCodeBlock[] = [];
+
+        for (const token of tokens) {
+            if (token.type !== 'fence') {
+                continue;
+            }
+            const language = parseLanguage(token.info);
+            const meta = parseMeta(token.info);
+            const lineStart = token.map?.[0] ?? 0;
+            const lineEnd = token.map?.[1] ?? lineStart;
+            const parsed = parseBlockOptions(token.content);
+            blocks.push({
+                id: buildBlockId(lineStart, lineEnd, language, parsed.content),
+                language,
+                meta,
+                content: parsed.content,
+                options: parsed.options,
+                lineStart,
+                lineEnd,
+            });
+        }
+
+        return blocks;
+    }
+
+    private resolveExecutableBlocks(codeBlocks: ParsedCodeBlock[]): PreparedCodeBlock[] {
+        const executableBlocks: PreparedCodeBlock[] = [];
+        for (const block of codeBlocks) {
+            const handler = this.handlers.match(block);
+            if (!handler) {
+                continue;
+            }
+            executableBlocks.push({
+                block,
+                handlerId: handler.id,
+            });
+        }
+        return executableBlocks;
+    }
+}
+
+const wikilinkRule: RuleInline = (state, silent): boolean => {
+    const { src } = state;
+    const start = state.pos;
+    if (src.charCodeAt(start) !== 0x5b || src.charCodeAt(start + 1) !== 0x5b) {
+        return false;
+    }
+
+    const close = src.indexOf(']]', start + 2);
+    if (close < 0) {
+        return false;
+    }
+
+    const iri = src.slice(start + 2, close).trim();
+    if (!iri) {
+        return false;
+    }
+
+    if (!silent) {
+        const label = deriveWikiLabel(iri);
+        const open = state.push('link_open', 'a', 1);
+        open.attrSet('class', 'wikilink');
+        open.attrSet('iri', iri);
+        open.attrSet('href', '#');
+        open.attrSet('title', iri);
+
+        const text = state.push('text', '', 0);
+        text.content = label;
+
+        state.push('link_close', 'a', -1);
+    }
+
+    state.pos = close + 2;
+    return true;
+};
+
+function deriveWikiLabel(iri: string): string {
+    const normalized = iri.trim().replace(/^<|>$/g, '');
+    if (!normalized) {
+        return iri;
+    }
+    const fragment = normalized.split('#').pop() ?? '';
+    if (fragment && normalized.includes('#')) {
+        return decodeLabelPart(fragment);
+    }
+
+    const withoutQuery = normalized.split('?')[0];
+    const pathParts = withoutQuery.replace(/\/+$/, '').split('/');
+    const lastSegment = pathParts[pathParts.length - 1] ?? '';
+    if (lastSegment) {
+        return decodeLabelPart(lastSegment);
+    }
+    return normalized;
+}
+
+function decodeLabelPart(value: string): string {
+    try {
+        return decodeURIComponent(value);
+    } catch {
+        return value;
+    }
+}
+
+function parseBlockOptions(content: string): { content: string; options?: Record<string, unknown> } {
+    const normalized = content.replace(/^\uFEFF/, '');
+    const match = /^(---\s*\r?\n[\s\S]*?\r?\n---\s*\r?\n?)([\s\S]*)$/.exec(normalized);
+    if (!match) {
+        return { content };
+    }
+    const rawOptions = match[1]
+        .replace(/^---\s*\r?\n/, '')
+        .replace(/\r?\n---\s*\r?\n?$/, '');
+    const options = parseYamlMap(rawOptions) ?? {};
+    return {
+        content: match[2],
+        options: Object.keys(options).length > 0 ? options : undefined,
+    };
+}
+
+function parseLanguage(info: string): string {
+    if (!info.trim()) {
+        return '';
+    }
+    const first = info.trim().split(/\s+/)[0];
+    return first.toLowerCase();
+}
+
+function parseMeta(info: string): string | undefined {
+    const trimmed = info.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const index = trimmed.indexOf(' ');
+    if (index === -1) {
+        return undefined;
+    }
+    return trimmed.slice(index + 1).trim() || undefined;
+}
+
+function buildBlockId(lineStart: number, lineEnd: number, language: string, content: string): string {
+    return `block-${lineStart}-${lineEnd}-${hash32(`${language}|${content}`)}`;
+}
+
+function hash32(input: string): string {
+    let hash = 2166136261;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16);
+}

package/src/md/md-types.ts

@@ -0,0 +1,48 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+export interface ParsedCodeBlock {
+    id: string;
+    language: string;
+    meta?: string;
+    content: string;
+    options?: Record<string, unknown>;
+    lineStart: number;
+    lineEnd: number;
+}
+
+export interface MarkdownFrontMatter {
+    raw: string;
+    contextUri?: string;
+    data?: Record<string, unknown>;
+}
+
+export interface PreparedCodeBlock {
+    block: ParsedCodeBlock;
+    handlerId: string;
+}
+
+export interface PreparedMarkdownDocument {
+    markdown: string;
+    renderedHtml: string;
+    frontMatter?: MarkdownFrontMatter;
+    contextUri?: string;
+    codeBlocks: ParsedCodeBlock[];
+    executableBlocks: PreparedCodeBlock[];
+}
+
+export interface MarkdownExecutionContext {
+    documentUri: string;
+    modelUri?: string;
+}
+
+export interface CodeBlockExecutionResult {
+    ok: boolean;
+    output?: string;
+    error?: string;
+}
+
+export interface CodeBlockHandler {
+    id: string;
+    supports(block: ParsedCodeBlock): boolean;
+    execute(context: MarkdownExecutionContext, block: ParsedCodeBlock, signal: AbortSignal): Promise<CodeBlockExecutionResult>;
+}

package/src/md/md-yaml.ts

@@ -0,0 +1,17 @@
+// Copyright (c) 2026 Modelware. All rights reserved.
+
+import { parse } from 'yaml';
+
+export function parseYamlMap(input: string): Record<string, unknown> | undefined {
+    try {
+        const parsed = parse(input);
+        return isPlainObject(parsed) ? parsed : undefined;
+    } catch {
+        return undefined;
+    }
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+