@jant/core 0.3.35 → 0.3.37

package/src/lib/__tests__/summary.test.ts

@@ -0,0 +1,264 @@
+import { describe, it, expect } from "vitest";
+import { extractBodyText } from "../summary.js";
+
+describe("extractBodyText", () => {
+  it("extracts text from paragraphs", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Hello world" }],
+        },
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Second paragraph" }],
+        },
+      ],
+    });
+
+    expect(extractBodyText(doc)).toBe("Hello world Second paragraph");
+  });
+
+  it("extracts text from headings", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "heading",
+          attrs: { level: 1 },
+          content: [{ type: "text", text: "My Title" }],
+        },
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Body text" }],
+        },
+      ],
+    });
+
+    expect(extractBodyText(doc)).toBe("My Title Body text");
+  });
+
+  it("extracts text from bullet lists", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "bulletList",
+          content: [
+            {
+              type: "listItem",
+              content: [
+                {
+                  type: "paragraph",
+                  content: [{ type: "text", text: "Item one" }],
+                },
+              ],
+            },
+            {
+              type: "listItem",
+              content: [
+                {
+                  type: "paragraph",
+                  content: [{ type: "text", text: "Item two" }],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(extractBodyText(doc)).toContain("Item one");
+    expect(extractBodyText(doc)).toContain("Item two");
+  });
+
+  it("extracts text from ordered lists", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "orderedList",
+          content: [
+            {
+              type: "listItem",
+              content: [
+                {
+                  type: "paragraph",
+                  content: [{ type: "text", text: "First" }],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(extractBodyText(doc)).toContain("First");
+  });
+
+  it("extracts text from blockquotes", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "blockquote",
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Quoted text" }],
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(extractBodyText(doc)).toContain("Quoted text");
+  });
+
+  it("extracts text from code blocks", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "codeBlock",
+          content: [{ type: "text", text: "const x = 1;" }],
+        },
+      ],
+    });
+
+    expect(extractBodyText(doc)).toBe("const x = 1;");
+  });
+
+  it("extracts text from tables", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "table",
+          content: [
+            {
+              type: "tableRow",
+              content: [
+                {
+                  type: "tableHeader",
+                  content: [
+                    {
+                      type: "paragraph",
+                      content: [{ type: "text", text: "Header" }],
+                    },
+                  ],
+                },
+              ],
+            },
+            {
+              type: "tableRow",
+              content: [
+                {
+                  type: "tableCell",
+                  content: [
+                    {
+                      type: "paragraph",
+                      content: [{ type: "text", text: "Cell data" }],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(extractBodyText(doc)).toContain("Header");
+    expect(extractBodyText(doc)).toContain("Cell data");
+  });
+
+  it("skips image nodes", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Before image" }],
+        },
+        {
+          type: "image",
+          attrs: { src: "https://example.com/img.png", alt: "Alt text" },
+        },
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "After image" }],
+        },
+      ],
+    });
+
+    const result = extractBodyText(doc);
+    expect(result).toContain("Before image");
+    expect(result).toContain("After image");
+    expect(result).not.toContain("Alt text");
+    expect(result).not.toContain("img.png");
+  });
+
+  it("skips moreBreak nodes", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Before break" }],
+        },
+        { type: "moreBreak" },
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "After break" }],
+        },
+      ],
+    });
+
+    const result = extractBodyText(doc);
+    expect(result).toContain("Before break");
+    expect(result).toContain("After break");
+  });
+
+  it("skips horizontalRule nodes", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Above rule" }],
+        },
+        { type: "horizontalRule" },
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Below rule" }],
+        },
+      ],
+    });
+
+    const result = extractBodyText(doc);
+    expect(result).toContain("Above rule");
+    expect(result).toContain("Below rule");
+  });
+
+  it("returns null for invalid JSON", () => {
+    expect(extractBodyText("not json")).toBeNull();
+    expect(extractBodyText("{invalid")).toBeNull();
+  });
+
+  it("returns null for empty doc", () => {
+    const doc = JSON.stringify({ type: "doc", content: [] });
+    expect(extractBodyText(doc)).toBeNull();
+  });
+
+  it("returns null for non-doc type", () => {
+    const doc = JSON.stringify({ type: "paragraph", content: [] });
+    expect(extractBodyText(doc)).toBeNull();
+  });
+
+  it("returns null for doc without content", () => {
+    const doc = JSON.stringify({ type: "doc" });
+    expect(extractBodyText(doc)).toBeNull();
+  });
+});

package/src/lib/__tests__/theme.test.ts

@@ -23,7 +23,7 @@ describe("buildThemeStyle", () => {
     expect(css).toContain("--font-body:");
     expect(css).toContain("--font-heading:");
     expect(css).toContain("Charter");
-    expect(css).toContain(":root.dark");
+    expect(css).toContain("prefers-color-scheme: dark");
   });
 
   it("font override merges with color theme", () => {

package/src/lib/__tests__/timeline.test.ts

@@ -11,7 +11,6 @@ import { describe, it, expect, beforeEach } from "vitest";
 import { createTestDatabase } from "../../__tests__/helpers/db.js";
 import { createPostService } from "../../services/post.js";
 import { createMediaService } from "../../services/media.js";
-import { createPathRegistryService } from "../../services/path-registry.js";
 import { buildMediaMap } from "../media-helpers.js";
 import type { Database } from "../../db/index.js";
 import type { PostWithMedia } from "../../types.js";
@@ -24,14 +23,14 @@ describe("Timeline data assembly", () => {
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    postService = createPostService(db, createPathRegistryService(db));
+    postService = createPostService(db, { slugIdLength: 5 });
     mediaService = createMediaService(db);
   });
 
   it("assembles timeline items with media attachments", async () => {
     const post = await postService.create({
       format: "note",
-      body: "Hello",
+      bodyMarkdown: "Hello",
     });
 
     const posts = await postService.list({
@@ -57,19 +56,19 @@ describe("Timeline data assembly", () => {
     expect(items[0]?.post.mediaAttachments).toEqual([]);
   });
 
-  it("identifies thread roots and builds thread previews", async () => {
+  it("identifies thread roots and builds thread context", async () => {
     const root = await postService.create({
       format: "note",
-      body: "Thread root",
+      bodyMarkdown: "Thread root",
     });
     await postService.create({
       format: "note",
-      body: "Reply 1",
+      bodyMarkdown: "Reply 1",
       replyToId: root.id,
     });
     await postService.create({
       format: "note",
-      body: "Reply 2",
+      bodyMarkdown: "Reply 2",
       replyToId: root.id,
     });
 
@@ -90,10 +89,12 @@ describe("Timeline data assembly", () => {
     expect(threadRootIds).toEqual([root.id]);
     expect(replyCounts.get(root.id)).toBe(2);
 
-    const threadPreviews = await postService.getThreadPreviews(threadRootIds);
-    const replies = threadPreviews.get(root.id);
-    expect(replies).toHaveLength(2);
-    expect(replies?.[0]?.body).toBe("Reply 1");
+    const threadContexts =
+      await postService.getThreadTimelineContext(threadRootIds);
+    const ctx = threadContexts.get(root.id);
+    expect(ctx).toBeDefined();
+    expect(ctx?.latestReply.bodyText).toBe("Reply 2");
+    expect(ctx?.totalReplyCount).toBe(2);
 
     // Assemble items
     const rawMediaMap = await mediaService.getByPostIds(postIds);
@@ -105,18 +106,20 @@ describe("Timeline data assembly", () => {
         mediaAttachments: mediaMap.get(post.id) ?? [],
       };
 
-      const replyCount = replyCounts.get(post.id) ?? 0;
-      const previewReplies = threadPreviews.get(post.id);
+      const threadCtx = threadContexts.get(post.id);
 
-      if (replyCount > 0 && previewReplies) {
+      if (threadCtx) {
         return {
           post: postWithMedia,
           threadPreview: {
-            replies: previewReplies.map((r) => ({
-              ...r,
+            latestReply: {
+              ...threadCtx.latestReply,
               mediaAttachments: [],
-            })),
-            totalReplyCount: replyCount,
+            },
+            parentReply: threadCtx.parentReply
+              ? { ...threadCtx.parentReply, mediaAttachments: [] }
+              : undefined,
+            totalReplyCount: threadCtx.totalReplyCount,
           },
         };
       }
@@ -126,18 +129,18 @@ describe("Timeline data assembly", () => {
 
     expect(items).toHaveLength(1);
     expect(items[0]?.threadPreview).toBeDefined();
-    expect(items[0]?.threadPreview?.replies).toHaveLength(2);
+    expect(items[0]?.threadPreview?.latestReply.bodyText).toBe("Reply 2");
     expect(items[0]?.threadPreview?.totalReplyCount).toBe(2);
   });
 
   it("excludes replies from top-level list", async () => {
     const root = await postService.create({
       format: "note",
-      body: "Root",
+      bodyMarkdown: "Root",
     });
     await postService.create({
       format: "note",
-      body: "Reply",
+      bodyMarkdown: "Reply",
       replyToId: root.id,
     });
 
@@ -148,7 +151,7 @@ describe("Timeline data assembly", () => {
     });
 
     expect(posts).toHaveLength(1);
-    expect(posts[0]?.body).toBe("Root");
+    expect(posts[0]?.bodyText).toBe("Root");
   });
 
   it("supports cursor pagination for load more", async () => {
@@ -157,7 +160,7 @@ describe("Timeline data assembly", () => {
       posts.push(
         await postService.create({
           format: "note",
-          body: `Post ${i}`,
+          bodyMarkdown: `Post ${i}`,
           publishedAt: 1000 + i,
         }),
       );
@@ -188,7 +191,7 @@ describe("Timeline data assembly", () => {
     for (let i = 0; i < 5; i++) {
       await postService.create({
         format: "note",
-        body: `Post ${i}`,
+        bodyMarkdown: `Post ${i}`,
         publishedAt: 1000 + i,
       });
     }
@@ -203,8 +206,8 @@ describe("Timeline data assembly", () => {
       offset: 0,
     });
     expect(page1).toHaveLength(2);
-    expect(page1[0]?.body).toBe("Post 4");
-    expect(page1[1]?.body).toBe("Post 3");
+    expect(page1[0]?.bodyText).toBe("Post 4");
+    expect(page1[1]?.bodyText).toBe("Post 3");
 
     // Page 2
     const page2 = await postService.list({
@@ -214,8 +217,8 @@ describe("Timeline data assembly", () => {
       offset: 2,
     });
     expect(page2).toHaveLength(2);
-    expect(page2[0]?.body).toBe("Post 2");
-    expect(page2[1]?.body).toBe("Post 1");
+    expect(page2[0]?.bodyText).toBe("Post 2");
+    expect(page2[1]?.bodyText).toBe("Post 1");
 
     // Page 3 (partial)
     const page3 = await postService.list({
@@ -225,14 +228,14 @@ describe("Timeline data assembly", () => {
       offset: 4,
     });
     expect(page3).toHaveLength(1);
-    expect(page3[0]?.body).toBe("Post 0");
+    expect(page3[0]?.bodyText).toBe("Post 0");
   });
 
   it("computes total pages from count", async () => {
     for (let i = 0; i < 5; i++) {
       await postService.create({
         format: "note",
-        body: `Post ${i}`,
+        bodyMarkdown: `Post ${i}`,
       });
     }