@redocly/realm-plugin-asciidoc 0.1.0

package/lib/asciidoc-parser.js

@@ -0,0 +1,747 @@
+import path from 'node:path';
+import Asciidoctor from '@asciidoctor/core';
+const asciidoctor = Asciidoctor();
+export function parseAsciidoc(content, relativePath, contentRoot) {
+    var _a;
+    const absolutePath = path.resolve(contentRoot, relativePath);
+    const doc = asciidoctor.load(content, {
+        safe: 'safe',
+        base_dir: path.dirname(absolutePath),
+        docfile: absolutePath,
+        attributes: {
+            showtitle: true,
+            'source-highlighter': 'highlight.js',
+            icons: 'font',
+            idprefix: '',
+            idseparator: '-',
+        },
+    });
+    const title = ((_a = doc.getDocumentTitle()) === null || _a === void 0 ? void 0 : _a.toString()) || '';
+    const rawAttributes = doc.getAttributes();
+    const attributes = {};
+    for (const [key, value] of Object.entries(rawAttributes)) {
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            attributes[key] = value;
+        }
+    }
+    // Walk the AST to produce serializable content nodes
+    const topBlocks = doc.getBlocks();
+    const contentNodes = [];
+    // AsciiDoc `= Title` (level 0) is the document title — asciidoctor excludes it from
+    // getBlocks()/getSections(). Prepend it as an H1 heading so it renders on the page.
+    if (title) {
+        const { html: titleHtml, icons: titleIcons } = extractInlineIcons(title);
+        contentNodes.push({
+            type: 'section',
+            id: '',
+            title: stripInlineHtml(title),
+            titleHtml,
+            titleIcons,
+            level: 1,
+            children: [],
+        });
+    }
+    contentNodes.push(...convertBlocks(topBlocks, relativePath));
+    // Build section tree for TOC, search, and AI docs
+    const sections = buildSectionTree(doc.getSections());
+    // Extract links from converted HTML (used for sitemap / link checking)
+    const convertedHtml = doc.convert();
+    const links = extractLinks(convertedHtml, relativePath);
+    return {
+        title,
+        attributes,
+        sections,
+        contentNodes,
+        links,
+        sourceContent: content,
+    };
+}
+function convertBlocks(blocks, relativePath) {
+    const nodes = [];
+    for (let i = 0; i < blocks.length; i++) {
+        const block = blocks[i];
+        const context = block.getContext();
+        switch (context) {
+            case 'section':
+                nodes.push(convertSection(block, relativePath));
+                break;
+            case 'paragraph':
+                nodes.push(convertParagraph(block));
+                break;
+            case 'listing': {
+                const codeNode = convertListing(block, blocks[i + 1]);
+                // If we consumed a colist, skip it
+                if (codeNode.type === 'codeBlock' &&
+                    codeNode.calloutDescriptions &&
+                    codeNode.calloutDescriptions.length > 0) {
+                    const next = blocks[i + 1];
+                    if (next && next.getContext() === 'colist') {
+                        i++;
+                    }
+                }
+                nodes.push(codeNode);
+                break;
+            }
+            case 'literal':
+                nodes.push(convertLiteral(block));
+                break;
+            case 'admonition':
+                nodes.push(convertAdmonition(block, relativePath));
+                break;
+            case 'ulist':
+                nodes.push(convertList(block, false, relativePath));
+                break;
+            case 'olist':
+                nodes.push(convertList(block, true, relativePath));
+                break;
+            case 'dlist':
+                nodes.push(convertDescriptionList(block, relativePath));
+                break;
+            case 'table':
+                nodes.push(convertTable(block));
+                break;
+            case 'image':
+                nodes.push(convertImage(block, relativePath));
+                break;
+            case 'quote':
+            case 'verse':
+                nodes.push(convertQuote(block, relativePath));
+                break;
+            case 'sidebar':
+                nodes.push(convertSidebar(block, relativePath));
+                break;
+            case 'example':
+                nodes.push(convertExample(block, relativePath));
+                break;
+            case 'open':
+                nodes.push(convertOpen(block, relativePath));
+                break;
+            case 'thematic_break':
+                nodes.push({ type: 'thematicBreak' });
+                break;
+            case 'pass':
+            case 'stem':
+                nodes.push(convertPassthrough(block));
+                break;
+            case 'preamble':
+                // Preamble is a wrapper; recurse into its children
+                nodes.push(...convertBlocks(block.getBlocks(), relativePath));
+                break;
+            case 'toc':
+                // Skip generated TOC — we use our own
+                break;
+            case 'colist':
+                // Colist is consumed alongside listing blocks; if orphaned, skip
+                break;
+            default:
+                console.warn(`[asciidoc-plugin] Unsupported block type "${context}" — skipping.`);
+                break;
+        }
+    }
+    return nodes;
+}
+function convertSection(section, relativePath) {
+    const id = section.getId() || slugify(section.getTitle() || '');
+    const rawTitle = section.getTitle() || '';
+    const level = section.getLevel();
+    // Section titles can contain inline icons (e.g. `== icon:flag[] Heading`)
+    const { html: titleHtml, icons: titleIcons } = extractInlineIcons(rawTitle);
+    // Plain text title (strip HTML) for TOC and search
+    const title = stripInlineHtml(rawTitle);
+    const children = convertBlocks(section.getBlocks(), relativePath);
+    return {
+        type: 'section',
+        id,
+        title,
+        titleHtml,
+        titleIcons,
+        level,
+        children,
+    };
+}
+function convertParagraph(block) {
+    const html = block.getContent() || '';
+    const { html: processedHtml, icons } = extractInlineIcons(html);
+    const role = block.getRole() || undefined;
+    return {
+        type: 'paragraph',
+        contentHtml: processedHtml,
+        icons,
+        role,
+    };
+}
+function convertListing(block, nextBlock) {
+    const lang = block.getAttribute('language') || '';
+    const rawSource = block.getSource() || '';
+    const title = block.getTitle() || undefined;
+    // Parse callout markers from source: <1>, <2>, etc.
+    const { cleaned, callouts } = parseCallouts(rawSource);
+    // Check if next block is a colist (callout list)
+    let calloutDescriptions;
+    if (nextBlock && nextBlock.getContext() === 'colist') {
+        calloutDescriptions = extractColistDescriptions(nextBlock);
+    }
+    return {
+        type: 'codeBlock',
+        lang,
+        source: cleaned,
+        title,
+        callouts: callouts.length > 0 ? callouts : undefined,
+        calloutDescriptions: calloutDescriptions && calloutDescriptions.length > 0 ? calloutDescriptions : undefined,
+    };
+}
+function convertLiteral(block) {
+    const source = block.getSource() || '';
+    return {
+        type: 'codeBlock',
+        lang: '',
+        source,
+        title: block.getTitle() || undefined,
+    };
+}
+const ADMONITION_TYPE_MAP = {
+    note: 'info',
+    tip: 'success',
+    warning: 'warning',
+    caution: 'warning',
+    important: 'danger',
+};
+function convertAdmonition(block, relativePath) {
+    const style = (block.getStyle() || 'note').toLowerCase();
+    const admonitionType = ADMONITION_TYPE_MAP[style] || 'info';
+    const name = style.charAt(0).toUpperCase() + style.slice(1);
+    const innerBlocks = block.getBlocks();
+    const children = convertBlocks(innerBlocks, relativePath);
+    return {
+        type: 'admonition',
+        admonitionType,
+        name,
+        children,
+    };
+}
+function convertList(block, ordered, relativePath) {
+    const items = [];
+    for (const item of block.getItems()) {
+        const textHtml = item.getText() || '';
+        const { html: processedHtml, icons } = extractInlineIcons(textHtml);
+        const childBlocks = item.hasBlocks() ? item.getBlocks() : [];
+        const children = convertBlocks(childBlocks, relativePath);
+        items.push({
+            contentHtml: processedHtml,
+            icons,
+            children,
+        });
+    }
+    return {
+        type: 'list',
+        ordered,
+        items,
+    };
+}
+function convertDescriptionList(block, relativePath) {
+    const items = [];
+    const rawItems = block.getItems();
+    for (const pair of rawItems) {
+        if (!Array.isArray(pair) || pair.length < 2)
+            continue;
+        const [terms, definition] = pair;
+        const termsHtml = [];
+        if (Array.isArray(terms)) {
+            for (const term of terms) {
+                const text = typeof term.getText === 'function' ? term.getText() : String(term);
+                termsHtml.push(text);
+            }
+        }
+        let descriptionHtml = '';
+        let descriptionIcons = [];
+        let children = [];
+        if (definition && typeof definition.getText === 'function') {
+            const rawHtml = definition.getText() || '';
+            const extracted = extractInlineIcons(rawHtml);
+            descriptionHtml = extracted.html;
+            descriptionIcons = extracted.icons;
+            if (typeof definition.hasBlocks === 'function' && definition.hasBlocks()) {
+                children = convertBlocks(definition.getBlocks(), relativePath);
+            }
+        }
+        items.push({
+            termsHtml,
+            descriptionHtml,
+            descriptionIcons,
+            children,
+        });
+    }
+    return {
+        type: 'descriptionList',
+        items,
+    };
+}
+function convertTable(block) {
+    const rows = block.getRows();
+    const title = block.getTitle() || undefined;
+    const convertRow = (row) => row.map((cell) => {
+        var _a;
+        const colSpan = cell.getColumnSpan();
+        const rowSpan = cell.getRowSpan();
+        // getContent() returns rendered HTML for asciidoc cells; getText() for plain text cells
+        const style = (_a = cell.getStyle) === null || _a === void 0 ? void 0 : _a.call(cell);
+        const contentHtml = (style === 'asciidoc' ? cell.getContent() : cell.getText()) || '';
+        return Object.assign(Object.assign({ contentHtml }, (colSpan > 1 ? { colSpan } : {})), (rowSpan > 1 ? { rowSpan } : {}));
+    });
+    return {
+        type: 'table',
+        title,
+        head: (rows.head || []).map(convertRow),
+        body: (rows.body || []).map(convertRow),
+        foot: (rows.foot || []).map(convertRow),
+    };
+}
+function convertImage(block, relativePath) {
+    const target = block.getAttribute('target') || '';
+    const alt = block.getAttribute('alt') || '';
+    const width = block.getAttribute('width');
+    const height = block.getAttribute('height');
+    const title = block.getTitle() || undefined;
+    const src = normalizeImageSrc(target, relativePath);
+    return Object.assign(Object.assign({ type: 'image', src,
+        alt,
+        title }, (width ? { width: String(width) } : {})), (height ? { height: String(height) } : {}));
+}
+function convertQuote(block, relativePath) {
+    const attribution = block.getAttribute('attribution') || undefined;
+    const citeTitle = block.getAttribute('citetitle') || undefined;
+    const innerBlocks = block.getBlocks();
+    const children = innerBlocks.length > 0
+        ? convertBlocks(innerBlocks, relativePath)
+        : block.getContent()
+            ? [
+                {
+                    type: 'paragraph',
+                    contentHtml: block.getContent() || '',
+                    icons: [],
+                },
+            ]
+            : [];
+    return {
+        type: 'quote',
+        attribution,
+        citeTitle,
+        children,
+    };
+}
+function convertSidebar(block, relativePath) {
+    return {
+        type: 'sidebar',
+        title: block.getTitle() || undefined,
+        children: convertBlocks(block.getBlocks(), relativePath),
+    };
+}
+function convertExample(block, relativePath) {
+    const isCollapsible = block.isOption('collapsible');
+    if (isCollapsible) {
+        return {
+            type: 'collapsible',
+            title: block.getTitle() || undefined,
+            children: convertBlocks(block.getBlocks(), relativePath),
+        };
+    }
+    return {
+        type: 'example',
+        title: block.getTitle() || undefined,
+        children: convertBlocks(block.getBlocks(), relativePath),
+    };
+}
+function convertOpen(block, relativePath) {
+    // An open block is a generic container — just recurse into children
+    const children = convertBlocks(block.getBlocks(), relativePath);
+    if (children.length === 1)
+        return children[0];
+    // Return as an example-like container if it has a role
+    const role = block.getRole();
+    if (role) {
+        return {
+            type: 'paragraph',
+            contentHtml: block.getContent() || '',
+            icons: [],
+            role,
+        };
+    }
+    // Just flatten open blocks
+    return {
+        type: 'example',
+        title: undefined,
+        children,
+    };
+}
+function convertPassthrough(block) {
+    return {
+        type: 'htmlPassthrough',
+        html: block.getContent() || '',
+    };
+}
+/**
+ * Parses raw AsciiDoc source callout markers like `<1>` `<2>` from code.
+ * Returns cleaned source and callout positions.
+ */
+function parseCallouts(source) {
+    const callouts = [];
+    const calloutRegex = /\s*<(\d+)>\s*$/;
+    const lines = source.split('\n');
+    const cleanedLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        const match = line.match(calloutRegex);
+        if (match) {
+            callouts.push({ line: i + 1, number: parseInt(match[1], 10) });
+            line = line.replace(calloutRegex, '');
+        }
+        cleanedLines.push(line);
+    }
+    return { cleaned: cleanedLines.join('\n'), callouts };
+}
+/**
+ * Extracts callout descriptions from a colist (callout list) block.
+ */
+function extractColistDescriptions(colist) {
+    const descriptions = [];
+    try {
+        const items = colist.getItems();
+        if (items && Array.isArray(items)) {
+            for (const item of items) {
+                if (typeof item.getText === 'function') {
+                    descriptions.push(stripInlineHtml(item.getText()));
+                }
+            }
+        }
+    }
+    catch (_a) {
+        // Colist may not support getItems on all versions
+    }
+    return descriptions;
+}
+/**
+ * Known Font Awesome brand icon names that live under the `brands/` style.
+ */
+const FA_BRAND_ICONS = new Set([
+    'github',
+    'twitter',
+    'facebook',
+    'linkedin',
+    'youtube',
+    'google',
+    'apple',
+    'android',
+    'windows',
+    'docker',
+    'npm',
+    'node-js',
+    'node',
+    'react',
+    'angular',
+    'vuejs',
+    'python',
+    'java',
+    'php',
+    'rust',
+    'golang',
+    'aws',
+    'slack',
+    'discord',
+    'reddit',
+    'stackoverflow',
+    'stack-overflow',
+    'gitlab',
+    'bitbucket',
+    'codepen',
+    'jsfiddle',
+    'bootstrap',
+    'sass',
+    'less',
+    'css3',
+    'html5',
+    'js',
+    'markdown',
+    'stripe',
+    'paypal',
+    'shopify',
+    'wordpress',
+    'medium',
+    'dev',
+    'figma',
+    'sketch',
+    'dribbble',
+    'behance',
+    'instagram',
+    'pinterest',
+    'tiktok',
+    'whatsapp',
+    'telegram',
+    'x-twitter',
+]);
+/**
+ * Extracts `<i class="fa fa-*">` icons from inline HTML and replaces them
+ * with `<!--icon:N-->` placeholders. The extracted icon data is stored in
+ * the InlineIcon array so the template can render CDNIcon components.
+ */
+function extractInlineIcons(html) {
+    const icons = [];
+    const processed = html.replace(/<i class="fa\s+fa-([a-z0-9-]+)([^"]*)"[^>]*><\/i>/gi, (_match, name, extraClasses) => {
+        let iconName = name;
+        let style = 'solid';
+        if (iconName.endsWith('-o')) {
+            iconName = iconName.slice(0, -2);
+            style = 'regular';
+        }
+        if (FA_BRAND_ICONS.has(iconName)) {
+            style = 'brands';
+        }
+        const size = extraClasses.includes('fa-2x') ? '2em' : undefined;
+        const idx = icons.length;
+        icons.push({ name: iconName, style, size });
+        return `<!--icon:${idx}-->`;
+    });
+    return { html: processed, icons };
+}
+function buildSectionTree(sections) {
+    return sections.map((section) => {
+        const id = section.getId() || slugify(section.getTitle() || '');
+        const title = section.getTitle() || '';
+        const level = section.getLevel();
+        // Extract plain text from the section's non-section blocks
+        const textContent = extractTextFromBlocks(section.getBlocks());
+        // Recurse into child sections
+        const childSections = section
+            .getBlocks()
+            .filter((b) => b.getContext() === 'section');
+        return {
+            id,
+            title,
+            level,
+            textContent,
+            children: buildSectionTree(childSections),
+        };
+    });
+}
+function extractTextFromBlocks(blocks) {
+    var _a;
+    const parts = [];
+    for (const block of blocks) {
+        const context = block.getContext();
+        if (context === 'section')
+            continue;
+        if (context === 'paragraph' || context === 'verse') {
+            const html = block.getContent();
+            if (html)
+                parts.push(stripInlineHtml(html));
+        }
+        else if (context === 'literal') {
+            const source = block.getSource();
+            if (source)
+                parts.push(normalizeUnicode(source));
+        }
+        else if (context === 'listing') {
+            const lang = block.getAttribute('language') || '';
+            const source = block.getSource();
+            if (source)
+                parts.push('```' + lang + '\n' + normalizeUnicode(source) + '\n```');
+        }
+        else if (context === 'ulist' || context === 'olist') {
+            try {
+                const items = block.getItems();
+                if (items && Array.isArray(items)) {
+                    const isOrdered = context === 'olist';
+                    const lines = [];
+                    for (let idx = 0; idx < items.length; idx++) {
+                        const item = items[idx];
+                        if (typeof item.getText === 'function') {
+                            const prefix = isOrdered ? `${idx + 1}. ` : '- ';
+                            lines.push(prefix + stripInlineHtml(item.getText()));
+                        }
+                    }
+                    if (lines.length)
+                        parts.push(lines.join('\n'));
+                }
+            }
+            catch (_b) {
+                /* skip if getItems fails */
+            }
+        }
+        else if (context === 'dlist') {
+            try {
+                const items = block.getItems();
+                if (items && Array.isArray(items)) {
+                    const lines = [];
+                    for (const pair of items) {
+                        if (Array.isArray(pair)) {
+                            const [terms, definition] = pair;
+                            if (Array.isArray(terms)) {
+                                for (const t of terms) {
+                                    if (typeof t.getText === 'function') {
+                                        lines.push('**' + stripInlineHtml(t.getText()) + '**');
+                                    }
+                                }
+                            }
+                            if (definition && typeof definition.getText === 'function') {
+                                lines.push(': ' + stripInlineHtml(definition.getText()));
+                            }
+                        }
+                    }
+                    if (lines.length)
+                        parts.push(lines.join('\n'));
+                }
+            }
+            catch (_c) {
+                /* skip */
+            }
+        }
+        else if (context === 'table') {
+            try {
+                parts.push(tableToMarkdown(block));
+            }
+            catch (_d) {
+                /* skip */
+            }
+        }
+        else if (context === 'admonition') {
+            const style = (((_a = block.getStyle) === null || _a === void 0 ? void 0 : _a.call(block)) || 'note').toUpperCase();
+            const innerBlocks = block.getBlocks();
+            const inner = (innerBlocks === null || innerBlocks === void 0 ? void 0 : innerBlocks.length)
+                ? extractTextFromBlocks(innerBlocks)
+                : stripInlineHtml(block.getContent() || '');
+            if (inner) {
+                parts.push(`> [!${style}]\n> ${inner.replace(/\n/g, '\n> ')}`);
+            }
+        }
+        else if (context === 'quote' ||
+            context === 'open' ||
+            context === 'example' ||
+            context === 'sidebar' ||
+            context === 'preamble') {
+            const innerBlocks = block.getBlocks();
+            if (innerBlocks && innerBlocks.length > 0) {
+                parts.push(extractTextFromBlocks(innerBlocks));
+            }
+            else {
+                const html = block.getContent();
+                if (html)
+                    parts.push(stripInlineHtml(html));
+            }
+        }
+    }
+    return parts.filter(Boolean).join('\n\n');
+}
+function tableToMarkdown(block) {
+    const rows = block.getRows();
+    const headRows = [];
+    const bodyRows = [];
+    const footRows = [];
+    const extractRow = (row) => row.map((cell) => { var _a; return stripInlineHtml(((_a = cell.getText) === null || _a === void 0 ? void 0 : _a.call(cell)) || '').replace(/\|/g, '\\|'); });
+    for (const row of rows.head || []) {
+        if (Array.isArray(row))
+            headRows.push(extractRow(row));
+    }
+    for (const row of rows.body || []) {
+        if (Array.isArray(row))
+            bodyRows.push(extractRow(row));
+    }
+    for (const row of rows.foot || []) {
+        if (Array.isArray(row))
+            footRows.push(extractRow(row));
+    }
+    const allRows = [...headRows, ...bodyRows, ...footRows];
+    if (allRows.length === 0)
+        return '';
+    const colCount = Math.max(...allRows.map((r) => r.length));
+    const pad = (row) => {
+        while (row.length < colCount)
+            row.push('');
+        return row;
+    };
+    const lines = [];
+    if (headRows.length > 0) {
+        for (const row of headRows) {
+            lines.push('| ' + pad(row).join(' | ') + ' |');
+        }
+    }
+    else {
+        // Use first body row as header if no explicit header
+        const firstRow = bodyRows.shift();
+        if (firstRow) {
+            lines.push('| ' + pad(firstRow).join(' | ') + ' |');
+        }
+    }
+    // Separator row
+    lines.push('| ' + Array(colCount).fill('---').join(' | ') + ' |');
+    for (const row of bodyRows) {
+        lines.push('| ' + pad(row).join(' | ') + ' |');
+    }
+    for (const row of footRows) {
+        lines.push('| ' + pad(row).join(' | ') + ' |');
+    }
+    return lines.join('\n');
+}
+function extractLinks(html, _relativePath) {
+    const links = [];
+    const linkRegex = /<a\s+[^>]*href="([^"]*)"[^>]*>([^<]*)<\/a>/gi;
+    let match;
+    while ((match = linkRegex.exec(html)) !== null) {
+        const href = match[1];
+        const text = match[2];
+        let type = 'link';
+        if (href.startsWith('#')) {
+            type = 'xref';
+        }
+        else if (href.startsWith('http://') || href.startsWith('https://')) {
+            type = 'url';
+        }
+        links.push({ href, text, type });
+    }
+    return links;
+}
+function normalizeImageSrc(src, relativePath) {
+    if (!src)
+        return src;
+    if (src.startsWith('/') ||
+        src.startsWith('//') ||
+        src.startsWith('data:') ||
+        /^[a-z][a-z\d+\-.]*:/i.test(src)) {
+        return src;
+    }
+    const baseDir = path.posix.dirname(relativePath);
+    const resolvedPath = path.posix.normalize(path.posix.join(baseDir, src));
+    return `/${resolvedPath.replace(/^\/+/, '')}`;
+}
+function stripInlineHtml(text) {
+    return decodeHtmlEntities(text
+        .replace(/<span class="icon"><i class="fa[^"]*fa-([^"\s]+)"[^>]*><\/i><\/span>/gi, (_m, name) => `:${name}:`)
+        .replace(/<i class="fa[^"]*fa-([^"\s]+)"[^>]*><\/i>/gi, (_m, name) => `:${name}:`)
+        .replace(/<[^>]+>/g, ''));
+}
+function decodeHtmlEntities(text) {
+    return normalizeUnicode(text
+        .replace(/&#(\d+);/g, (_m, code) => String.fromCodePoint(Number(code)))
+        .replace(/&#x([0-9a-f]+);/gi, (_m, hex) => String.fromCodePoint(parseInt(hex, 16)))
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&apos;/g, "'"));
+}
+function normalizeUnicode(text) {
+    return text
+        .replace(/\u2014/g, '--')
+        .replace(/\u2013/g, '-')
+        .replace(/\u2018|\u2019/g, "'")
+        .replace(/\u201C|\u201D/g, '"')
+        .replace(/\u2026/g, '...')
+        .replace(/\u00A0/g, ' ');
+}
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+//# sourceMappingURL=asciidoc-parser.js.map