n8n-nodes-notion-advanced 1.1.32-beta → 1.2.1-beta

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

@@ -9,5 +9,9 @@ export declare class NotionAITool implements INodeType {
     static createDatabaseEntry(executeFunctions: IExecuteFunctions, itemIndex: number): Promise<IDataObject>;
     static queryDatabase(executeFunctions: IExecuteFunctions, itemIndex: number): Promise<IDataObject>;
     static parseContentToBlocks(content: string): IDataObject[];
+    static processXmlTags(content: string, blocks: IDataObject[]): string;
+    static getCalloutEmoji(type: string): string;
+    static getCalloutColor(type: string): string;
+    static parseBasicMarkdown(text: string): IDataObject[];
     static parsePropertiesToUpdate(propertiesString: string): IDataObject;
 }

package/nodes/NotionAdvanced/NotionAITool.node.js

@@ -446,96 +446,651 @@ class NotionAITool {
     }
     static parseContentToBlocks(content) {
         const blocks = [];
-        const lines = content.split('\n');
+        // Handle both actual newlines and escaped \n characters
+        const normalizedContent = content.replace(/\\n/g, '\n');
+        // First, process XML-like tags for reliable parsing
+        const processedContent = NotionAITool.processXmlTags(normalizedContent, blocks);
+        // Then process remaining content with traditional markdown patterns
+        const lines = processedContent.split('\n');
         for (let i = 0; i < lines.length; i++) {
-            const line = lines[i].trim();
-            if (!line)
+            const line = lines[i];
+            const trimmedLine = line.trim();
+            // Skip completely empty lines and XML placeholders
+            if (!trimmedLine || trimmedLine.startsWith('__XML_BLOCK_'))
                 continue;
-            // Parse different content types
-            if (line.startsWith('# ')) {
+            // Traditional markdown patterns (for backwards compatibility)
+            if (trimmedLine.startsWith('# ')) {
                 blocks.push({
-                    object: 'block',
                     type: 'heading_1',
                     heading_1: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(line.substring(2))],
+                        rich_text: [(0, NotionUtils_1.createRichText)(trimmedLine.substring(2).trim())],
                     },
                 });
             }
-            else if (line.startsWith('## ')) {
+            else if (trimmedLine.startsWith('## ')) {
                 blocks.push({
-                    object: 'block',
                     type: 'heading_2',
                     heading_2: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(line.substring(3))],
+                        rich_text: [(0, NotionUtils_1.createRichText)(trimmedLine.substring(3).trim())],
                     },
                 });
             }
-            else if (line.startsWith('### ')) {
+            else if (trimmedLine.startsWith('### ')) {
                 blocks.push({
-                    object: 'block',
                     type: 'heading_3',
                     heading_3: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(line.substring(4))],
+                        rich_text: [(0, NotionUtils_1.createRichText)(trimmedLine.substring(4).trim())],
                     },
                 });
             }
-            else if (line.startsWith('- ') || line.startsWith('* ')) {
+            else if (trimmedLine === '---' || trimmedLine === '***') {
+                blocks.push({
+                    type: 'divider',
+                    divider: {},
+                });
+            }
+            else if (trimmedLine.includes('[!') && trimmedLine.startsWith('>')) {
+                // Callout blocks: > [!info] content
+                const calloutMatch = trimmedLine.match(/^>\s*\[!(\w+)\]\s*(.*)/i);
+                if (calloutMatch) {
+                    const [, calloutType, text] = calloutMatch;
+                    const emoji = NotionAITool.getCalloutEmoji(calloutType.toLowerCase());
+                    const color = NotionAITool.getCalloutColor(calloutType.toLowerCase());
+                    blocks.push({
+                        type: 'callout',
+                        callout: {
+                            rich_text: NotionAITool.parseBasicMarkdown(text),
+                            icon: { type: 'emoji', emoji },
+                            color: color,
+                        },
+                    });
+                }
+                else {
+                    blocks.push({
+                        type: 'quote',
+                        quote: {
+                            rich_text: NotionAITool.parseBasicMarkdown(trimmedLine.substring(1).trim()),
+                        },
+                    });
+                }
+            }
+            else if (trimmedLine.startsWith('![') && trimmedLine.includes('](') && trimmedLine.endsWith(')')) {
+                // Image: ![alt text](url)
+                const match = trimmedLine.match(/^!\[(.*?)\]\((.*?)\)$/);
+                if (match) {
+                    const [, altText, url] = match;
+                    blocks.push({
+                        type: 'image',
+                        image: {
+                            type: 'external',
+                            external: { url },
+                            caption: altText ? NotionAITool.parseBasicMarkdown(altText) : [],
+                        },
+                    });
+                }
+            }
+            else if (trimmedLine.startsWith('$$') && trimmedLine.endsWith('$$') && trimmedLine.length > 4) {
+                // Equation: $$equation$$
+                const equation = trimmedLine.substring(2, trimmedLine.length - 2).trim();
+                blocks.push({
+                    type: 'equation',
+                    equation: {
+                        expression: equation,
+                    },
+                });
+            }
+            else if ((trimmedLine.startsWith('http://') || trimmedLine.startsWith('https://')) && !trimmedLine.includes(' ')) {
+                // Check if it's a video URL for embed, otherwise bookmark
+                const videoPatterns = [
+                    /(?:https?:\/\/)?(?:www\.)?(?:youtube\.com\/watch\?v=|youtu\.be\/)/i,
+                    /(?:https?:\/\/)?(?:www\.)?(?:vimeo\.com\/)/i,
+                    /(?:https?:\/\/)?(?:www\.)?(?:dailymotion\.com\/video\/)/i,
+                    /(?:https?:\/\/)?(?:www\.)?(?:twitch\.tv\/)/i,
+                    /(?:https?:\/\/)?(?:www\.)?(?:loom\.com\/share\/)/i,
+                    /(?:https?:\/\/)?(?:www\.)?(?:figma\.com\/)/i,
+                    /(?:https?:\/\/)?(?:www\.)?(?:miro\.com\/)/i,
+                    /(?:https?:\/\/)?(?:codepen\.io\/)/i
+                ];
+                const isEmbeddableUrl = videoPatterns.some(pattern => pattern.test(trimmedLine));
+                if (isEmbeddableUrl) {
+                    blocks.push({
+                        type: 'embed',
+                        embed: {
+                            url: trimmedLine,
+                        },
+                    });
+                }
+                else {
+                    blocks.push({
+                        type: 'bookmark',
+                        bookmark: {
+                            url: trimmedLine,
+                        },
+                    });
+                }
+            }
+            else if (trimmedLine.startsWith('- [') && (trimmedLine.includes('[ ]') || trimmedLine.includes('[x]') || trimmedLine.includes('[X]'))) {
+                // To-do list items: - [ ] or - [x] or - [X]
+                const isChecked = trimmedLine.includes('[x]') || trimmedLine.includes('[X]');
+                const text = trimmedLine.replace(/^-\s*\[[ xX]\]\s*/, '').trim();
+                blocks.push({
+                    type: 'to_do',
+                    to_do: {
+                        rich_text: NotionAITool.parseBasicMarkdown(text),
+                        checked: isChecked,
+                    },
+                });
+            }
+            else if (trimmedLine.startsWith('- ') && !trimmedLine.startsWith('- [')) {
+                // Bullet list items: - item (but not todos)
+                const listText = trimmedLine.substring(2).trim();
                 blocks.push({
-                    object: 'block',
                     type: 'bulleted_list_item',
                     bulleted_list_item: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(line.substring(2))],
+                        rich_text: NotionAITool.parseBasicMarkdown(listText),
                     },
                 });
             }
-            else if (line.match(/^\d+\. /)) {
+            else if (/^\d+\.\s/.test(trimmedLine)) {
+                // Numbered list items: 1. item
+                const listText = trimmedLine.replace(/^\d+\.\s/, '').trim();
                 blocks.push({
-                    object: 'block',
                     type: 'numbered_list_item',
                     numbered_list_item: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(line.replace(/^\d+\. /, ''))],
+                        rich_text: NotionAITool.parseBasicMarkdown(listText),
                     },
                 });
             }
-            else if (line.startsWith('> ')) {
+            else if (trimmedLine.startsWith('> ') && !trimmedLine.includes('[!')) {
+                // Quote block (but not callout)
                 blocks.push({
-                    object: 'block',
                     type: 'quote',
                     quote: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(line.substring(2))],
+                        rich_text: NotionAITool.parseBasicMarkdown(trimmedLine.substring(2).trim()),
                     },
                 });
             }
-            else if (line.startsWith('```')) {
+            else if (trimmedLine.startsWith('```')) {
                 // Handle code blocks
+                const language = trimmedLine.substring(3).trim() || 'plain text';
                 const codeLines = [];
                 i++; // Skip the opening ```
+                // Collect all code lines until closing ```
                 while (i < lines.length && !lines[i].trim().startsWith('```')) {
                     codeLines.push(lines[i]);
                     i++;
                 }
                 blocks.push({
-                    object: 'block',
                     type: 'code',
                     code: {
                         rich_text: [(0, NotionUtils_1.createRichText)(codeLines.join('\n'))],
-                        language: 'plain text',
+                        language: language === 'plain text' ? 'plain_text' : language,
                     },
                 });
             }
             else {
-                // Regular paragraph
+                // Regular paragraph - handle basic markdown formatting
+                const richText = NotionAITool.parseBasicMarkdown(trimmedLine);
                 blocks.push({
-                    object: 'block',
                     type: 'paragraph',
                     paragraph: {
-                        rich_text: [(0, NotionUtils_1.createRichText)(line)],
+                        rich_text: richText,
                     },
                 });
             }
         }
         return blocks;
     }
+    // New XML-like tag processing function
+    static processXmlTags(content, blocks) {
+        let processedContent = content;
+        let blockCounter = 0;
+        // Process XML-like tags in order of priority
+        const tagProcessors = [
+            // Callouts: <callout type="info">content</callout>
+            {
+                regex: /<callout\s*(?:type="([^"]*)")?\s*>(.*?)<\/callout>/gis,
+                processor: (match, type = 'info', content) => {
+                    const emoji = NotionAITool.getCalloutEmoji(type.toLowerCase());
+                    const color = NotionAITool.getCalloutColor(type.toLowerCase());
+                    blocks.push({
+                        type: 'callout',
+                        callout: {
+                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                            icon: { type: 'emoji', emoji },
+                            color: color,
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Code blocks: <code language="javascript">content</code>
+            {
+                regex: /<code\s*(?:language="([^"]*)")?\s*>(.*?)<\/code>/gis,
+                processor: (match, language = 'plain_text', content) => {
+                    blocks.push({
+                        type: 'code',
+                        code: {
+                            rich_text: [(0, NotionUtils_1.createRichText)(content.trim())],
+                            language: language === 'plain text' ? 'plain_text' : language,
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Images: <image src="url" alt="description">caption</image>
+            {
+                regex: /<image\s+src="([^"]*)"(?:\s+alt="([^"]*)")?\s*>(.*?)<\/image>/gis,
+                processor: (match, src, alt = '', caption = '') => {
+                    const captionText = caption.trim() || alt;
+                    blocks.push({
+                        type: 'image',
+                        image: {
+                            type: 'external',
+                            external: { url: src },
+                            caption: captionText ? NotionAITool.parseBasicMarkdown(captionText) : [],
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Self-closing images: <image src="url" alt="description"/>
+            {
+                regex: /<image\s+src="([^"]*)"(?:\s+alt="([^"]*)")?\s*\/>/gis,
+                processor: (match, src, alt = '') => {
+                    blocks.push({
+                        type: 'image',
+                        image: {
+                            type: 'external',
+                            external: { url: src },
+                            caption: alt ? NotionAITool.parseBasicMarkdown(alt) : [],
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Equations: <equation>E=mc^2</equation>
+            {
+                regex: /<equation>(.*?)<\/equation>/gis,
+                processor: (match, expression) => {
+                    blocks.push({
+                        type: 'equation',
+                        equation: {
+                            expression: expression.trim(),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Embeds: <embed>url</embed>
+            {
+                regex: /<embed>(.*?)<\/embed>/gis,
+                processor: (match, url) => {
+                    blocks.push({
+                        type: 'embed',
+                        embed: {
+                            url: url.trim(),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Bookmarks: <bookmark>url</bookmark>
+            {
+                regex: /<bookmark>(.*?)<\/bookmark>/gis,
+                processor: (match, url) => {
+                    blocks.push({
+                        type: 'bookmark',
+                        bookmark: {
+                            url: url.trim(),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Toggles: <toggle>title</toggle>
+            {
+                regex: /<toggle>(.*?)<\/toggle>/gis,
+                processor: (match, title) => {
+                    blocks.push({
+                        type: 'toggle',
+                        toggle: {
+                            rich_text: NotionAITool.parseBasicMarkdown(title.trim()),
+                            children: [],
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Quotes: <quote>content</quote>
+            {
+                regex: /<quote>(.*?)<\/quote>/gis,
+                processor: (match, content) => {
+                    blocks.push({
+                        type: 'quote',
+                        quote: {
+                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Dividers: <divider/> or <divider></divider>
+            {
+                regex: /<divider\s*\/?>/gis,
+                processor: (match) => {
+                    blocks.push({
+                        type: 'divider',
+                        divider: {},
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // To-do items: <todo checked="true">content</todo>
+            {
+                regex: /<todo\s*(?:checked="([^"]*)")?\s*>(.*?)<\/todo>/gis,
+                processor: (match, checked = 'false', content) => {
+                    const isChecked = checked.toLowerCase() === 'true';
+                    blocks.push({
+                        type: 'to_do',
+                        to_do: {
+                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                            checked: isChecked,
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Headings: <h1>content</h1>, <h2>content</h2>, <h3>content</h3>
+            {
+                regex: /<h([123])>(.*?)<\/h[123]>/gis,
+                processor: (match, level, content) => {
+                    const headingType = `heading_${level}`;
+                    blocks.push({
+                        type: headingType,
+                        [headingType]: {
+                            rich_text: [(0, NotionUtils_1.createRichText)(content.trim())],
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Paragraphs: <p>content</p>
+            {
+                regex: /<p>(.*?)<\/p>/gis,
+                processor: (match, content) => {
+                    blocks.push({
+                        type: 'paragraph',
+                        paragraph: {
+                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Bulleted lists: <ul><li>item</li></ul>
+            {
+                regex: /<ul>(.*?)<\/ul>/gis,
+                processor: (match, listContent) => {
+                    // Extract individual list items
+                    const items = listContent.match(/<li>(.*?)<\/li>/gis) || [];
+                    items.forEach(item => {
+                        const itemContent = item.replace(/<\/?li>/gi, '').trim();
+                        blocks.push({
+                            type: 'bulleted_list_item',
+                            bulleted_list_item: {
+                                rich_text: NotionAITool.parseBasicMarkdown(itemContent),
+                            },
+                        });
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Numbered lists: <ol><li>item</li></ol>
+            {
+                regex: /<ol>(.*?)<\/ol>/gis,
+                processor: (match, listContent) => {
+                    // Extract individual list items
+                    const items = listContent.match(/<li>(.*?)<\/li>/gis) || [];
+                    items.forEach(item => {
+                        const itemContent = item.replace(/<\/?li>/gi, '').trim();
+                        blocks.push({
+                            type: 'numbered_list_item',
+                            numbered_list_item: {
+                                rich_text: NotionAITool.parseBasicMarkdown(itemContent),
+                            },
+                        });
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Standalone list items: <li>content</li>
+            {
+                regex: /<li>(.*?)<\/li>/gis,
+                processor: (match, content) => {
+                    blocks.push({
+                        type: 'bulleted_list_item',
+                        bulleted_list_item: {
+                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Blockquotes: <blockquote>content</blockquote>
+            {
+                regex: /<blockquote>(.*?)<\/blockquote>/gis,
+                processor: (match, content) => {
+                    blocks.push({
+                        type: 'quote',
+                        quote: {
+                            rich_text: NotionAITool.parseBasicMarkdown(content.trim()),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Preformatted text: <pre>content</pre>
+            {
+                regex: /<pre>(.*?)<\/pre>/gis,
+                processor: (match, content) => {
+                    blocks.push({
+                        type: 'code',
+                        code: {
+                            rich_text: [(0, NotionUtils_1.createRichText)(content.trim())],
+                            language: 'plain_text',
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Strong/Bold: <strong>content</strong> or <b>content</b>
+            {
+                regex: /<(strong|b)>(.*?)<\/(strong|b)>/gis,
+                processor: (match, tag, content) => {
+                    blocks.push({
+                        type: 'paragraph',
+                        paragraph: {
+                            rich_text: NotionAITool.parseBasicMarkdown(`**${content.trim()}**`),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Emphasis/Italic: <em>content</em> or <i>content</i>
+            {
+                regex: /<(em|i)>(.*?)<\/(em|i)>/gis,
+                processor: (match, tag, content) => {
+                    blocks.push({
+                        type: 'paragraph',
+                        paragraph: {
+                            rich_text: NotionAITool.parseBasicMarkdown(`*${content.trim()}*`),
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+            // Line breaks: <br/> or <br>
+            {
+                regex: /<br\s*\/?>/gis,
+                processor: (match) => {
+                    blocks.push({
+                        type: 'paragraph',
+                        paragraph: {
+                            rich_text: [(0, NotionUtils_1.createRichText)('')],
+                        },
+                    });
+                    return `__XML_BLOCK_${blockCounter++}__`;
+                }
+            },
+        ];
+        // Process each tag type
+        tagProcessors.forEach(({ regex, processor }) => {
+            processedContent = processedContent.replace(regex, (match, group1, group2, group3) => {
+                return processor(match, group1 || '', group2 || '', group3 || '');
+            });
+        });
+        return processedContent;
+    }
+    // Helper function to get callout emoji based on type
+    static getCalloutEmoji(type) {
+        const emojiMap = {
+            'info': 'ℹ️',
+            'warning': '⚠️',
+            'danger': '🚨',
+            'error': '❌',
+            'note': '📝',
+            'tip': '💡',
+            'success': '✅',
+            'question': '❓',
+        };
+        return emojiMap[type] || 'ℹ️';
+    }
+    // Helper function to get callout color based on type
+    static getCalloutColor(type) {
+        const colorMap = {
+            'info': 'blue',
+            'warning': 'yellow',
+            'danger': 'red',
+            'error': 'red',
+            'note': 'gray',
+            'tip': 'green',
+            'success': 'green',
+            'question': 'purple',
+        };
+        return colorMap[type] || 'gray';
+    }
+    // Helper function to parse basic markdown formatting in text
+    static parseBasicMarkdown(text) {
+        const richTextObjects = [];
+        // Find and collect all formatting patterns with their positions
+        const patterns = [
+            { 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: 'strikethrough' }, // ~~strikethrough~~
+            { regex: /`([^`]+)`/g, type: 'code' }, // `code`
+        ];
+        const matches = [];
+        // Collect all matches
+        patterns.forEach(pattern => {
+            const regex = new RegExp(pattern.regex.source, 'g');
+            let match;
+            while ((match = regex.exec(text)) !== null) {
+                if (pattern.type === 'link') {
+                    matches.push({
+                        start: match.index,
+                        end: match.index + match[0].length,
+                        text: match[1], // Link text
+                        type: pattern.type,
+                        url: match[2] // Link URL
+                    });
+                }
+                else {
+                    matches.push({
+                        start: match.index,
+                        end: match.index + match[0].length,
+                        text: match[1], // Inner text
+                        type: pattern.type
+                    });
+                }
+            }
+        });
+        // Sort matches by position and resolve overlaps (prefer longer matches)
+        matches.sort((a, b) => {
+            if (a.start !== b.start)
+                return a.start - b.start;
+            return (b.end - b.start) - (a.end - a.start); // Prefer longer matches
+        });
+        // Remove overlapping matches (keep the first/longer one)
+        const resolvedMatches = [];
+        for (const match of matches) {
+            const hasOverlap = resolvedMatches.some(existing => (match.start < existing.end && match.end > existing.start));
+            if (!hasOverlap) {
+                resolvedMatches.push(match);
+            }
+        }
+        // Sort again by position
+        resolvedMatches.sort((a, b) => a.start - b.start);
+        // If no formatting found, return simple rich text
+        if (resolvedMatches.length === 0) {
+            return [(0, NotionUtils_1.createRichText)(text)];
+        }
+        // Build rich text segments
+        let lastIndex = 0;
+        resolvedMatches.forEach(match => {
+            // Add plain text before this match
+            if (match.start > lastIndex) {
+                const plainText = text.substring(lastIndex, match.start);
+                if (plainText) {
+                    richTextObjects.push((0, NotionUtils_1.createRichText)(plainText));
+                }
+            }
+            // Add formatted text
+            const richTextObj = {
+                type: 'text',
+                text: { content: match.text },
+                annotations: {}
+            };
+            // Apply formatting based on type
+            switch (match.type) {
+                case 'bold':
+                    richTextObj.annotations.bold = true;
+                    break;
+                case 'italic':
+                    richTextObj.annotations.italic = true;
+                    break;
+                case 'bold_italic':
+                    richTextObj.annotations.bold = true;
+                    richTextObj.annotations.italic = true;
+                    break;
+                case 'strikethrough':
+                    richTextObj.annotations.strikethrough = true;
+                    break;
+                case 'code':
+                    richTextObj.annotations.code = true;
+                    break;
+                case 'link':
+                    richTextObj.text.link = { url: match.url };
+                    break;
+            }
+            // Clean up empty annotations
+            if (Object.keys(richTextObj.annotations).length === 0) {
+                delete richTextObj.annotations;
+            }
+            richTextObjects.push(richTextObj);
+            lastIndex = match.end;
+        });
+        // Add remaining plain text
+        if (lastIndex < text.length) {
+            const remainingText = text.substring(lastIndex);
+            if (remainingText) {
+                richTextObjects.push((0, NotionUtils_1.createRichText)(remainingText));
+            }
+        }
+        return richTextObjects.length > 0 ? richTextObjects : [(0, NotionUtils_1.createRichText)(text)];
+    }
     static parsePropertiesToUpdate(propertiesString) {
         try {
             // Try to parse as JSON first

package/nodes/NotionAdvanced/NotionUtils.d.ts

@@ -64,6 +64,10 @@ export declare function createBookmarkBlock(url: string, caption?: RichTextObjec
  * Creates an embed block
  */
 export declare function createEmbedBlock(url: string, caption?: RichTextObject[]): Block;
+/**
+ * Creates a toggle block
+ */
+export declare function createToggleBlock(text: string | RichTextObject[], color?: NotionColor, children?: Block[]): Block;
 /**
  * Creates a table block with rows
  */

package/nodes/NotionAdvanced/NotionUtils.js

@@ -16,6 +16,7 @@ exports.createEquationBlock = createEquationBlock;
 exports.createImageBlock = createImageBlock;
 exports.createBookmarkBlock = createBookmarkBlock;
 exports.createEmbedBlock = createEmbedBlock;
+exports.createToggleBlock = createToggleBlock;
 exports.createTableBlock = createTableBlock;
 exports.convertBlockInput = convertBlockInput;
 exports.resolvePageId = resolvePageId;
@@ -294,6 +295,19 @@ function createEmbedBlock(url, caption) {
         },
     };
 }
+/**
+ * Creates a toggle block
+ */
+function createToggleBlock(text, color, children) {
+    return {
+        type: 'toggle',
+        toggle: {
+            rich_text: typeof text === 'string' ? [createRichText(text)] : text,
+            color,
+            children,
+        },
+    };
+}
 /**
  * Creates a table block with rows
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-notion-advanced",
-  "version": "1.1.32-beta",
+  "version": "1.2.1-beta",
   "description": "Advanced n8n Notion nodes: Full-featured workflow node + AI Agent Tool for intelligent Notion automation with 25+ block types (BETA)",
   "scripts": {
     "build": "echo 'Already built'",