n8n-nodes-notion-advanced 1.2.20-beta → 1.2.21-beta

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

@@ -43,7 +43,9 @@ export declare class NotionAITool implements INodeType {
     }[]): string;
     static getUtf8BytePosition(str: string, charIndex: number): number;
     static buildXMLTree(content: string, tagProcessors: any[]): XMLNode[];
-    static processXMLTreeDepthFirst(nodes: XMLNode[], blocks: IDataObject[], placeholderPrefix: string): Map<string, string>;
+    static processXMLTreeDepthFirst(nodes: XMLNode[], blocks: IDataObject[], placeholderPrefix: string, placeholderCounter: {
+        value: number;
+    }): Map<string, string>;
     static applyHierarchicalReplacements(content: string, nodes: XMLNode[], replacements: Map<string, string>): string;
     static getAllNodesFromTree(nodes: XMLNode[]): XMLNode[];
     static processXmlTags(content: string, blocks: IDataObject[]): string;

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -480,7 +480,7 @@ class NotionAITool {
         for (let i = 0; i < lines.length; i++) {
             const line = lines[i];
             const trimmedLine = line.trim();
-            // Skip completely empty lines and XML placeholders (now using dynamic prefix check)
+            // Skip completely empty lines and XML placeholders (consistent format check)
             if (!trimmedLine || /__XML_[a-f0-9]{8}_\d+__/.test(trimmedLine))
                 continue;
             // Skip lines that contain XML tag patterns (to prevent double processing)
@@ -789,9 +789,8 @@ class NotionAITool {
         return rootNodes;
     }
     // Process XML tree depth-first (children before parents)
-    static processXMLTreeDepthFirst(nodes, blocks, placeholderPrefix) {
+    static processXMLTreeDepthFirst(nodes, blocks, placeholderPrefix, placeholderCounter) {
         const replacements = new Map();
-        let blockCounter = 0;
         const processNode = (node) => {
             // First, process all children depth-first
             for (const child of node.children) {
@@ -835,14 +834,14 @@ class NotionAITool {
                 // Handle special list processors
                 if (node.listProcessor && (node.tagName === 'ul' || node.tagName === 'ol')) {
                     node.listProcessor(innerContent, blocks);
-                    return `${placeholderPrefix}${blockCounter++}__`;
+                    return `${placeholderPrefix}${placeholderCounter.value++}__`;
                 }
                 // Use blockCreator to create the block
                 const block = node.processor(...node.groups);
                 if (block) {
                     blocks.push(block);
                 }
-                return `${placeholderPrefix}${blockCounter++}__`;
+                return `${placeholderPrefix}${placeholderCounter.value++}__`;
             }
             catch (error) {
                 console.warn(`Error processing XML node ${node.tagName}:`, error);
@@ -888,8 +887,10 @@ class NotionAITool {
     // New hierarchical XML-like tag processing function
     static processXmlTags(content, blocks) {
         let processedContent = content;
-        // Generate unique placeholder prefix to avoid collisions
-        const placeholderPrefix = `__XML_${(0, crypto_1.randomUUID)().slice(0, 8)}_`;
+        // Generate consistent placeholder format: __XML_{uuid8}_{counter}__
+        const placeholderUuid = (0, crypto_1.randomUUID)().slice(0, 8);
+        const placeholderPrefix = `__XML_${placeholderUuid}_`;
+        let placeholderCounter = 0;
         // Debug mode for development
         const DEBUG_ORDERING = process.env.NODE_ENV === 'development';
         // Define all tag processors
@@ -1153,7 +1154,8 @@ class NotionAITool {
                 })));
             }
             // Step 2: Process tree depth-first (children before parents)
-            const replacements = NotionAITool.processXMLTreeDepthFirst(xmlTree, blocks, placeholderPrefix);
+            const counterRef = { value: 0 };
+            const replacements = NotionAITool.processXMLTreeDepthFirst(xmlTree, blocks, placeholderPrefix, counterRef);
             // Step 3: Apply hierarchical replacements to content
             processedContent = NotionAITool.applyHierarchicalReplacements(processedContent, xmlTree, replacements);
             // Step 4: Clean up any remaining HTML tags
@@ -1180,7 +1182,7 @@ class NotionAITool {
                                 if (block) {
                                     blocks.push(block);
                                 }
-                                return `${placeholderPrefix}${Math.random()}__`;
+                                return `${placeholderPrefix}${placeholderCounter++}__`;
                             }
                             catch (error) {
                                 console.warn('Error in fallback processor:', error);
@@ -1212,29 +1214,16 @@ class NotionAITool {
     // Cleanup function to remove remaining HTML tags and XML_BLOCK artifacts
     static cleanupRemainingHtml(content, placeholderPrefix) {
         let cleaned = content;
-        // Remove XML_BLOCK placeholder artifacts (support both old and new format)
+        // Simplified placeholder cleanup - use one consistent pattern
         if (placeholderPrefix) {
-            // More aggressive placeholder cleanup with multiple patterns
-            const placeholderPatterns = [
-                new RegExp(`${placeholderPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\d+__`, 'g'),
-                new RegExp(`_${placeholderPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\d+_`, 'g'),
-                new RegExp(`${placeholderPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\d+`, 'g')
-            ];
-            placeholderPatterns.forEach(pattern => {
-                cleaned = cleaned.replace(pattern, '');
-            });
+            // Clean up our specific placeholder format: __XML_{uuid8}_{number}__
+            const escapedPrefix = placeholderPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const placeholderPattern = new RegExp(`${escapedPrefix}\\d+__`, 'g');
+            cleaned = cleaned.replace(placeholderPattern, '');
         }
-        // Comprehensive fallback cleanup for all possible placeholder formats
-        const fallbackPatterns = [
-            /__XML_BLOCK_\d+__/g,
-            /__XML_[a-f0-9]{8}_\d+__/g,
-            /_XML_[a-f0-9]{8}_\d+_/g,
-            /__XML_[a-f0-9-]+_\d+__/g,
-            /_XML_[a-f0-9-]+_\d+_/g
-        ];
-        fallbackPatterns.forEach(pattern => {
-            cleaned = cleaned.replace(pattern, '');
-        });
+        // Single fallback cleanup for the standard format only
+        const standardPlaceholderPattern = /__XML_[a-f0-9]{8}_\d+__/g;
+        cleaned = cleaned.replace(standardPlaceholderPattern, '');
         // Remove entire lines containing XML content to prevent double processing
         const xmlContentLines = [
             /^.*<[^>]+>.*$/gm, // Any line with XML/HTML tags
@@ -1283,20 +1272,6 @@ class NotionAITool {
         cleaned = cleaned.replace(/^\s*[\r\n]/gm, '');
         // Remove multiple consecutive line breaks
         cleaned = cleaned.replace(/\n{3,}/g, '\n\n');
-        // Remove lines that contain only XML_BLOCK artifacts (more patterns)
-        const artifactPatterns = [
-            /^.*__XML_BLOCK_\d+__.*$/gm,
-            /^.*__XML_[a-f0-9]{8}_\d+__.*$/gm,
-            /^.*_XML_[a-f0-9]{8}_\d+_.*$/gm,
-            /^.*__XML_[a-f0-9-]+_\d+__.*$/gm,
-            /^.*_XML_[a-f0-9-]+_\d+_.*$/gm
-        ];
-        artifactPatterns.forEach(pattern => {
-            cleaned = cleaned.replace(pattern, '');
-        });
-        // Final cleanup of any remaining isolated placeholder patterns
-        cleaned = cleaned.replace(/\b_+XML_[a-f0-9-]+_\d+_*\b/g, '');
-        cleaned = cleaned.replace(/\b_*XML_[a-f0-9-]+_\d+_+\b/g, '');
         return cleaned.trim();
     }
     // Helper function to process nested HTML elements in list items
@@ -1365,12 +1340,12 @@ class NotionAITool {
     // Helper function to convert inline HTML to markdown
     static convertInlineHtmlToMarkdown(content) {
         let processed = content;
-        // Convert HTML formatting tags to markdown equivalents
+        // Convert HTML formatting tags to markdown equivalents - process in order to handle nested tags
         const htmlToMarkdown = [
             { regex: /<strong\s*[^>]*>(.*?)<\/strong>/gis, replacement: '**$1**' },
             { regex: /<b\s*[^>]*>(.*?)<\/b>/gis, replacement: '**$1**' },
-            { regex: /<em\s*[^>]*>(.*?)<\/em>/gis, replacement: '*$1*' },
-            { regex: /<i\s*[^>]*>(.*?)<\/i>/gis, replacement: '*$1*' },
+            { regex: /<em\s*[^>]*>(.*?)<\/em>/gis, replacement: '_$1_' }, // Use underscore to avoid conflicts
+            { regex: /<i\s*[^>]*>(.*?)<\/i>/gis, replacement: '_$1_' }, // Use underscore to avoid conflicts
             { regex: /<code\s*[^>]*>(.*?)<\/code>/gis, replacement: '`$1`' },
             { regex: /<a\s+href="([^"]*)"[^>]*>(.*?)<\/a>/gis, replacement: '[$2]($1)' },
             { regex: /<u\s*[^>]*>(.*?)<\/u>/gis, replacement: '$1' }, // Notion doesn't support underline
@@ -1512,7 +1487,8 @@ class NotionAITool {
             { regex: /\[([^\]]+)\]\(([^)]+)\)/g, type: 'link' }, // [text](url)
             { regex: /\*\*\*([^*]+)\*\*\*/g, type: 'bold_italic' }, // ***bold italic***
             { regex: /\*\*([^*]+)\*\*/g, type: 'bold' }, // **bold**
-            { regex: /\*([^*]+)\*/g, type: 'italic' }, // *italic*
+            { regex: /_([^_]+)_/g, type: 'italic' }, // _italic_ (changed from *)
+            { regex: /\*([^*]+)\*/g, type: 'italic' }, // *italic* (keep for backward compatibility)
             { regex: /~~([^~]+)~~/g, type: 'strikethrough' }, // ~~strikethrough~~
             { regex: /`([^`]+)`/g, type: 'code' }, // `code`
         ];

package/package.json

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