koguma 0.6.6 → 2.0.0

package/src/rich-text/lexical-compat.test.ts

@@ -1,513 +0,0 @@
-/**
- * lexical-compat.test.ts
- *
- * Compatibility matrix — ensures lexicalToKoguma() correctly handles every
- * node type registered in koguma's admin editor (admin/src/components/blocks/editor-x/nodes.ts).
- *
- * Uses real-world JSON fixtures that mirror what Lexical actually serializes.
- * No Lexical package import required — purely JSON-driven.
- */
-import { describe, test, expect } from 'bun:test';
-import { lexicalToKoguma } from './lexical-to-koguma.ts';
-
-// ── Node registry (mirrors admin/src/components/blocks/editor-x/nodes.ts) ──
-// This list defines what MUST be handled (or intentionally stripped).
-// If you add a node to the editor, add a fixture and assertion here.
-
-const NODE_REGISTRY = [
-  // Core Lexical
-  'root', // handled: wraps everything
-  'paragraph', // → { type: 'paragraph' }
-  'text', // → { type: 'text' }
-  'linebreak', // → { type: 'line-break' } inline
-  // @lexical/rich-text
-  'heading', // → { type: 'heading', level }
-  'quote', // → { type: 'quote' }
-  // @lexical/list
-  'list', // → { type: 'list', ordered, items }
-  'listitem', // → KogumaListItem
-  // @lexical/link
-  'link', // → { type: 'link' }
-  'autolink', // → { type: 'link' } (same shape)
-  // @lexical/table
-  'table', // → { type: 'table' }
-  'tablerow', // → KogumaTableRow
-  'tablecell', // → KogumaTableCell
-  // @lexical/code
-  'code', // → { type: 'code', text }
-  'code-highlight', // → concatenated into parent code.text
-  // @lexical/overflow
-  'overflow', // STRIPPED: editor UI only
-  // @lexical/hashtag
-  'hashtag', // → { type: 'custom', name: 'hashtag' } inline
-  // Custom admin nodes
-  'image', // → { type: 'image' }
-  'tweet', // → { type: 'custom', name: 'tweet' }
-  'youtube', // → { type: 'custom', name: 'youtube' }
-  'layoutcontainer', // → { type: 'layout', columns }
-  'layoutitem', // handled by layoutcontainer conversion
-  'mention', // → { type: 'custom', name: 'mention' } inline
-  'emoji', // → { type: 'text' } (flattened)
-  'keyword', // STRIPPED: editor UI only
-  'autocomplete' // STRIPPED: editor UI only
-] as const;
-
-// Helper: wrap node(s) in a Lexical root state
-function state(children: Record<string, unknown>[]): unknown {
-  return { root: { type: 'root', version: 1, children } };
-}
-function para(children: Record<string, unknown>[]): Record<string, unknown> {
-  return { type: 'paragraph', version: 1, format: 0, children };
-}
-function text(t: string, format = 0): Record<string, unknown> {
-  return { type: 'text', text: t, format, version: 1 };
-}
-
-// ── Per-node assertions ───────────────────────────────────────────────
-
-describe('Lexical compat — registered node coverage', () => {
-  test('paragraph → { type: "paragraph" }', () => {
-    const doc = lexicalToKoguma(state([para([text('Hello')])]));
-    expect(doc.nodes[0].type).toBe('paragraph');
-  });
-
-  test('text → { type: "text" } inline', () => {
-    const doc = lexicalToKoguma(state([para([text('World')])]));
-    const p = doc.nodes[0] as {
-      children: Array<{ type: string; text: string }>;
-    };
-    expect(p.children[0].type).toBe('text');
-    expect(p.children[0].text).toBe('World');
-  });
-
-  test('linebreak → { type: "line-break" } inline', () => {
-    const doc = lexicalToKoguma(
-      state([para([text('A'), { type: 'linebreak', version: 1 }, text('B')])])
-    );
-    const p = doc.nodes[0] as { children: Array<{ type: string }> };
-    expect(p.children[1].type).toBe('line-break');
-  });
-
-  test('heading h1–h6 → { type: "heading", level }', () => {
-    for (let level = 1; level <= 6; level++) {
-      const doc = lexicalToKoguma(
-        state([
-          {
-            type: 'heading',
-            version: 1,
-            tag: `h${level}`,
-            children: [text(`H${level}`)]
-          }
-        ])
-      );
-      const h = doc.nodes[0] as { type: string; level: number };
-      expect(h.type).toBe('heading');
-      expect(h.level).toBe(level);
-    }
-  });
-
-  test('quote → { type: "quote" }', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'quote',
-          version: 1,
-          children: [para([text('Wise words')])]
-        }
-      ])
-    );
-    expect(doc.nodes[0].type).toBe('quote');
-  });
-
-  test('list (bullet) → { type: "list", ordered: false }', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'list',
-          version: 1,
-          listType: 'bullet',
-          start: 1,
-          tag: 'ul',
-          children: [
-            { type: 'listitem', version: 1, value: 1, children: [text('Item')] }
-          ]
-        }
-      ])
-    );
-    const l = doc.nodes[0] as { ordered: boolean; items: unknown[] };
-    expect(l.ordered).toBe(false);
-    expect(l.items).toHaveLength(1);
-  });
-
-  test('list (number) → { type: "list", ordered: true }', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'list',
-          version: 1,
-          listType: 'number',
-          start: 1,
-          tag: 'ol',
-          children: [
-            { type: 'listitem', version: 1, value: 1, children: [text('One')] }
-          ]
-        }
-      ])
-    );
-    expect((doc.nodes[0] as { ordered: boolean }).ordered).toBe(true);
-  });
-
-  test('list (check) → items with checked property', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'list',
-          version: 1,
-          listType: 'check',
-          start: 1,
-          tag: 'ul',
-          children: [
-            {
-              type: 'listitem',
-              version: 1,
-              value: 1,
-              checked: true,
-              children: [text('Done')]
-            },
-            {
-              type: 'listitem',
-              version: 1,
-              value: 2,
-              checked: false,
-              children: [text('Todo')]
-            }
-          ]
-        }
-      ])
-    );
-    const items = (doc.nodes[0] as { items: Array<{ checked?: boolean }> })
-      .items;
-    expect(items[0].checked).toBe(true);
-    expect(items[1].checked).toBe(false);
-  });
-
-  test('link → { type: "link" } inline', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([
-          {
-            type: 'link',
-            version: 1,
-            url: 'https://koguma.dev',
-            target: null,
-            children: [text('Koguma')]
-          }
-        ])
-      ])
-    );
-    const p = doc.nodes[0] as { children: Array<{ type: string }> };
-    expect(p.children[0].type).toBe('link');
-  });
-
-  test('autolink → { type: "link" } (same as link)', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([
-          {
-            type: 'autolink',
-            version: 1,
-            url: 'https://auto.link',
-            target: null,
-            children: [text('auto')]
-          }
-        ])
-      ])
-    );
-    const p = doc.nodes[0] as { children: Array<{ type: string }> };
-    expect(p.children[0].type).toBe('link');
-  });
-
-  test('table → { type: "table" } with rows/cells', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'table',
-          version: 1,
-          children: [
-            {
-              type: 'tablerow',
-              version: 1,
-              children: [
-                { type: 'tablecell', version: 1, children: [text('Col A')] }
-              ]
-            }
-          ]
-        }
-      ])
-    );
-    expect(doc.nodes[0].type).toBe('table');
-    const t = doc.nodes[0] as { rows: Array<{ cells: unknown[] }> };
-    expect(t.rows[0].cells).toHaveLength(1);
-  });
-
-  test('code + code-highlight children → { type: "code", text }', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'code',
-          version: 1,
-          language: 'js',
-          children: [
-            {
-              type: 'code-highlight',
-              text: 'let',
-              highlightType: 'keyword',
-              version: 1
-            },
-            { type: 'text', text: ' x = 1', format: 0, version: 1 }
-          ]
-        }
-      ])
-    );
-    const code = doc.nodes[0] as { type: string; text: string };
-    expect(code.type).toBe('code');
-    expect(code.text).toBe('let x = 1');
-  });
-
-  test('overflow → stripped (null/not in output)', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([text('Real')]),
-        { type: 'overflow', version: 1, children: [] }
-      ])
-    );
-    expect(doc.nodes).toHaveLength(1);
-  });
-
-  test('hashtag → { type: "custom", name: "hashtag" } inline', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([
-          { type: 'hashtag', version: 1, hashtag: 'openai', text: '#openai' }
-        ])
-      ])
-    );
-    const p = doc.nodes[0] as {
-      children: Array<{
-        type: string;
-        name: string;
-        data: Record<string, unknown>;
-      }>;
-    };
-    expect(p.children[0].type).toBe('custom');
-    expect(p.children[0].name).toBe('hashtag');
-    expect(p.children[0].data.tag).toBe('openai');
-  });
-
-  test('ImageNode → { type: "image" } block', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'image',
-          version: 1,
-          src: 'https://cdn.example.com/bear.jpg',
-          altText: 'A bear',
-          width: 1200,
-          height: 800,
-          children: []
-        }
-      ])
-    );
-    const img = doc.nodes[0] as {
-      type: string;
-      url: string;
-      alt?: string;
-      width?: number;
-    };
-    expect(img.type).toBe('image');
-    expect(img.url).toBe('https://cdn.example.com/bear.jpg');
-    expect(img.alt).toBe('A bear');
-    expect(img.width).toBe(1200);
-  });
-
-  test('TweetNode → { type: "custom", name: "tweet" } block', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'tweet',
-          version: 1,
-          tweetId: '1234567890',
-          children: []
-        }
-      ])
-    );
-    const custom = doc.nodes[0] as {
-      type: string;
-      name: string;
-      data: Record<string, unknown>;
-    };
-    expect(custom.type).toBe('custom');
-    expect(custom.name).toBe('tweet');
-    expect(custom.data.tweetId).toBe('1234567890');
-  });
-
-  test('YouTubeNode → { type: "custom", name: "youtube" } block', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'youtube',
-          version: 1,
-          videoId: 'dQw4w9WgXcQ',
-          children: []
-        }
-      ])
-    );
-    const custom = doc.nodes[0] as {
-      type: string;
-      name: string;
-      data: Record<string, unknown>;
-    };
-    expect(custom.type).toBe('custom');
-    expect(custom.name).toBe('youtube');
-    expect(custom.data.videoId).toBe('dQw4w9WgXcQ');
-  });
-
-  test('LayoutContainerNode → { type: "layout", columns }', () => {
-    const doc = lexicalToKoguma(
-      state([
-        {
-          type: 'layoutcontainer',
-          version: 1,
-          children: [
-            {
-              type: 'layoutitem',
-              version: 1,
-              children: [para([text('Col A')])]
-            },
-            {
-              type: 'layoutitem',
-              version: 1,
-              children: [para([text('Col B')])]
-            }
-          ]
-        }
-      ])
-    );
-    const layout = doc.nodes[0] as { type: string; columns: unknown[][] };
-    expect(layout.type).toBe('layout');
-    expect(layout.columns).toHaveLength(2);
-    expect(layout.columns[0]).toHaveLength(1);
-    expect(layout.columns[1]).toHaveLength(1);
-  });
-
-  test('MentionNode → { type: "custom", name: "mention" } inline', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([
-          {
-            type: 'mention',
-            version: 1,
-            id: 'user_42',
-            name: 'Matthew',
-            text: '@Matthew'
-          }
-        ])
-      ])
-    );
-    const p = doc.nodes[0] as {
-      children: Array<{
-        type: string;
-        name: string;
-        data: Record<string, unknown>;
-      }>;
-    };
-    const mention = p.children[0];
-    expect(mention.type).toBe('custom');
-    expect(mention.name).toBe('mention');
-    expect(mention.data.id).toBe('user_42');
-    expect(mention.data.name).toBe('Matthew');
-  });
-
-  test('EmojiNode → flattened to { type: "text" } inline', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([
-          {
-            type: 'emoji',
-            version: 1,
-            text: '🐻'
-          }
-        ])
-      ])
-    );
-    const p = doc.nodes[0] as {
-      children: Array<{ type: string; text: string }>;
-    };
-    expect(p.children[0].type).toBe('text');
-    expect(p.children[0].text).toBe('🐻');
-  });
-
-  test('KeywordNode → stripped', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([
-          text('Before'),
-          { type: 'keyword', version: 1, text: 'magic' },
-          text('After')
-        ])
-      ])
-    );
-    const p = doc.nodes[0] as { children: unknown[] };
-    expect(p.children).toHaveLength(2); // keyword stripped
-  });
-
-  test('AutocompleteNode (block) → stripped', () => {
-    const doc = lexicalToKoguma(
-      state([
-        para([text('Real content')]),
-        { type: 'autocomplete', version: 1, uuid: 'abc', children: [] }
-      ])
-    );
-    expect(doc.nodes).toHaveLength(1);
-  });
-});
-
-// ── Coverage integrity check ──────────────────────────────────────────
-
-describe('Lexical compat — registry coverage', () => {
-  test('all registered node types are accounted for in this test file', () => {
-    // This test ensures that as new nodes are added to NODE_REGISTRY,
-    // someone notices this file needs updating.
-    const accountedFor = new Set([
-      'root',
-      'paragraph',
-      'text',
-      'linebreak',
-      'heading',
-      'quote',
-      'list',
-      'listitem',
-      'link',
-      'autolink',
-      'table',
-      'tablerow',
-      'tablecell',
-      'code',
-      'code-highlight',
-      'overflow',
-      'hashtag',
-      'image',
-      'tweet',
-      'youtube',
-      'layoutcontainer',
-      'layoutitem',
-      'mention',
-      'emoji',
-      'keyword',
-      'autocomplete'
-    ]);
-    for (const nodeType of NODE_REGISTRY) {
-      expect(accountedFor.has(nodeType)).toBe(true);
-    }
-  });
-});