n8n-nodes-notion-advanced 1.2.32-beta → 1.2.34-beta

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -1487,21 +1487,27 @@ class NotionAITool {
             processed = processed.replace(/<\/?li\s*[^>]*>/gi, '');
             // Remove any other common list-related fragments
             processed = processed.replace(/<\/?[uo]l\s*[^>]*>/gi, '');
-            // Simple cleanup - just remove remaining HTML tags and clean whitespace
-            // Avoid convertInlineHtmlToMarkdown to prevent duplication issues
+            // Convert inline HTML formatting to markdown BEFORE removing tags
+            processed = NotionAITool.convertInlineHtmlToMarkdown(processed);
+            // Final cleanup of any remaining unhandled tags
             const result = processed
-                .replace(/<[^>]*>/g, ' ') // Remove any remaining HTML tags
                 .replace(/\s+/g, ' ') // Clean up whitespace
                 .trim();
             return result;
         }
         catch (error) {
             console.warn('Error processing nested HTML in list item:', error);
-            // Fallback: aggressively remove all HTML tags and return clean text
-            return processed
-                .replace(/<[^>]*>/g, ' ')
-                .replace(/\s+/g, ' ')
-                .trim();
+            // Fallback: convert inline HTML then remove any remaining tags
+            try {
+                const fallback = NotionAITool.convertInlineHtmlToMarkdown(processed);
+                return fallback.replace(/\s+/g, ' ').trim();
+            }
+            catch (fallbackError) {
+                return processed
+                    .replace(/<[^>]*>/g, ' ')
+                    .replace(/\s+/g, ' ')
+                    .trim();
+            }
         }
     }
     // Helper function to convert inline HTML to markdown
@@ -1538,7 +1544,6 @@ class NotionAITool {
     }
     // Build hierarchy structure for lists using HierarchyNode approach
     static buildListHierarchy(listContent, listType, childHierarchyNodes) {
-        var _a;
         try {
             // Process each <li> element and build hierarchy
             const listItems = NotionAITool.extractListItemsWithBranching(listContent);
@@ -1547,7 +1552,7 @@ class NotionAITool {
             const listItemPositions = NotionAITool.getListItemPositions(listContent);
             for (let i = 0; i < listItems.length; i++) {
                 const item = listItems[i];
-                if (!item.text && !item.children.length)
+                if (!item.text && !item.children.length && !(item.extractedChildBlocks && item.extractedChildBlocks.length > 0))
                     continue;
                 // Create list item block
                 const listItemBlock = {
@@ -1565,19 +1570,24 @@ class NotionAITool {
                 }
                 // Collect child hierarchy nodes for this list item based on position mapping
                 const itemChildNodes = [];
-                // Map child hierarchy nodes that belong to this specific list item
-                if (i < listItemPositions.length) {
-                    const currentItemStart = listItemPositions[i].start;
-                    const currentItemEnd = listItemPositions[i].end;
-                    for (const childNode of childHierarchyNodes) {
-                        const childPosition = (_a = childNode.metadata) === null || _a === void 0 ? void 0 : _a.sourcePosition;
-                        if (childPosition !== undefined &&
-                            childPosition >= currentItemStart &&
-                            childPosition < currentItemEnd) {
-                            itemChildNodes.push(childNode);
-                        }
+                // Add extracted child blocks (from XML tags within list items)
+                // These are the primary source for child blocks in list items
+                if (item.extractedChildBlocks && Array.isArray(item.extractedChildBlocks)) {
+                    const extractedBlocks = item.extractedChildBlocks;
+                    for (const block of extractedBlocks) {
+                        itemChildNodes.push({
+                            block,
+                            children: [],
+                            metadata: {
+                                sourcePosition: i,
+                                tagName: block.type
+                            }
+                        });
                     }
                 }
+                // Note: We prioritize extractedChildBlocks over childHierarchyNodes for list items
+                // since list-specific processing in extractListItemsWithBranching is more accurate
+                // for handling child blocks within <li> elements
                 // Process nested list children (traditional nested lists)
                 if (item.children.length > 0) {
                     for (const child of item.children) {
@@ -1597,7 +1607,7 @@ class NotionAITool {
                         tagName: listType
                     }
                 };
-                // Only add if it has content or children
+                // Only add if it has content or children (including extracted child blocks)
                 const listData = listItemBlock[listType];
                 if ((listData.rich_text && listData.rich_text.length > 0) || itemChildNodes.length > 0) {
                     listItemHierarchyNodes.push(listItemHierarchyNode);
@@ -1824,13 +1834,198 @@ class NotionAITool {
                 continue;
             }
             const item = { text: '', children: [] };
-            // Process the content to separate text from nested lists
+            // STEP 1: Extract and convert child block XML to actual blocks before removing from parent text
+            let parentTextContent = fullItemContent;
+            const extractedChildBlocks = [];
+            // List of XML tags that create child blocks (these should be removed from parent text)
+            const childBlockTags = [
+                'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+                'blockquote', 'quote', 'callout', 'code', 'pre',
+                'todo', 'toggle', 'image', 'embed', 'bookmark',
+                'equation', 'divider'
+            ];
+            // Extract child blocks first, then remove from parent text
+            childBlockTags.forEach(tag => {
+                // Extract and process paired tags first
+                const pairedRegex = new RegExp(`<${tag}[^>]*>(.*?)<\\/${tag}>`, 'gis');
+                let match;
+                while ((match = pairedRegex.exec(parentTextContent)) !== null) {
+                    const fullMatch = match[0];
+                    const content = match[1];
+                    // Create child block based on tag type
+                    try {
+                        let childBlock = null;
+                        switch (tag) {
+                            case 'embed':
+                                childBlock = {
+                                    type: 'embed',
+                                    embed: { url: content.trim() }
+                                };
+                                break;
+                            case 'bookmark':
+                                childBlock = {
+                                    type: 'bookmark',
+                                    bookmark: { url: content.trim() }
+                                };
+                                break;
+                            case 'p':
+                                const markdownContent = NotionAITool.convertInlineHtmlToMarkdown(content.trim());
+                                childBlock = {
+                                    type: 'paragraph',
+                                    paragraph: { rich_text: NotionAITool.parseBasicMarkdown(markdownContent) }
+                                };
+                                break;
+                            case 'h1':
+                            case 'h2':
+                            case 'h3':
+                                const headingType = `heading_${tag.charAt(1)}`;
+                                childBlock = {
+                                    type: headingType,
+                                    [headingType]: { rich_text: [{ type: 'text', text: { content: content.trim() } }] }
+                                };
+                                break;
+                            case 'quote':
+                            case 'blockquote':
+                                childBlock = {
+                                    type: 'quote',
+                                    quote: { rich_text: NotionAITool.parseBasicMarkdown(content.trim()) }
+                                };
+                                break;
+                            case 'callout':
+                                // Extract type attribute if present
+                                const typeMatch = fullMatch.match(/type="([^"]*)"/);
+                                const calloutType = typeMatch ? typeMatch[1] : 'info';
+                                const emoji = NotionAITool.getCalloutEmoji(calloutType.toLowerCase());
+                                const color = NotionAITool.getCalloutColor(calloutType.toLowerCase());
+                                childBlock = {
+                                    type: 'callout',
+                                    callout: {
+                                        rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                                        icon: { type: 'emoji', emoji },
+                                        color: color
+                                    }
+                                };
+                                break;
+                            case 'code':
+                            case 'pre':
+                                // Extract language attribute if present
+                                const langMatch = fullMatch.match(/language="([^"]*)"/);
+                                const language = langMatch ? langMatch[1] : 'plain_text';
+                                childBlock = {
+                                    type: 'code',
+                                    code: {
+                                        rich_text: [{ type: 'text', text: { content: content.trim() } }],
+                                        language: language === 'plain text' ? 'plain_text' : language
+                                    }
+                                };
+                                break;
+                            case 'todo':
+                                // Extract checked attribute if present
+                                const checkedMatch = fullMatch.match(/checked="([^"]*)"/);
+                                const isChecked = checkedMatch ? checkedMatch[1].toLowerCase() === 'true' : false;
+                                childBlock = {
+                                    type: 'to_do',
+                                    to_do: {
+                                        rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                                        checked: isChecked
+                                    }
+                                };
+                                break;
+                            case 'toggle':
+                                childBlock = {
+                                    type: 'toggle',
+                                    toggle: {
+                                        rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                                        children: []
+                                    }
+                                };
+                                break;
+                            case 'equation':
+                                childBlock = {
+                                    type: 'equation',
+                                    equation: { expression: content.trim() }
+                                };
+                                break;
+                            case 'image':
+                                // Extract src and alt attributes
+                                const srcMatch = fullMatch.match(/src="([^"]*)"/);
+                                const altMatch = fullMatch.match(/alt="([^"]*)"/);
+                                const src = srcMatch ? srcMatch[1] : '';
+                                const alt = altMatch ? altMatch[1] : '';
+                                const caption = content.trim() || alt;
+                                childBlock = {
+                                    type: 'image',
+                                    image: {
+                                        type: 'external',
+                                        external: { url: src },
+                                        caption: caption ? NotionAITool.parseBasicMarkdown(caption) : []
+                                    }
+                                };
+                                break;
+                            case 'divider':
+                                childBlock = {
+                                    type: 'divider',
+                                    divider: {}
+                                };
+                                break;
+                        }
+                        if (childBlock) {
+                            extractedChildBlocks.push(childBlock);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error creating child block for tag ${tag}:`, error);
+                    }
+                }
+                // Handle self-closing tags (mainly for divider, image)
+                const selfClosingRegex = new RegExp(`<${tag}[^>]*\\/>`, 'gis');
+                let selfMatch;
+                while ((selfMatch = selfClosingRegex.exec(parentTextContent)) !== null) {
+                    const fullMatch = selfMatch[0];
+                    try {
+                        let childBlock = null;
+                        if (tag === 'divider') {
+                            childBlock = {
+                                type: 'divider',
+                                divider: {}
+                            };
+                        }
+                        else if (tag === 'image') {
+                            // Extract src and alt attributes
+                            const srcMatch = fullMatch.match(/src="([^"]*)"/);
+                            const altMatch = fullMatch.match(/alt="([^"]*)"/);
+                            const src = srcMatch ? srcMatch[1] : '';
+                            const alt = altMatch ? altMatch[1] : '';
+                            childBlock = {
+                                type: 'image',
+                                image: {
+                                    type: 'external',
+                                    external: { url: src },
+                                    caption: alt ? NotionAITool.parseBasicMarkdown(alt) : []
+                                }
+                            };
+                        }
+                        if (childBlock) {
+                            extractedChildBlocks.push(childBlock);
+                        }
+                    }
+                    catch (error) {
+                        console.warn(`Error creating self-closing child block for tag ${tag}:`, error);
+                    }
+                }
+                // Now remove both paired and self-closing tags from parent text
+                parentTextContent = parentTextContent.replace(pairedRegex, '');
+                parentTextContent = parentTextContent.replace(selfClosingRegex, '');
+            });
+            // Store extracted child blocks in the item for later use
+            item.extractedChildBlocks = extractedChildBlocks;
+            // STEP 2: Process the content to separate remaining text from nested lists
             let contentPos = 0;
             let textParts = [];
-            while (contentPos < fullItemContent.length) {
+            while (contentPos < parentTextContent.length) {
                 // Look for the next nested list (ul or ol)
-                const nextUlStart = fullItemContent.indexOf('<ul', contentPos);
-                const nextOlStart = fullItemContent.indexOf('<ol', contentPos);
+                const nextUlStart = parentTextContent.indexOf('<ul', contentPos);
+                const nextOlStart = parentTextContent.indexOf('<ol', contentPos);
                 let nextListStart = -1;
                 let listType = '';
                 if (nextUlStart !== -1 && (nextOlStart === -1 || nextUlStart < nextOlStart)) {
@@ -1843,22 +2038,22 @@ class NotionAITool {
                 }
                 if (nextListStart === -1) {
                     // No more nested lists - add remaining text
-                    const remainingText = fullItemContent.substring(contentPos);
+                    const remainingText = parentTextContent.substring(contentPos);
                     if (remainingText.trim()) {
                         textParts.push(remainingText);
                     }
                     break;
                 }
                 // Add text before the nested list
-                const textBefore = fullItemContent.substring(contentPos, nextListStart);
+                const textBefore = parentTextContent.substring(contentPos, nextListStart);
                 if (textBefore.trim()) {
                     textParts.push(textBefore);
                 }
                 // Find the end of this nested list
-                const listOpenEnd = fullItemContent.indexOf('>', nextListStart);
+                const listOpenEnd = parentTextContent.indexOf('>', nextListStart);
                 if (listOpenEnd === -1) {
                     // Malformed list tag
-                    textParts.push(fullItemContent.substring(contentPos));
+                    textParts.push(parentTextContent.substring(contentPos));
                     break;
                 }
                 // Track depth to find the matching closing tag
@@ -1867,9 +2062,9 @@ class NotionAITool {
                 let listEnd = -1;
                 const openTag = `<${listType}`;
                 const closeTag = `</${listType}>`;
-                while (listSearchPos < fullItemContent.length && listDepth > 0) {
-                    const nextListOpen = fullItemContent.indexOf(openTag, listSearchPos);
-                    const nextListClose = fullItemContent.indexOf(closeTag, listSearchPos);
+                while (listSearchPos < parentTextContent.length && listDepth > 0) {
+                    const nextListOpen = parentTextContent.indexOf(openTag, listSearchPos);
+                    const nextListClose = parentTextContent.indexOf(closeTag, listSearchPos);
                     if (nextListClose === -1)
                         break;
                     if (nextListOpen !== -1 && nextListOpen < nextListClose) {
@@ -1886,7 +2081,8 @@ class NotionAITool {
                     }
                 }
                 if (listEnd !== -1) {
-                    // Extract the content between <ul>/<ol> and </ul>/<ol>
+                    // Extract the content between <ul>/<ol> and </ul>/<ol> from ORIGINAL content
+                    // (not parentTextContent which has child blocks removed)
                     const listContent = fullItemContent.substring(listOpenEnd + 1, listEnd - closeTag.length);
                     item.children.push({
                         type: listType,
@@ -1896,7 +2092,7 @@ class NotionAITool {
                 }
                 else {
                     // Malformed nested list - treat remaining as text
-                    textParts.push(fullItemContent.substring(contentPos));
+                    textParts.push(parentTextContent.substring(contentPos));
                     break;
                 }
             }
@@ -1908,8 +2104,8 @@ class NotionAITool {
                     item.text = cleanText;
                 }
             }
-            // Only add items that have either text or children
-            if (item.text.trim() || item.children.length > 0) {
+            // Only add items that have either text, children, or extracted child blocks
+            if (item.text.trim() || item.children.length > 0 || (item.extractedChildBlocks && item.extractedChildBlocks.length > 0)) {
                 items.push(item);
             }
             pos = liEnd + 5; // Move past </li>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-notion-advanced",
-  "version": "1.2.32-beta",
+  "version": "1.2.34-beta",
   "description": "Advanced n8n Notion nodes: Full-featured workflow node + AI Agent Tool for intelligent Notion automation with 25+ block types (BETA)",
   "scripts": {},
   "files": [