koguma 0.6.6 → 2.0.0

package/src/rich-text/lexical-to-koguma.ts

@@ -1,400 +0,0 @@
-/**
- * lexical-to-koguma.ts
- *
- * Converts Lexical's SerializedEditorState into a KogumaDocument.
- * Runs server-side at read time in queries.ts — no Lexical package dependency required.
- * All node types registered in koguma admin's editor-x/nodes.ts are handled.
- */
-import type {
-  KogumaDocument,
-  KogumaBlockNode,
-  KogumaInlineNode,
-  KogumaListItem,
-  KogumaTableRow,
-  KogumaTableCell
-} from '../config/types.ts';
-
-// ── Lexical format bitmask constants ────────────────────────────────
-const IS_BOLD = 1;
-const IS_ITALIC = 2;
-const IS_STRIKETHROUGH = 4;
-const IS_UNDERLINE = 8;
-const IS_CODE = 16;
-const IS_SUBSCRIPT = 32;
-const IS_SUPERSCRIPT = 64;
-
-// ── Loose types for Lexical's serialized JSON ───────────────────────
-
-interface LexicalNode {
-  type: string;
-  version?: number;
-  children?: LexicalNode[];
-  text?: string;
-  format?: number;
-  tag?: string;
-  listType?: 'bullet' | 'number' | 'check';
-  checked?: boolean;
-  value?: number;
-  url?: string;
-  target?: string | null;
-  newTab?: boolean;
-  src?: string;
-  altText?: string;
-  width?: number | null;
-  height?: number | null;
-  language?: string;
-  hashtag?: string;
-  id?: string;
-  name?: string;
-  key?: string;
-  [k: string]: unknown;
-}
-
-interface LexicalRoot {
-  root: LexicalNode;
-}
-
-// ── Main entry point ────────────────────────────────────────────────
-
-export function lexicalToKoguma(input: unknown): KogumaDocument {
-  if (!input || typeof input !== 'object') return { nodes: [] };
-
-  const state = input as Partial<LexicalRoot>;
-  if (!state.root?.children) return { nodes: [] };
-
-  return {
-    nodes: convertBlockNodes(state.root.children)
-  };
-}
-
-// ── Block node conversion ────────────────────────────────────────────
-
-function convertBlockNodes(nodes: LexicalNode[]): KogumaBlockNode[] {
-  const result: KogumaBlockNode[] = [];
-
-  for (const node of nodes) {
-    const block = convertBlockNode(node);
-    if (block) result.push(block);
-  }
-
-  return result;
-}
-
-function convertBlockNode(node: LexicalNode): KogumaBlockNode | null {
-  switch (node.type) {
-    case 'paragraph':
-      return {
-        type: 'paragraph',
-        key: node.key,
-        align: convertElementAlign(node.format as number | undefined),
-        children: convertInlineNodes(node.children ?? [])
-      };
-
-    case 'heading':
-      return {
-        type: 'heading',
-        key: node.key,
-        level: headingLevel(node.tag ?? 'h2'),
-        children: convertInlineNodes(node.children ?? [])
-      };
-
-    case 'quote':
-      return {
-        type: 'quote',
-        key: node.key,
-        children: convertInlineNodes(flattenQuoteChildren(node.children ?? []))
-      };
-
-    case 'list':
-      return convertList(node);
-
-    case 'code':
-      return {
-        type: 'code',
-        key: node.key,
-        language: node.language ?? undefined,
-        text: extractCodeText(node.children ?? [])
-      };
-
-    case 'image':
-      return {
-        type: 'image',
-        key: node.key,
-        url: node.src ?? '',
-        alt: node.altText ?? undefined,
-        width: node.width ?? undefined,
-        height: node.height ?? undefined
-      };
-
-    case 'horizontalrule':
-      return { type: 'hr', key: node.key };
-
-    case 'table':
-      return convertTable(node);
-
-    case 'layoutcontainer':
-      return convertLayout(node);
-
-    // Intentionally stripped — editor UI artefacts only, never persisted meaningfully
-    case 'overflow':
-    case 'autocomplete':
-    case 'keyword':
-      return null;
-
-    default:
-      // All other custom nodes (tweet, youtube, emoji embedded as block, etc.)
-      return {
-        type: 'custom',
-        key: node.key,
-        name: node.type,
-        data: nodeToData(node)
-      };
-  }
-}
-
-// ── List conversion ──────────────────────────────────────────────────
-
-function convertList(node: LexicalNode): KogumaBlockNode {
-  const ordered = node.listType === 'number';
-  const items: KogumaListItem[] = [];
-
-  for (const child of node.children ?? []) {
-    if (child.type !== 'listitem') continue;
-    items.push(convertListItem(child, node.listType));
-  }
-
-  return { type: 'list', key: node.key, ordered, items };
-}
-
-function convertListItem(node: LexicalNode, listType?: string): KogumaListItem {
-  const inlineChildren: KogumaInlineNode[] = [];
-  let nestedList: KogumaListItem['nestedList'] | undefined;
-
-  for (const child of node.children ?? []) {
-    if (child.type === 'list') {
-      // Nested list — recurse
-      const nested = convertList(child) as {
-        type: 'list';
-        ordered: boolean;
-        items: KogumaListItem[];
-      };
-      nestedList = { ordered: nested.ordered, items: nested.items };
-    } else {
-      inlineChildren.push(...convertInlineNode(child));
-    }
-  }
-
-  const item: KogumaListItem = {
-    key: node.key,
-    children: inlineChildren,
-    nestedList
-  };
-
-  // Checklist items have `checked` defined (true or false)
-  if (listType === 'check') {
-    item.checked = node.checked ?? false;
-  }
-
-  return item;
-}
-
-// ── Table conversion ─────────────────────────────────────────────────
-
-function convertTable(node: LexicalNode): KogumaBlockNode {
-  const rows: KogumaTableRow[] = [];
-
-  for (let i = 0; i < (node.children ?? []).length; i++) {
-    const rowNode = (node.children ?? [])[i];
-    if (rowNode.type !== 'tablerow') continue;
-
-    const cells: KogumaTableCell[] = [];
-    for (const cellNode of rowNode.children ?? []) {
-      if (cellNode.type !== 'tablecell') continue;
-      cells.push({
-        key: cellNode.key,
-        children: convertInlineNodes(cellNode.children ?? [])
-      });
-    }
-
-    rows.push({
-      key: rowNode.key,
-      isHeader: i === 0, // First row is treated as header
-      cells
-    });
-  }
-
-  return { type: 'table', key: node.key, rows };
-}
-
-// ── Layout conversion ────────────────────────────────────────────────
-
-function convertLayout(node: LexicalNode): KogumaBlockNode {
-  const columns: KogumaBlockNode[][] = [];
-
-  for (const itemNode of node.children ?? []) {
-    if (itemNode.type !== 'layoutitem') continue;
-    columns.push(convertBlockNodes(itemNode.children ?? []));
-  }
-
-  return { type: 'layout', key: node.key, columns };
-}
-
-// ── Inline node conversion ───────────────────────────────────────────
-
-function convertInlineNodes(nodes: LexicalNode[]): KogumaInlineNode[] {
-  return nodes.flatMap(convertInlineNode);
-}
-
-function convertInlineNode(node: LexicalNode): KogumaInlineNode[] {
-  switch (node.type) {
-    case 'text': {
-      const fmt = node.format ?? 0;
-      const textNode: KogumaInlineNode = {
-        type: 'text',
-        key: node.key,
-        text: node.text ?? ''
-      };
-      if (fmt & IS_BOLD) textNode.bold = true;
-      if (fmt & IS_ITALIC) textNode.italic = true;
-      if (fmt & IS_UNDERLINE) textNode.underline = true;
-      if (fmt & IS_STRIKETHROUGH) textNode.strikethrough = true;
-      if (fmt & IS_CODE) textNode.code = true;
-      if (fmt & IS_SUBSCRIPT) textNode.subscript = true;
-      if (fmt & IS_SUPERSCRIPT) textNode.superscript = true;
-      return [textNode];
-    }
-
-    case 'link':
-    case 'autolink': {
-      const linkUrl = node.url ?? '';
-      const newTab = node.newTab ?? node.target === '_blank';
-      return [
-        {
-          type: 'link',
-          key: node.key,
-          url: linkUrl,
-          newTab: newTab || undefined,
-          children: convertInlineNodes(node.children ?? [])
-        }
-      ];
-    }
-
-    case 'linebreak':
-      return [{ type: 'line-break', key: node.key }];
-
-    case 'image':
-      return [
-        {
-          type: 'inline-image',
-          key: node.key,
-          url: node.src ?? '',
-          alt: node.altText ?? undefined
-        }
-      ];
-
-    case 'hashtag':
-      return [
-        {
-          type: 'custom',
-          key: node.key,
-          name: 'hashtag',
-          data: { tag: node.hashtag ?? node.text ?? '' }
-        }
-      ];
-
-    case 'mention':
-      return [
-        {
-          type: 'custom',
-          key: node.key,
-          name: 'mention',
-          data: { id: node.id ?? '', name: node.name ?? node.text ?? '' }
-        }
-      ];
-
-    case 'emoji':
-      // Flatten emoji to plain text — it's just a Unicode character
-      return [{ type: 'text', key: node.key, text: node.text ?? '' }];
-
-    case 'keyword':
-    case 'autocomplete':
-    case 'tab':
-      // Editor-only UI nodes — strip from output
-      return [];
-
-    // CodeHighlightNode appears inline but should not appear outside code blocks
-    // If encountered here, treat as plain text
-    case 'code-highlight':
-    case 'codehighlight':
-      return [{ type: 'text', key: node.key, text: node.text ?? '' }];
-
-    default: {
-      // Unknown inline custom node — preserve as custom inline
-      if (node.text != null) {
-        // If it has text content and children, try inlining
-        const children = convertInlineNodes(node.children ?? []);
-        if (children.length > 0) return children;
-        return [{ type: 'text', text: node.text }];
-      }
-      return [
-        {
-          type: 'custom',
-          key: node.key,
-          name: node.type,
-          data: nodeToData(node)
-        }
-      ];
-    }
-  }
-}
-
-// ── Helpers ──────────────────────────────────────────────────────────
-
-function headingLevel(tag: string): 1 | 2 | 3 | 4 | 5 | 6 {
-  const n = parseInt(tag.replace('h', ''), 10);
-  if (n >= 1 && n <= 6) return n as 1 | 2 | 3 | 4 | 5 | 6;
-  return 2;
-}
-
-type Align = 'left' | 'center' | 'right' | 'justify';
-function convertElementAlign(format?: number): Align | undefined {
-  switch (format) {
-    case 1:
-      return 'left';
-    case 2:
-      return 'center';
-    case 3:
-      return 'right';
-    case 4:
-      return 'justify';
-    default:
-      return undefined;
-  }
-}
-
-/** Extract plain text from CodeHighlightNode children */
-function extractCodeText(children: LexicalNode[]): string {
-  return children
-    .filter(
-      c =>
-        c.type === 'code-highlight' ||
-        c.type === 'codehighlight' ||
-        c.type === 'text' ||
-        c.type === 'linebreak'
-    )
-    .map(c => (c.type === 'linebreak' ? '\n' : (c.text ?? '')))
-    .join('');
-}
-
-/** Quote nodes wrap a paragraph — unwrap to get inline children */
-function flattenQuoteChildren(children: LexicalNode[]): LexicalNode[] {
-  return children.flatMap(child =>
-    child.type === 'paragraph' ? (child.children ?? []) : [child]
-  );
-}
-
-/** Strip Lexical internals, keep content data fields */
-function nodeToData(node: LexicalNode): Record<string, unknown> {
-  const { type: _type, version: _v, children: _c, key: _k, ...rest } = node;
-  return rest as Record<string, unknown>;
-}

package/src/rich-text/markdown-to-koguma.ts

@@ -1,164 +0,0 @@
-/**
- * markdown-to-koguma.ts — Lightweight markdown → KogumaDocument converter.
- *
- * Designed for seed content (author-controlled markdown), not arbitrary user input.
- * Supports: headings, paragraphs, bold, italic, code, links, lists, code blocks, HR.
- */
-import type {
-  KogumaDocument,
-  KogumaBlockNode,
-  KogumaInlineNode,
-  KogumaListItem
-} from '../config/types.ts';
-
-// ── Inline parsing ──────────────────────────────────────────────────
-
-function parseInline(text: string): KogumaInlineNode[] {
-  const nodes: KogumaInlineNode[] = [];
-  // Regex: links, bold, italic, inline code
-  const re =
-    /\[([^\]]+)\]\(([^)]+)\)|`([^`]+)`|\*\*(.+?)\*\*|\*(.+?)\*|([^[`*]+)/g;
-  let match: RegExpExecArray | null;
-
-  while ((match = re.exec(text)) !== null) {
-    if (match[1] !== undefined && match[2] !== undefined) {
-      // Link
-      nodes.push({
-        type: 'link',
-        url: match[2],
-        children: [{ type: 'text', text: match[1] }]
-      });
-    } else if (match[3] !== undefined) {
-      // Inline code
-      nodes.push({ type: 'text', text: match[3], code: true });
-    } else if (match[4] !== undefined) {
-      // Bold
-      nodes.push({ type: 'text', text: match[4], bold: true });
-    } else if (match[5] !== undefined) {
-      // Italic
-      nodes.push({ type: 'text', text: match[5], italic: true });
-    } else if (match[6] !== undefined && match[6].length > 0) {
-      // Plain text
-      nodes.push({ type: 'text', text: match[6] });
-    }
-  }
-
-  return nodes.length > 0 ? nodes : [{ type: 'text', text }];
-}
-
-// ── Block parsing ───────────────────────────────────────────────────
-
-export function markdownToKoguma(markdown: string): KogumaDocument {
-  const lines = markdown.split('\n');
-  const nodes: KogumaBlockNode[] = [];
-  let i = 0;
-
-  while (i < lines.length) {
-    const line = lines[i]!;
-
-    // Blank line — skip
-    if (line.trim() === '') {
-      i++;
-      continue;
-    }
-
-    // Fenced code block
-    const codeMatch = line.match(/^```(\w*)$/);
-    if (codeMatch) {
-      const language = codeMatch[1] || undefined;
-      const codeLines: string[] = [];
-      i++;
-      while (i < lines.length && !lines[i]!.startsWith('```')) {
-        codeLines.push(lines[i]!);
-        i++;
-      }
-      i++; // skip closing ```
-      nodes.push({ type: 'code', language, text: codeLines.join('\n') });
-      continue;
-    }
-
-    // Heading
-    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-    if (headingMatch) {
-      const level = headingMatch[1]!.length as 1 | 2 | 3 | 4 | 5 | 6;
-      nodes.push({
-        type: 'heading',
-        level,
-        children: parseInline(headingMatch[2]!)
-      });
-      i++;
-      continue;
-    }
-
-    // Horizontal rule
-    if (/^(-{3,}|\*{3,}|_{3,})$/.test(line.trim())) {
-      nodes.push({ type: 'hr' });
-      i++;
-      continue;
-    }
-
-    // Unordered list
-    if (/^[-*+]\s/.test(line)) {
-      const items: KogumaListItem[] = [];
-      while (i < lines.length && /^[-*+]\s/.test(lines[i]!)) {
-        items.push({
-          children: parseInline(lines[i]!.replace(/^[-*+]\s/, ''))
-        });
-        i++;
-      }
-      nodes.push({ type: 'list', ordered: false, items });
-      continue;
-    }
-
-    // Ordered list
-    if (/^\d+\.\s/.test(line)) {
-      const items: KogumaListItem[] = [];
-      while (i < lines.length && /^\d+\.\s/.test(lines[i]!)) {
-        items.push({
-          children: parseInline(lines[i]!.replace(/^\d+\.\s/, ''))
-        });
-        i++;
-      }
-      nodes.push({ type: 'list', ordered: true, items });
-      continue;
-    }
-
-    // Blockquote
-    if (line.startsWith('> ')) {
-      const quoteLines: string[] = [];
-      while (i < lines.length && lines[i]!.startsWith('> ')) {
-        quoteLines.push(lines[i]!.slice(2));
-        i++;
-      }
-      nodes.push({
-        type: 'quote',
-        children: parseInline(quoteLines.join(' '))
-      });
-      continue;
-    }
-
-    // Paragraph (default)
-    const paraLines: string[] = [];
-    while (
-      i < lines.length &&
-      lines[i]!.trim() !== '' &&
-      !lines[i]!.startsWith('#') &&
-      !lines[i]!.startsWith('```') &&
-      !/^[-*+]\s/.test(lines[i]!) &&
-      !/^\d+\.\s/.test(lines[i]!) &&
-      !lines[i]!.startsWith('> ') &&
-      !/^(-{3,}|\*{3,}|_{3,})$/.test(lines[i]!.trim())
-    ) {
-      paraLines.push(lines[i]!);
-      i++;
-    }
-    if (paraLines.length > 0) {
-      nodes.push({
-        type: 'paragraph',
-        children: parseInline(paraLines.join(' '))
-      });
-    }
-  }
-
-  return { nodes };
-}