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

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

@@ -43,12 +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, placeholderCounter: {
+    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 (consistent format 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,7 +788,7 @@ class NotionAITool {
         return rootNodes;
     }
     // Process XML tree depth-first (children before parents)
-    static processXMLTreeDepthFirst(nodes, blocks, placeholderPrefix, placeholderCounter) {
+    static processXMLTreeDepthFirst(nodes, blocks, placeholderCounter) {
         const replacements = new Map();
         const processNode = (node) => {
             // First, process all children depth-first
@@ -834,14 +833,14 @@ class NotionAITool {
                 // Handle special list processors
                 if (node.listProcessor && (node.tagName === 'ul' || node.tagName === 'ol')) {
                     node.listProcessor(innerContent, blocks);
-                    return `${placeholderPrefix}${placeholderCounter.value++}__`;
+                    return `__BLOCK_${placeholderCounter.value++}__`;
                 }
                 // Use blockCreator to create the block
                 const block = node.processor(...node.groups);
                 if (block) {
                     blocks.push(block);
                 }
-                return `${placeholderPrefix}${placeholderCounter.value++}__`;
+                return `__BLOCK_${placeholderCounter.value++}__`;
             }
             catch (error) {
                 console.warn(`Error processing XML node ${node.tagName}:`, error);
@@ -887,10 +886,10 @@ class NotionAITool {
     // New hierarchical XML-like tag processing function
     static processXmlTags(content, blocks) {
         let processedContent = content;
-        // Generate consistent placeholder format: __XML_{uuid8}_{counter}__
-        const placeholderUuid = (0, crypto_1.randomUUID)().slice(0, 8);
-        const placeholderPrefix = `__XML_${placeholderUuid}_`;
-        let placeholderCounter = 0;
+        // 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
@@ -1154,12 +1153,12 @@ class NotionAITool {
                 })));
             }
             // Step 2: Process tree depth-first (children before parents)
-            const counterRef = { value: 0 };
-            const replacements = NotionAITool.processXMLTreeDepthFirst(xmlTree, blocks, placeholderPrefix, counterRef);
+            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`);
             }
@@ -1182,7 +1181,7 @@ class NotionAITool {
                                 if (block) {
                                     blocks.push(block);
                                 }
-                                return `${placeholderPrefix}${placeholderCounter++}__`;
+                                return `__BLOCK_${placeholderCounter++}__`;
                             }
                             catch (error) {
                                 console.warn('Error in fallback processor:', error);
@@ -1207,10 +1206,27 @@ 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;
@@ -1221,9 +1237,17 @@ class NotionAITool {
             const placeholderPattern = new RegExp(`${escapedPrefix}\\d+__`, 'g');
             cleaned = cleaned.replace(placeholderPattern, '');
         }
-        // Single fallback cleanup for the standard format only
-        const standardPlaceholderPattern = /__XML_[a-f0-9]{8}_\d+__/g;
-        cleaned = cleaned.replace(standardPlaceholderPattern, '');
+        // Comprehensive fallback cleanup for all possible placeholder formats
+        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
+        ];
+        placeholderPatterns.forEach(pattern => {
+            cleaned = cleaned.replace(pattern, '');
+        });
         // Remove entire lines containing XML content to prevent double processing
         const xmlContentLines = [
             /^.*<[^>]+>.*$/gm, // Any line with XML/HTML tags

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-notion-advanced",
-  "version": "1.2.21-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": [