@jant/core 0.3.39 → 1.0.0

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

@@ -36,11 +36,12 @@ describe("Timeline data assembly", () => {
   let postService: ReturnType<typeof createPostService>;
   let mediaService: ReturnType<typeof createMediaService>;
   let collectionService: ReturnType<typeof createCollectionService>;
+  let pathService: ReturnType<typeof createPathService>;
 
   beforeEach(() => {
     const testDb = createTestDatabase();
     db = testDb.db as unknown as Database;
-    const pathService = createPathService(db, DEFAULT_TEST_SITE_ID);
+    pathService = createPathService(db, DEFAULT_TEST_SITE_ID);
     postService = createPostService(
       db,
       { slugIdLength: 5 },
@@ -62,6 +63,7 @@ describe("Timeline data assembly", () => {
           posts: postService,
           media: mediaService,
           collections: collectionService,
+          paths: pathService,
         },
         appConfig: {
           pageSize: 20,
@@ -104,7 +106,7 @@ describe("Timeline data assembly", () => {
       format: "note",
       bodyMarkdown: "Thread root",
     });
-    await postService.create({
+    const reply1 = await postService.create({
       format: "note",
       bodyMarkdown: "Reply 1",
       replyToId: root.id,
@@ -112,7 +114,7 @@ describe("Timeline data assembly", () => {
     await postService.create({
       format: "note",
       bodyMarkdown: "Reply 2",
-      replyToId: root.id,
+      replyToId: reply1.id,
     });
 
     const posts = await postService.list({
@@ -155,13 +157,22 @@ describe("Timeline data assembly", () => {
         return {
           post: postWithMedia,
           threadPreview: {
+            secondReply: threadCtx.secondReply
+              ? {
+                  ...threadCtx.secondReply,
+                  mediaAttachments: [],
+                }
+              : undefined,
+            penultimateReply: threadCtx.penultimateReply
+              ? {
+                  ...threadCtx.penultimateReply,
+                  mediaAttachments: [],
+                }
+              : undefined,
             latestReply: {
               ...threadCtx.latestReply,
               mediaAttachments: [],
             },
-            parentReply: threadCtx.parentReply
-              ? { ...threadCtx.parentReply, mediaAttachments: [] }
-              : undefined,
             totalReplyCount: threadCtx.totalReplyCount,
           },
         };
@@ -172,6 +183,7 @@ describe("Timeline data assembly", () => {
 
     expect(items).toHaveLength(1);
     expect(items[0]?.threadPreview).toBeDefined();
+    expect(items[0]?.threadPreview?.secondReply?.bodyText).toBe("Reply 1");
     expect(items[0]?.threadPreview?.latestReply.bodyText).toBe("Reply 2");
     expect(items[0]?.threadPreview?.totalReplyCount).toBe(2);
   });
@@ -298,7 +310,7 @@ describe("Timeline data assembly", () => {
       format: "note",
       bodyMarkdown: "Thread root",
     });
-    await postService.create({
+    const reply1 = await postService.create({
       format: "note",
       bodyMarkdown: "Reply 1",
       replyToId: root.id,
@@ -306,7 +318,7 @@ describe("Timeline data assembly", () => {
     const latestReply = await postService.create({
       format: "note",
       bodyMarkdown: "Reply 2",
-      replyToId: root.id,
+      replyToId: reply1.id,
     });
 
     const item = await assembleTimelineItem(createTimelineContext(), root.id);
@@ -317,7 +329,7 @@ describe("Timeline data assembly", () => {
     expect(item?.threadPreview?.totalReplyCount).toBe(2);
   });
 
-  it('shows an "In thread" link for featured root posts with replies', async () => {
+  it("keeps featured root posts with replies in curated thread mode", async () => {
     const root = await postService.create({
       format: "note",
       bodyMarkdown: "Featured root",
@@ -347,9 +359,6 @@ describe("Timeline data assembly", () => {
         highlighted: false,
       }),
     ]);
-    expect(result.items[0]?.post.threadRootPermalink).toBe(
-      result.items[0]?.post.permalink,
-    );
   });
 
   it("renders a standalone featured root without curated thread chrome", async () => {
@@ -373,7 +382,7 @@ describe("Timeline data assembly", () => {
       format: "note",
       bodyMarkdown: "Root",
     });
-    await postService.create({
+    const reply1 = await postService.create({
       format: "note",
       bodyMarkdown: "Reply 1",
       replyToId: root.id,
@@ -381,17 +390,17 @@ describe("Timeline data assembly", () => {
     const featuredReplyA = await postService.create({
       format: "note",
       bodyMarkdown: "Featured reply A",
-      replyToId: root.id,
+      replyToId: reply1.id,
     });
-    await postService.create({
+    const reply3 = await postService.create({
       format: "note",
       bodyMarkdown: "Reply 3",
-      replyToId: root.id,
+      replyToId: featuredReplyA.id,
     });
     const featuredReplyB = await postService.create({
       format: "note",
       bodyMarkdown: "Featured reply B",
-      replyToId: root.id,
+      replyToId: reply3.id,
     });
 
     await db
@@ -498,7 +507,7 @@ describe("Timeline data assembly", () => {
     await postService.create({
       format: "note",
       bodyMarkdown: "Later non-featured reply",
-      replyToId: olderFeaturedRoot.id,
+      replyToId: olderFeaturedReply.id,
     });
 
     const result = await assembleFeaturedTimeline(createTimelineContext(), {
@@ -524,15 +533,15 @@ describe("Timeline data assembly", () => {
       bodyMarkdown: "Collected reply A",
       replyToId: firstRoot.id,
     });
-    await postService.create({
+    const hiddenMiddleReply = await postService.create({
       format: "note",
       bodyMarkdown: "Hidden middle reply",
-      replyToId: firstRoot.id,
+      replyToId: collectedReplyA.id,
     });
     const collectedReplyB = await postService.create({
       format: "note",
       bodyMarkdown: "Collected reply B",
-      replyToId: firstRoot.id,
+      replyToId: hiddenMiddleReply.id,
     });
     const secondRoot = await postService.create({
       format: "note",
@@ -561,7 +570,7 @@ describe("Timeline data assembly", () => {
     ]);
 
     const result = await assembleCollectionTimeline(createTimelineContext(), {
-      collectionId: collection.id,
+      collectionIds: [collection.id],
       isAuthenticated: true,
       sortOrder: "newest",
     });
@@ -611,7 +620,7 @@ describe("Timeline data assembly", () => {
     });
 
     const result = await assembleCollectionTimeline(createTimelineContext(), {
-      collectionId: collection.id,
+      collectionIds: [collection.id],
       isAuthenticated: true,
       sortOrder: "newest",
     });
@@ -630,9 +639,88 @@ describe("Timeline data assembly", () => {
         highlighted: false,
       }),
     ]);
-    expect(result.items[0]?.post.threadRootPermalink).toBe(
-      result.items[0]?.post.permalink,
-    );
+  });
+
+  it("highlights the union of collected posts across multiple collections", async () => {
+    const smart = await collectionService.create({
+      slug: "smart",
+      title: "Smart",
+    });
+    const movies = await collectionService.create({
+      slug: "movies",
+      title: "Movies",
+    });
+    const firstRoot = await postService.create({
+      format: "note",
+      bodyMarkdown: "Thread root",
+    });
+    const smartReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Smart reply",
+      replyToId: firstRoot.id,
+    });
+    const hiddenMiddleReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Hidden middle reply",
+      replyToId: smartReply.id,
+    });
+    const movieReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Movie reply",
+      replyToId: hiddenMiddleReply.id,
+    });
+    const secondRoot = await postService.create({
+      format: "note",
+      bodyMarkdown: "Second thread root",
+    });
+
+    await db.insert(postCollections).values([
+      {
+        siteId: DEFAULT_TEST_SITE_ID,
+        postId: smartReply.id,
+        collectionId: smart.id,
+        createdAt: 100,
+      },
+      {
+        siteId: DEFAULT_TEST_SITE_ID,
+        postId: movieReply.id,
+        collectionId: movies.id,
+        createdAt: 200,
+      },
+      {
+        siteId: DEFAULT_TEST_SITE_ID,
+        postId: secondRoot.id,
+        collectionId: movies.id,
+        createdAt: 300,
+      },
+    ]);
+
+    const result = await assembleCollectionTimeline(createTimelineContext(), {
+      collectionIds: [smart.id, movies.id],
+      isAuthenticated: true,
+      sortOrder: "newest",
+    });
+
+    expect(result.items).toHaveLength(2);
+    expect(result.items[0]?.post.id).toBe(secondRoot.id);
+    expect(result.items[1]?.post.id).toBe(firstRoot.id);
+    expect(result.items[1]?.curatedThread?.segments).toEqual([
+      expect.objectContaining({
+        post: expect.objectContaining({ id: firstRoot.id }),
+        hiddenBeforeCount: 0,
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: smartReply.id }),
+        hiddenBeforeCount: 0,
+        highlighted: true,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: movieReply.id }),
+        hiddenBeforeCount: 1,
+        highlighted: true,
+      }),
+    ]);
   });
 
   it("omits private timeline items from unauthenticated partial refreshes", async () => {

package/src/lib/__tests__/tiptap-render.test.ts

@@ -0,0 +1,224 @@
+import { describe, expect, it } from "vitest";
+import {
+  renderTiptapDocument,
+  renderTiptapJson,
+  trimTiptapBody,
+} from "../tiptap-render.js";
+
+function doc(...content: Record<string, unknown>[]) {
+  return { type: "doc", content };
+}
+
+function p(...content: Record<string, unknown>[]) {
+  return { type: "paragraph", content };
+}
+
+function text(value: string, marks?: Record<string, unknown>[]) {
+  return marks
+    ? { type: "text", text: value, marks }
+    : { type: "text", text: value };
+}
+
+describe("renderTiptapDocument", () => {
+  it("renders parsed document objects directly", () => {
+    expect(renderTiptapDocument(doc(p(text("Hello world"))))).toBe(
+      "<p>Hello world</p>",
+    );
+  });
+
+  it("renders links with safe target attributes when present", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p(
+          text("OpenAI", [
+            {
+              type: "link",
+              attrs: {
+                href: "https://openai.com",
+                target: "_blank",
+              },
+            },
+          ]),
+        ),
+      ),
+    );
+
+    expect(html).toBe(
+      '<p><a href="https://openai.com" target="_blank" rel="noopener noreferrer">OpenAI</a></p>',
+    );
+  });
+
+  it("renders rich image figures consistently", () => {
+    const html = renderTiptapDocument(
+      doc({
+        type: "image",
+        attrs: {
+          src: "https://example.com/img.png",
+          alt: "Alt",
+          title: "Title",
+          caption: "Caption",
+          href: "https://example.com/source",
+          layout: "wide",
+        },
+      }),
+    );
+
+    expect(html).toBe(
+      '<figure data-layout="wide"><a href="https://example.com/source"><img src="https://example.com/img.png" alt="Alt" title="Title"></a><figcaption>Caption</figcaption></figure>',
+    );
+  });
+
+  it("renders footnote references as inline sidenotes", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p(text("Body copy"), {
+          type: "footnoteReference",
+          attrs: { label: "1" },
+        }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "1" },
+          content: [p(text("Footnote body"))],
+        },
+      ),
+    );
+
+    expect(html).toBe(
+      '<p>Body copy<label for="sn-1" class="margin-toggle sidenote-number"></label>' +
+        '<input type="checkbox" id="sn-1" class="margin-toggle"/>' +
+        '<span class="sidenote">Footnote body</span></p>',
+    );
+  });
+
+  it("renders footnote reference without definition gracefully", () => {
+    const html = renderTiptapDocument(
+      doc(
+        p(text("Body copy"), {
+          type: "footnoteReference",
+          attrs: { label: "1" },
+        }),
+      ),
+    );
+
+    expect(html).toBe(
+      '<p>Body copy<label for="sn-1" class="margin-toggle sidenote-number"></label>' +
+        '<input type="checkbox" id="sn-1" class="margin-toggle"/>' +
+        '<span class="sidenote"></span></p>',
+    );
+  });
+
+  it("renders code blocks as escaped text, not nested inline markup", () => {
+    const html = renderTiptapDocument(
+      doc({
+        type: "codeBlock",
+        attrs: { language: "ts" },
+        content: [{ type: "text", text: "const x = `<div>`;" }],
+      }),
+    );
+
+    expect(html).toBe(
+      '<pre><code class="language-ts">const x = `&lt;div&gt;`;</code></pre>',
+    );
+  });
+
+  it("falls back to rendering children for unknown nodes", () => {
+    const html = renderTiptapDocument(
+      doc({
+        type: "unknownWrapper",
+        content: [p(text("Still visible"))],
+      }),
+    );
+
+    expect(html).toBe("<p>Still visible</p>");
+  });
+});
+
+describe("renderTiptapJson", () => {
+  it("returns an empty string for invalid JSON", () => {
+    expect(renderTiptapJson("not json")).toBe("");
+  });
+
+  it("returns an empty string for non-doc JSON", () => {
+    expect(renderTiptapDocument({ type: "paragraph" })).toBe("");
+  });
+});
+
+describe("trimTiptapBody", () => {
+  it("removes leading empty paragraphs", () => {
+    const input = JSON.stringify(doc(p(), p(text("Hello"))));
+    const expected = JSON.stringify(doc(p(text("Hello"))));
+    expect(trimTiptapBody(input)).toBe(expected);
+  });
+
+  it("removes trailing empty paragraphs", () => {
+    const input = JSON.stringify(doc(p(text("Hello")), p(), p()));
+    const expected = JSON.stringify(doc(p(text("Hello"))));
+    expect(trimTiptapBody(input)).toBe(expected);
+  });
+
+  it("removes both leading and trailing empty paragraphs", () => {
+    const input = JSON.stringify(doc(p(), p(text("Hello")), p()));
+    const expected = JSON.stringify(doc(p(text("Hello"))));
+    expect(trimTiptapBody(input)).toBe(expected);
+  });
+
+  it("preserves inner empty paragraphs", () => {
+    const input = JSON.stringify(doc(p(text("A")), p(), p(text("B"))));
+    expect(trimTiptapBody(input)).toBe(input);
+  });
+
+  it("returns null when all paragraphs are empty", () => {
+    const input = JSON.stringify(doc(p(), p()));
+    expect(trimTiptapBody(input)).toBeNull();
+  });
+
+  it("returns the original string when no trimming needed", () => {
+    const input = JSON.stringify(doc(p(text("Hello"))));
+    expect(trimTiptapBody(input)).toBe(input);
+  });
+
+  it("treats whitespace-only text as empty", () => {
+    const input = JSON.stringify(
+      doc(p(text("  ")), p(text("Hello")), p(text("\n"))),
+    );
+    const expected = JSON.stringify(doc(p(text("Hello"))));
+    expect(trimTiptapBody(input)).toBe(expected);
+  });
+
+  it("does not strip paragraphs with images", () => {
+    const imgParagraph = {
+      type: "paragraph",
+      content: [{ type: "image", attrs: { src: "test.png" } }],
+    };
+    const input = JSON.stringify(doc(imgParagraph, p()));
+    const expected = JSON.stringify(doc(imgParagraph));
+    expect(trimTiptapBody(input)).toBe(expected);
+  });
+
+  it("does not strip non-paragraph blocks like headings with content", () => {
+    const heading = {
+      type: "heading",
+      attrs: { level: 1 },
+      content: [text("Title")],
+    };
+    const input = JSON.stringify(doc(p(), heading, p()));
+    const expected = JSON.stringify(doc(heading));
+    expect(trimTiptapBody(input)).toBe(expected);
+  });
+
+  it("strips empty headings", () => {
+    const emptyHeading = { type: "heading", attrs: { level: 1 } };
+    const input = JSON.stringify(doc(emptyHeading, p(text("Hello"))));
+    const expected = JSON.stringify(doc(p(text("Hello"))));
+    expect(trimTiptapBody(input)).toBe(expected);
+  });
+
+  it("returns original string for invalid JSON", () => {
+    expect(trimTiptapBody("not json")).toBe("not json");
+  });
+
+  it("returns original string for non-doc JSON", () => {
+    const input = JSON.stringify({ type: "paragraph" });
+    expect(trimTiptapBody(input)).toBe(input);
+  });
+});

package/src/lib/__tests__/tiptap-to-markdown.test.ts

@@ -308,6 +308,52 @@ describe("tiptapJsonToMarkdown", () => {
     });
   });
 
+  describe("footnotes", () => {
+    it("converts footnote references and single-paragraph definitions", () => {
+      const json = doc(
+        p(text("Body copy"), {
+          type: "footnoteReference",
+          attrs: { label: "1" },
+        }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "1" },
+          content: [p(text("Footnote body"))],
+        },
+      );
+
+      expect(tiptapJsonToMarkdown(json)).toBe(
+        "Body copy[^1]\n\n[^1]: Footnote body",
+      );
+    });
+
+    it("converts multi-block footnote definitions with indented bodies", () => {
+      const json = doc(
+        p(text("Body copy"), {
+          type: "footnoteReference",
+          attrs: { label: "1" },
+        }),
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "1" },
+          content: [
+            p(text("First paragraph")),
+            {
+              type: "bulletList",
+              content: [
+                { type: "listItem", content: [p(text("Nested item"))] },
+              ],
+            },
+          ],
+        },
+      );
+
+      expect(tiptapJsonToMarkdown(json)).toBe(
+        "Body copy[^1]\n\n[^1]:\n    First paragraph\n\n    - Nested item",
+      );
+    });
+  });
+
   describe("hard breaks", () => {
     it("converts hard breaks to trailing spaces + newline", () => {
       const json = doc(
@@ -351,6 +397,11 @@ describe("tiptapJsonToMarkdown", () => {
         '<figure data-jant-node="image" data-jant-layout="wide"><a href="https://example.com/source"><img src="https://example.com/img.png" alt="Alt" title="Title"></a><figcaption>Caption</figcaption></figure>';
       expect(roundtrip(md)).toBe(md);
     });
+
+    it("round-trips footnotes", () => {
+      const md = "Body copy[^1]\n\n[^1]: Footnote body";
+      expect(roundtrip(md)).toBe(md);
+    });
   });
 
   describe("edge cases", () => {

package/src/lib/__tests__/video-playback.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest";
+import {
+  normalizeDurationSeconds,
+  shouldUseShortVideoExperience,
+} from "../video-playback.js";
+
+describe("normalizeDurationSeconds", () => {
+  it("rounds up fractional durations for storage and heuristics", () => {
+    expect(normalizeDurationSeconds(14.2)).toBe(15);
+  });
+
+  it("returns undefined for invalid durations", () => {
+    expect(normalizeDurationSeconds(0)).toBeUndefined();
+    expect(normalizeDurationSeconds(undefined)).toBeUndefined();
+  });
+});
+
+describe("shouldUseShortVideoExperience", () => {
+  it("accepts short lightweight videos", () => {
+    expect(
+      shouldUseShortVideoExperience({
+        mimeType: "video/mp4",
+        durationSeconds: 12,
+        size: 3_000_000,
+      }),
+    ).toBe(true);
+  });
+
+  it("rejects longer videos", () => {
+    expect(
+      shouldUseShortVideoExperience({
+        mimeType: "video/mp4",
+        durationSeconds: 16,
+        size: 3_000_000,
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects oversized videos even when short", () => {
+    expect(
+      shouldUseShortVideoExperience({
+        mimeType: "video/mp4",
+        durationSeconds: 12,
+        size: 20 * 1024 * 1024,
+      }),
+    ).toBe(false);
+  });
+});