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

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

@@ -43,10 +43,13 @@ 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[], 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;
+    static decodeHtmlEntities(content: string): string;
     static cleanupRemainingHtml(content: string, placeholderPrefix?: string): string;
     static processNestedHtmlInListItem(content: string): string;
     static convertInlineHtmlToMarkdown(content: string): string;

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotionAITool = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
-const crypto_1 = require("crypto");
 const NotionUtils_1 = require("./NotionUtils");
 class NotionAITool {
     constructor() {
@@ -480,8 +479,8 @@ 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)
-            if (!trimmedLine || /__XML_[a-f0-9]{8}_\d+__/.test(trimmedLine))
+            // Skip completely empty lines and placeholder artifacts
+            if (!trimmedLine || /__BLOCK_\d+__/.test(trimmedLine) || /^\d+__$/.test(trimmedLine))
                 continue;
             // Skip lines that contain XML tag patterns (to prevent double processing)
             const xmlTagPatterns = [
@@ -789,9 +788,8 @@ class NotionAITool {
         return rootNodes;
     }
     // Process XML tree depth-first (children before parents)
-    static processXMLTreeDepthFirst(nodes, blocks, placeholderPrefix) {
+    static processXMLTreeDepthFirst(nodes, blocks, 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 +833,14 @@ class NotionAITool {
                 // Handle special list processors
                 if (node.listProcessor && (node.tagName === 'ul' || node.tagName === 'ol')) {
                     node.listProcessor(innerContent, blocks);
-                    return `${placeholderPrefix}${blockCounter++}__`;
+                    return `__BLOCK_${placeholderCounter.value++}__`;
                 }
                 // Use blockCreator to create the block
                 const block = node.processor(...node.groups);
                 if (block) {
                     blocks.push(block);
                 }
-                return `${placeholderPrefix}${blockCounter++}__`;
+                return `__BLOCK_${placeholderCounter.value++}__`;
             }
             catch (error) {
                 console.warn(`Error processing XML node ${node.tagName}:`, error);
@@ -888,8 +886,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)}_`;
+        // First, decode HTML entities to proper XML tags
+        processedContent = NotionAITool.decodeHtmlEntities(processedContent);
+        // Use simple sequential placeholder format: __BLOCK_N__
+        let placeholderCounter = 1; // Start from 1 for cleaner numbering
         // Debug mode for development
         const DEBUG_ORDERING = process.env.NODE_ENV === 'development';
         // Define all tag processors
@@ -1153,11 +1153,12 @@ class NotionAITool {
                 })));
             }
             // Step 2: Process tree depth-first (children before parents)
-            const replacements = NotionAITool.processXMLTreeDepthFirst(xmlTree, blocks, placeholderPrefix);
+            const counterRef = { value: 1 };
+            const replacements = NotionAITool.processXMLTreeDepthFirst(xmlTree, blocks, counterRef);
             // Step 3: Apply hierarchical replacements to content
             processedContent = NotionAITool.applyHierarchicalReplacements(processedContent, xmlTree, replacements);
             // Step 4: Clean up any remaining HTML tags
-            processedContent = NotionAITool.cleanupRemainingHtml(processedContent, placeholderPrefix);
+            processedContent = NotionAITool.cleanupRemainingHtml(processedContent);
             if (DEBUG_ORDERING) {
                 console.log(`Processed ${xmlTree.length} root XML nodes hierarchically, created ${blocks.length} blocks`);
             }
@@ -1180,7 +1181,7 @@ class NotionAITool {
                                 if (block) {
                                     blocks.push(block);
                                 }
-                                return `${placeholderPrefix}${Math.random()}__`;
+                                return `__BLOCK_${placeholderCounter++}__`;
                             }
                             catch (error) {
                                 console.warn('Error in fallback processor:', error);
@@ -1205,34 +1206,46 @@ class NotionAITool {
             if (processedMatches.length > 0) {
                 processedContent = NotionAITool.optimizedReplace(processedContent, processedMatches);
             }
-            processedContent = NotionAITool.cleanupRemainingHtml(processedContent, placeholderPrefix);
+            processedContent = NotionAITool.cleanupRemainingHtml(processedContent);
         }
         return processedContent;
     }
+    // Helper function to decode HTML entities
+    static decodeHtmlEntities(content) {
+        const entityMap = {
+            '&lt;': '<',
+            '&gt;': '>',
+            '&amp;': '&',
+            '&quot;': '"',
+            '&apos;': "'",
+            '&#39;': "'",
+            '&nbsp;': ' ',
+        };
+        let decoded = content;
+        Object.entries(entityMap).forEach(([entity, char]) => {
+            decoded = decoded.replace(new RegExp(entity, 'g'), char);
+        });
+        return decoded;
+    }
     // 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
+        const placeholderPatterns = [
+            /__XML_[a-f0-9]{8}_\d+__/g, // Standard format: __XML_abc12345_1__
+            /\b[A-Z]{2}[a-z0-9]{8,12}_+\b/g, // Variations like "MLb82d670450__"
+            /\b[A-Za-z]{2,4}[a-f0-9]{6,12}_+\b/g, // More flexible pattern matching
+            /_[a-f0-9]{8,12}_\d+_*/g, // Underscore variations
+            /[a-f0-9]{8,12}_\d+__/g, // Without prefix
         ];
-        fallbackPatterns.forEach(pattern => {
+        placeholderPatterns.forEach(pattern => {
             cleaned = cleaned.replace(pattern, '');
         });
         // Remove entire lines containing XML content to prevent double processing
@@ -1283,20 +1296,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 +1364,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 +1511,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.22-beta",
   "description": "Advanced n8n Notion nodes: Full-featured workflow node + AI Agent Tool for intelligent Notion automation with 25+ block types (BETA)",
   "scripts": {},
   "files": [