n8n-nodes-notion-advanced 1.2.31-beta → 1.2.32-beta

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

@@ -66,6 +66,10 @@ export declare class NotionAITool implements INodeType {
     static processNestedHtmlInListItem(content: string): string;
     static convertInlineHtmlToMarkdown(content: string): string;
     static buildListHierarchy(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', childHierarchyNodes: HierarchyNode[]): HierarchyNode | null;
+    static getListItemPositions(content: string): Array<{
+        start: number;
+        end: number;
+    }>;
     static mapChildBlocksToListItems(listContent: string, childBlocks: IDataObject[], childNodes: XMLNode[]): Map<number, IDataObject[]>;
     static processNestedListWithChildBlocks(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[], listItemChildBlocks: Map<number, IDataObject[]>): void;
     static processNestedList(listContent: string, listType: 'bulleted_list_item' | 'numbered_list_item', blocks: IDataObject[], childNodes?: XMLNode[]): void;

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -872,11 +872,12 @@ class NotionAITool {
                 }
                 // For list processors, handle them specially
                 if (xmlNode.listProcessor && (xmlNode.tagName === 'ul' || xmlNode.tagName === 'ol')) {
-                    // Extract inner content
+                    // Extract inner content and calculate offset
                     const tagName = xmlNode.tagName.toLowerCase();
                     const openTagRegex = new RegExp(`^<${tagName}[^>]*>`, 'i');
                     const closeTagRegex = new RegExp(`</${tagName}>$`, 'i');
                     let innerContent = xmlNode.match;
+                    let contentStartOffset = 0;
                     const openMatch = xmlNode.match.match(openTagRegex);
                     const closeMatch = xmlNode.match.match(closeTagRegex);
                     if (openMatch && closeMatch) {
@@ -885,9 +886,23 @@ class NotionAITool {
                         const startIndex = openTag.length;
                         const endIndex = xmlNode.match.length - closeTag.length;
                         innerContent = xmlNode.match.substring(startIndex, endIndex);
+                        contentStartOffset = xmlNode.start + startIndex; // Absolute position where list content starts
                     }
+                    // Adjust child hierarchy node positions to be relative to list content
+                    const adjustedChildNodes = childHierarchyNodes.map(child => {
+                        var _a;
+                        return ({
+                            ...child,
+                            metadata: {
+                                ...child.metadata,
+                                sourcePosition: ((_a = child.metadata) === null || _a === void 0 ? void 0 : _a.sourcePosition) !== undefined
+                                    ? child.metadata.sourcePosition - contentStartOffset
+                                    : undefined
+                            }
+                        });
+                    });
                     // Build hierarchy structure for the list
-                    const listHierarchy = NotionAITool.buildListHierarchy(innerContent, xmlNode.tagName === 'ul' ? 'bulleted_list_item' : 'numbered_list_item', childHierarchyNodes);
+                    const listHierarchy = NotionAITool.buildListHierarchy(innerContent, xmlNode.tagName === 'ul' ? 'bulleted_list_item' : 'numbered_list_item', adjustedChildNodes);
                     return listHierarchy;
                 }
                 // For regular nodes, create block and attach children
@@ -1523,12 +1538,13 @@ 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);
             const listItemHierarchyNodes = [];
-            // Map child hierarchy nodes to list items based on position
-            let childNodeIndex = 0;
+            // Map child hierarchy nodes to list items based on actual position in source XML
+            const listItemPositions = NotionAITool.getListItemPositions(listContent);
             for (let i = 0; i < listItems.length; i++) {
                 const item = listItems[i];
                 if (!item.text && !item.children.length)
@@ -1547,16 +1563,19 @@ class NotionAITool {
                         listItemBlock[listType].rich_text = NotionAITool.parseBasicMarkdown(cleanText);
                     }
                 }
-                // Collect child hierarchy nodes for this list item
+                // Collect child hierarchy nodes for this list item based on position mapping
                 const itemChildNodes = [];
-                // Add child hierarchy nodes that belong to this list item
-                // For now, distribute them evenly - this could be improved with position mapping
-                const childrenPerItem = Math.floor(childHierarchyNodes.length / listItems.length);
-                const startIndex = i * childrenPerItem;
-                const endIndex = i === listItems.length - 1 ? childHierarchyNodes.length : startIndex + childrenPerItem;
-                for (let j = startIndex; j < endIndex; j++) {
-                    if (j < childHierarchyNodes.length) {
-                        itemChildNodes.push(childHierarchyNodes[j]);
+                // 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);
+                        }
                     }
                 }
                 // Process nested list children (traditional nested lists)
@@ -1608,6 +1627,55 @@ class NotionAITool {
             };
         }
     }
+    // Helper function to get position ranges for each list item in the content
+    static getListItemPositions(content) {
+        const positions = [];
+        let pos = 0;
+        while (pos < content.length) {
+            // Find next <li> tag
+            const liStart = content.indexOf('<li', pos);
+            if (liStart === -1)
+                break;
+            const liOpenEnd = content.indexOf('>', liStart);
+            if (liOpenEnd === -1)
+                break;
+            // Find the matching </li> using proper depth tracking
+            let depth = 0;
+            let searchPos = liOpenEnd + 1;
+            let liEnd = -1;
+            while (searchPos < content.length) {
+                const nextLiOpen = content.indexOf('<li', searchPos);
+                const nextLiClose = content.indexOf('</li>', searchPos);
+                if (nextLiClose === -1)
+                    break;
+                if (nextLiOpen !== -1 && nextLiOpen < nextLiClose) {
+                    depth++;
+                    searchPos = nextLiOpen + 3;
+                }
+                else {
+                    if (depth === 0) {
+                        liEnd = nextLiClose + 5; // Include the '</li>'
+                        break;
+                    }
+                    else {
+                        depth--;
+                        searchPos = nextLiClose + 5;
+                    }
+                }
+            }
+            if (liEnd !== -1) {
+                positions.push({
+                    start: liStart,
+                    end: liEnd
+                });
+                pos = liEnd;
+            }
+            else {
+                pos = liOpenEnd + 1;
+            }
+        }
+        return positions;
+    }
     // Helper function to map child blocks to specific list items (legacy support)
     static mapChildBlocksToListItems(listContent, childBlocks, childNodes) {
         const listItemChildBlocks = new Map();

package/package.json

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