n8n-nodes-notion-advanced 1.2.26-beta → 1.2.28-beta

package/nodes/NotionAdvanced/NotionAITool.node.d.ts

@@ -55,6 +55,7 @@ export declare class NotionAITool implements INodeType {
     static processNestedHtmlInListItem(content: string): string;
     static convertInlineHtmlToMarkdown(content: string): string;
     static processNestedList(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[]): void;
+    static extractListItems(content: string): string[];
     static getCalloutEmoji(type: string): string;
     static getCalloutColor(type: string): string;
     static parseBasicMarkdown(text: string): IDataObject[];

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -837,7 +837,34 @@ class NotionAITool {
     static processXMLTreeDepthFirst(nodes, blocks, placeholderCounter) {
         const replacements = new Map();
         const processNode = (node) => {
-            // First, process all children depth-first
+            // For lists, use the original match content to preserve structure
+            // This is the only case where we skip child processing to avoid fragmentation
+            if (node.listProcessor && (node.tagName === 'ul' || node.tagName === 'ol')) {
+                try {
+                    // Extract inner content directly from the original match
+                    const tagName = node.tagName.toLowerCase();
+                    const openTagRegex = new RegExp(`^<${tagName}[^>]*>`, 'i');
+                    const closeTagRegex = new RegExp(`</${tagName}>$`, 'i');
+                    let innerContent = node.match;
+                    const openMatch = node.match.match(openTagRegex);
+                    const closeMatch = node.match.match(closeTagRegex);
+                    if (openMatch && closeMatch) {
+                        const openTag = openMatch[0];
+                        const closeTag = closeMatch[0];
+                        const startIndex = openTag.length;
+                        const endIndex = node.match.length - closeTag.length;
+                        innerContent = node.match.substring(startIndex, endIndex);
+                    }
+                    // Process the list with complete content
+                    node.listProcessor(innerContent, blocks);
+                    return ''; // Remove completely - no placeholder needed
+                }
+                catch (error) {
+                    console.warn(`Error processing list node ${node.tagName}:`, error);
+                    return ''; // Remove even on error to prevent artifacts
+                }
+            }
+            // For non-list nodes, process children first (normal hierarchical processing)
             for (const child of node.children) {
                 const childReplacement = processNode(child);
                 replacements.set(child.id, childReplacement);
@@ -876,21 +903,16 @@ class NotionAITool {
             }
             // Process this node with updated inner content
             try {
-                // Handle special list processors
-                if (node.listProcessor && (node.tagName === 'ul' || node.tagName === 'ol')) {
-                    node.listProcessor(innerContent, blocks);
-                    return `__BLOCK_${placeholderCounter.value++}__`;
-                }
                 // Use blockCreator to create the block
                 const block = node.processor(...node.groups);
                 if (block) {
                     blocks.push(block);
                 }
-                return `__BLOCK_${placeholderCounter.value++}__`;
+                return ''; // Remove completely - no placeholder needed
             }
             catch (error) {
                 console.warn(`Error processing XML node ${node.tagName}:`, error);
-                return node.match; // Return original if processing fails
+                return ''; // Remove even on error to prevent artifacts
             }
         };
         // Process all root nodes
@@ -1203,9 +1225,7 @@ class NotionAITool {
             const replacements = NotionAITool.processXMLTreeDepthFirst(xmlTree, blocks, counterRef);
             // Step 3: Apply hierarchical replacements to content
             processedContent = NotionAITool.applyHierarchicalReplacements(processedContent, xmlTree, replacements);
-            // Step 4: Immediately replace all placeholders with empty strings since blocks are already in blocks array
-            processedContent = NotionAITool.cleanupAllPlaceholders(processedContent);
-            // Step 5: Clean up any remaining HTML tags
+            // Step 4: Clean up any remaining HTML tags
             processedContent = NotionAITool.cleanupRemainingHtml(processedContent);
             if (DEBUG_ORDERING) {
                 console.log(`Processed ${xmlTree.length} root XML nodes hierarchically, created ${blocks.length} blocks`);
@@ -1229,11 +1249,11 @@ class NotionAITool {
                                 if (block) {
                                     blocks.push(block);
                                 }
-                                return `__BLOCK_${placeholderCounter++}__`;
+                                return ''; // Remove completely - no placeholder needed
                             }
                             catch (error) {
                                 console.warn('Error in fallback processor:', error);
-                                return match;
+                                return ''; // Remove even on error
                             }
                         },
                         groups: match.slice(1)
@@ -1401,61 +1421,28 @@ class NotionAITool {
         if (!processed)
             return '';
         try {
-            // Handle multiple segments separated by HTML block elements
-            const segments = [];
-            // Split by block-level HTML elements like <p>, <div>, etc.
-            const blockElements = /<(p|div|h[1-6]|blockquote)\s*[^>]*>.*?<\/\1>/gis;
-            let lastIndex = 0;
-            let match;
-            const blockMatches = [];
-            while ((match = blockElements.exec(processed)) !== null) {
-                blockMatches.push({
-                    start: match.index,
-                    end: match.index + match[0].length,
-                    content: match[0],
-                    tag: match[1]
-                });
-            }
-            // Sort matches by position
-            blockMatches.sort((a, b) => a.start - b.start);
-            // Process text segments between block elements
-            blockMatches.forEach((blockMatch, index) => {
-                // Add text before this block element
-                if (blockMatch.start > lastIndex) {
-                    const beforeText = processed.substring(lastIndex, blockMatch.start).trim();
-                    if (beforeText) {
-                        segments.push(NotionAITool.convertInlineHtmlToMarkdown(beforeText));
-                    }
-                }
-                // Process content inside block element
-                const innerContent = blockMatch.content.replace(new RegExp(`^<${blockMatch.tag}[^>]*>`, 'i'), '')
-                    .replace(new RegExp(`</${blockMatch.tag}>$`, 'i'), '')
-                    .trim();
-                if (innerContent) {
-                    segments.push(NotionAITool.convertInlineHtmlToMarkdown(innerContent));
-                }
-                lastIndex = blockMatch.end;
-            });
-            // Add remaining text after last block element
-            if (lastIndex < processed.length) {
-                const remainingText = processed.substring(lastIndex).trim();
-                if (remainingText) {
-                    segments.push(NotionAITool.convertInlineHtmlToMarkdown(remainingText));
-                }
-            }
-            // If no block elements were found, process the whole content
-            if (blockMatches.length === 0) {
-                segments.push(NotionAITool.convertInlineHtmlToMarkdown(processed));
-            }
-            // Join segments with space and clean up
-            const result = segments.filter(s => s.trim()).join(' ').trim();
-            // Final cleanup of any remaining artifacts
-            return result.replace(/\s+/g, ' ').trim();
+            // First, aggressively remove any nested list tags and their content
+            // This prevents XML fragments from appearing in the final content
+            processed = processed.replace(/<[uo]l\s*[^>]*>[\s\S]*?<\/[uo]l>/gi, '');
+            // Remove any standalone list item tags that might be left behind
+            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
+            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: just remove HTML tags and return text
-            return processed.replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim();
+            // Fallback: aggressively remove all HTML tags and return clean text
+            return processed
+                .replace(/<[^>]*>/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
         }
     }
     // Helper function to convert inline HTML to markdown
@@ -1493,49 +1480,36 @@ class NotionAITool {
     // Helper function to process nested lists and flatten them for Notion
     static processNestedList(listContent, listType, blocks) {
         try {
-            // More robust list item extraction using regex
-            const liRegex = /<li[^>]*>([\s\S]*?)<\/li>/gi;
-            let match;
-            while ((match = liRegex.exec(listContent)) !== null) {
-                let itemContent = match[1].trim();
-                if (!itemContent)
+            // More robust list item extraction that handles nested <li> tags properly
+            const listItems = NotionAITool.extractListItems(listContent);
+            for (const itemContent of listItems) {
+                if (!itemContent.trim())
                     continue;
                 // Check if this item contains nested lists
                 const hasNestedList = /<[uo]l\s*[^>]*>/i.test(itemContent);
                 if (hasNestedList) {
-                    // Split content into parts: before nested list, nested list, after nested list
-                    const parts = itemContent.split(/(<[uo]l\s*[^>]*>[\s\S]*?<\/[uo]l>)/i);
-                    // Process the main content (before nested list)
-                    const mainContent = parts[0] ? parts[0].trim() : '';
-                    if (mainContent) {
-                        const cleanContent = NotionAITool.processNestedHtmlInListItem(mainContent);
-                        if (cleanContent) {
-                            blocks.push({
-                                type: listType,
-                                [listType]: {
-                                    rich_text: NotionAITool.parseBasicMarkdown(cleanContent),
-                                },
-                            });
-                        }
-                    }
-                    // Process nested lists
-                    for (let i = 1; i < parts.length; i += 2) {
-                        const nestedListHtml = parts[i];
-                        if (nestedListHtml) {
-                            const nestedListMatch = nestedListHtml.match(/<([uo]l)\s*[^>]*>([\s\S]*?)<\/\1>/i);
+                    // Split content into text parts and nested list parts
+                    const parts = itemContent.split(/(<[uo]l\s*[^>]*>[\s\S]*?<\/[uo]l>)/gi);
+                    for (let i = 0; i < parts.length; i++) {
+                        const part = parts[i].trim();
+                        if (!part)
+                            continue;
+                        // Check if this part is a nested list
+                        const isNestedList = /<[uo]l\s*[^>]*>[\s\S]*?<\/[uo]l>/gi.test(part);
+                        if (isNestedList) {
+                            // Process the nested list
+                            const nestedListMatch = part.match(/<([uo]l)\s*[^>]*>([\s\S]*?)<\/\1>/i);
                             if (nestedListMatch) {
-                                const [, nestedListTag, nestedContent] = nestedListMatch;
-                                const nestedListType = nestedListTag === 'ul' ? 'bulleted_list_item' : 'numbered_list_item';
+                                const [, listTag, innerContent] = nestedListMatch;
+                                const nestedListType = listTag === 'ul' ? 'bulleted_list_item' : 'numbered_list_item';
                                 // Recursively process nested list
-                                NotionAITool.processNestedList(nestedContent, nestedListType, blocks);
+                                NotionAITool.processNestedList(innerContent, nestedListType, blocks);
                             }
                         }
-                    }
-                    // Process any content after nested lists
-                    if (parts.length > 2) {
-                        const afterContent = parts.slice(2).join('').trim();
-                        if (afterContent) {
-                            const cleanContent = NotionAITool.processNestedHtmlInListItem(afterContent);
+                        else {
+                            // This is text content - clean it and add as a list item
+                            // Only process non-empty text parts as separate list items
+                            const cleanContent = NotionAITool.processNestedHtmlInListItem(part);
                             if (cleanContent) {
                                 blocks.push({
                                     type: listType,
@@ -1572,6 +1546,62 @@ class NotionAITool {
             });
         }
     }
+    // Helper function to properly extract list items handling nested <li> tags
+    static extractListItems(content) {
+        const items = [];
+        let currentPos = 0;
+        while (currentPos < content.length) {
+            // Find the next <li> opening tag
+            const liStart = content.indexOf('<li', currentPos);
+            if (liStart === -1)
+                break;
+            // Find the end of the opening tag
+            const openTagEnd = content.indexOf('>', liStart);
+            if (openTagEnd === -1)
+                break;
+            // Now find the matching closing </li> tag accounting for nesting
+            let depth = 1;
+            let pos = openTagEnd + 1;
+            let itemEnd = -1;
+            while (pos < content.length && depth > 0) {
+                const nextLiOpen = content.indexOf('<li', pos);
+                const nextLiClose = content.indexOf('</li>', pos);
+                // If no more closing tags, we're done
+                if (nextLiClose === -1)
+                    break;
+                // If there's an opening tag before the next closing tag, increase depth
+                if (nextLiOpen !== -1 && nextLiOpen < nextLiClose) {
+                    depth++;
+                    pos = nextLiOpen + 3; // Move past '<li'
+                }
+                else {
+                    // Found a closing tag
+                    depth--;
+                    if (depth === 0) {
+                        itemEnd = nextLiClose + 5; // Include the '</li>'
+                        break;
+                    }
+                    else {
+                        pos = nextLiClose + 5; // Move past '</li>'
+                    }
+                }
+            }
+            if (itemEnd !== -1) {
+                // Extract the content between <li...> and </li>
+                const fullMatch = content.substring(liStart, itemEnd);
+                const innerMatch = fullMatch.match(/<li[^>]*>([\s\S]*)<\/li>$/);
+                if (innerMatch) {
+                    items.push(innerMatch[1]);
+                }
+                currentPos = itemEnd;
+            }
+            else {
+                // Malformed HTML, skip this tag
+                currentPos = openTagEnd + 1;
+            }
+        }
+        return items;
+    }
     // Helper function to get callout emoji based on type
     static getCalloutEmoji(type) {
         const emojiMap = {

package/package.json

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