@moldable-ai/editor 0.1.7 → 0.1.9

package/dist/lib/lexical/translation.test.js

@@ -1,329 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createMoldableHeadlessEditor } from './headless-editor';
-import { $extractTranslatableSegments, $applyTranslations, $getTextSegmentsForTranslation, translateEditorState, } from './translation';
-import { $convertFromMarkdownString, $convertToMarkdownString, markdownTransformers } from './markdown-transformers';
-describe('Translation Utilities', () => {
-    describe('$extractTranslatableSegments', () => {
-        it('extracts text from a simple paragraph', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: 'Hello world' });
-                    resolve();
-                });
-            });
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            expect(segments).toHaveLength(1);
-            expect(segments[0].text).toBe('Hello world');
-        });
-        it('extracts text from multiple paragraphs', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: 'First paragraph\n\nSecond paragraph' });
-                    resolve();
-                });
-            });
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            expect(segments).toHaveLength(2);
-            expect(segments[0].text).toBe('First paragraph');
-            expect(segments[1].text).toBe('Second paragraph');
-        });
-        it('extracts text from headings', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: '# Title\n\nContent' });
-                    resolve();
-                });
-            });
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            expect(segments).toHaveLength(2);
-            expect(segments[0].text).toBe('Title');
-            expect(segments[1].text).toBe('Content');
-        });
-        it('extracts text from list items', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: '- Item 1\n- Item 2\n- Item 3' });
-                    resolve();
-                });
-            });
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            expect(segments).toHaveLength(3);
-            expect(segments[0].text).toBe('Item 1');
-            expect(segments[1].text).toBe('Item 2');
-            expect(segments[2].text).toBe('Item 3');
-        });
-        it('handles bold and italic text as separate segments', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: 'This is **bold** and *italic* text' });
-                    resolve();
-                });
-            });
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            // Bold and italic are separate text nodes
-            expect(segments.length).toBeGreaterThanOrEqual(3);
-            const allText = segments.map(s => s.text).join('');
-            expect(allText).toContain('bold');
-            expect(allText).toContain('italic');
-        });
-        it('extracts text from blockquotes', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: '> This is a quote' });
-                    resolve();
-                });
-            });
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            expect(segments).toHaveLength(1);
-            expect(segments[0].text).toBe('This is a quote');
-        });
-    });
-    describe('$applyTranslations', () => {
-        it('applies translations to text nodes', async () => {
-            const editor = createMoldableHeadlessEditor();
-            // Set up initial content
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: 'Hello world' });
-                    resolve();
-                });
-            });
-            // Get segments
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            // Apply translations
-            const translationMap = new Map();
-            translationMap.set(segments[0].nodeKey, 'Hej verden');
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $applyTranslations(translationMap);
-                    resolve();
-                });
-            });
-            // Verify translation was applied
-            const result = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($convertToMarkdownString({ transformers: markdownTransformers }));
-                });
-            });
-            expect(result).toBe('Hej verden');
-        });
-        it('preserves structure when applying translations', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: '# Title\n\n- Item 1\n- Item 2' });
-                    resolve();
-                });
-            });
-            const segments = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($extractTranslatableSegments());
-                });
-            });
-            // Translate each segment
-            const translationMap = new Map();
-            segments.forEach((seg) => {
-                if (seg.text === 'Title')
-                    translationMap.set(seg.nodeKey, 'Titel');
-                if (seg.text === 'Item 1')
-                    translationMap.set(seg.nodeKey, 'Element 1');
-                if (seg.text === 'Item 2')
-                    translationMap.set(seg.nodeKey, 'Element 2');
-            });
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $applyTranslations(translationMap);
-                    resolve();
-                });
-            });
-            const result = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($convertToMarkdownString({ transformers: markdownTransformers }));
-                });
-            });
-            expect(result).toContain('# Titel');
-            expect(result).toContain('- Element 1');
-            expect(result).toContain('- Element 2');
-        });
-    });
-    describe('$getTextSegmentsForTranslation', () => {
-        it('returns parallel arrays of texts and keys', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: 'Hello\n\nWorld' });
-                    resolve();
-                });
-            });
-            const result = await new Promise((resolve) => {
-                editor.getEditorState().read(() => {
-                    resolve($getTextSegmentsForTranslation());
-                });
-            });
-            expect(result.texts).toHaveLength(2);
-            expect(result.nodeKeys).toHaveLength(2);
-            expect(result.texts[0]).toBe('Hello');
-            expect(result.texts[1]).toBe('World');
-        });
-    });
-    describe('translateEditorState', () => {
-        it('translates content and returns markdown', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: '# Hello\n\nWorld' });
-                    resolve();
-                });
-            });
-            // Mock translate function
-            const translateFn = async (texts) => {
-                return texts.map((t) => {
-                    if (t === 'Hello')
-                        return 'Bonjour';
-                    if (t === 'World')
-                        return 'Monde';
-                    return t;
-                });
-            };
-            const result = await translateEditorState(editor, translateFn);
-            expect(result).toContain('# Bonjour');
-            expect(result).toContain('Monde');
-        });
-        it('preserves formatting during translation', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({
-                        markdown: '**Bold text** and *italic text*'
-                    });
-                    resolve();
-                });
-            });
-            const translateFn = async (texts) => {
-                return texts.map((t) => `[${t}]`); // Just wrap for testing
-            };
-            const result = await translateEditorState(editor, translateFn);
-            // Should preserve bold and italic markers
-            expect(result).toContain('**');
-            expect(result).toContain('*');
-        });
-        it('handles complex medical note structure', async () => {
-            const editor = createMoldableHeadlessEditor();
-            const medicalNote = `# Patient Notes
-
-## Chief Complaint
-Patient presents with chest pain.
-
-## Assessment
-- Stable condition
-- No immediate concerns
-
-> Doctor's note: Follow up in 2 weeks`;
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: medicalNote });
-                    resolve();
-                });
-            });
-            // Simple translation that uppercases everything
-            const translateFn = async (texts) => {
-                return texts.map((t) => t.toUpperCase());
-            };
-            const result = await translateEditorState(editor, translateFn);
-            // Should preserve structure
-            expect(result).toContain('# PATIENT NOTES');
-            expect(result).toContain('## CHIEF COMPLAINT');
-            expect(result).toContain('- STABLE CONDITION');
-            expect(result).toContain('>');
-        });
-        it('handles empty content', async () => {
-            const editor = createMoldableHeadlessEditor();
-            await new Promise((resolve) => {
-                editor.update(() => {
-                    $convertFromMarkdownString({ markdown: '' });
-                    resolve();
-                });
-            });
-            const translateFn = async (texts) => texts;
-            const result = await translateEditorState(editor, translateFn);
-            expect(result).toBe('');
-        });
-    });
-    describe('round-trip translation', () => {
-        const testCases = [
-            { name: 'simple paragraph', markdown: 'Hello world' },
-            { name: 'heading', markdown: '# Title' },
-            { name: 'multiple headings', markdown: '# H1\n\n## H2\n\n### H3' },
-            { name: 'bullet list', markdown: '- Item 1\n- Item 2\n- Item 3' },
-            { name: 'numbered list', markdown: '1. First\n2. Second\n3. Third' },
-            { name: 'blockquote', markdown: '> This is a quote' },
-            { name: 'bold text', markdown: '**bold**' },
-            { name: 'italic text', markdown: '*italic*' },
-            { name: 'mixed formatting', markdown: 'Normal **bold** and *italic*' },
-            { name: 'code inline', markdown: 'Use `code` here' },
-            { name: 'horizontal rule', markdown: 'Before\n\n***\n\nAfter' },
-        ];
-        testCases.forEach(({ name, markdown }) => {
-            it(`preserves structure for ${name}`, async () => {
-                const editor = createMoldableHeadlessEditor();
-                await new Promise((resolve) => {
-                    editor.update(() => {
-                        $convertFromMarkdownString({ markdown });
-                        resolve();
-                    });
-                });
-                // Identity translation (no change)
-                const translateFn = async (texts) => texts;
-                const result = await translateEditorState(editor, translateFn);
-                // Re-import and re-export to normalize
-                const editor2 = createMoldableHeadlessEditor();
-                await new Promise((resolve) => {
-                    editor2.update(() => {
-                        $convertFromMarkdownString({ markdown });
-                        resolve();
-                    });
-                });
-                const expected = await new Promise((resolve) => {
-                    editor2.getEditorState().read(() => {
-                        resolve($convertToMarkdownString({ transformers: markdownTransformers }));
-                    });
-                });
-                expect(result).toBe(expected);
-            });
-        });
-    });
-});