safe-mdx 1.3.2 → 1.3.6

package/dist/html/html-to-mdx-ast.js

@@ -0,0 +1,247 @@
+import { unified } from 'unified';
+import { convertAttributeNameToJSX } from './convert-attributes.js';
+import { parseHTML } from './domparser.js';
+import { remarkMdxJsxNormalize } from './remark-mdx-jsx-normalize.js';
+// Re-export the normalize plugin
+export { remarkMdxJsxNormalize };
+// Type guard functions for DOM nodes
+function isCommentNode(node) {
+    return node.nodeType === 8; // Node.COMMENT_NODE
+}
+function isTextNode(node) {
+    return node.nodeType === 3; // Node.TEXT_NODE
+}
+function isElementNode(node) {
+    return node.nodeType === 1; // Node.ELEMENT_NODE
+}
+// Default tag name converter (no transformation)
+function defaultConvertTagName({ tagName }) {
+    return tagName.toLowerCase();
+}
+// Default attribute value converter (no transformation)
+function defaultConvertAttributeValue({ value, }) {
+    return value;
+}
+// Convert HTML attribute to MDX JSX attribute
+function convertAttribute(attr, tagName, options) {
+    let jsxName = convertAttributeNameToJSX(attr.name);
+    // Apply attribute value transformation
+    const convertAttrValue = options?.convertAttributeValue || defaultConvertAttributeValue;
+    let value = convertAttrValue({
+        name: attr.name,
+        value: attr.value,
+        tagName,
+    });
+    // Handle boolean attributes
+    if (value === '' || value === attr.name) {
+        return {
+            type: 'mdxJsxAttribute',
+            name: jsxName,
+            value: null, // boolean true
+        };
+    }
+    // Handle special number attributes
+    const numberAttrs = [
+        'tabIndex',
+        'cols',
+        'rows',
+        'size',
+        'span',
+        'colSpan',
+        'rowSpan',
+        'border',
+    ];
+    if (numberAttrs.includes(jsxName) && value && !isNaN(Number(value))) {
+        return {
+            type: 'mdxJsxAttribute',
+            name: jsxName,
+            value: {
+                type: 'mdxJsxAttributeValueExpression',
+                value: value,
+                data: {
+                    estree: {
+                        type: 'Program',
+                        sourceType: 'module',
+                        body: [
+                            {
+                                type: 'ExpressionStatement',
+                                expression: {
+                                    type: 'Literal',
+                                    value: Number(value),
+                                },
+                            },
+                        ],
+                    },
+                },
+            },
+        };
+    }
+    // Handle style attribute - for now keep as string
+    // if (jsxName === 'style' && value.includes(':')) {
+    //     // Could enhance to parse CSS to object
+    //     return {
+    //         type: 'mdxJsxAttribute',
+    //         name: jsxName,
+    //         value: {
+    //             type: 'mdxJsxAttributeValueExpression',
+    //             value: `{${JSON.stringify(parseStyleString(value))}}`,
+    //             data: {
+    //                 estree: parseExpression(JSON.stringify(parseStyleString(value))),
+    //             },
+    //         },
+    //     }
+    // }
+    // String value
+    return {
+        type: 'mdxJsxAttribute',
+        name: jsxName,
+        value: value,
+    };
+}
+// Convert DOM node to MDX AST nodes - always returns an array
+function htmlNodeToMdxAst(node, options) {
+    if (isCommentNode(node)) {
+        // Convert comments to MDX JSX expression with comment
+        // For now, return empty array
+        // return [{
+        //     type: 'html',
+        //     value: `<!-- ${node.data} -->`
+        // }] as Html[]
+        return [];
+    }
+    if (isTextNode(node)) {
+        const textValue = node.textContent || '';
+        // If we have a textToMdast converter, use it
+        if (options?.textToMdast) {
+            try {
+                const result = options.textToMdast({ text: textValue });
+                return Array.isArray(result) ? result : [result];
+            }
+            catch (error) {
+                // Call onError callback if provided, otherwise log
+                if (options.onError) {
+                    options.onError(error, textValue);
+                }
+                else {
+                    console.error('Failed to convert text to mdast:', error);
+                    console.error('Text content:', textValue);
+                }
+                // Fallback to simple text node
+                return [
+                    {
+                        type: 'text',
+                        value: textValue,
+                    },
+                ];
+            }
+        }
+        // Default: return simple text node
+        return [
+            {
+                type: 'text',
+                value: textValue,
+            },
+        ];
+    }
+    if (!isElementNode(node)) {
+        return [];
+    }
+    const convertTagNameFn = options?.convertTagName || defaultConvertTagName;
+    // Use localName which is always lowercase in both browser and linkedom
+    const componentName = convertTagNameFn({ tagName: node.localName });
+    // If convertTagName returns empty string, skip this element and only return its children
+    if (componentName === '') {
+        // Process children but skip the element wrapper
+        const children = [];
+        for (const child of Array.from(node.childNodes)) {
+            children.push(...htmlNodeToMdxAst(child, options));
+        }
+        return children;
+    }
+    // Convert attributes
+    const attributes = [];
+    for (const attr of Array.from(node.attributes)) {
+        attributes.push(convertAttribute(attr, node.tagName, options));
+    }
+    // Process children
+    const children = [];
+    for (const child of Array.from(node.childNodes)) {
+        children.push(...htmlNodeToMdxAst(child, options));
+    }
+    // Always create MdxJsxTextElement initially
+    // The conversion to MdxJsxFlowElement will be handled by a separate plugin
+    const element = {
+        type: 'mdxJsxTextElement',
+        name: componentName,
+        attributes,
+        children: children,
+    };
+    return [element];
+}
+// Main function to parse HTML and return MDX AST - always returns an array
+export function htmlToMdxAst(options) {
+    // Parse HTML with linkedom
+    const { document } = parseHTML(options.html.trim());
+    // linkedom behavior:
+    // - If input is a fragment (like "<div>Hello</div>"), the content becomes direct children of document
+    // - If input has body tag, it creates proper body element
+    // - We need to handle both cases
+    // linkedom behavior:
+    // - When parsing fragments, content becomes direct children of document
+    // - Accessing document.body on fragments auto-creates HEAD and BODY as children
+    // - We must avoid accessing document.body to prevent this
+    // Just use document's direct children and filter for relevant nodes
+    const childNodes = Array.from(document.childNodes).filter((node) => node.nodeType === 1 || // Element nodes
+        node.nodeType === 3 || // Text nodes
+        node.nodeType === 8);
+    let results = [];
+    for (const node of childNodes) {
+        results.push(...htmlNodeToMdxAst(node, options));
+    }
+    // Apply the normalize plugin if we have a parentType
+    if (options.parentType && results.length > 0) {
+        // Create a temporary AST node with the same parent type
+        const parentType = options.parentType;
+        const tempRoot = {
+            type: 'root',
+            children: results,
+        };
+        // If we have a specific parent type, wrap the content in that parent
+        // to provide proper context for the normalize plugin
+        let astToProcess;
+        if (parentType !== 'root') {
+            // Create a parent node of the specified type with our content as children
+            const parentNode = {
+                type: parentType,
+                children: tempRoot.children,
+            };
+            astToProcess = {
+                type: 'root',
+                children: [parentNode],
+            };
+        }
+        else {
+            astToProcess = tempRoot;
+        }
+        // Create a simple processor and run the normalize plugin
+        const processor = unified().use(remarkMdxJsxNormalize);
+        processor.runSync(astToProcess);
+        // Extract the result back
+        if (parentType !== 'root') {
+            // Get the children from the parent node we created
+            const processedParent = astToProcess.children[0];
+            results = processedParent.children;
+        }
+        else {
+            // Get children directly from root
+            results = astToProcess.children;
+        }
+    }
+    return results;
+}
+// Export a wrapper that always returns an array for consistency
+// Note: htmlToMdxAst now already returns an array, so this is just an alias
+export function parseHtmlToMdxAst(options) {
+    return htmlToMdxAst(options);
+}
+//# sourceMappingURL=html-to-mdx-ast.js.map

package/dist/html/html-to-mdx-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-to-mdx-ast.js","sourceRoot":"","sources":["../../src/html/html-to-mdx-ast.ts"],"names":[],"mappings":"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"}

package/dist/html/html-to-mdx-ast.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=html-to-mdx-ast.test.d.ts.map

package/dist/html/html-to-mdx-ast.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-to-mdx-ast.test.d.ts","sourceRoot":"","sources":["../../src/html/html-to-mdx-ast.test.ts"],"names":[],"mappings":""}

package/dist/html/html-to-mdx-ast.test.js

@@ -0,0 +1,411 @@
+import { test, expect, describe } from 'vitest';
+import React from 'react';
+import { renderToStaticMarkup } from 'react-dom/server';
+import { parseHtmlToMdxAst, htmlToMdxAst, } from './html-to-mdx-ast.js';
+import { unified } from 'unified';
+import remarkMdx from 'remark-mdx';
+import remarkStringify from 'remark-stringify';
+import remarkParse from 'remark-parse';
+import { mdxParse } from '../parse.js';
+import { MdastToJsx } from '../safe-mdx.js';
+// Default components for testing
+const components = {
+    Heading({ level, children, ...props }) {
+        return React.createElement('h1', props, children);
+    },
+    Cards({ level, children, ...props }) {
+        return React.createElement('div', props, children);
+    },
+};
+// Helper to convert HTML to MDX string and rendered HTML
+async function htmlToMdxString({ html, withProcessor = false, onError, convertTagName, convertAttributeValue, }) {
+    // If withProcessor is true, create a textToMdast that parses markdown
+    const textToMdast = withProcessor
+        ? ({ text }) => {
+            const markdownProcessor = unified()
+                .use(remarkParse)
+                .use(remarkMdx);
+            const mdast = markdownProcessor.parse(text);
+            markdownProcessor.runSync(mdast);
+            // Return the children of the root node
+            return mdast.children || [];
+        }
+        : undefined;
+    const mdxAst = parseHtmlToMdxAst({
+        html,
+        textToMdast,
+        onError,
+        convertTagName,
+        convertAttributeValue,
+    });
+    // Generate MDX string
+    const processor = unified().use(remarkMdx).use(remarkStringify, {
+    // bullet: '-',
+    // fence: '`',
+    // fences: true
+    });
+    // Create a root node with the content
+    const root = {
+        type: 'root',
+        children: mdxAst,
+    };
+    const mdx = processor.stringify(root);
+    // Generate HTML using MdastToJsx like in safe-mdx.test.tsx
+    // First parse the MDX to get the full AST
+    const mdast = mdxParse(mdx);
+    const visitor = new MdastToJsx({ markdown: mdx, mdast, components });
+    const jsx = visitor.run();
+    const renderedHtml = renderToStaticMarkup(jsx);
+    return { mdx, html: renderedHtml };
+}
+describe('parseHtmlToMdxAst', () => {
+    test('parses simple HTML element', () => {
+        const result = parseHtmlToMdxAst({ html: '<div>Hello</div>' });
+        expect(result).toMatchInlineSnapshot(`
+          [
+            {
+              "attributes": [],
+              "children": [
+                {
+                  "type": "text",
+                  "value": "Hello",
+                },
+              ],
+              "name": "div",
+              "type": "mdxJsxTextElement",
+            },
+          ]
+        `);
+    });
+    test('filters out non-HTML elements when convertTagName returns empty string', () => {
+        const result = parseHtmlToMdxAst({
+            html: '<custom-element>Hello <span>world</span></custom-element>',
+            convertTagName: ({ tagName }) => {
+                // Only keep span, filter out custom-element
+                if (tagName === 'span')
+                    return 'span';
+                return tagName;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+          [
+            {
+              "attributes": [],
+              "children": [
+                {
+                  "type": "text",
+                  "value": "Hello ",
+                },
+                {
+                  "attributes": [],
+                  "children": [
+                    {
+                      "type": "text",
+                      "value": "world",
+                    },
+                  ],
+                  "name": "span",
+                  "type": "mdxJsxTextElement",
+                },
+              ],
+              "name": "custom-element",
+              "type": "mdxJsxTextElement",
+            },
+          ]
+        `);
+    });
+    test('handles self-closing tags', () => {
+        const result = parseHtmlToMdxAst({
+            html: '<img src="https://example.com/img.jpg" />',
+        });
+        expect(result).toMatchInlineSnapshot(`
+          [
+            {
+              "attributes": [
+                {
+                  "name": "src",
+                  "type": "mdxJsxAttribute",
+                  "value": "https://example.com/img.jpg",
+                },
+              ],
+              "children": [],
+              "name": "img",
+              "type": "mdxJsxTextElement",
+            },
+          ]
+        `);
+    });
+    test('handles span with attributes', () => {
+        const result = parseHtmlToMdxAst({
+            html: '<span color="blue">colored text</span>',
+        });
+        expect(result).toMatchInlineSnapshot(`
+          [
+            {
+              "attributes": [
+                {
+                  "name": "color",
+                  "type": "mdxJsxAttribute",
+                  "value": "blue",
+                },
+              ],
+              "children": [
+                {
+                  "type": "text",
+                  "value": "colored text",
+                },
+              ],
+              "name": "span",
+              "type": "mdxJsxTextElement",
+            },
+          ]
+        `);
+    });
+    test('handles mixed content', () => {
+        const result = parseHtmlToMdxAst({
+            html: 'Some text <strong>bold</strong> more text',
+        });
+        expect(result).toMatchInlineSnapshot(`
+          [
+            {
+              "type": "text",
+              "value": "Some text ",
+            },
+            {
+              "attributes": [],
+              "children": [
+                {
+                  "type": "text",
+                  "value": "bold",
+                },
+              ],
+              "name": "strong",
+              "type": "mdxJsxTextElement",
+            },
+            {
+              "type": "text",
+              "value": " more text",
+            },
+          ]
+        `);
+    });
+    test('handles comments', () => {
+        const result = parseHtmlToMdxAst({ html: '<!-- This is a comment -->' });
+        expect(result).toMatchInlineSnapshot(`[]`);
+    });
+    test('handles table with attributes', () => {
+        const result = parseHtmlToMdxAst({
+            html: '<table class="data-table"><tr><td>Cell</td></tr></table>',
+        });
+        expect(result).toMatchInlineSnapshot(`
+          [
+            {
+              "attributes": [
+                {
+                  "name": "className",
+                  "type": "mdxJsxAttribute",
+                  "value": "data-table",
+                },
+              ],
+              "children": [
+                {
+                  "attributes": [],
+                  "children": [
+                    {
+                      "attributes": [],
+                      "children": [
+                        {
+                          "type": "text",
+                          "value": "Cell",
+                        },
+                      ],
+                      "name": "td",
+                      "type": "mdxJsxTextElement",
+                    },
+                  ],
+                  "name": "tr",
+                  "type": "mdxJsxTextElement",
+                },
+              ],
+              "name": "table",
+              "type": "mdxJsxTextElement",
+            },
+          ]
+        `);
+    });
+});
+describe('parseHtmlToMdxAst with markdown processor', () => {
+    test('parses markdown inside HTML tags', async () => {
+        const htmlToConvert = '<div>This is **bold** text</div>';
+        const result = await htmlToMdxString({
+            html: htmlToConvert,
+            withProcessor: true,
+            onError: (e) => {
+                throw e;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+          {
+            "html": "<div>This is <strong>bold</strong> text</div>",
+            "mdx": "<div>This is **bold** text</div>
+          ",
+          }
+        `);
+    });
+    test('handles mixed markdown and HTML inside tags', async () => {
+        const htmlToConvert = '<div>**Bold text:** <a href="#">link</a></div>';
+        const result = await htmlToMdxString({
+            html: htmlToConvert,
+            withProcessor: true,
+            onError: (e) => {
+                throw e;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+          {
+            "html": "<div><strong>Bold text:</strong><a href="#">link</a></div>",
+            "mdx": "<div>**Bold text:**<a href="#">link</a></div>
+          ",
+          }
+        `);
+    });
+    test('handles markdown inside table cells', async () => {
+        const htmlToConvert = '<table><tr><td>**Bold** text and [link](http://example.com)</td></tr></table>';
+        const result = await htmlToMdxString({
+            html: htmlToConvert,
+            withProcessor: true,
+            onError: (e) => {
+                throw e;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+          {
+            "html": "<table><tr><td><strong>Bold</strong> text and <a href="http://example.com" title="">link</a></td></tr></table>",
+            "mdx": "<table><tr><td>**Bold** text and [link](http://example.com)</td></tr></table>
+          ",
+          }
+        `);
+    });
+    test('preserves plain text when no markdown', async () => {
+        const htmlToConvert = '<div>Plain text without markdown</div>';
+        const result = await htmlToMdxString({
+            html: htmlToConvert,
+            withProcessor: true,
+            onError: (e) => {
+                throw e;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+          {
+            "html": "<div>Plain text without markdown</div>",
+            "mdx": "<div>Plain text without markdown</div>
+          ",
+          }
+        `);
+    });
+    test('handles nested HTML tags with markdown', async () => {
+        const htmlToConvert = '<div><span>**Bold** and <a href="#">link</a></span></div>';
+        const result = await htmlToMdxString({
+            html: htmlToConvert,
+            withProcessor: true,
+            onError: (e) => {
+                throw e;
+            },
+        });
+        expect(result).toMatchInlineSnapshot(`
+          {
+            "html": "<div><span><strong>Bold</strong> and<a href="#">link</a></span></div>",
+            "mdx": "<div><span>**Bold** and<a href="#">link</a></span></div>
+          ",
+          }
+        `);
+    });
+    test('normalize plugin without parentType does not apply', () => {
+        // Without parentType, normalization should not happen
+        const withoutParent = htmlToMdxAst({
+            html: '<span>Text</span>'
+        });
+        // Without normalization, elements remain as initially created (text elements)
+        expect(withoutParent).toHaveLength(1);
+        expect(withoutParent[0]).toMatchObject({
+            type: 'mdxJsxTextElement',
+            name: 'span'
+        });
+    });
+    test('applies normalize plugin with parentType', () => {
+        // Test with a block element inside a paragraph (phrasing context)
+        const blockInParagraph = htmlToMdxAst({
+            html: '<div>Block in paragraph</div>',
+            parentType: 'paragraph'
+        });
+        // Even though div is a block element, it should remain mdxJsxFlowElement
+        // because block-level tags have priority
+        expect(blockInParagraph).toHaveLength(1);
+        expect(blockInParagraph[0]).toMatchObject({
+            type: 'mdxJsxFlowElement',
+            name: 'div'
+        });
+        // Test with inline element in paragraph (should be text element)
+        const inlineInParagraph = htmlToMdxAst({
+            html: '<span>Inline in paragraph</span>',
+            parentType: 'paragraph'
+        });
+        expect(inlineInParagraph).toHaveLength(1);
+        expect(inlineInParagraph[0]).toMatchObject({
+            type: 'mdxJsxTextElement',
+            name: 'span'
+        });
+        // Test with inline element in root (should be flow element)
+        const inlineInRoot = htmlToMdxAst({
+            html: '<span>Inline in root</span>',
+            parentType: 'root'
+        });
+        expect(inlineInRoot).toHaveLength(1);
+        expect(inlineInRoot[0]).toMatchObject({
+            type: 'mdxJsxFlowElement',
+            name: 'span'
+        });
+        // Test with multiple elements
+        const multipleElements = htmlToMdxAst({
+            html: '<span>First</span><div>Second</div>',
+            parentType: 'paragraph'
+        });
+        expect(multipleElements).toHaveLength(2);
+        expect(multipleElements[0]).toMatchObject({
+            type: 'mdxJsxTextElement',
+            name: 'span'
+        });
+        expect(multipleElements[1]).toMatchObject({
+            type: 'mdxJsxFlowElement',
+            name: 'div'
+        });
+        // Test with nested elements - the normalize plugin should handle nested context correctly
+        const nestedElements = htmlToMdxAst({
+            html: '<div><span>Nested span</span><p><em>Emphasis</em></p></div>',
+            parentType: 'root'
+        });
+        // The plugin normalizes based on the entire tree structure
+        expect(nestedElements).toHaveLength(1);
+        expect(nestedElements[0]).toMatchObject({
+            type: 'mdxJsxFlowElement',
+            name: 'div',
+            children: expect.arrayContaining([
+                expect.objectContaining({
+                    type: 'mdxJsxFlowElement',
+                    name: 'span'
+                }),
+                expect.objectContaining({
+                    type: 'mdxJsxFlowElement',
+                    name: 'p',
+                    children: expect.arrayContaining([
+                        expect.objectContaining({
+                            type: 'mdxJsxTextElement',
+                            name: 'em'
+                        })
+                    ])
+                })
+            ])
+        });
+    });
+});
+//# sourceMappingURL=html-to-mdx-ast.test.js.map