@jant/core 0.3.22 → 0.3.24

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

@@ -5,28 +5,23 @@ import type {
   TimelineCardProps,
   ThreadPreviewProps,
   TimelineFeedProps,
-  PostType,
+  Format,
   HomePageProps,
 } from "../../types.js";
 import type { FC } from "hono/jsx";
 
 // Create simple mock components for testing (avoids importing .tsx files with i18n)
 const MockNoteCard: FC<TimelineCardProps> = () => null;
-const MockArticleCard: FC<TimelineCardProps> = () => null;
 const MockLinkCard: FC<TimelineCardProps> = () => null;
 const MockQuoteCard: FC<TimelineCardProps> = () => null;
-const MockImageCard: FC<TimelineCardProps> = () => null;
 const MockThreadPreview: FC<ThreadPreviewProps> = () => null;
 const MockTimelineFeed: FC<TimelineFeedProps> = () => null;
 const MockHomePage: FC<HomePageProps> = () => null;
 
-const DEFAULT_CARD_MAP: Record<PostType, FC<TimelineCardProps>> = {
+const DEFAULT_CARD_MAP: Record<Format, FC<TimelineCardProps>> = {
   note: MockNoteCard,
-  article: MockArticleCard,
   link: MockLinkCard,
   quote: MockQuoteCard,
-  image: MockImageCard,
-  page: MockNoteCard,
 };
 
 describe("theme-components", () => {
@@ -35,12 +30,6 @@ describe("theme-components", () => {
       expect(resolveCardComponent("note", DEFAULT_CARD_MAP)).toBe(MockNoteCard);
     });
 
-    it("returns default ArticleCard for article type", () => {
-      expect(resolveCardComponent("article", DEFAULT_CARD_MAP)).toBe(
-        MockArticleCard,
-      );
-    });
-
     it("returns default LinkCard for link type", () => {
       expect(resolveCardComponent("link", DEFAULT_CARD_MAP)).toBe(MockLinkCard);
     });
@@ -51,16 +40,6 @@ describe("theme-components", () => {
       );
     });
 
-    it("returns default ImageCard for image type", () => {
-      expect(resolveCardComponent("image", DEFAULT_CARD_MAP)).toBe(
-        MockImageCard,
-      );
-    });
-
-    it("returns NoteCard as fallback for page type", () => {
-      expect(resolveCardComponent("page", DEFAULT_CARD_MAP)).toBe(MockNoteCard);
-    });
-
     it("returns theme override when provided", () => {
       const CustomNote: FC<TimelineCardProps> = () => null;
       const overrides: ThemeComponents = { NoteCard: CustomNote };
@@ -71,8 +50,8 @@ describe("theme-components", () => {
 
     it("returns default when theme has no override for type", () => {
       const overrides: ThemeComponents = {};
-      expect(resolveCardComponent("article", DEFAULT_CARD_MAP, overrides)).toBe(
-        MockArticleCard,
+      expect(resolveCardComponent("link", DEFAULT_CARD_MAP, overrides)).toBe(
+        MockLinkCard,
       );
     });
   });

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

@@ -4,6 +4,8 @@ import {
   isWithinMonth,
   toISOString,
   formatDate,
+  formatTime,
+  formatRelativeTime,
   formatYearMonth,
 } from "../time.js";
 
@@ -91,6 +93,66 @@ describe("formatDate", () => {
   });
 });
 
+describe("formatTime", () => {
+  it("formats as HH:MM in 24-hour format", () => {
+    // 2024-01-15T12:30:00Z = 1705321800
+    expect(formatTime(1705321800)).toBe("12:30");
+  });
+
+  it("zero-pads hours and minutes", () => {
+    // 2024-02-01T00:00:00Z = 1706745600
+    expect(formatTime(1706745600)).toBe("00:00");
+  });
+
+  it("formats evening time correctly", () => {
+    // 2024-02-01T23:05:00Z = 1706828700
+    expect(formatTime(1706828700)).toBe("23:05");
+  });
+
+  it("formats single-digit hour with padding", () => {
+    // 2024-02-01T09:07:00Z = 1706778420
+    expect(formatTime(1706778420)).toBe("09:07");
+  });
+});
+
+describe("formatRelativeTime", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("returns '1m' for timestamps less than 60 seconds ago", () => {
+    expect(formatRelativeTime(now() - 10)).toBe("1m");
+    expect(formatRelativeTime(now() - 59)).toBe("1m");
+  });
+
+  it("returns minutes for timestamps under 1 hour", () => {
+    expect(formatRelativeTime(now() - 60)).toBe("1m");
+    expect(formatRelativeTime(now() - 300)).toBe("5m");
+    expect(formatRelativeTime(now() - 3540)).toBe("59m");
+  });
+
+  it("returns hours for timestamps under 24 hours", () => {
+    expect(formatRelativeTime(now() - 3600)).toBe("1h");
+    expect(formatRelativeTime(now() - 7200)).toBe("2h");
+    expect(formatRelativeTime(now() - 82800)).toBe("23h");
+  });
+
+  it("returns days for timestamps up to 7 days", () => {
+    expect(formatRelativeTime(now() - 86400)).toBe("1d");
+    expect(formatRelativeTime(now() - 3 * 86400)).toBe("3d");
+    expect(formatRelativeTime(now() - 7 * 86400)).toBe("7d");
+  });
+
+  it("returns 'MMM D' for timestamps older than 7 days", () => {
+    // Use a fixed timestamp to get a predictable date
+    // Feb 1, 2024 00:00:00 UTC
+    const feb1 = 1706745600;
+    // Mock now() to return Feb 16, 2024
+    vi.spyOn(Date, "now").mockReturnValue((feb1 + 15 * 86400) * 1000);
+    expect(formatRelativeTime(feb1)).toBe("Feb 1");
+  });
+});
+
 describe("formatYearMonth", () => {
   it("formats as YYYY-MM", () => {
     expect(formatYearMonth(1706745600)).toBe("2024-02");

package/src/{routes/api → lib}/__tests__/timeline.test.ts

@@ -1,19 +1,20 @@
 /**
- * Timeline API Tests
+ * Timeline Data Assembly Tests
  *
  * Tests the timeline data assembly logic via the service layer.
  * The actual route handler renders JSX components which require the Lingui SWC
  * plugin (not available in vitest). We test the underlying service operations
- * that power the timeline API instead.
+ * that power the timeline instead.
  */
 
 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 { buildMediaMap } from "../../../lib/media-helpers.js";
-import type { Database } from "../../../db/index.js";
-import type { PostWithMedia } from "../../../types.js";
+import { createTestDatabase } from "../../__tests__/helpers/db.js";
+import { createPostService } from "../../services/post.js";
+import { createMediaService } from "../../services/media.js";
+import { buildMediaMap } from "../media-helpers.js";
+import { groupByDate } from "../timeline.js";
+import type { Database } from "../../db/index.js";
+import type { PostWithMedia, TimelineItemView } from "../../types.js";
 
 describe("Timeline data assembly", () => {
   let db: Database;
@@ -29,15 +30,13 @@ describe("Timeline data assembly", () => {
 
   it("assembles timeline items with media attachments", async () => {
     const post = await postService.create({
-      type: "note",
-      content: "Hello",
-      visibility: "featured",
+      format: "note",
+      body: "Hello",
     });
 
     const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 21,
     });
 
@@ -60,25 +59,23 @@ describe("Timeline data assembly", () => {
 
   it("identifies thread roots and builds thread previews", async () => {
     const root = await postService.create({
-      type: "note",
-      content: "Thread root",
-      visibility: "featured",
+      format: "note",
+      body: "Thread root",
     });
     await postService.create({
-      type: "note",
-      content: "Reply 1",
+      format: "note",
+      body: "Reply 1",
       replyToId: root.id,
     });
     await postService.create({
-      type: "note",
-      content: "Reply 2",
+      format: "note",
+      body: "Reply 2",
       replyToId: root.id,
     });
 
     const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 21,
     });
 
@@ -96,7 +93,7 @@ describe("Timeline data assembly", () => {
     const threadPreviews = await postService.getThreadPreviews(threadRootIds);
     const replies = threadPreviews.get(root.id);
     expect(replies).toHaveLength(2);
-    expect(replies?.[0]?.content).toBe("Reply 1");
+    expect(replies?.[0]?.body).toBe("Reply 1");
 
     // Assemble items
     const rawMediaMap = await mediaService.getByPostIds(postIds);
@@ -133,50 +130,25 @@ describe("Timeline data assembly", () => {
     expect(items[0]?.threadPreview?.totalReplyCount).toBe(2);
   });
 
-  it("excludes pages from timeline", async () => {
-    await postService.create({
-      type: "note",
-      content: "A note",
-      visibility: "quiet",
-    });
-    await postService.create({
-      type: "page",
-      content: "A page",
-      visibility: "quiet",
-    });
-
-    const posts = await postService.list({
-      visibility: ["featured", "quiet"],
-      excludeReplies: true,
-      excludeTypes: ["page"],
-      limit: 21,
-    });
-
-    expect(posts).toHaveLength(1);
-    expect(posts[0]?.type).toBe("note");
-  });
-
   it("excludes replies from top-level list", async () => {
     const root = await postService.create({
-      type: "note",
-      content: "Root",
-      visibility: "quiet",
+      format: "note",
+      body: "Root",
     });
     await postService.create({
-      type: "note",
-      content: "Reply",
+      format: "note",
+      body: "Reply",
       replyToId: root.id,
     });
 
     const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 21,
     });
 
     expect(posts).toHaveLength(1);
-    expect(posts[0]?.content).toBe("Root");
+    expect(posts[0]?.body).toBe("Root");
   });
 
   it("supports cursor pagination for load more", async () => {
@@ -184,9 +156,8 @@ describe("Timeline data assembly", () => {
     for (let i = 0; i < 5; i++) {
       posts.push(
         await postService.create({
-          type: "note",
-          content: `Post ${i}`,
-          visibility: "quiet",
+          format: "note",
+          body: `Post ${i}`,
           publishedAt: 1000 + i,
         }),
       );
@@ -194,9 +165,8 @@ describe("Timeline data assembly", () => {
 
     // First page
     const page1 = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 3,
     });
     expect(page1).toHaveLength(3);
@@ -205,9 +175,8 @@ describe("Timeline data assembly", () => {
     const lastPost = page1[page1.length - 1];
     expect(lastPost).toBeDefined();
     const page2 = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: 3,
       cursor: lastPost?.id,
     });
@@ -218,18 +187,16 @@ describe("Timeline data assembly", () => {
   it("correctly determines hasMore flag", async () => {
     for (let i = 0; i < 3; i++) {
       await postService.create({
-        type: "note",
-        content: `Post ${i}`,
-        visibility: "quiet",
+        format: "note",
+        body: `Post ${i}`,
       });
     }
 
     // Request limit + 1 to check for more
     const pageSize = 2;
     const posts = await postService.list({
-      visibility: ["featured", "quiet"],
+      status: "published",
       excludeReplies: true,
-      excludeTypes: ["page"],
       limit: pageSize + 1,
     });
 
@@ -240,3 +207,78 @@ describe("Timeline data assembly", () => {
     expect(displayPosts).toHaveLength(2);
   });
 });
+
+describe("groupByDate", () => {
+  function makeItem(dateStr: string, formatted: string): TimelineItemView {
+    return {
+      post: {
+        id: 1,
+        permalink: "/p/1",
+        format: "note",
+        status: "published",
+        featured: true,
+        pinned: false,
+        publishedAt: `${dateStr}T12:00:00.000Z`,
+        publishedAtFormatted: formatted,
+        publishedAtTime: "12:00",
+        publishedAtRelative: "1d",
+        updatedAt: `${dateStr}T12:00:00.000Z`,
+        media: [],
+      },
+    };
+  }
+
+  it("returns empty array for empty input", () => {
+    expect(groupByDate([])).toEqual([]);
+  });
+
+  it("groups items by YYYY-MM-DD date key", () => {
+    const items = [
+      makeItem("2024-02-01", "Feb 1, 2024"),
+      makeItem("2024-02-01", "Feb 1, 2024"),
+      makeItem("2024-02-02", "Feb 2, 2024"),
+    ];
+
+    const groups = groupByDate(items);
+    expect(groups).toHaveLength(2);
+    expect(groups[0]?.dateKey).toBe("2024-02-01");
+    expect(groups[0]?.label).toBe("Feb 1, 2024");
+    expect(groups[0]?.items).toHaveLength(2);
+    expect(groups[1]?.dateKey).toBe("2024-02-02");
+    expect(groups[1]?.items).toHaveLength(1);
+  });
+
+  it("creates separate groups for non-contiguous same dates", () => {
+    const items = [
+      makeItem("2024-02-01", "Feb 1, 2024"),
+      makeItem("2024-02-02", "Feb 2, 2024"),
+      makeItem("2024-02-01", "Feb 1, 2024"),
+    ];
+
+    const groups = groupByDate(items);
+    expect(groups).toHaveLength(3);
+    expect(groups[0]?.dateKey).toBe("2024-02-01");
+    expect(groups[1]?.dateKey).toBe("2024-02-02");
+    expect(groups[2]?.dateKey).toBe("2024-02-01");
+  });
+
+  it("handles a single item", () => {
+    const items = [makeItem("2024-06-15", "Jun 15, 2024")];
+    const groups = groupByDate(items);
+    expect(groups).toHaveLength(1);
+    expect(groups[0]?.dateKey).toBe("2024-06-15");
+    expect(groups[0]?.items).toHaveLength(1);
+  });
+
+  it("uses the first item's formatted date as the group label", () => {
+    const items = [
+      makeItem("2024-03-10", "Mar 10, 2024"),
+      makeItem("2024-03-10", "March 10"),
+    ];
+
+    const groups = groupByDate(items);
+    expect(groups).toHaveLength(1);
+    // Label comes from first item in the group
+    expect(groups[0]?.label).toBe("Mar 10, 2024");
+  });
+});