execonvert 0.4.0

package/dist/cli/src/elpx-markdown.js

@@ -0,0 +1,201 @@
+import TurndownService from 'turndown';
+// @ts-expect-error turndown-plugin-gfm does not ship TypeScript declarations.
+import { gfm } from 'turndown-plugin-gfm';
+import { convertElpxToHtml } from './converter.js';
+export async function convertElpxToMarkdown(file, options, onProgress) {
+    const htmlResult = await convertElpxToHtml(file, {
+        selectedPageIds: options.selectedPageIds,
+        // Markdown should be generated from the stable exported source, not from rendered browser output.
+        useRenderedPages: false,
+    }, onProgress);
+    onProgress?.({ phase: 'render', message: 'Convirtiendo HTML a Markdown...', messageKey: 'progress.htmlToMarkdown' });
+    const markdown = normalizeGeneratedMarkdown(convertHtmlDocumentToMarkdown(htmlResult.html, options));
+    return {
+        blob: new Blob([markdown], { type: 'text/markdown;charset=utf-8' }),
+        filename: toMarkdownFilename(file.name),
+        pageCount: htmlResult.pageCount,
+    };
+}
+function normalizeGeneratedMarkdown(markdown) {
+    return markdown
+        .replace(/\n{2,}\d+\n{2,}(?=#{3,6}\s)/g, '\n\n')
+        .replace(/[ \t]+\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n');
+}
+function convertHtmlDocumentToMarkdown(html, options) {
+    const document = new DOMParser().parseFromString(html, 'text/html');
+    const root = document.body;
+    const title = root.querySelector('h1')?.textContent?.trim() || '';
+    const subtitle = root.querySelector('.project-subtitle')?.textContent?.trim() || '';
+    const sections = Array.from(root.querySelectorAll('section.page'));
+    const turndown = createTurndownService(options);
+    const parts = [];
+    if (title) {
+        parts.push(`**${title}**`);
+    }
+    if (subtitle) {
+        parts.push(`_${subtitle}_`);
+    }
+    if (sections.length === 0) {
+        const markdown = turndownFragment(root, turndown, options).trim();
+        if (markdown) {
+            parts.push(markdown);
+        }
+    }
+    else {
+        for (const section of sections) {
+            const sectionMarkdown = turndownFragment(section, turndown, options).trim();
+            if (sectionMarkdown) {
+                parts.push(sectionMarkdown);
+            }
+        }
+    }
+    return parts.filter(Boolean).join('\n\n').trimEnd() + '\n';
+}
+function createTurndownService(options) {
+    const turndown = new TurndownService({
+        headingStyle: 'atx',
+        codeBlockStyle: 'fenced',
+        bulletListMarker: '-',
+        emDelimiter: '_',
+        strongDelimiter: '**',
+    });
+    turndown.use(gfm);
+    turndown.addRule('imageHandling', {
+        filter: 'img',
+        replacement: (_content, node) => {
+            const element = node;
+            const alt = element.getAttribute('alt') || 'Imagen';
+            const src = element.getAttribute('src') || '';
+            if (!options.includeImages) {
+                return alt ? `_${alt}_` : '';
+            }
+            return src ? `![${alt}](${src})` : alt;
+        },
+    });
+    turndown.addRule('sectionRule', {
+        filter: 'section',
+        replacement: (content) => `\n\n${content.trim()}\n\n`,
+    });
+    return turndown;
+}
+function turndownFragment(root, turndown, options) {
+    const clone = root.cloneNode(true);
+    const tableTokens = replaceTablesWithMarkdownTokens(clone, options);
+    let markdown = turndown.turndown(clone.innerHTML);
+    for (const [token, tableMarkdown] of tableTokens) {
+        markdown = markdown.replace(token, `\n\n${tableMarkdown}\n\n`);
+    }
+    return markdown;
+}
+function toMarkdownFilename(inputName) {
+    const stem = inputName.replace(/\.[^.]+$/, '') || 'documento';
+    return `${stem}.md`;
+}
+function replaceTablesWithMarkdownTokens(root, options) {
+    const cellTurndown = createTurndownService(options);
+    const tokens = new Map();
+    const tables = Array.from(root.querySelectorAll('table')).reverse();
+    tables.forEach((table, index) => {
+        const markdown = tableElementToMarkdown(table, cellTurndown);
+        const token = `EXE_MD_TABLE_${index}_${Math.random().toString(36).slice(2, 10)}`;
+        tokens.set(token, markdown);
+        table.replaceWith(root.ownerDocument.createTextNode(token));
+    });
+    return tokens;
+}
+function tableElementToMarkdown(table, cellTurndown) {
+    const rows = extractTableRows(table, cellTurndown);
+    if (rows.length === 0) {
+        return '';
+    }
+    const columnCount = Math.max(...rows.map(row => row.length));
+    if (columnCount === 0) {
+        return '';
+    }
+    const normalizedRows = rows.map(row => {
+        const padded = row.slice();
+        while (padded.length < columnCount) {
+            padded.push('');
+        }
+        return padded;
+    });
+    const header = normalizedRows[0];
+    const body = normalizedRows.slice(1);
+    const separator = header.map(() => '---');
+    const lines = [
+        `| ${header.join(' | ')} |`,
+        `| ${separator.join(' | ')} |`,
+        ...body.map(row => `| ${row.join(' | ')} |`),
+    ];
+    return lines.join('\n');
+}
+function extractTableRows(table, cellTurndown) {
+    const view = table.ownerDocument.defaultView;
+    const HTMLElementCtor = view?.HTMLElement;
+    const HTMLTableRowElementCtor = view?.HTMLTableRowElement;
+    const HTMLTableCellElementCtor = view?.HTMLTableCellElement;
+    const rowGroups = Array.from(table.children).filter((child) => {
+        const isElement = HTMLElementCtor ? child instanceof HTMLElementCtor : child.nodeType === 1;
+        return isElement && ['thead', 'tbody', 'tfoot'].includes(child.tagName.toLowerCase());
+    });
+    const directRows = rowGroups.length > 0
+        ? rowGroups.flatMap(group => Array.from(group.children))
+        : Array.from(table.children);
+    const tableRows = directRows.filter((row) => {
+        if (HTMLTableRowElementCtor) {
+            return row instanceof HTMLTableRowElementCtor;
+        }
+        return row.nodeType === 1 && row.tagName.toLowerCase() === 'tr';
+    });
+    const grid = [];
+    for (const rowElement of tableRows) {
+        const rowIndex = grid.length;
+        const row = grid[rowIndex] || [];
+        let columnIndex = 0;
+        while (row[columnIndex] !== undefined) {
+            columnIndex += 1;
+        }
+        for (const cell of Array.from(rowElement.children)) {
+            const isTableCell = HTMLTableCellElementCtor
+                ? cell instanceof HTMLTableCellElementCtor
+                : cell.nodeType === 1 && /^(td|th)$/i.test(cell.tagName);
+            if (!isTableCell) {
+                continue;
+            }
+            const tableCell = cell;
+            while (row[columnIndex] !== undefined) {
+                columnIndex += 1;
+            }
+            const colspan = Math.max(1, Number.parseInt(tableCell.getAttribute('colspan') || '1', 10) || 1);
+            const rowspan = Math.max(1, Number.parseInt(tableCell.getAttribute('rowspan') || '1', 10) || 1);
+            const content = normalizeTableCell(cellToMarkdown(tableCell, cellTurndown));
+            for (let rowOffset = 0; rowOffset < rowspan; rowOffset += 1) {
+                const targetRow = grid[rowIndex + rowOffset] || [];
+                grid[rowIndex + rowOffset] = targetRow;
+                for (let colOffset = 0; colOffset < colspan; colOffset += 1) {
+                    targetRow[columnIndex + colOffset] = rowOffset === 0 && colOffset === 0 ? content : '';
+                }
+            }
+            columnIndex += colspan;
+        }
+    }
+    return grid.filter(row => row.some(cell => cell !== undefined && cell !== ''));
+}
+function cellToMarkdown(cell, cellTurndown) {
+    const clone = cell.cloneNode(true);
+    for (const nestedTable of Array.from(clone.querySelectorAll('table'))) {
+        nestedTable.replaceWith(clone.ownerDocument.createTextNode(normalizeTableCell(nestedTable.textContent || '')));
+    }
+    return cellTurndown.turndown(clone.innerHTML);
+}
+function normalizeTableCell(value) {
+    return value
+        .replace(/\r/g, '')
+        .replace(/\n{2,}/g, '<br><br>')
+        .replace(/\n/g, '<br>')
+        .replace(/\s+/g, ' ')
+        .replace(/<br>(?:\s*<br>)+/g, '<br><br>')
+        .replace(/\|/g, '\\|')
+        .trim();
+}