koguma 0.6.5 → 0.6.6

package/cli/index.ts

@@ -529,6 +529,8 @@ async function cmdSeed() {
     // Lazy-load markdown converter
     const { markdownToKoguma } =
       await import('../src/rich-text/markdown-to-koguma.ts');
+    const { kogumaToLexical } =
+      await import('../src/rich-text/koguma-to-lexical.ts');
 
     let totalEntries = 0;
 
@@ -546,7 +548,8 @@ async function cmdSeed() {
           entry,
           ct.fieldMeta,
           assetIndex,
-          markdownToKoguma
+          markdownToKoguma,
+          kogumaToLexical
         );
 
         for (const r of resolutions) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koguma",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "description": "🐻 A little CMS with big heart — schema-driven, runs on Cloudflare's free tier",
   "type": "module",
   "license": "MIT",

package/src/db/sql.ts

@@ -99,7 +99,9 @@ export function processSeedEntry(
   entry: Record<string, unknown>,
   fieldMeta: Record<string, FieldMeta>,
   assetIndex: AssetIndex,
-  markdownToKoguma: (md: string) => { nodes: unknown[] }
+  markdownToKoguma: (md: string) => { nodes: unknown[] },
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  kogumaToLexical: (doc: any) => Record<string, unknown>
 ): { processed: Record<string, unknown>; resolutions: string[] } {
   const processed: Record<string, unknown> = {
     id: (entry.id as string) ?? crypto.randomUUID(),
@@ -121,8 +123,9 @@ export function processSeedEntry(
       }
     } else if (meta.fieldType === 'richText' && typeof value === 'string') {
       const doc = markdownToKoguma(value);
-      processed[fieldId] = JSON.stringify(doc);
-      resolutions.push(`${fieldId}: markdown → KogumaDocument`);
+      const lexical = kogumaToLexical(doc);
+      processed[fieldId] = JSON.stringify(lexical);
+      resolutions.push(`${fieldId}: markdown → Lexical JSON`);
     } else if (meta.fieldType === 'images' && Array.isArray(value)) {
       const ids = value.map((v: unknown) => {
         if (typeof v !== 'string') return v;

package/src/rich-text/index.ts

@@ -1,3 +1,4 @@
 export { lexicalToKoguma } from './lexical-to-koguma.ts';
+export { kogumaToLexical } from './koguma-to-lexical.ts';
 export { richTextToPlain } from './plain.ts';
 export type { PlainTextOptions } from './plain.ts';

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

@@ -0,0 +1,340 @@
+/**
+ * koguma-to-lexical.ts — Converts KogumaDocument back to Lexical's SerializedEditorState.
+ *
+ * The inverse of lexicalToKoguma(). Used by the seed pipeline to store
+ * content in the format D1/admin expects (Lexical JSON), rather than
+ * the public-API KogumaDocument format.
+ */
+import type {
+  KogumaDocument,
+  KogumaBlockNode,
+  KogumaInlineNode,
+  KogumaListItem
+} from '../config/types.ts';
+
+// ── Lexical format bitmask constants (mirror of lexical-to-koguma.ts) ──
+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;
+
+// ── Output types (Lexical serialized JSON) ──────────────────────────
+
+interface LexicalNode {
+  type: string;
+  version: number;
+  [k: string]: unknown;
+}
+
+// ── Main entry point ────────────────────────────────────────────────
+
+export function kogumaToLexical(doc: KogumaDocument): Record<string, unknown> {
+  return {
+    root: {
+      type: 'root',
+      children: doc.nodes.map(convertBlockNode),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    }
+  };
+}
+
+// ── Block node conversion ────────────────────────────────────────────
+
+function convertBlockNode(node: KogumaBlockNode): LexicalNode {
+  switch (node.type) {
+    case 'paragraph':
+      return {
+        type: 'paragraph',
+        version: 1,
+        children: (node.children ?? []).map(convertInlineNode),
+        direction: 'ltr',
+        format: alignToFormat(node.align),
+        indent: 0,
+        textFormat: 0,
+        textStyle: ''
+      };
+
+    case 'heading':
+      return {
+        type: 'heading',
+        version: 1,
+        tag: `h${node.level ?? 2}`,
+        children: (node.children ?? []).map(convertInlineNode),
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        textFormat: 0,
+        textStyle: ''
+      };
+
+    case 'quote':
+      return {
+        type: 'quote',
+        version: 1,
+        children: [
+          {
+            type: 'paragraph',
+            version: 1,
+            children: (node.children ?? []).map(convertInlineNode),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            textFormat: 0,
+            textStyle: ''
+          }
+        ],
+        direction: 'ltr',
+        format: '',
+        indent: 0
+      };
+
+    case 'list':
+      return convertList(node);
+
+    case 'code':
+      return {
+        type: 'code',
+        version: 1,
+        language: node.language ?? null,
+        children: codeTextToHighlightNodes(node.text ?? ''),
+        direction: 'ltr',
+        format: '',
+        indent: 0
+      };
+
+    case 'image':
+      return {
+        type: 'image',
+        version: 1,
+        src: node.url ?? '',
+        altText: node.alt ?? '',
+        width: node.width ?? null,
+        height: node.height ?? null
+      };
+
+    case 'hr':
+      return {
+        type: 'horizontalrule',
+        version: 1
+      };
+
+    case 'table':
+      return convertTable(node);
+
+    case 'layout':
+      return convertLayout(node);
+
+    case 'custom':
+      return {
+        type: node.name ?? 'unknown',
+        version: 1,
+        ...(node.data ?? {})
+      };
+
+    default:
+      return {
+        type: 'paragraph',
+        version: 1,
+        children: [],
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        textFormat: 0,
+        textStyle: ''
+      };
+  }
+}
+
+// ── List conversion ──────────────────────────────────────────────────
+
+function convertList(node: KogumaBlockNode): LexicalNode {
+  const ordered = (node as any).ordered ?? false;
+  const listType = ordered ? 'number' : 'bullet';
+  const items = (node as any).items ?? [];
+
+  return {
+    type: 'list',
+    version: 1,
+    listType,
+    start: 1,
+    tag: ordered ? 'ol' : 'ul',
+    children: items.map((item: KogumaListItem, i: number) =>
+      convertListItem(item, listType, i + 1)
+    ),
+    direction: 'ltr',
+    format: '',
+    indent: 0
+  };
+}
+
+function convertListItem(
+  item: KogumaListItem,
+  listType: string,
+  value: number
+): LexicalNode {
+  const children: LexicalNode[] = (item.children ?? []).map(convertInlineNode);
+
+  if (item.nestedList) {
+    children.push(
+      convertList({
+        type: 'list',
+        ordered: item.nestedList.ordered,
+        items: item.nestedList.items
+      } as any)
+    );
+  }
+
+  return {
+    type: 'listitem',
+    version: 1,
+    value,
+    children,
+    checked: listType === 'check' ? (item.checked ?? false) : undefined,
+    direction: 'ltr',
+    format: '',
+    indent: 0
+  };
+}
+
+// ── Table conversion ─────────────────────────────────────────────────
+
+function convertTable(node: KogumaBlockNode): LexicalNode {
+  const rows = (node as any).rows ?? [];
+  return {
+    type: 'table',
+    version: 1,
+    children: rows.map((row: any) => ({
+      type: 'tablerow',
+      version: 1,
+      key: row.key,
+      children: (row.cells ?? []).map((cell: any) => ({
+        type: 'tablecell',
+        version: 1,
+        key: cell.key,
+        children: (cell.children ?? []).map(convertInlineNode)
+      }))
+    }))
+  };
+}
+
+// ── Layout conversion ────────────────────────────────────────────────
+
+function convertLayout(node: KogumaBlockNode): LexicalNode {
+  const columns = (node as any).columns ?? [];
+  return {
+    type: 'layoutcontainer',
+    version: 1,
+    children: columns.map((col: KogumaBlockNode[]) => ({
+      type: 'layoutitem',
+      version: 1,
+      children: col.map(convertBlockNode)
+    }))
+  };
+}
+
+// ── Inline node conversion ───────────────────────────────────────────
+
+function convertInlineNode(node: KogumaInlineNode): LexicalNode {
+  switch (node.type) {
+    case 'text': {
+      let format = 0;
+      if (node.bold) format |= IS_BOLD;
+      if (node.italic) format |= IS_ITALIC;
+      if (node.underline) format |= IS_UNDERLINE;
+      if (node.strikethrough) format |= IS_STRIKETHROUGH;
+      if (node.code) format |= IS_CODE;
+      if (node.subscript) format |= IS_SUBSCRIPT;
+      if (node.superscript) format |= IS_SUPERSCRIPT;
+
+      return {
+        type: 'text',
+        version: 1,
+        text: node.text ?? '',
+        format,
+        detail: 0,
+        mode: 'normal',
+        style: ''
+      };
+    }
+
+    case 'link':
+      return {
+        type: 'link',
+        version: 1,
+        url: node.url ?? '',
+        target: node.newTab ? '_blank' : null,
+        children: (node.children ?? []).map(convertInlineNode),
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        rel: null
+      };
+
+    case 'line-break':
+      return {
+        type: 'linebreak',
+        version: 1
+      };
+
+    case 'custom':
+      return {
+        type: node.name ?? 'unknown',
+        version: 1,
+        ...(node.data ?? {})
+      };
+
+    default:
+      return {
+        type: 'text',
+        version: 1,
+        text: (node as any).text ?? '',
+        format: 0,
+        detail: 0,
+        mode: 'normal',
+        style: ''
+      };
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function alignToFormat(align?: string): string | number {
+  switch (align) {
+    case 'left':
+      return 1;
+    case 'center':
+      return 2;
+    case 'right':
+      return 3;
+    case 'justify':
+      return 4;
+    default:
+      return '';
+  }
+}
+
+/** Convert plain code text to Lexical CodeHighlightNode children */
+function codeTextToHighlightNodes(text: string): LexicalNode[] {
+  const lines = text.split('\n');
+  const nodes: LexicalNode[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) {
+      nodes.push({ type: 'linebreak', version: 1 });
+    }
+    nodes.push({
+      type: 'code-highlight',
+      version: 1,
+      text: lines[i]!,
+      highlightType: null
+    });
+  }
+
+  return nodes;
+}