@jant/core 0.0.1

package/src/routes/feed/rss.ts

@@ -0,0 +1,119 @@
+/**
+ * RSS Feed Routes
+ */
+
+import { Hono } from "hono";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import * as sqid from "../../lib/sqid.js";
+import * as time from "../../lib/time.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const rssRoutes = new Hono<Env>();
+
+// RSS 2.0 Feed - main feed at /feed
+rssRoutes.get("/", async (c) => {
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+  const siteDescription = (await c.var.services.settings.get("SITE_DESCRIPTION")) ?? "";
+  const siteUrl = c.env.SITE_URL;
+
+  const posts = await c.var.services.posts.list({
+    visibility: ["featured", "quiet"],
+    limit: 50,
+  });
+
+  const items = posts
+    .map((post) => {
+      const link = `${siteUrl}/p/${sqid.encode(post.id)}`;
+      const title = post.title || `Post #${post.id}`;
+      const pubDate = new Date(post.publishedAt * 1000).toUTCString();
+
+      return `
+    <item>
+      <title><![CDATA[${escapeXml(title)}]]></title>
+      <link>${link}</link>
+      <guid isPermaLink="true">${link}</guid>
+      <pubDate>${pubDate}</pubDate>
+      <description><![CDATA[${post.contentHtml || ""}]]></description>
+    </item>`;
+    })
+    .join("");
+
+  const rss = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${escapeXml(siteName)}</title>
+    <link>${siteUrl}</link>
+    <description>${escapeXml(siteDescription)}</description>
+    <language>en</language>
+    <atom:link href="${siteUrl}/feed" rel="self" type="application/rss+xml"/>
+    ${items}
+  </channel>
+</rss>`;
+
+  return new Response(rss, {
+    headers: {
+      "Content-Type": "application/rss+xml; charset=utf-8",
+    },
+  });
+});
+
+// Atom Feed
+rssRoutes.get("/atom.xml", async (c) => {
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+  const siteDescription = (await c.var.services.settings.get("SITE_DESCRIPTION")) ?? "";
+  const siteUrl = c.env.SITE_URL;
+
+  const posts = await c.var.services.posts.list({
+    visibility: ["featured", "quiet"],
+    limit: 50,
+  });
+
+  const entries = posts
+    .map((post) => {
+      const link = `${siteUrl}/p/${sqid.encode(post.id)}`;
+      const title = post.title || `Post #${post.id}`;
+      const updated = time.toISOString(post.updatedAt);
+      const published = time.toISOString(post.publishedAt);
+
+      return `
+  <entry>
+    <title>${escapeXml(title)}</title>
+    <link href="${link}" rel="alternate"/>
+    <id>${link}</id>
+    <published>${published}</published>
+    <updated>${updated}</updated>
+    <content type="html"><![CDATA[${post.contentHtml || ""}]]></content>
+  </entry>`;
+    })
+    .join("");
+
+  const now = time.toISOString(time.now());
+
+  const atom = `<?xml version="1.0" encoding="UTF-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title>${escapeXml(siteName)}</title>
+  <subtitle>${escapeXml(siteDescription)}</subtitle>
+  <link href="${siteUrl}" rel="alternate"/>
+  <link href="${siteUrl}/feed/atom.xml" rel="self"/>
+  <id>${siteUrl}/</id>
+  <updated>${now}</updated>
+  ${entries}
+</feed>`;
+
+  return new Response(atom, {
+    headers: {
+      "Content-Type": "application/atom+xml; charset=utf-8",
+    },
+  });
+});
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}

package/src/routes/feed/sitemap.ts

@@ -0,0 +1,75 @@
+/**
+ * Sitemap Routes
+ */
+
+import { Hono } from "hono";
+import type { Bindings } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import * as sqid from "../../lib/sqid.js";
+import * as time from "../../lib/time.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const sitemapRoutes = new Hono<Env>();
+
+// XML Sitemap
+sitemapRoutes.get("/sitemap.xml", async (c) => {
+  const siteUrl = c.env.SITE_URL;
+
+  const posts = await c.var.services.posts.list({
+    visibility: ["featured", "quiet"],
+    limit: 1000,
+  });
+
+  const urls = posts
+    .map((post) => {
+      const loc = `${siteUrl}/p/${sqid.encode(post.id)}`;
+      const lastmod = time.toISOString(post.updatedAt).split("T")[0];
+      const priority = post.visibility === "featured" ? "0.8" : "0.6";
+
+      return `
+  <url>
+    <loc>${loc}</loc>
+    <lastmod>${lastmod}</lastmod>
+    <priority>${priority}</priority>
+  </url>`;
+    })
+    .join("");
+
+  // Add homepage
+  const homepageUrl = `
+  <url>
+    <loc>${siteUrl}/</loc>
+    <priority>1.0</priority>
+    <changefreq>daily</changefreq>
+  </url>`;
+
+  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+  ${homepageUrl}
+  ${urls}
+</urlset>`;
+
+  return new Response(sitemap, {
+    headers: {
+      "Content-Type": "application/xml; charset=utf-8",
+    },
+  });
+});
+
+// robots.txt
+sitemapRoutes.get("/robots.txt", (c) => {
+  const siteUrl = c.env.SITE_URL;
+
+  const robots = `User-agent: *
+Allow: /
+
+Sitemap: ${siteUrl}/sitemap.xml
+`;
+
+  return new Response(robots, {
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8",
+    },
+  });
+});

package/src/routes/pages/archive.tsx

@@ -0,0 +1,223 @@
+/**
+ * Archive Page Route
+ *
+ * Shows all posts, optionally filtered by type
+ */
+
+import { Hono } from "hono";
+import { useLingui } from "../../i18n/index.js";
+import type { Bindings, Post, PostType } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { BaseLayout } from "../../theme/layouts/index.js";
+import { Pagination } from "../../theme/components/index.js";
+import { POST_TYPES } from "../../types.js";
+import * as sqid from "../../lib/sqid.js";
+import * as time from "../../lib/time.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+const PAGE_SIZE = 50;
+
+export const archiveRoutes = new Hono<Env>();
+
+function getTypeLabel(type: string): string {
+  const { t } = useLingui();
+  const labels: Record<string, string> = {
+    note: t({ message: "Note", comment: "@context: Post type label - note" }),
+    article: t({ message: "Article", comment: "@context: Post type label - article" }),
+    link: t({ message: "Link", comment: "@context: Post type label - link" }),
+    quote: t({ message: "Quote", comment: "@context: Post type label - quote" }),
+    image: t({ message: "Image", comment: "@context: Post type label - image" }),
+    page: t({ message: "Page", comment: "@context: Post type label - page" }),
+  };
+  return labels[type] ?? type;
+}
+
+function getTypeLabelPlural(type: string): string {
+  const { t } = useLingui();
+  const labels: Record<string, string> = {
+    note: t({ message: "Notes", comment: "@context: Post type label plural - notes" }),
+    article: t({ message: "Articles", comment: "@context: Post type label plural - articles" }),
+    link: t({ message: "Links", comment: "@context: Post type label plural - links" }),
+    quote: t({ message: "Quotes", comment: "@context: Post type label plural - quotes" }),
+    image: t({ message: "Images", comment: "@context: Post type label plural - images" }),
+    page: t({ message: "Pages", comment: "@context: Post type label plural - pages" }),
+  };
+  return labels[type] ?? `${type}s`;
+}
+
+function formatYearMonth(yearMonth: string): string {
+  const [year, month] = yearMonth.split("-");
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- yearMonth format YYYY-MM guarantees both year and month exist
+  const date = new Date(parseInt(year!, 10), parseInt(month!, 10) - 1);
+  return date.toLocaleDateString("en-US", { year: "numeric", month: "long" });
+}
+
+function ArchiveContent({
+  displayPosts,
+  hasMore,
+  nextCursor,
+  type,
+  grouped,
+  replyCounts,
+}: {
+  displayPosts: Post[];
+  hasMore: boolean;
+  nextCursor?: number;
+  type?: string;
+  grouped: Map<string, Post[]>;
+  replyCounts: Map<number, number>;
+}) {
+  const { t } = useLingui();
+  const title = type
+    ? getTypeLabelPlural(type)
+    : t({ message: "Archive", comment: "@context: Archive page title" });
+
+  return (
+    <div class="container py-8">
+      <header class="mb-8">
+        <h1 class="text-2xl font-semibold">{title}</h1>
+
+        {/* Type filter */}
+        <nav class="flex flex-wrap gap-2 mt-4">
+          <a
+            href="/archive"
+            class={`badge ${!type ? "badge-primary" : "badge-outline"}`}
+          >
+            {t({ message: "All", comment: "@context: Archive filter - all types" })}
+          </a>
+          {POST_TYPES.filter((t) => t !== "page").map((typeKey) => (
+            <a
+              key={typeKey}
+              href={`/archive?type=${typeKey}`}
+              class={`badge ${type === typeKey ? "badge-primary" : "badge-outline"}`}
+            >
+              {getTypeLabelPlural(typeKey)}
+            </a>
+          ))}
+        </nav>
+      </header>
+
+      <main>
+        {displayPosts.length === 0 ? (
+          <p class="text-muted-foreground">
+            {t({ message: "No posts found.", comment: "@context: Archive empty state" })}
+          </p>
+        ) : (
+          Array.from(grouped.entries()).map(([yearMonth, monthPosts]) => (
+            <section key={yearMonth} class="mb-8">
+              <h2 class="text-lg font-medium mb-4 text-muted-foreground">
+                {formatYearMonth(yearMonth)}
+              </h2>
+              <div class="flex flex-col gap-3">
+                {monthPosts.map((post) => {
+                  const replyCount = replyCounts.get(post.id);
+                  return (
+                    <article key={post.id} class="flex items-baseline gap-4">
+                      <time
+                        class="text-sm text-muted-foreground w-12 shrink-0"
+                        datetime={time.toISOString(post.publishedAt)}
+                      >
+                        {new Date(post.publishedAt * 1000).getDate()}
+                      </time>
+                      <div class="flex-1 min-w-0">
+                        <a
+                          href={`/p/${sqid.encode(post.id)}`}
+                          class="hover:underline"
+                        >
+                          {post.title || post.content?.slice(0, 80) || `Post #${post.id}`}
+                        </a>
+                        {!type && (
+                          <span class="ml-2 badge-outline text-xs">{getTypeLabel(post.type)}</span>
+                        )}
+                        {replyCount && replyCount > 0 && (
+                          <span class="ml-2 text-xs text-muted-foreground">
+                            ({replyCount === 1
+                              ? t({ message: "1 reply", comment: "@context: Archive post reply indicator - single" })
+                              : t({ message: "{count} replies", comment: "@context: Archive post reply indicator - plural", values: { count: String(replyCount) } })})
+                          </span>
+                        )}
+                      </div>
+                    </article>
+                  );
+                })}
+              </div>
+            </section>
+          ))
+        )}
+      </main>
+
+      {/* Pagination */}
+      <Pagination
+        baseUrl={type ? `/archive?type=${type}` : "/archive"}
+        hasMore={hasMore}
+        nextCursor={nextCursor}
+      />
+
+      <nav class="mt-4">
+        <a href="/" class="text-sm hover:underline">
+          ← {t({ message: "Back to home", comment: "@context: Navigation link back to home page" })}
+        </a>
+      </nav>
+    </div>
+  );
+}
+
+// Archive page - all posts
+archiveRoutes.get("/", async (c) => {
+  const typeParam = c.req.query("type") as PostType | undefined;
+  const type = typeParam && POST_TYPES.includes(typeParam) ? typeParam : undefined;
+
+  // Parse cursor
+  const cursorParam = c.req.query("cursor");
+  const cursor = cursorParam ? parseInt(cursorParam, 10) : undefined;
+
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+
+  // Fetch one extra to check for more
+  const posts = await c.var.services.posts.list({
+    type,
+    visibility: ["featured", "quiet"],
+    excludeReplies: true,
+    cursor,
+    limit: PAGE_SIZE + 1,
+  });
+
+  const hasMore = posts.length > PAGE_SIZE;
+  const displayPosts = hasMore ? posts.slice(0, PAGE_SIZE) : posts;
+
+  // Get reply counts for thread indicators
+  const postIds = displayPosts.map((p) => p.id);
+  const replyCounts = await c.var.services.posts.getReplyCounts(postIds);
+
+  // Get next cursor
+  const nextCursor = hasMore && displayPosts.length > 0
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Length check above guarantees element exists
+    ? displayPosts[displayPosts.length - 1]!.id
+    : undefined;
+
+  // Group posts by year-month
+  const grouped = new Map<string, typeof displayPosts>();
+  for (const post of displayPosts) {
+    const date = new Date(post.publishedAt * 1000);
+    const key = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`;
+    if (!grouped.has(key)) {
+      grouped.set(key, []);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Map.set() above guarantees key exists
+    grouped.get(key)!.push(post);
+  }
+
+  return c.html(
+    <BaseLayout title={`Archive - ${siteName}`} c={c}>
+      <ArchiveContent
+        displayPosts={displayPosts}
+        hasMore={hasMore}
+        nextCursor={nextCursor}
+        type={type}
+        grouped={grouped}
+        replyCounts={replyCounts}
+      />
+    </BaseLayout>
+  );
+});

package/src/routes/pages/collection.tsx

@@ -0,0 +1,79 @@
+/**
+ * Collection Page Route
+ */
+
+import { Hono } from "hono";
+import { useLingui } from "../../i18n/index.js";
+import type { Bindings, Collection, Post } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { BaseLayout } from "../../theme/layouts/index.js";
+import * as sqid from "../../lib/sqid.js";
+import * as time from "../../lib/time.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const collectionRoutes = new Hono<Env>();
+
+function CollectionContent({ collection, posts }: { collection: Collection; posts: Post[] }) {
+  const { t } = useLingui();
+
+  return (
+    <div class="container py-8">
+      <header class="mb-8">
+        <h1 class="text-2xl font-semibold">{collection.title}</h1>
+        {collection.description && (
+          <p class="text-muted-foreground mt-2">{collection.description}</p>
+        )}
+      </header>
+
+      <main class="flex flex-col gap-6">
+        {posts.length === 0 ? (
+          <p class="text-muted-foreground">{t({ message: "No posts in this collection.", comment: "@context: Empty state message" })}</p>
+        ) : (
+          posts.map((post) => (
+            <article key={post.id} class="h-entry">
+              {post.title && (
+                <h2 class="p-name text-lg font-medium mb-2">
+                  <a href={`/p/${sqid.encode(post.id)}`} class="u-url hover:underline">
+                    {post.title}
+                  </a>
+                </h2>
+              )}
+              <div
+                class="e-content prose prose-sm"
+                dangerouslySetInnerHTML={{ __html: post.contentHtml || "" }}
+              />
+              <footer class="mt-2 text-sm text-muted-foreground">
+                <time class="dt-published" datetime={time.toISOString(post.publishedAt)}>
+                  {time.formatDate(post.publishedAt)}
+                </time>
+              </footer>
+            </article>
+          ))
+        )}
+      </main>
+
+      <nav class="mt-8">
+        <a href="/" class="text-sm hover:underline">
+          {t({ message: "← Back to home", comment: "@context: Navigation link" })}
+        </a>
+      </nav>
+    </div>
+  );
+}
+
+collectionRoutes.get("/:path", async (c) => {
+  const path = c.req.param("path");
+
+  const collection = await c.var.services.collections.getByPath(path);
+  if (!collection) return c.notFound();
+
+  const posts = await c.var.services.collections.getPosts(collection.id);
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+
+  return c.html(
+    <BaseLayout title={`${collection.title} - ${siteName}`} description={collection.description ?? undefined} c={c}>
+      <CollectionContent collection={collection} posts={posts} />
+    </BaseLayout>
+  );
+});

package/src/routes/pages/home.tsx

@@ -0,0 +1,93 @@
+/**
+ * Home Page Route
+ */
+
+import { Hono } from "hono";
+import { useLingui } from "../../i18n/index.js";
+import type { Bindings, Post } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { BaseLayout } from "../../theme/layouts/index.js";
+import * as sqid from "../../lib/sqid.js";
+import * as time from "../../lib/time.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const homeRoutes = new Hono<Env>();
+
+function HomeContent({ siteName, posts }: { siteName: string; posts: Post[] }) {
+  const { t } = useLingui();
+
+  return (
+    <div class="container py-8">
+      <header class="mb-8 flex items-center justify-between">
+        <h1 class="text-2xl font-semibold">{siteName}</h1>
+        <nav class="flex items-center gap-4 text-sm">
+          <a href="/archive" class="text-muted-foreground hover:text-foreground">
+            {t({ message: "Archive", comment: "@context: Navigation link to archive page" })}
+          </a>
+          <a href="/feed" class="text-muted-foreground hover:text-foreground">
+            RSS
+          </a>
+        </nav>
+      </header>
+
+      <main class="flex flex-col gap-6">
+        {posts.length === 0 ? (
+          <p class="text-muted-foreground">{t({ message: "No posts yet.", comment: "@context: Empty state message on home page" })}</p>
+        ) : (
+          posts.map((post) => (
+            <article key={post.id} class="h-entry">
+              {post.title && (
+                <h2 class="p-name text-lg font-medium mb-2">
+                  <a href={`/p/${sqid.encode(post.id)}`} class="u-url hover:underline">
+                    {post.title}
+                  </a>
+                </h2>
+              )}
+              <div
+                class="e-content prose prose-sm"
+                dangerouslySetInnerHTML={{ __html: post.contentHtml || "" }}
+              />
+              <footer class="mt-2 text-sm text-muted-foreground">
+                <time class="dt-published" datetime={time.toISOString(post.publishedAt)}>
+                  {time.formatDate(post.publishedAt)}
+                </time>
+                {post.visibility === "featured" && (
+                  <span class="ml-2 text-xs">{t({ message: "Featured", comment: "@context: Post visibility badge" })}</span>
+                )}
+              </footer>
+            </article>
+          ))
+        )}
+      </main>
+
+      {posts.length >= 20 && (
+        <nav class="mt-8 text-center">
+          <a href="/archive" class="text-sm text-muted-foreground hover:text-foreground">
+            {t({ message: "View all posts →", comment: "@context: Link to view all posts on archive page" })}
+          </a>
+        </nav>
+      )}
+    </div>
+  );
+}
+
+homeRoutes.get("/", async (c) => {
+  const isComplete = await c.var.services.settings.isOnboardingComplete();
+  if (!isComplete) {
+    return c.redirect("/setup");
+  }
+
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+
+  const posts = await c.var.services.posts.list({
+    visibility: ["featured", "quiet"],
+    limit: 20,
+  });
+
+  return c.html(
+    <BaseLayout title={siteName} c={c}>
+      <HomeContent siteName={siteName} posts={posts} />
+    </BaseLayout>
+  );
+});

package/src/routes/pages/page.tsx

@@ -0,0 +1,64 @@
+/**
+ * Custom Page Route
+ *
+ * Catch-all route for custom pages accessible via their path field
+ */
+
+import { Hono } from "hono";
+import { useLingui } from "../../i18n/index.js";
+import type { Bindings, Post } from "../../types.js";
+import type { AppVariables } from "../../app.js";
+import { BaseLayout } from "../../theme/layouts/index.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const pageRoutes = new Hono<Env>();
+
+function PageContent({ page }: { page: Post }) {
+  const { t } = useLingui();
+
+  return (
+    <div class="container py-8 max-w-2xl">
+      <article class="h-entry">
+        {page.title && <h1 class="p-name text-3xl font-semibold mb-6">{page.title}</h1>}
+
+        <div
+          class="e-content prose"
+          dangerouslySetInnerHTML={{ __html: page.contentHtml || "" }}
+        />
+      </article>
+
+      <nav class="mt-8 pt-6 border-t">
+        <a href="/" class="text-sm hover:underline">
+          ← {t({ message: "Back to home", comment: "@context: Navigation link back to home page" })}
+        </a>
+      </nav>
+    </div>
+  );
+}
+
+// Catch-all for custom page paths
+pageRoutes.get("/:path", async (c) => {
+  const path = c.req.param("path");
+
+  // Look up page by path
+  const page = await c.var.services.posts.getByPath(path);
+
+  // Not found or not a page
+  if (!page || page.type !== "page") {
+    return c.notFound();
+  }
+
+  // Don't show drafts
+  if (page.visibility === "draft") {
+    return c.notFound();
+  }
+
+  const siteName = (await c.var.services.settings.get("SITE_NAME")) ?? "Jant";
+
+  return c.html(
+    <BaseLayout title={`${page.title} - ${siteName}`} description={page.content?.slice(0, 160)} c={c}>
+      <PageContent page={page} />
+    </BaseLayout>
+  );
+});