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

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -1544,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);
@@ -1553,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 = {
@@ -1571,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) {
@@ -1603,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);
@@ -1830,8 +1834,9 @@ class NotionAITool {
                 continue;
             }
             const item = { text: '', children: [] };
-            // STEP 1: Remove child block XML from content to get clean parent text
+            // 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',
@@ -1839,14 +1844,181 @@ class NotionAITool {
                 'todo', 'toggle', 'image', 'embed', 'bookmark',
                 'equation', 'divider'
             ];
-            // Remove child block XML from parent text
+            // Extract child blocks first, then remove from parent text
             childBlockTags.forEach(tag => {
-                // Remove both self-closing and paired tags
+                // 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');
-                const pairedRegex = new RegExp(`<${tag}[^>]*>.*?<\\/${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 = [];
@@ -1932,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.33-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": [