@jotx-labs/adapters 2.2.0

package/dist/editor/TiptapAdapter.js

@@ -0,0 +1,1020 @@
+"use strict";
+/**
+ * jotx 2.0 TiptapAdapter - Bridge between @jotx/core and Tiptap editor
+ *
+ * Converts:
+ * - Core BlockNode (jotx 2.0 format) ↔ Tiptap JSON
+ *
+ * All text content uses properties.text (consistent with jotx 2.0 syntax)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TiptapAdapter = void 0;
+const core_1 = require("@jotx/core");
+/**
+ * jotx 2.0 TiptapAdapter - Updated for consistent property-based syntax
+ */
+class TiptapAdapter {
+    /**
+     * Parse Markdown-style formatting in text and convert to Tiptap content with marks
+     * Handles: **bold**, *italic*, ~~strike~~, `code`, [link](url), ==highlight==
+     */
+    parseFormattedText(text) {
+        if (!text)
+            return [];
+        const nodes = [];
+        let pos = 0;
+        // Regex patterns for inline formatting (order matters!)
+        // Using .+? (non-greedy) instead of [^x]+ to allow nested formatting
+        const patterns = [
+            { type: 'code', regex: /`([^`]+)`/g, marks: ['code'] },
+            { type: 'jotxlink', regex: /\[\[([^\]]+)\]\]/g, marks: [] }, // [[target]] -> jotxlink node
+            { type: 'link', regex: /\[([^\]]+)\]\(([^)]+)\)/g, marks: [] }, // Special handling
+            { type: 'bold', regex: /\*\*(.+?)\*\*/g, marks: ['bold'] }, // Changed [^*]+ to .+?
+            { type: 'italic', regex: /\*(.+?)\*/g, marks: ['italic'] }, // Changed [^*]+ to .+?
+            { type: 'strike', regex: /~~(.+?)~~/g, marks: ['strike'] }, // Changed [^~]+ to .+?
+            { type: 'highlight', regex: /==(.+?)==/g, marks: ['highlight'] }, // Changed [^=]+ to .+?
+            { type: 'textStyle', regex: /<span style="color:([^"]+)">(.+?)<\/span>/g, marks: [] }
+        ];
+        const matches = [];
+        for (const pattern of patterns) {
+            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
+                        marks: [{ type: 'link', attrs: { href: match[2] } }]
+                    });
+                }
+                else if (pattern.type === 'jotxlink') {
+                    // [[target|text]] or [[target]]
+                    const content = match[1];
+                    const parts = content.split('|');
+                    const target = parts[0];
+                    const text = parts[1] || target;
+                    // We represent inline wikilink as a 'jotxlink' NODE, not a mark.
+                    // Note: This requires the schema to allow 'jotxlink' inline.
+                    matches.push({
+                        start: match.index,
+                        end: match.index + match[0].length,
+                        text: text,
+                        marks: [], // No marks, it's a node (handled later? No, this array is matches with marks)
+                        // Wait, parseFormattedText returns TiptapNode[].
+                        // I need to intercept this in the loop below.
+                        // I'll attach a special 'nodeType' property to the match object if possible?
+                        // The Match interface doesn't support it.
+                        // I'll update Match interface? No, I'll use 'marks' to signal it.
+                        // Actually, I can add a custom type to marks: { type: 'jotxlink', attrs: { target } }
+                        // But 'jotxlink' is a node type, not mark type.
+                        // If I use a mark, I have to ensure Tiptap has a mark for it.
+                        // User wants 'jotxlink' block.
+                        // If it's inline, it must be inline node.
+                        // I'll cheat: Use a special mark 'jotxlink_mark' and convert it to node in the loop?
+                        // Or better: Modify Match interface.
+                    });
+                    // Wait, I can't modify Match interface easily it's inside the method.
+                    // Let's look at the existing code again relative to where I am inserting.
+                    // I will use a dummy mark { type: 'INTERNAL_JOTXLINK', attrs: { target } }
+                    // and then in the loop convert it to a node.
+                    matches.push({
+                        start: match.index,
+                        end: match.index + match[0].length,
+                        text: text,
+                        marks: [{ type: 'INTERNAL_JOTXLINK', attrs: { target } }]
+                    });
+                }
+                else if (pattern.type === 'textStyle') {
+                    matches.push({
+                        start: match.index,
+                        end: match.index + match[0].length,
+                        text: match[2], // Content
+                        marks: [{ type: 'textStyle', attrs: { color: match[1] } }]
+                    });
+                }
+                else {
+                    matches.push({
+                        start: match.index,
+                        end: match.index + match[0].length,
+                        text: match[1], // Content inside marks
+                        marks: pattern.marks.map(type => ({ type }))
+                    });
+                }
+            }
+        }
+        // Sort matches by start position, then by length (longer first for preference)
+        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 first/longer match)
+        const filteredMatches = [];
+        for (const match of matches) {
+            const overlaps = filteredMatches.some(existing => (match.start >= existing.start && match.start < existing.end) ||
+                (match.end > existing.start && match.end <= existing.end) ||
+                (match.start <= existing.start && match.end >= existing.end));
+            if (!overlaps) {
+                filteredMatches.push(match);
+            }
+        }
+        // Sort filtered matches by start position
+        filteredMatches.sort((a, b) => a.start - b.start);
+        // Build content nodes
+        let lastPos = 0;
+        for (const match of filteredMatches) {
+            // Add plain text before this match
+            if (match.start > lastPos) {
+                const plainText = text.substring(lastPos, match.start);
+                if (plainText) {
+                    nodes.push({ type: 'text', text: plainText });
+                }
+            }
+            // Check for internal jotxlink mark
+            const jotxLinkMark = match.marks.find(m => m.type === 'INTERNAL_JOTXLINK');
+            if (jotxLinkMark) {
+                nodes.push({
+                    type: 'jotxlink',
+                    attrs: {
+                        target: jotxLinkMark.attrs?.target,
+                        text: match.text
+                    }
+                });
+            }
+            else {
+                // Add formatted text
+                nodes.push({
+                    type: 'text',
+                    text: match.text,
+                    marks: match.marks
+                });
+            }
+            lastPos = match.end;
+        }
+        // Add remaining plain text
+        if (lastPos < text.length) {
+            const plainText = text.substring(lastPos);
+            if (plainText) {
+                nodes.push({ type: 'text', text: plainText });
+            }
+        }
+        // If no matches found, return plain text
+        if (nodes.length === 0 && text) {
+            nodes.push({ type: 'text', text });
+        }
+        return nodes;
+    }
+    /**
+     * Convert a single BlockNode to Tiptap node
+     * Reads from properties.text (jotx 2.0 format) and parses Markdown-style formatting
+     */
+    blockToTiptap(block) {
+        const text = block.properties?.text || '';
+        switch (block.type) {
+            // ========== TEXT BLOCKS ==========
+            case 'heading':
+                const level = block.properties?.level ? parseInt(String(block.properties.level)) : 1;
+                return {
+                    type: 'heading',
+                    attrs: { level, blockId: block.id },
+                    content: this.parseFormattedText(text)
+                };
+            case 'list':
+                const listType = block.properties?.listtype === 'numbered' || block.properties?.type === 'numbered' ? 'orderedList' : 'bulletList';
+                return {
+                    type: listType,
+                    attrs: { blockId: block.id },
+                    content: (block.children || []).map(b => this.blockToTiptap(b))
+                };
+            case 'listitem':
+                return {
+                    type: 'listItem',
+                    attrs: { blockId: block.id },
+                    content: [{
+                            type: 'paragraph',
+                            content: this.parseFormattedText(text)
+                        }, ...(block.children || []).map(b => this.blockToTiptap(b))]
+                };
+            case 'checklist':
+                return {
+                    type: 'taskList',
+                    attrs: { blockId: block.id },
+                    content: (block.children || []).map(b => this.blockToTiptap(b))
+                };
+            case 'taskitem':
+                return {
+                    type: 'taskItem',
+                    attrs: {
+                        checked: block.properties?.checked === true || block.properties?.checked === 'true',
+                        blockId: block.id
+                    },
+                    content: [{
+                            type: 'paragraph',
+                            content: this.parseFormattedText(text)
+                        }, ...(block.children || []).map(b => this.blockToTiptap(b))]
+                };
+            case 'paragraph':
+                return {
+                    type: 'paragraph',
+                    attrs: { blockId: block.id },
+                    content: this.parseFormattedText(text)
+                };
+            case 'quote':
+                return {
+                    type: 'blockquote',
+                    attrs: { blockId: block.id },
+                    content: [{
+                            type: 'paragraph',
+                            content: this.parseFormattedText(text)
+                        }]
+                };
+            // ========== CODE & MEDIA BLOCKS ==========
+            case 'code':
+                return {
+                    type: 'codeBlock',
+                    attrs: {
+                        language: block.properties?.language || 'plaintext',
+                        blockId: block.id
+                    },
+                    content: [{ type: 'text', text }]
+                };
+            case 'codereference':
+                return {
+                    type: 'codeReference',
+                    attrs: {
+                        path: block.properties?.path || '',
+                        lines: block.properties?.lines || '',
+                        language: block.properties?.language || 'typescript',
+                        blockId: block.id
+                    },
+                    content: text ? [{ type: 'text', text }] : []
+                };
+            case 'math':
+                return {
+                    type: 'math',
+                    attrs: {
+                        src: block.properties?.src || '',
+                        display: block.properties?.display || 'block',
+                        blockId: block.id
+                    }
+                };
+            case 'mermaid':
+                return {
+                    type: 'mermaid',
+                    attrs: {
+                        src: block.properties?.src || '',
+                        showSource: block.properties?.showsource === 'true',
+                        blockId: block.id
+                    }
+                };
+            case 'chart':
+                return {
+                    type: 'chart',
+                    attrs: {
+                        chartType: block.properties?.charttype || 'bar',
+                        json: block.properties?.json || '',
+                        showSource: block.properties?.showsource === 'true',
+                        blockId: block.id
+                    }
+                };
+            case 'datetime':
+                return {
+                    type: 'datetime',
+                    attrs: {
+                        value: block.properties?.value || '',
+                        mode: block.properties?.mode || 'datetime',
+                        blockId: block.id
+                    }
+                };
+            case 'floatimage':
+                return {
+                    type: 'floatImageBlock',
+                    attrs: {
+                        src: block.properties?.src || '',
+                        alt: block.properties?.alt || '',
+                        width: block.properties?.width ? parseInt(block.properties.width) : 400,
+                        height: block.properties?.height || 'auto',
+                        float: block.properties?.float || 'left',
+                        caption: block.properties?.caption || '',
+                        title: block.properties?.title || '',
+                        description: block.properties?.description || '',
+                        image: block.properties?.image || '',
+                        siteName: block.properties?.sitename || '',
+                        blockId: block.id
+                    },
+                    content: (block.children || []).map(child => this.blockToTiptap(child))
+                };
+            case 'jotxlink':
+                return {
+                    type: 'jotxlink',
+                    attrs: {
+                        target: block.properties?.target || '',
+                        text: block.properties?.text || '',
+                        blockId: block.id
+                    }
+                };
+            case 'blockref':
+                return {
+                    type: 'blockref',
+                    attrs: {
+                        ref: block.properties?.ref || '',
+                        blockId: block.id
+                    }
+                };
+            // ========== MISSING BLOCKS (Added for Roundtrip Fix) ==========
+            case 'video':
+                const srcOrUrl = block.properties?.src || block.properties?.url || '';
+                return {
+                    type: 'videoBlock',
+                    attrs: {
+                        src: srcOrUrl,
+                        url: srcOrUrl,
+                        title: block.properties?.title || '',
+                        type: block.properties?.type || 'youtube',
+                        width: block.properties?.width || 800,
+                        height: block.properties?.height || 450,
+                        controls: block.properties?.controls === 'true' ? 'true' : 'false',
+                        autoplay: block.properties?.autoplay === 'true' ? 'true' : 'false',
+                        muted: block.properties?.muted === 'true' ? 'true' : 'false',
+                        loop: block.properties?.loop === 'true' ? 'true' : 'false',
+                        blockId: block.id
+                    }
+                };
+            case 'link':
+                return {
+                    type: 'linkBlock',
+                    attrs: {
+                        href: block.properties?.url || block.properties?.href || '',
+                        blockId: block.id
+                    },
+                    content: [{ type: 'text', text: block.properties?.text || '' }]
+                };
+            case 'divider':
+                return {
+                    type: 'horizontalRule',
+                    attrs: { blockId: block.id }
+                };
+            case 'attach':
+                return {
+                    type: 'attach',
+                    attrs: {
+                        path: block.properties?.path || '',
+                        text: block.properties?.text || block.properties?.name || '',
+                        blockId: block.id
+                    },
+                    content: (block.children || []).map(child => this.blockToTiptap(child))
+                };
+            case 'image':
+                return {
+                    type: 'imageBlock',
+                    attrs: {
+                        src: block.properties?.src || '',
+                        alt: block.properties?.alt || '',
+                        caption: block.properties?.caption || '',
+                        width: block.properties?.width ? parseInt(block.properties.width) : 800,
+                        align: block.properties?.align || 'center',
+                        blockId: block.id
+                    }
+                };
+            // ========== PROPERTIES TABLE (2-column key-value table) ==========
+            case 'properties':
+                // Properties table has automatic "Key", "Value", and "Type" headers
+                const propsHeaderRow = {
+                    type: 'tableRow',
+                    content: [
+                        {
+                            type: 'tableHeader',
+                            content: [{
+                                    type: 'paragraph',
+                                    content: [{
+                                            type: 'text',
+                                            text: 'Key',
+                                            marks: [{ type: 'bold' }]
+                                        }]
+                                }]
+                        },
+                        {
+                            type: 'tableHeader',
+                            content: [{
+                                    type: 'paragraph',
+                                    content: [{
+                                            type: 'text',
+                                            text: 'Value',
+                                            marks: [{ type: 'bold' }]
+                                        }]
+                                }]
+                        },
+                        {
+                            type: 'tableHeader',
+                            content: [{
+                                    type: 'paragraph',
+                                    content: [{
+                                            type: 'text',
+                                            text: 'Type',
+                                            marks: [{ type: 'bold' }]
+                                        }]
+                                }]
+                        }
+                    ]
+                };
+                // Convert property rows
+                const propRows = (block.children || []).map(prop => ({
+                    type: 'tableRow',
+                    attrs: { blockId: prop.id },
+                    content: [
+                        {
+                            type: 'tableCell',
+                            content: [{
+                                    type: 'paragraph',
+                                    content: prop.properties?.key ? [{
+                                            type: 'text',
+                                            text: prop.properties.key
+                                        }] : []
+                                }]
+                        },
+                        {
+                            type: 'tableCell',
+                            content: [{
+                                    type: 'paragraph',
+                                    content: prop.properties?.value ? [{
+                                            type: 'text',
+                                            text: prop.properties.value
+                                        }] : []
+                                }]
+                        },
+                        {
+                            type: 'tableCell',
+                            content: [{
+                                    type: 'paragraph',
+                                    content: prop.properties?.type ? [{
+                                            type: 'text',
+                                            text: prop.properties.type
+                                        }] : [{
+                                            type: 'text',
+                                            text: 'text'
+                                        }]
+                                }]
+                        }
+                    ]
+                }));
+                return {
+                    type: 'table',
+                    attrs: { blockId: block.id },
+                    content: [propsHeaderRow, ...propRows]
+                };
+            // ========== CONTAINER BLOCKS (Added for Roundtrip Fix) ==========
+            case 'toggle':
+                return {
+                    type: 'toggle',
+                    attrs: {
+                        title: block.properties?.title || 'Toggle',
+                        collapsed: block.properties?.collapsed === 'true',
+                        blockId: block.id
+                    },
+                    content: (block.children || []).map(child => this.blockToTiptap(child))
+                };
+            case 'section':
+                return {
+                    type: 'section',
+                    attrs: {
+                        title: block.properties?.title || 'Section',
+                        collapsed: block.properties?.collapsed === 'true',
+                        blockId: block.id
+                    },
+                    content: (block.children || []).map(child => this.blockToTiptap(child))
+                };
+            case 'callout':
+                // Callout in AST has 'text' property, but Tiptap node expects content children (paragraph)
+                return {
+                    type: 'callout',
+                    attrs: {
+                        variant: block.properties?.variant || 'info',
+                        blockId: block.id
+                    },
+                    content: [{
+                            type: 'paragraph',
+                            content: [{ type: 'text', text: block.properties?.text || '' }]
+                        }]
+                };
+            // ========== TABLE (complex nested structure) ==========
+            case 'table':
+                // Parse column names from the columns property
+                const columnNames = (block.properties?.columns || '')
+                    .split(',')
+                    .map((c) => c.trim())
+                    .filter(Boolean);
+                // Create header row with bold, capitalized column names
+                const headerRow = {
+                    type: 'tableRow',
+                    content: columnNames.map((name) => ({
+                        type: 'tableHeader',
+                        content: [{
+                                type: 'paragraph',
+                                content: [{
+                                        type: 'text',
+                                        text: name.charAt(0).toUpperCase() + name.slice(1),
+                                        marks: [{ type: 'bold' }]
+                                    }]
+                            }]
+                    }))
+                };
+                // Convert data rows
+                const dataRows = (block.children || []).map(row => ({
+                    type: 'tableRow',
+                    attrs: { blockId: row.id },
+                    content: (row.children || []).map(cell => ({
+                        type: 'tableCell',
+                        attrs: { blockId: cell.id },
+                        content: (cell.children || []).map(b => this.blockToTiptap(b))
+                    }))
+                }));
+                return {
+                    type: 'table',
+                    attrs: { blockId: block.id },
+                    content: [headerRow, ...dataRows]
+                };
+            default:
+                // Fallback: render as paragraph
+                return {
+                    type: 'paragraph',
+                    attrs: { blockId: block.id },
+                    content: text ? [{ type: 'text', text }] : []
+                };
+        }
+    }
+    /**
+     * Convert Tiptap node to BlockNode
+     * Writes to properties.text (jotx 2.0 format)
+     * (Reverse direction - for saving edits from Tiptap)
+     */
+    tiptapToBlock(node, index) {
+        // Preserve existing ID or generate new one
+        const blockId = node.attrs?.blockId || (0, core_1.generateBlockId)();
+        const attrs = node.attrs || {};
+        const content = node.content || [];
+        switch (node.type) {
+            // ========== TEXT BLOCKS ==========
+            case 'heading':
+                const level = attrs.level || 1;
+                return {
+                    id: blockId,
+                    type: 'heading',
+                    properties: {
+                        text: this.extractText(node),
+                        level: level
+                    },
+                    children: undefined
+                };
+            case 'paragraph':
+                return {
+                    id: blockId,
+                    type: 'paragraph',
+                    properties: {
+                        text: this.extractText(node)
+                    },
+                    children: undefined
+                };
+            case 'blockquote':
+                return {
+                    id: blockId,
+                    type: 'quote',
+                    properties: {
+                        text: this.extractText(node)
+                    },
+                    children: undefined
+                };
+            // ========== CODE & MEDIA BLOCKS ==========
+            case 'codeBlock':
+                return {
+                    id: blockId,
+                    type: 'code',
+                    properties: {
+                        language: attrs.language || 'plaintext',
+                        text: this.extractText(node)
+                    },
+                    children: undefined
+                };
+            case 'math':
+                return {
+                    id: blockId,
+                    type: 'math',
+                    properties: {
+                        src: attrs.src || this.extractText(node),
+                        display: attrs.display || 'block'
+                    },
+                    children: undefined
+                };
+            case 'image':
+            case 'imageBlock':
+                return {
+                    id: blockId,
+                    type: 'image',
+                    properties: {
+                        src: this.convertWebviewUriToRelativePath(attrs.src || ''),
+                        alt: attrs.alt || '',
+                        width: attrs.width || 800,
+                        height: attrs.height || 'auto',
+                        align: attrs.align || 'center',
+                        caption: attrs.caption || ''
+                    },
+                    children: undefined
+                };
+            case 'floatImageBlock':
+                // Float image is now a CONTAINER with content children
+                return {
+                    id: blockId,
+                    type: 'floatimage',
+                    properties: {
+                        src: this.convertWebviewUriToRelativePath(attrs.src || ''),
+                        alt: attrs.alt || '',
+                        width: attrs.width || 400,
+                        height: attrs.height || 'auto',
+                        float: attrs.float || 'left',
+                        caption: attrs.caption || '',
+                        title: attrs.title || '',
+                        description: attrs.description || '',
+                        image: attrs.image || '',
+                        sitename: attrs.siteName || ''
+                    },
+                    children: content.map(child => this.tiptapToBlock(child)) || []
+                };
+            case 'videoBlock':
+                return {
+                    id: blockId,
+                    type: 'video',
+                    properties: {
+                        type: attrs.type || 'youtube',
+                        src: this.convertWebviewUriToRelativePath(attrs.src || attrs.url || ''),
+                        title: attrs.title || '',
+                        width: attrs.width || 800,
+                        height: attrs.height || 450,
+                        controls: attrs.controls || 'true',
+                        autoplay: attrs.autoplay || 'false',
+                        muted: attrs.muted || 'false',
+                        loop: attrs.loop || 'false'
+                    },
+                    children: undefined
+                };
+            case 'codeReference':
+                return {
+                    id: blockId,
+                    type: 'codereference',
+                    properties: {
+                        path: attrs.path || '',
+                        lines: attrs.lines || '',
+                        language: attrs.language || 'typescript',
+                        text: this.extractText(node)
+                    },
+                    children: undefined
+                };
+            // ========== CONTAINER BLOCKS ==========
+            case 'callout':
+                return {
+                    id: blockId,
+                    type: 'callout',
+                    properties: {
+                        variant: attrs.variant || 'info',
+                        text: this.extractText(node)
+                    },
+                    children: undefined
+                };
+            case 'toggle':
+                return {
+                    id: blockId,
+                    type: 'toggle',
+                    properties: {
+                        title: attrs.title || 'Toggle',
+                        collapsed: attrs.collapsed ? 'true' : 'false'
+                    },
+                    children: content.map((child, i) => this.tiptapToBlock(child))
+                };
+            case 'section':
+                return {
+                    id: blockId,
+                    type: 'section',
+                    properties: {
+                        title: attrs.title || 'Section',
+                        collapsed: attrs.collapsed ? 'true' : 'false'
+                    },
+                    children: content.map((child, i) => this.tiptapToBlock(child))
+                };
+            // ========== LIST BLOCKS (write to children in jotx 2.0) ==========
+            case 'bulletList':
+            case 'orderedList':
+                return {
+                    id: blockId,
+                    type: 'list',
+                    properties: {
+                        listtype: node.type === 'orderedList' ? 'numbered' : 'bulleted'
+                    },
+                    children: content.map(child => this.tiptapToBlock(child))
+                };
+            case 'listItem':
+                // Segregate content: first paragraph is 'text', rest are children
+                let itemText = '';
+                const childBlocks = [];
+                let hasFoundText = false;
+                if (content) {
+                    for (const child of content) {
+                        // The first paragraph is considered the item's main text
+                        if (!hasFoundText && child.type === 'paragraph') {
+                            itemText = this.extractText(child);
+                            hasFoundText = true;
+                        }
+                        else {
+                            // Any other blocks (sub-lists, etc.) are children
+                            childBlocks.push(this.tiptapToBlock(child));
+                        }
+                    }
+                }
+                return {
+                    type: 'listitem',
+                    id: blockId,
+                    properties: {
+                        text: itemText
+                    },
+                    children: childBlocks.length > 0 ? childBlocks : undefined
+                };
+            case 'taskList':
+                return {
+                    type: 'checklist',
+                    id: blockId,
+                    properties: {},
+                    children: content.map(child => this.tiptapToBlock(child))
+                };
+            case 'taskItem':
+                // Same logic as listItem
+                let taskText = '';
+                const taskChildren = [];
+                let hasFoundTaskText = false;
+                if (content) {
+                    for (const child of content) {
+                        if (!hasFoundTaskText && child.type === 'paragraph') {
+                            taskText = this.extractText(child);
+                            hasFoundTaskText = true;
+                        }
+                        else {
+                            taskChildren.push(this.tiptapToBlock(child));
+                        }
+                    }
+                }
+                return {
+                    type: 'taskitem',
+                    id: blockId,
+                    properties: {
+                        checked: attrs.checked ? 'true' : 'false',
+                        text: taskText
+                    },
+                    children: taskChildren.length > 0 ? taskChildren : undefined
+                };
+            // ========== SEPARATOR & EMBED BLOCKS ==========
+            case 'horizontalRule':
+                return {
+                    id: blockId,
+                    type: 'divider',
+                    properties: {},
+                    children: undefined
+                };
+            case 'linkBlock':
+                return {
+                    id: blockId,
+                    type: 'link',
+                    properties: {
+                        text: this.extractText(node)
+                    },
+                    children: undefined
+                };
+            case 'attach':
+                return {
+                    id: blockId,
+                    type: 'attach',
+                    properties: {
+                        path: attrs.path || '',
+                        text: this.extractText(node)
+                    },
+                    children: content.map(child => this.tiptapToBlock(child))
+                };
+            // ========== RICH / INTERACTIVE BLOCKS ==========
+            case 'mermaid':
+                return {
+                    id: blockId,
+                    type: 'mermaid',
+                    properties: {
+                        src: attrs.src || this.extractText(node),
+                        showsource: attrs.showSource ? 'true' : 'false'
+                    },
+                    children: undefined
+                };
+            case 'chart':
+                return {
+                    id: blockId,
+                    type: 'chart',
+                    properties: {
+                        charttype: attrs.chartType || 'bar',
+                        json: attrs.json || this.extractText(node),
+                        showsource: attrs.showSource ? 'true' : 'false'
+                    },
+                    children: undefined
+                };
+            case 'datetime':
+                return {
+                    id: blockId,
+                    type: 'datetime',
+                    properties: {
+                        value: attrs.value || '',
+                        mode: attrs.mode || 'datetime',
+                        timezone: attrs.timezone || ''
+                    },
+                    children: undefined
+                };
+            case 'jotxlink':
+                return {
+                    id: blockId,
+                    type: 'jotxlink',
+                    properties: {
+                        target: attrs.target || '',
+                        text: attrs.text || ''
+                    },
+                    children: undefined
+                };
+            case 'blockref':
+                return {
+                    id: blockId,
+                    type: 'blockref',
+                    properties: {
+                        ref: attrs.ref || ''
+                    },
+                    children: undefined
+                };
+            // ========== TABLE (complex nested structure) ==========
+            case 'table':
+                const allRows = content;
+                const headerRow = allRows[0];
+                const dataRows = allRows.slice(1); // Skip header row
+                // Extract column names from header row
+                const columnNames = (headerRow?.content || []).map(cell => {
+                    // Extract text from the first paragraph in the cell
+                    const firstPara = cell.content?.[0];
+                    const text = firstPara?.content?.[0]?.text || '';
+                    return text.trim();
+                }).filter(Boolean);
+                // Check if this is a properties table (Key, Value, Type columns)
+                const isPropertiesTable = columnNames.length === 3 &&
+                    columnNames[0] === 'Key' &&
+                    columnNames[1] === 'Value' &&
+                    columnNames[2] === 'Type';
+                if (isPropertiesTable) {
+                    // Convert to properties block
+                    const props = dataRows.map((rowNode, i) => {
+                        const cells = rowNode.content || [];
+                        const keyCell = cells[0];
+                        const valueCell = cells[1];
+                        const typeCell = cells[2];
+                        // Extract text from cells
+                        const key = keyCell?.content?.[0]?.content?.[0]?.text || '';
+                        const value = valueCell?.content?.[0]?.content?.[0]?.text || '';
+                        const type = typeCell?.content?.[0]?.content?.[0]?.text || 'text';
+                        return {
+                            type: 'property',
+                            id: rowNode.attrs?.blockId || `prop_${i + 1}`,
+                            properties: {
+                                key,
+                                value,
+                                type
+                            },
+                            children: undefined
+                        };
+                    });
+                    return {
+                        id: blockId,
+                        type: 'properties',
+                        properties: {},
+                        children: props
+                    };
+                }
+                // Regular table
+                const columns = columnNames.join(', ');
+                // Convert data rows to jotx 2.0 structure (rows/cells as children)
+                const rows = dataRows.map((rowNode, i) => ({
+                    type: 'row',
+                    id: rowNode.attrs?.blockId || `row_${i + 1}`,
+                    properties: {},
+                    children: (rowNode.content || []).map((cellNode, j) => ({
+                        type: 'cell',
+                        id: cellNode.attrs?.blockId || `cell_${j + 1}`,
+                        properties: {},
+                        children: (cellNode.content || []).map((b) => this.tiptapToBlock(b))
+                    }))
+                }));
+                return {
+                    id: blockId,
+                    type: 'table',
+                    properties: {
+                        columns
+                    },
+                    children: rows
+                };
+            default:
+                // Fallback: convert to paragraph
+                return {
+                    id: blockId,
+                    type: 'paragraph',
+                    properties: {
+                        text: this.extractText(node)
+                    },
+                    children: undefined
+                };
+        }
+    }
+    /**
+     * Convert Tiptap document to BlockNodes
+     */
+    tiptapToBlocks(doc) {
+        return (doc.content || []).map((node) => this.tiptapToBlock(node));
+    }
+    /**
+     * Extract text content from Tiptap node WITH formatting (Markdown-style)
+     * Converts Tiptap marks to Markdown syntax for storage in jotx files
+     */
+    extractText(node) {
+        // Direct text node with marks
+        if (node.text !== undefined) {
+            let text = node.text;
+            // Apply marks in the correct order (innermost to outermost)
+            if (node.marks && node.marks.length > 0) {
+                // Sort marks for consistent nesting: code > link > strong > em > strike > highlight
+                const sortedMarks = [...node.marks].sort((a, b) => {
+                    const order = { code: 1, link: 2, bold: 3, strong: 3, italic: 4, em: 4, strike: 5, highlight: 6 };
+                    return (order[a.type] || 99) - (order[b.type] || 99);
+                });
+                for (const mark of sortedMarks) {
+                    switch (mark.type) {
+                        case 'code':
+                            text = `\`${text}\``;
+                            break;
+                        case 'link':
+                            const href = mark.attrs?.href || '';
+                            text = `[${text}](${href})`;
+                            break;
+                        case 'bold':
+                        case 'strong':
+                            text = `**${text}**`;
+                            break;
+                        case 'italic':
+                        case 'em':
+                            text = `*${text}*`;
+                            break;
+                        case 'strike':
+                            text = `~~${text}~~`;
+                            break;
+                        case 'highlight':
+                            text = `==${text}==`;
+                            break;
+                    }
+                }
+            }
+            return text;
+        }
+        // Recurse through content
+        if (!node.content)
+            return '';
+        return node.content.map(child => this.extractText(child)).join('');
+    }
+    /**
+     * Convert webview URI back to relative path for serialization
+     * Examples:
+     *   vscode-webview://.../ attachments/image.png → attachments/image.png
+     *   attachments/image.png → attachments/image.png (no change)
+     *   https://... → https://... (no change for external URLs)
+     */
+    convertWebviewUriToRelativePath(uri) {
+        if (!uri)
+            return '';
+        // Already a relative path? Return as-is
+        if (uri.startsWith('attachments/'))
+            return uri;
+        // External URL (http/https)? Return as-is
+        if (uri.startsWith('http://') || uri.startsWith('https://'))
+            return uri;
+        // Webview URI? Extract filename from path
+        if (uri.includes('vscode-webview://') || uri.includes('vscode-webview-resource://')) {
+            // Extract the last part after /attachments/
+            const match = uri.match(/\/attachments\/([^?#]+)/);
+            if (match) {
+                return `attachments/${decodeURIComponent(match[1])}`;
+            }
+        }
+        // Fallback: if it looks like a file path with attachments, extract it
+        if (uri.includes('/attachments/')) {
+            const parts = uri.split('/attachments/');
+            if (parts.length > 1) {
+                return `attachments/${decodeURIComponent(parts[parts.length - 1]).split('?')[0]}`;
+            }
+        }
+        // Can't parse - return original
+        return uri;
+    }
+}
+exports.TiptapAdapter = TiptapAdapter;
+//# sourceMappingURL=TiptapAdapter.js.map