vibeman 0.0.1 → 0.0.3

package/dist/runtime/api/lib/markdown-utils.js

@@ -1,282 +0,0 @@
-import { marked } from 'marked';
-import TurndownService from 'turndown';
-import { gfm } from 'turndown-plugin-gfm';
-marked.setOptions({
-    gfm: true,
-    breaks: false,
-});
-const turndownService = new TurndownService({
-    headingStyle: 'atx',
-    hr: '---',
-    bulletListMarker: '-',
-    codeBlockStyle: 'fenced',
-    fence: '```',
-});
-// Use GitHub Flavored Markdown plugin
-turndownService.use(gfm);
-// Custom rule for regular list items to use single space after dash
-turndownService.addRule('listItem', {
-    filter: (node) => {
-        return (node.nodeName === 'LI' && !node.getAttribute('data-type') // Not a task item
-        );
-    },
-    replacement: (content, node, _options) => {
-        content = content
-            .replace(/^\n+/, '') // Remove leading newlines
-            .replace(/\n+$/, '\n') // Replace trailing newlines with just one
-            .replace(/\n/gm, '\n  '); // Indent subsequent lines
-        let prefix = '- '; // Use single space after dash
-        const parent = node.parentNode;
-        if (parent && parent.nodeName === 'OL') {
-            const index = Array.prototype.indexOf.call(parent.children, node);
-            const start = parent.getAttribute('start');
-            const startIndex = start ? parseInt(start, 10) - 1 : 0;
-            prefix = startIndex + index + 1 + '. ';
-        }
-        return prefix + content + (node.nextSibling && !/\n$/.test(content) ? '\n' : '');
-    },
-});
-// Custom rule for TipTap TaskItems
-turndownService.addRule('tiptapTaskItem', {
-    filter: (node, _options) => {
-        return (node.nodeName === 'LI' &&
-            node.getAttribute('data-type') === 'taskItem' &&
-            node.getAttribute('data-checked') !== null);
-    },
-    replacement: (content, node) => {
-        const element = node;
-        const isChecked = element.getAttribute('data-checked') === 'true';
-        const checkbox = isChecked ? '[x]' : '[ ]';
-        // Extract text content from the div > p structure
-        const contentDiv = element.querySelector('div');
-        const textContent = contentDiv ? contentDiv.textContent?.trim() || '' : content.trim();
-        return `- ${checkbox} ${textContent}`;
-    },
-});
-// Custom rule for TipTap TaskLists - handles nested structure properly
-turndownService.addRule('tiptapTaskList', {
-    filter: (node) => {
-        return node.nodeName === 'UL' && node.getAttribute('data-type') === 'taskList';
-    },
-    replacement: (content, node) => {
-        // Process only direct child li elements to preserve nesting
-        const directItems = Array.from(node.children).filter((child) => child.nodeName === 'LI' && child.getAttribute('data-type') === 'taskItem');
-        if (directItems.length === 0)
-            return content;
-        const processTaskItem = (li, indent = '') => {
-            const isChecked = li.getAttribute('data-checked') === 'true';
-            const checkbox = isChecked ? '[x]' : '[ ]';
-            // Get text content from the div, excluding nested lists
-            const contentDiv = li.querySelector('div');
-            let textContent = '';
-            if (contentDiv) {
-                // Clone the div to avoid modifying the original
-                const tempDiv = contentDiv.cloneNode(true);
-                // Remove any nested ul elements from the clone to get just the text
-                const nestedLists = Array.from(tempDiv.querySelectorAll('ul'));
-                nestedLists.forEach((list) => {
-                    if (list instanceof Element) {
-                        list.remove();
-                    }
-                });
-                textContent = tempDiv.textContent?.trim() || '';
-            }
-            let result = `${indent}- ${checkbox} ${textContent}`;
-            // Process nested task lists
-            const nestedList = li.querySelector('ul[data-type="taskList"]');
-            if (nestedList) {
-                const nestedItems = Array.from(nestedList.children).filter((child) => child.nodeName === 'LI' && child.getAttribute('data-type') === 'taskItem');
-                nestedItems.forEach((nestedLi) => {
-                    if (nestedLi instanceof Element) {
-                        result += '\n' + processTaskItem(nestedLi, indent + '  ');
-                    }
-                });
-            }
-            return result;
-        };
-        return '\n' + directItems.map((li) => processTaskItem(li)).join('\n') + '\n';
-    },
-});
-// Override paragraph handling to preserve paragraph breaks
-// Ensure there is a blank line between paragraphs in markdown
-turndownService.addRule('paragraph', {
-    filter: 'p',
-    replacement: (content) => {
-        return '\n\n' + content.trim() + '\n\n';
-    },
-});
-/**
- * Clean up HTML by removing <p> tags within <li> elements under <ul> or <ol> lists
- */
-function cleanupListParagraphs(html) {
-    if (!html?.trim())
-        return html;
-    // Use DOM parsing to handle nested structures properly
-    if (typeof window !== 'undefined') {
-        const parser = new DOMParser();
-        const doc = parser.parseFromString(html, 'text/html');
-        // Find all <li> elements within <ul> or <ol>
-        const listItems = doc.querySelectorAll('ul > li, ol > li');
-        listItems.forEach((li) => {
-            // Find all <p> tags directly within this <li>
-            const paragraphs = Array.from(li.querySelectorAll('p'));
-            paragraphs.forEach((p) => {
-                // Only remove <p> if it's a direct child or within the list item structure
-                if (p.parentElement === li ||
-                    (p.parentElement && ['UL', 'OL', 'LI'].includes(p.parentElement.nodeName))) {
-                    // Replace <p> with its content
-                    const content = p.innerHTML;
-                    const textNode = doc.createDocumentFragment();
-                    textNode.appendChild(doc.createTextNode(content));
-                    // For better HTML structure, we'll replace with the content directly
-                    p.outerHTML = content;
-                }
-            });
-        });
-        return doc.body.innerHTML;
-    }
-    // Fallback for server-side: use regex approach (less robust but works)
-    // Remove <p> and </p> tags within <li> elements
-    return html
-        .replace(/<li([^>]*)><p>/g, '<li$1>')
-        .replace(/<\/p><\/li>/g, '</li>')
-        .replace(/<\/p><ul>/g, '<ul>')
-        .replace(/<\/p><ol>/g, '<ol>')
-        .replace(/<\/ul><p>/g, '</ul>')
-        .replace(/<\/ol><p>/g, '</ol>');
-}
-/**
- * Convert GFM checkbox HTML to Tiptap TaskItem format
- */
-function convertToTiptapTaskItems(html) {
-    if (!html?.trim())
-        return html;
-    // Use DOM parsing for better accuracy
-    if (typeof window !== 'undefined') {
-        const parser = new DOMParser();
-        const doc = parser.parseFromString(html, 'text/html');
-        // Process all ul elements, starting from the deepest nested ones
-        const lists = Array.from(doc.querySelectorAll('ul')).reverse();
-        lists.forEach((ul) => {
-            let hasTaskItems = false;
-            // Only process direct children li elements to preserve nesting
-            const directListItems = Array.from(ul.children).filter((child) => child.nodeName === 'LI');
-            directListItems.forEach((li) => {
-                const checkbox = li.querySelector('input[type="checkbox"]');
-                if (checkbox) {
-                    hasTaskItems = true;
-                    // Get the checkbox state
-                    const isChecked = checkbox.hasAttribute('checked');
-                    // Set TaskItem attributes
-                    li.setAttribute('data-type', 'taskItem');
-                    li.setAttribute('data-checked', isChecked ? 'true' : 'false');
-                    // Get the text content, preserving nested structure
-                    const clonedLi = li.cloneNode(true);
-                    // Remove the checkbox from the clone
-                    const clonedCheckbox = clonedLi.querySelector('input[type="checkbox"]');
-                    if (clonedCheckbox) {
-                        clonedCheckbox.remove();
-                    }
-                    // Extract nested lists to preserve them
-                    const nestedLists = Array.from(clonedLi.querySelectorAll('ul'));
-                    const nestedListsHTML = nestedLists.map((list) => list.outerHTML);
-                    // Remove nested lists temporarily to get just the text content
-                    nestedLists.forEach((list) => {
-                        if (list instanceof Element) {
-                            list.remove();
-                        }
-                    });
-                    // Get the text content
-                    const textContent = clonedLi.textContent?.trim() || '';
-                    // Create the proper TipTap structure
-                    let innerHTML = `
-            <label contenteditable="false">
-              <input type="checkbox" ${isChecked ? 'checked' : ''}>
-              <span></span>
-            </label>
-            <div>
-              <p>${textContent}</p>`;
-                    // Add back any nested lists, ensuring they have the correct data-type
-                    if (nestedListsHTML.length > 0) {
-                        nestedListsHTML.forEach((nestedHTML) => {
-                            // Make sure nested task lists have the correct data-type attribute
-                            let processedHTML = nestedHTML;
-                            if (nestedHTML.includes('data-type="taskItem"') &&
-                                !nestedHTML.includes('data-type="taskList"')) {
-                                processedHTML = nestedHTML.replace('<ul>', '<ul data-type="taskList">');
-                            }
-                            innerHTML += processedHTML;
-                        });
-                    }
-                    innerHTML += '</div>';
-                    li.innerHTML = innerHTML.trim();
-                }
-            });
-            // If this ul contains task items, mark it as a taskList
-            if (hasTaskItems) {
-                ul.setAttribute('data-type', 'taskList');
-            }
-        });
-        return doc.body.innerHTML;
-    }
-    // Fallback for server-side: use regex approach (less robust)
-    return (html
-        // First pass: Convert list items with checkboxes
-        .replace(/<li>(\s*)<input\s+([^>]*?)type="checkbox"([^>]*?)>([^<]*)/gi, (match, leadingSpace, beforeType, afterType, textContent) => {
-        const isChecked = beforeType.includes('checked') || afterType.includes('checked');
-        const cleanText = textContent.trim();
-        return `<li data-type="taskItem" data-checked="${isChecked ? 'true' : 'false'}">
-          <label contenteditable="false">
-            <input type="checkbox" ${isChecked ? 'checked' : ''}>
-            <span></span>
-          </label>
-          <div>
-            <p>${cleanText}</p>
-          </div>`;
-    })
-        // Second pass: Mark parent ul as taskList if it contains taskItems
-        .replace(/<ul>(\s*(?:<li[^>]*data-type="taskItem"[^>]*>[\s\S]*?<\/li>\s*)+)<\/ul>/gi, '<ul data-type="taskList">$1</ul>'));
-}
-/**
- * Pre-process markdown to ensure proper task list item boundaries
- */
-function preprocessMarkdownTaskItems(markdown) {
-    if (!markdown?.trim())
-        return markdown;
-    // Split markdown into lines
-    const lines = markdown.split('\n');
-    const processedLines = [];
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const nextLine = i + 1 < lines.length ? lines[i + 1] : '';
-        processedLines.push(line);
-        // If current line is a task item and next line is not empty and not indented
-        // and not another list item, add a blank line to separate them
-        if (line.trim().match(/^-\s+\[[ x]\]/) &&
-            nextLine.trim() &&
-            !nextLine.match(/^-\s+/) &&
-            !nextLine.match(/^\s{2,}/)) {
-            processedLines.push(''); // Add blank line
-        }
-    }
-    return processedLines.join('\n');
-}
-/**
- * Convert markdown to HTML for Tiptap editor
- */
-export function markdownToHtml(markdown) {
-    if (!markdown?.trim())
-        return '';
-    const preprocessedMarkdown = preprocessMarkdownTaskItems(markdown);
-    const html = marked(preprocessedMarkdown);
-    return convertToTiptapTaskItems(html);
-}
-/**
- * Convert HTML to markdown for storage
- */
-export function htmlToMarkdown(html) {
-    if (!html?.trim())
-        return '';
-    const cleanedHtml = cleanupListParagraphs(html);
-    return turndownService.turndown(cleanedHtml);
-}

package/dist/runtime/api/lib/markdown-utils.test.js

@@ -1,348 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { markdownToHtml, htmlToMarkdown } from './markdown-utils.js';
-describe('markdown-utils', () => {
-    describe('markdownToHtml', () => {
-        it('should return empty string for empty input', () => {
-            expect(markdownToHtml('')).toBe('');
-            expect(markdownToHtml('  ')).toBe('');
-            expect(markdownToHtml(null)).toBe('');
-            expect(markdownToHtml(undefined)).toBe('');
-        });
-        it('should convert task item to HTML', () => {
-            const markdown = `- [ ] Task item
-- [x] Checked task`;
-            const html = markdownToHtml(markdown);
-            // Check for proper TipTap TaskList structure
-            expect(html).toContain('data-type="taskList"');
-            expect(html).toContain('data-type="taskItem"');
-            expect(html).toContain('data-checked="false"');
-            expect(html).toContain('data-checked="true"');
-            expect(html).toContain('<label contenteditable="false">');
-            expect(html).toContain('<input type="checkbox" >');
-            expect(html).toContain('<input type="checkbox" checked>');
-            expect(html).toContain('<p>Task item</p>');
-            expect(html).toContain('<p>Checked task</p>');
-        });
-        it('should convert basic markdown to HTML', () => {
-            const markdown = '# Heading 1\n\nThis is a paragraph.\n\n**Bold text** and *italic text*.';
-            const html = markdownToHtml(markdown);
-            expect(html).toContain('<h1>Heading 1</h1>');
-            expect(html).toContain('<p>This is a paragraph.</p>');
-            expect(html).toContain('<strong>Bold text</strong>');
-            expect(html).toContain('<em>italic text</em>');
-        });
-        //     it('should convert simple task lists to HTML with data-type attribute', () => {
-        //       const markdown = '- [ ] Unchecked task\n- [x] Checked task';
-        //       const html = markdownToHtml(markdown);
-        //       expect(html).toContain('data-type="taskItem"');
-        //       expect(html).toContain('<input type="checkbox" disabled>');
-        //       expect(html).toContain('<input type="checkbox" checked disabled>');
-        //       expect(html).toContain('Unchecked task');
-        //       expect(html).toContain('Checked task');
-        //     });
-        //     it('should handle two-level nested task lists', () => {
-        //       const markdown = `- [ ] Parent task
-        //   - [ ] Child task 1
-        //   - [x] Child task 2`;
-        //       const html = markdownToHtml(markdown);
-        //       expect(html).toContain('Parent task');
-        //       expect(html).toContain('Child task 1');
-        //       expect(html).toContain('Child task 2');
-        //       expect(html).toMatch(/<ul>[\s\S]*<ul>/); // Nested ul elements
-        //     });
-        //     it('should handle three-level nested task lists', () => {
-        //       const markdown = `- [ ] Level 1
-        //   - [ ] Level 2
-        //     - [x] Level 3`;
-        //       const html = markdownToHtml(markdown);
-        //       expect(html).toContain('Level 1');
-        //       expect(html).toContain('Level 2');
-        //       expect(html).toContain('Level 3');
-        //       // Should have at least 3 ul elements for 3 levels
-        //       const ulCount = (html.match(/<ul>/g) || []).length;
-        //       expect(ulCount).toBeGreaterThanOrEqual(3);
-        //     });
-        //     it('should handle deeply nested task lists (5 levels)', () => {
-        //       const markdown = `- [ ] Level 1
-        //   - [ ] Level 2
-        //     - [ ] Level 3
-        //       - [ ] Level 4
-        //         - [x] Level 5`;
-        //       const html = markdownToHtml(markdown);
-        //       expect(html).toContain('Level 1');
-        //       expect(html).toContain('Level 5');
-        //       const ulCount = (html.match(/<ul>/g) || []).length;
-        //       expect(ulCount).toBeGreaterThanOrEqual(5);
-        //     });
-        //     it('should handle mixed task lists and regular lists', () => {
-        //       const markdown = `- [ ] Task item
-        //   - Regular nested item
-        //   - [ ] Nested task
-        // - Another regular item`;
-        //       const html = markdownToHtml(markdown);
-        //       expect(html).toContain('Task item');
-        //       expect(html).toContain('Regular nested item');
-        //       expect(html).toContain('Nested task');
-        //       expect(html).toContain('Another regular item');
-        //     });
-        //     it('should handle task lists with complex content', () => {
-        //       const markdown = `- [ ] Task with **bold** and *italic*
-        //   - [ ] Task with \`code\`
-        //   - [ ] Task with [link](https://example.com)`;
-        //       const html = markdownToHtml(markdown);
-        //       // Complex markdown inside task items may not be parsed yet
-        //       // This is a known limitation - task item text is not re-parsed for markdown
-        //       expect(html).toContain('Task with **bold** and *italic*');
-        //       expect(html).toContain('Task with `code`');
-        //       expect(html).toContain('Task with [link](https://example.com)');
-        //     });
-        it('should handle numbered lists', () => {
-            const markdown = '1. First item\n2. Second item\n3. Third item';
-            const html = markdownToHtml(markdown);
-            expect(html).toContain('<ol>');
-            expect(html).toContain('First item');
-            expect(html).toContain('Second item');
-        });
-        it('should handle code blocks', () => {
-            const markdown = '```javascript\nconst hello = "world";\n```';
-            const html = markdownToHtml(markdown);
-            expect(html).toContain('<pre>');
-            expect(html).toContain('<code');
-            expect(html).toContain('hello');
-        });
-        it('should handle blockquotes', () => {
-            const markdown = '> This is a quote';
-            const html = markdownToHtml(markdown);
-            expect(html).toContain('<blockquote>');
-            expect(html).toContain('This is a quote');
-        });
-    });
-    describe('htmlToMarkdown', () => {
-        it('should return empty string for empty input', () => {
-            expect(htmlToMarkdown('')).toBe('');
-            expect(htmlToMarkdown('  ')).toBe('');
-            expect(htmlToMarkdown(null)).toBe('');
-            expect(htmlToMarkdown(undefined)).toBe('');
-        });
-        it('should convert basic HTML to markdown', () => {
-            const html = '<h1>Heading 1</h1><p>This is a paragraph.</p><p><strong>Bold text</strong> and <em>italic text</em>.</p>';
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('# Heading 1');
-            expect(markdown).toContain('This is a paragraph.');
-            expect(markdown).toContain('**Bold text**');
-            // Turndown uses underscore for italic by default
-            expect(markdown).toContain('_italic text_');
-        });
-        it('should convert task list HTML back to markdown', () => {
-            const html = `<ul>
-        <li data-type="taskItem"><input type="checkbox" disabled> Unchecked task</li>
-        <li data-type="taskItem"><input type="checkbox" checked disabled> Checked task</li>
-      </ul>`;
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('-   [ ]  Unchecked task');
-            expect(markdown).toContain('-   [x]  Checked task');
-        });
-        it('should preserve two-level nested task list indentation', () => {
-            const html = `<ul>
-        <li data-type="taskItem"><input type="checkbox" disabled> Parent task
-          <ul>
-            <li data-type="taskItem"><input type="checkbox" disabled> Child task 1</li>
-            <li data-type="taskItem"><input type="checkbox" checked disabled> Child task 2</li>
-          </ul>
-        </li>
-      </ul>`;
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('-   [ ]  Parent task');
-            expect(markdown).toContain('    -   [ ]  Child task 1');
-            expect(markdown).toContain('    -   [x]  Child task 2');
-        });
-        it('should preserve three-level nested task list indentation', () => {
-            const html = `<ul>
-        <li data-type="taskItem"><input type="checkbox" disabled> Level 1
-          <ul>
-            <li data-type="taskItem"><input type="checkbox" disabled> Level 2
-              <ul>
-                <li data-type="taskItem"><input type="checkbox" checked disabled> Level 3</li>
-              </ul>
-            </li>
-          </ul>
-        </li>
-      </ul>`;
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('-   [ ]  Level 1');
-            expect(markdown).toContain('    -   [ ]  Level 2');
-            expect(markdown).toContain('        -   [x]  Level 3');
-        });
-        it('should handle regular nested lists', () => {
-            const html = `<ul>
-        <li>Parent item
-          <ul>
-            <li>Child item 1</li>
-            <li>Child item 2</li>
-          </ul>
-        </li>
-      </ul>`;
-            const markdown = htmlToMarkdown(html);
-            // Turndown may add extra spacing in lists
-            expect(markdown).toContain('Parent item');
-            expect(markdown).toContain('Child item 1');
-            expect(markdown).toContain('Child item 2');
-            // Check for proper nesting with indentation
-            expect(markdown).toMatch(/.*Child item 1/);
-        });
-        it('should handle numbered lists', () => {
-            const html = '<ol><li>First</li><li>Second</li><li>Third</li></ol>';
-            const markdown = htmlToMarkdown(html);
-            // Turndown may add extra spacing after the period
-            expect(markdown).toMatch(/1\.\s+First/);
-            expect(markdown).toMatch(/2\.\s+Second/);
-            expect(markdown).toMatch(/3\.\s+Third/);
-        });
-        it('should handle code blocks', () => {
-            const html = '<pre><code class="language-javascript">const hello = "world";</code></pre>';
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('```');
-            expect(markdown).toContain('const hello = "world";');
-        });
-        it('should handle inline code', () => {
-            const html = '<p>Use <code>npm install</code> to install.</p>';
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('`npm install`');
-        });
-        it('should handle links', () => {
-            const html = '<p>Visit <a href="https://example.com">example</a></p>';
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('[example](https://example.com)');
-        });
-        it('should handle blockquotes', () => {
-            const html = '<blockquote><p>This is a quote</p></blockquote>';
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('> This is a quote');
-        });
-        it('should handle horizontal rules', () => {
-            const html = '<hr>';
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('---');
-        });
-        it('should render list item', () => {
-            const html = '<li>Test</li>';
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('- Test');
-        });
-    });
-    //   describe('Round-trip conversion', () => {
-    //     it('should preserve simple task lists through round-trip conversion', () => {
-    //       const original = '- [ ] Task 1\n- [x] Task 2';
-    //       const html = markdownToHtml(original);
-    //       const result = htmlToMarkdown(html);
-    //       expect(result).toContain('- [ ] Task 1');
-    //       expect(result).toContain('- [x] Task 2');
-    //     });
-    //     it('should preserve two-level nested task lists through round-trip conversion', () => {
-    //       const original = `- [ ] Parent task
-    //   - [ ] Child task 1
-    //   - [x] Child task 2`;
-    //       const html = markdownToHtml(original);
-    //       const result = htmlToMarkdown(html);
-    //       expect(result).toContain('- [ ] Parent task');
-    //       expect(result).toContain('  - [ ] Child task 1');
-    //       expect(result).toContain('  - [x] Child task 2');
-    //     });
-    //     it('should preserve three-level nested task lists through round-trip conversion', () => {
-    //       const original = `- [ ] Level 1
-    //   - [ ] Level 2
-    //     - [x] Level 3`;
-    //       const html = markdownToHtml(original);
-    //       const result = htmlToMarkdown(html);
-    //       expect(result).toContain('- [ ] Level 1');
-    //       expect(result).toContain('  - [ ] Level 2');
-    //       expect(result).toContain('    - [x] Level 3');
-    //     });
-    //     it('should preserve complex nested task list structure', () => {
-    //       const original = `- [ ] Task 1
-    //   - [ ] Task 1.1
-    //   - [x] Task 1.2
-    //     - [ ] Task 1.2.1
-    //     - [ ] Task 1.2.2
-    // - [ ] Task 2
-    //   - [ ] Task 2.1`;
-    //       const html = markdownToHtml(original);
-    //       const result = htmlToMarkdown(html);
-    //       // Check all items are present
-    //       expect(result).toContain('- [ ] Task 1');
-    //       expect(result).toContain('  - [ ] Task 1.1');
-    //       expect(result).toContain('  - [x] Task 1.2');
-    //       expect(result).toContain('    - [ ] Task 1.2.1');
-    //       expect(result).toContain('    - [ ] Task 1.2.2');
-    //       expect(result).toContain('- [ ] Task 2');
-    //       expect(result).toContain('  - [ ] Task 2.1');
-    //     });
-    //     it('should handle task list with description formatting', () => {
-    //       const original = `- [ ] Add button to trigger task refinement
-    //   - [ ] **Description**: Clear explanation
-    //   - [ ] *Acceptance Criteria*: Tests pass
-    //   - [ ] \`Technical Details\`: Use React`;
-    //       const html = markdownToHtml(original);
-    //       const result = htmlToMarkdown(html);
-    //       expect(result).toContain('- [ ] Add button to trigger task refinement');
-    //       // Markdown inside task items may not be preserved through round-trip
-    //       // This is a known limitation of the current implementation
-    //       expect(result).toContain('Description');
-    //       expect(result).toContain('Acceptance Criteria');
-    //       expect(result).toContain('Technical Details');
-    //     });
-    //   });
-    describe('Edge cases', () => {
-        it('should handle malformed task list syntax gracefully', () => {
-            const markdown = '- [] Invalid task\n-[x] Another invalid\n- [ ] Valid task';
-            const html = markdownToHtml(markdown);
-            // Should still parse what it can
-            expect(html).toContain('Valid task');
-        });
-        // it('should handle empty task descriptions', () => {
-        //   const markdown = '- [ ] \n- [x] ';
-        //   const html = markdownToHtml(markdown);
-        //   expect(html).toContain('data-type="taskItem"');
-        // });
-        // it('should handle very deeply nested lists (10 levels)', () => {
-        //   let markdown = '- [ ] L1';
-        //   for (let i = 2; i <= 10; i++) {
-        //     markdown += '\n' + '  '.repeat(i - 1) + `- [ ] L${i}`;
-        //   }
-        //   const html = markdownToHtml(markdown);
-        //   const result = htmlToMarkdown(html);
-        //   expect(result).toContain('- [ ] L1');
-        //   expect(result).toContain('  '.repeat(9) + '- [ ] L10');
-        // });
-        it('should handle mixed content in list items', () => {
-            const html = `<ul>
-        <li data-type="taskItem"><input type="checkbox" disabled> Task with <strong>bold</strong> and <a href="#">link</a></li>
-      </ul>`;
-            const markdown = htmlToMarkdown(html);
-            expect(markdown).toContain('-   [ ]  Task with **bold** and [link](#)');
-        });
-        it('should strip extra whitespace properly', () => {
-            const html = `<ul>
-        <li data-type="taskItem">  <input type="checkbox" disabled>   Task with spaces   </li>
-      </ul>`;
-            const markdown = htmlToMarkdown(html);
-            expect(markdown.trim()).toBe('-   [ ]  Task with spaces');
-        });
-        it('should handle nested task lists properly', () => {
-            const nestedMarkdown = `- [ ] Parent task with nested items:
-  - [ ] Child task 1
-  - [x] Child task 2`;
-            const html = markdownToHtml(nestedMarkdown);
-            // Check that HTML contains proper nesting structure
-            expect(html).toContain('data-type="taskList"');
-            expect(html).toContain('data-type="taskItem"');
-            expect(html).toContain('data-checked="false"');
-            expect(html).toContain('data-checked="true"');
-            expect(html).toContain('Parent task with nested items:');
-            expect(html).toContain('Child task 1');
-            expect(html).toContain('Child task 2');
-            // Verify the nested structure is present in HTML
-            expect(html).toMatch(/<li[^>]*data-type="taskItem"[^>]*>.*<ul>.*<li[^>]*data-type="taskItem"/s);
-        });
-    });
-});

package/dist/runtime/api/lib/tiptap-utils.clamp-selection.test.js

@@ -1,27 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { clampSelectionPos } from './tiptap-utils.js';
-describe('clampSelectionPos', () => {
-    it('keeps positions within valid range', () => {
-        const res = clampSelectionPos(5, 8, 20);
-        expect(res).toEqual({ from: 5, to: 8 });
-    });
-    it('clamps underflow to 1', () => {
-        const res = clampSelectionPos(-10, 0, 20);
-        expect(res).toEqual({ from: 1, to: 1 });
-    });
-    it('clamps overflow to doc.nodeSize - 2', () => {
-        const res = clampSelectionPos(100, 200, 20);
-        // maxPos = 18 for nodeSize 20
-        expect(res).toEqual({ from: 18, to: 18 });
-    });
-    it('orders from/to when anchor > head', () => {
-        const res = clampSelectionPos(10, 5, 20);
-        expect(res).toEqual({ from: 5, to: 10 });
-    });
-    it('handles tiny documents safely', () => {
-        const res0 = clampSelectionPos(5, 6, 0);
-        expect(res0).toEqual({ from: 1, to: 1 });
-        const res1 = clampSelectionPos(2, 3, 1);
-        expect(res1).toEqual({ from: 1, to: 1 });
-    });
-});