@jant/core 0.3.22 → 0.3.24

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

@@ -7,8 +7,8 @@ import {
   toPostView,
   toPostViews,
   toMediaView,
-  toNavLinkView,
-  toNavLinkViews,
+  toNavItemView,
+  toNavItemViews,
   toSearchResultView,
   toArchiveGroups,
 } from "../view.js";
@@ -16,7 +16,7 @@ import type { MediaContext } from "../view.js";
 import type {
   PostWithMedia,
   Media,
-  NavigationLink,
+  NavItem,
   SearchResult,
   Post,
 } from "../../types.js";
@@ -30,15 +30,18 @@ const CTX_WITH_URLS: MediaContext = {
 function makePost(overrides: Partial<Post> = {}): Post {
   return {
     id: 1,
-    type: "note",
-    visibility: "featured",
+    format: "note",
+    status: "published",
+    featured: 0,
+    pinned: 0,
+    slug: null,
     title: null,
-    path: null,
-    content: "Hello world",
-    contentHtml: "<p>Hello world</p>",
-    sourceUrl: null,
-    sourceName: null,
-    sourceDomain: null,
+    url: null,
+    body: "Hello world",
+    bodyHtml: "<p>Hello world</p>",
+    quoteText: null,
+    rating: null,
+    collectionId: null,
     replyToId: null,
     threadId: null,
     deletedAt: null,
@@ -78,11 +81,13 @@ function makeMedia(overrides: Partial<Media> = {}): Media {
   };
 }
 
-function makeNavLink(overrides: Partial<NavigationLink> = {}): NavigationLink {
+function makeNavItem(overrides: Partial<NavItem> = {}): NavItem {
   return {
     id: 1,
+    type: "link",
     label: "Home",
     url: "/",
+    pageId: null,
     position: 0,
     createdAt: 1706745600,
     updatedAt: 1706745600,
@@ -95,13 +100,19 @@ function makeNavLink(overrides: Partial<NavigationLink> = {}): NavigationLink {
 // =============================================================================
 
 describe("toPostView", () => {
-  it("generates permalink from post id", () => {
-    const post = makePostWithMedia({ id: 123 });
+  it("generates permalink from post id when no slug", () => {
+    const post = makePostWithMedia({ id: 123, slug: null });
     const view = toPostView(post, EMPTY_CTX);
     expect(view.permalink).toMatch(/^\/p\/.+$/);
     expect(view.permalink.length).toBeGreaterThan(3);
   });
 
+  it("generates permalink from slug when slug is set", () => {
+    const post = makePostWithMedia({ id: 123, slug: "my-post" });
+    const view = toPostView(post, EMPTY_CTX);
+    expect(view.permalink).toBe("/my-post");
+  });
+
   it("formats dates correctly", () => {
     const post = makePostWithMedia({ publishedAt: 1706745600 });
     const view = toPostView(post, EMPTY_CTX);
@@ -109,52 +120,156 @@ describe("toPostView", () => {
     expect(view.publishedAtFormatted).toBe("Feb 1, 2024");
   });
 
-  it("generates excerpt from content", () => {
-    const shortContent = "Short text";
-    const longContent = "A".repeat(200);
+  it("generates excerpt from body", () => {
+    const shortBody = "Short text";
+    const longBody = "A".repeat(200);
 
     const shortView = toPostView(
-      makePostWithMedia({ content: shortContent }),
+      makePostWithMedia({ body: shortBody }),
       EMPTY_CTX,
     );
     expect(shortView.excerpt).toBe("Short text");
 
     const longView = toPostView(
-      makePostWithMedia({ content: longContent }),
+      makePostWithMedia({ body: longBody }),
       EMPTY_CTX,
     );
     expect(longView.excerpt).toBe("A".repeat(160) + "...");
   });
 
-  it("handles null content gracefully", () => {
-    const view = toPostView(makePostWithMedia({ content: null }), EMPTY_CTX);
+  it("computes summaryHtml for posts with title and bodyHtml", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        title: "My Article",
+        body: "Short article body",
+        bodyHtml: "<p>Short article body</p>",
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBe("<p>Short article body</p>");
+    expect(view.summaryHasMore).toBe(false);
+  });
+
+  it("truncates summaryHtml for long articles", () => {
+    const p1 = `<p>${"A".repeat(300)}</p>`;
+    const p2 = `<p>${"B".repeat(300)}</p>`;
+    const view = toPostView(
+      makePostWithMedia({
+        title: "Long Article",
+        body: "A".repeat(300) + "B".repeat(300),
+        bodyHtml: p1 + p2,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBe(p1);
+    expect(view.summaryHasMore).toBe(true);
+  });
+
+  it("does not compute summaryHtml for posts without title", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        title: null,
+        bodyHtml: "<p>Just a note</p>",
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBeUndefined();
+    expect(view.summaryHasMore).toBeUndefined();
+  });
+
+  it("does not compute summaryHtml for posts without bodyHtml", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        title: "Title Only",
+        bodyHtml: null,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.summaryHtml).toBeUndefined();
+    expect(view.summaryHasMore).toBeUndefined();
+  });
+
+  it("handles null body gracefully", () => {
+    const view = toPostView(
+      makePostWithMedia({ body: null, bodyHtml: null }),
+      EMPTY_CTX,
+    );
     expect(view.excerpt).toBeUndefined();
-    expect(view.content).toBeUndefined();
+    expect(view.bodyHtml).toBeUndefined();
+    expect(view.body).toBeUndefined();
   });
 
   it("converts null fields to undefined", () => {
     const view = toPostView(makePostWithMedia(), EMPTY_CTX);
     expect(view.title).toBeUndefined();
-    expect(view.path).toBeUndefined();
-    expect(view.sourceUrl).toBeUndefined();
-    expect(view.sourceName).toBeUndefined();
-    expect(view.sourceDomain).toBeUndefined();
+    expect(view.slug).toBeUndefined();
+    expect(view.url).toBeUndefined();
+    expect(view.quoteText).toBeUndefined();
+    expect(view.rating).toBeUndefined();
+    expect(view.collectionId).toBeUndefined();
     expect(view.replyToId).toBeUndefined();
     expect(view.threadRootId).toBeUndefined();
   });
 
-  it("preserves non-null source fields", () => {
+  it("preserves non-null url field", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        url: "https://example.com",
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.url).toBe("https://example.com");
+  });
+
+  it("preserves non-null quoteText field", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        format: "quote",
+        quoteText: "Something wise",
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.quoteText).toBe("Something wise");
+  });
+
+  it("maps format, status, featured, and pinned correctly", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        format: "link",
+        status: "draft",
+        featured: 1,
+        pinned: 1,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.format).toBe("link");
+    expect(view.status).toBe("draft");
+    expect(view.featured).toBe(true);
+    expect(view.pinned).toBe(true);
+  });
+
+  it("converts featured=0 and pinned=0 to false", () => {
     const view = toPostView(
       makePostWithMedia({
-        sourceUrl: "https://example.com",
-        sourceName: "Example",
-        sourceDomain: "example.com",
+        featured: 0,
+        pinned: 0,
       }),
       EMPTY_CTX,
     );
-    expect(view.sourceUrl).toBe("https://example.com");
-    expect(view.sourceName).toBe("Example");
-    expect(view.sourceDomain).toBe("example.com");
+    expect(view.featured).toBe(false);
+    expect(view.pinned).toBe(false);
+  });
+
+  it("preserves rating and collectionId when set", () => {
+    const view = toPostView(
+      makePostWithMedia({
+        rating: 5,
+        collectionId: 42,
+      }),
+      EMPTY_CTX,
+    );
+    expect(view.rating).toBe(5);
+    expect(view.collectionId).toBe(42);
   });
 
   it("converts media attachments to MediaView", () => {
@@ -194,8 +309,8 @@ describe("toPostViews", () => {
     const posts = [makePostWithMedia({ id: 1 }), makePostWithMedia({ id: 2 })];
     const views = toPostViews(posts, EMPTY_CTX);
     expect(views).toHaveLength(2);
-    expect(views[0]!.id).toBe(1);
-    expect(views[1]!.id).toBe(2);
+    expect(views[0]).toHaveProperty("id", 1);
+    expect(views[1]).toHaveProperty("id", 2);
   });
 });
 
@@ -249,40 +364,40 @@ describe("toMediaView", () => {
 });
 
 // =============================================================================
-// toNavLinkView
+// toNavItemView
 // =============================================================================
 
-describe("toNavLinkView", () => {
+describe("toNavItemView", () => {
   it("marks home link active on exact / match", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/" }), "/");
+    const view = toNavItemView(makeNavItem({ url: "/" }), "/");
     expect(view.isActive).toBe(true);
     expect(view.isExternal).toBe(false);
   });
 
   it("marks home link inactive on other paths", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/" }), "/archive");
+    const view = toNavItemView(makeNavItem({ url: "/" }), "/archive");
     expect(view.isActive).toBe(false);
   });
 
   it("matches prefix for non-root links", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/archive" }), "/archive");
+    const view = toNavItemView(makeNavItem({ url: "/archive" }), "/archive");
     expect(view.isActive).toBe(true);
 
-    const viewSub = toNavLinkView(
-      makeNavLink({ url: "/archive" }),
+    const viewSub = toNavItemView(
+      makeNavItem({ url: "/archive" }),
       "/archive/2024",
     );
     expect(viewSub.isActive).toBe(true);
   });
 
   it("does not false-match similar prefixes", () => {
-    const view = toNavLinkView(makeNavLink({ url: "/arch" }), "/archive");
+    const view = toNavItemView(makeNavItem({ url: "/arch" }), "/archive");
     expect(view.isActive).toBe(false);
   });
 
   it("marks external links as external and never active", () => {
-    const view = toNavLinkView(
-      makeNavLink({ url: "https://example.com" }),
+    const view = toNavItemView(
+      makeNavItem({ url: "https://example.com" }),
       "/",
     );
     expect(view.isExternal).toBe(true);
@@ -290,24 +405,35 @@ describe("toNavLinkView", () => {
   });
 
   it("handles http:// links", () => {
-    const view = toNavLinkView(makeNavLink({ url: "http://example.com" }), "/");
+    const view = toNavItemView(makeNavItem({ url: "http://example.com" }), "/");
     expect(view.isExternal).toBe(true);
     expect(view.isActive).toBe(false);
   });
+
+  it("includes type and pageId in view", () => {
+    const view = toNavItemView(makeNavItem({ type: "page", pageId: 5 }), "/");
+    expect(view.type).toBe("page");
+    expect(view.pageId).toBe(5);
+  });
+
+  it("converts null pageId to undefined", () => {
+    const view = toNavItemView(makeNavItem({ pageId: null }), "/");
+    expect(view.pageId).toBeUndefined();
+  });
 });
 
-describe("toNavLinkViews", () => {
-  it("converts multiple links", () => {
-    const links = [
-      makeNavLink({ id: 1, url: "/" }),
-      makeNavLink({ id: 2, url: "/archive" }),
-      makeNavLink({ id: 3, url: "https://github.com" }),
+describe("toNavItemViews", () => {
+  it("converts multiple items", () => {
+    const items = [
+      makeNavItem({ id: 1, url: "/" }),
+      makeNavItem({ id: 2, url: "/archive" }),
+      makeNavItem({ id: 3, url: "https://github.com" }),
     ];
-    const views = toNavLinkViews(links, "/archive");
+    const views = toNavItemViews(items, "/archive");
     expect(views).toHaveLength(3);
-    expect(views[0]!.isActive).toBe(false);
-    expect(views[1]!.isActive).toBe(true);
-    expect(views[2]!.isExternal).toBe(true);
+    expect(views[0]).toHaveProperty("isActive", false);
+    expect(views[1]).toHaveProperty("isActive", true);
+    expect(views[2]).toHaveProperty("isExternal", true);
   });
 });
 
@@ -329,6 +455,28 @@ describe("toSearchResultView", () => {
     expect(view.rank).toBe(1.5);
     expect(view.snippet).toBe("...matching <b>text</b>...");
   });
+
+  it("uses new post fields in search result view", () => {
+    const result: SearchResult = {
+      post: makePost({
+        id: 10,
+        format: "link",
+        status: "published",
+        featured: 1,
+        pinned: 0,
+        url: "https://example.com",
+        slug: "my-link",
+      }),
+      rank: 0.8,
+    };
+    const view = toSearchResultView(result, EMPTY_CTX);
+    expect(view.post.format).toBe("link");
+    expect(view.post.status).toBe("published");
+    expect(view.post.featured).toBe(true);
+    expect(view.post.pinned).toBe(false);
+    expect(view.post.url).toBe("https://example.com");
+    expect(view.post.permalink).toBe("/my-link");
+  });
 });
 
 // =============================================================================
@@ -347,15 +495,16 @@ describe("toArchiveGroups", () => {
     const groups = toArchiveGroups(grouped, EMPTY_CTX);
     expect(groups).toHaveLength(2);
 
-    expect(groups[0]!.year).toBe("2024");
-    expect(groups[0]!.month).toBe("02");
-    expect(groups[0]!.label).toBe("February 2024");
-    expect(groups[0]!.posts).toHaveLength(2);
+    expect(groups[0]).toHaveProperty("year", "2024");
+    expect(groups[0]).toHaveProperty("month", "02");
+    expect(groups[0]).toHaveProperty("label", "February 2024");
+    expect(groups[0]).toHaveProperty("posts");
+    expect(groups[0]?.posts).toHaveLength(2);
 
-    expect(groups[1]!.year).toBe("2024");
-    expect(groups[1]!.month).toBe("01");
-    expect(groups[1]!.label).toBe("January 2024");
-    expect(groups[1]!.posts).toHaveLength(1);
+    expect(groups[1]).toHaveProperty("year", "2024");
+    expect(groups[1]).toHaveProperty("month", "01");
+    expect(groups[1]).toHaveProperty("label", "January 2024");
+    expect(groups[1]?.posts).toHaveLength(1);
   });
 
   it("converts posts to PostView within groups", () => {
@@ -363,9 +512,10 @@ describe("toArchiveGroups", () => {
     grouped.set("2024-02", [makePost({ id: 1 })]);
 
     const groups = toArchiveGroups(grouped, EMPTY_CTX);
-    const post = groups[0]!.posts[0]!;
-    expect(post.permalink).toBeDefined();
-    expect(post.publishedAtFormatted).toBeDefined();
+    const post = groups[0]?.posts[0];
+    expect(post).toBeDefined();
+    expect(post?.permalink).toBeDefined();
+    expect(post?.publishedAtFormatted).toBeDefined();
   });
 
   it("handles empty map", () => {

package/src/lib/constants.ts

@@ -7,6 +7,7 @@
  */
 export const RESERVED_PATHS = [
   "featured",
+  "collections",
   "signin",
   "signout",
   "setup",
@@ -15,10 +16,6 @@ export const RESERVED_PATHS = [
   "feed",
   "search",
   "archive",
-  "notes",
-  "articles",
-  "links",
-  "quotes",
   "media",
   "pages",
   "reset",

package/src/lib/excerpt.ts

@@ -0,0 +1,87 @@
+/**
+ * HTML Excerpt Utilities
+ *
+ * Generates paragraph-aware excerpts from HTML content for article
+ * previews in timelines. Breaks only at paragraph boundaries.
+ */
+
+/**
+ * Strips HTML tags from a string, returning plain text.
+ *
+ * @param html - HTML string to strip
+ * @returns Plain text without HTML tags
+ *
+ * @example
+ * ```typescript
+ * stripHtml("<p>Hello <strong>world</strong></p>") // "Hello world"
+ * ```
+ */
+export function stripHtml(html: string): string {
+  return html.replace(/<[^>]*>/g, "");
+}
+
+/**
+ * Result of extracting an HTML excerpt.
+ */
+export interface HtmlExcerpt {
+  /** HTML excerpt (complete paragraphs only) */
+  excerpt: string;
+  /** Whether the original content has more text beyond the excerpt */
+  hasMore: boolean;
+}
+
+/**
+ * Extracts a paragraph-aware HTML excerpt from body HTML.
+ *
+ * Uses a greedy algorithm: accumulates paragraphs until the total
+ * plain-text length exceeds 500 characters, then stops. At least
+ * one paragraph is always included.
+ *
+ * If the content contains a `<!--more-->` marker, the content before
+ * the marker is used as the excerpt instead.
+ *
+ * @param bodyHtml - Full HTML body content
+ * @returns Excerpt HTML and whether there is more content
+ *
+ * @example
+ * ```typescript
+ * // Short content — returned as-is with hasMore = false
+ * getHtmlExcerpt("<p>Short post.</p>")
+ * // { excerpt: "<p>Short post.</p>", hasMore: false }
+ *
+ * // Long content — truncated at paragraph boundary
+ * getHtmlExcerpt("<p>" + "A".repeat(300) + "</p><p>" + "B".repeat(300) + "</p>")
+ * // { excerpt: "<p>AAA...</p>", hasMore: true }
+ *
+ * // Manual break with <!--more-->
+ * getHtmlExcerpt("<p>Intro</p><!--more--><p>Rest</p>")
+ * // { excerpt: "<p>Intro</p>", hasMore: true }
+ * ```
+ */
+export function getHtmlExcerpt(bodyHtml: string): HtmlExcerpt {
+  // Honor manual <!--more--> marker
+  if (bodyHtml.includes("<!--more-->")) {
+    const excerpt = bodyHtml.split("<!--more-->")[0]!;
+    return { excerpt, hasMore: true };
+  }
+
+  const paragraphs = bodyHtml.match(/<p>[\s\S]*?<\/p>/g) || [];
+
+  // No paragraphs found — return full content
+  if (paragraphs.length === 0) {
+    return { excerpt: bodyHtml, hasMore: false };
+  }
+
+  let excerpt = "";
+  let charCount = 0;
+
+  for (const p of paragraphs) {
+    const textLen = stripHtml(p).length;
+    if (charCount + textLen > 500 && excerpt) break;
+    excerpt += p;
+    charCount += textLen;
+  }
+
+  const hasMore = excerpt.length < bodyHtml.length;
+  return { excerpt, hasMore };
+}

package/src/lib/feed.ts

@@ -51,7 +51,7 @@ export function defaultRssRenderer(data: FeedData): string {
       <link>${link}</link>
       <guid isPermaLink="true">${link}</guid>
       <pubDate>${pubDate}</pubDate>
-      <description><![CDATA[${post.contentHtml || ""}]]></description>${enclosure}
+      <description><![CDATA[${post.bodyHtml || ""}]]></description>${enclosure}
     </item>`;
     })
     .join("");
@@ -90,7 +90,7 @@ export function defaultAtomRenderer(data: FeedData): string {
     <id>${link}</id>
     <published>${post.publishedAt}</published>
     <updated>${post.updatedAt}</updated>
-    <content type="html"><![CDATA[${post.contentHtml || ""}]]></content>
+    <content type="html"><![CDATA[${post.bodyHtml || ""}]]></content>
   </entry>`;
     })
     .join("");
@@ -112,17 +112,17 @@ export function defaultAtomRenderer(data: FeedData): string {
 /**
  * Default Sitemap renderer.
  *
- * @param data - Sitemap data with PostView[] (pre-computed URLs)
+ * @param data - Sitemap data with PostView[] and PageView[]
  * @returns Sitemap XML string
  */
 export function defaultSitemapRenderer(data: SitemapData): string {
-  const { siteUrl, posts } = data;
+  const { siteUrl, posts, pages } = data;
 
-  const urls = posts
+  const postUrls = posts
     .map((post) => {
       const loc = `${siteUrl}${post.permalink}`;
       const lastmod = post.updatedAt.split("T")[0];
-      const priority = post.visibility === "featured" ? "0.8" : "0.6";
+      const priority = post.featured ? "0.8" : "0.6";
 
       return `
   <url>
@@ -133,6 +133,20 @@ export function defaultSitemapRenderer(data: SitemapData): string {
     })
     .join("");
 
+  const pageUrls = pages
+    .map((page) => {
+      const loc = `${siteUrl}/${page.slug}`;
+      const lastmod = page.updatedAt.split("T")[0];
+
+      return `
+  <url>
+    <loc>${loc}</loc>
+    <lastmod>${lastmod}</lastmod>
+    <priority>0.7</priority>
+  </url>`;
+    })
+    .join("");
+
   const homepageUrl = `
   <url>
     <loc>${siteUrl}/</loc>
@@ -143,6 +157,7 @@ export function defaultSitemapRenderer(data: SitemapData): string {
   return `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   ${homepageUrl}
-  ${urls}
+  ${postUrls}
+  ${pageUrls}
 </urlset>`;
 }

package/src/lib/navigation.ts

@@ -6,14 +6,14 @@
 
 import type { Context } from "hono";
 import { getSiteName } from "./config.js";
-import type { NavLinkView } from "../types.js";
-import { toNavLinkViews } from "./view.js";
+import type { NavItemView } from "../types.js";
+import { toNavItemViews } from "./view.js";
 
 /**
  * Navigation data needed by SiteLayout
  */
 export interface NavigationData {
-  links: NavLinkView[];
+  links: NavItemView[];
   currentPath: string;
   siteName: string;
 }
@@ -21,8 +21,7 @@ export interface NavigationData {
 /**
  * Fetch navigation data for public pages.
  *
- * Ensures default links exist (Home, Archive, RSS) and returns
- * NavLinkView[] with pre-computed isActive/isExternal state.
+ * Returns NavItemView[] with pre-computed isActive/isExternal state.
  *
  * @param c - Hono context
  * @returns Navigation data for SiteLayout
@@ -38,9 +37,9 @@ export interface NavigationData {
  * ```
  */
 export async function getNavigationData(c: Context): Promise<NavigationData> {
-  const navigationLinks = await c.var.services.navigationLinks.ensureDefaults();
+  const items = await c.var.services.navItems.list();
   const currentPath = new URL(c.req.url).pathname;
   const siteName = await getSiteName(c);
-  const links = toNavLinkViews(navigationLinks, currentPath);
+  const links = toNavItemViews(items, currentPath);
   return { links, currentPath, siteName };
 }

package/src/lib/render.tsx

@@ -12,7 +12,7 @@ import type { Context } from "hono";
 import type { Child } from "hono/jsx";
 import type { ThemeComponents, SiteLayoutProps } from "../types.js";
 import { BaseLayout } from "../theme/layouts/BaseLayout.js";
-import { SiteLayout as DefaultSiteLayout } from "../theme/layouts/SiteLayout.js";
+import { ThreadsSiteLayout as DefaultSiteLayout } from "../themes/threads/ThreadsSiteLayout.js";
 import type { NavigationData } from "./navigation.js";
 
 export interface RenderPublicPageOptions {