@jant/core 0.3.23 → 0.3.25

package/dist/lib/feed.js

@@ -33,7 +33,7 @@
       <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("");
     return `<?xml version="1.0" encoding="UTF-8"?>
@@ -65,7 +65,7 @@
     <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("");
     const now = new Date().toISOString();
@@ -83,19 +83,29 @@
 /**
  * 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) {
-    const { siteUrl, posts } = data;
-    const urls = posts.map((post)=>{
+    const { siteUrl, posts, pages } = data;
+    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>
     <loc>${loc}</loc>
     <lastmod>${lastmod}</lastmod>
     <priority>${priority}</priority>
+  </url>`;
+    }).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 = `
@@ -107,6 +117,7 @@
     return `<?xml version="1.0" encoding="UTF-8"?>
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
   ${homepageUrl}
-  ${urls}
+  ${postUrls}
+  ${pageUrls}
 </urlset>`;
 }

package/dist/lib/nav-reorder.js

@@ -13,7 +13,7 @@ if (list) {
             const ids = [
                 ...list.querySelectorAll("[data-id]")
             ].map((el)=>Number(el.dataset.id));
-            fetch("/dash/navigation/reorder", {
+            fetch("/dash/pages/reorder", {
                 method: "POST",
                 headers: {
                     "Content-Type": "application/json"

package/dist/lib/navigation.js

@@ -3,12 +3,12 @@
  *
  * Provides shared data fetching for public page navigation.
  */ import { getSiteName } from "./config.js";
-import { toNavLinkViews } from "./view.js";
+import { toNavItemViews } from "./view.js";
 /**
  * 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.
+ * Also checks authentication status and loads collections for authenticated users.
  *
  * @param c - Hono context
  * @returns Navigation data for SiteLayout
@@ -23,13 +23,37 @@ import { toNavLinkViews } from "./view.js";
  * });
  * ```
  */ export async function getNavigationData(c) {
-    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);
+    // Only include description if explicitly set (DB or env), not the default
+    const dbDescription = await c.var.services.settings.get("SITE_DESCRIPTION");
+    const envDescription = c.env.SITE_DESCRIPTION;
+    const siteDescription = dbDescription || (typeof envDescription === "string" ? envDescription : "");
+    const links = toNavItemViews(items, currentPath);
+    // Check auth status for compose button
+    let isAuthenticated = false;
+    let collections = [];
+    if (c.var.auth) {
+        try {
+            const session = await c.var.auth.api.getSession({
+                headers: c.req.raw.headers
+            });
+            isAuthenticated = !!session?.user;
+        } catch  {
+        // Not authenticated
+        }
+    }
+    // Only load collections when authenticated (for compose dialog)
+    if (isAuthenticated) {
+        collections = await c.var.services.collections.list();
+    }
     return {
         links,
         currentPath,
-        siteName
+        siteName,
+        siteDescription,
+        isAuthenticated,
+        collections
     };
 }

package/dist/lib/pagination.js

@@ -0,0 +1,44 @@
+/**
+ * Pagination Utilities
+ *
+ * Pure utility functions for page-based pagination.
+ */ /**
+ * Computes which page numbers to display in a numbered pagination control.
+ * Always includes: first page, last page, current page, and 1 page on each side of current.
+ * Gaps between non-consecutive pages are represented by 0 (ellipsis marker).
+ *
+ * @param currentPage - The current active page (1-indexed)
+ * @param totalPages - Total number of pages
+ * @returns Array of page numbers, with 0 representing ellipsis gaps
+ *
+ * @example
+ * ```ts
+ * getPageNumbers(1, 5)    // [1, 2, 3, 4, 5]
+ * getPageNumbers(1, 20)   // [1, 2, 0, 20]
+ * getPageNumbers(10, 20)  // [1, 0, 9, 10, 11, 0, 20]
+ * ```
+ */ export function getPageNumbers(currentPage, totalPages) {
+    if (totalPages <= 7) {
+        return Array.from({
+            length: totalPages
+        }, (_, i)=>i + 1);
+    }
+    const pages = new Set();
+    pages.add(1);
+    pages.add(totalPages);
+    pages.add(currentPage);
+    if (currentPage > 1) pages.add(currentPage - 1);
+    if (currentPage < totalPages) pages.add(currentPage + 1);
+    const sorted = [
+        ...pages
+    ].sort((a, b)=>a - b);
+    // Insert 0 for gaps
+    const result = [];
+    for(let i = 0; i < sorted.length; i++){
+        if (i > 0 && sorted[i] - sorted[i - 1] > 1) {
+            result.push(0); // ellipsis marker
+        }
+        result.push(sorted[i]);
+    }
+    return result;
+}

package/dist/lib/render.js

@@ -3,17 +3,12 @@
  *
  * Provides a single entry point for rendering public pages with the
  * correct layout stack: BaseLayout > SiteLayout > content.
- *
- * BaseLayout is always the built-in implementation (handles Vite assets,
- * I18nProvider, toast). SiteLayout is resolved from theme components.
  */ import { jsx as _jsx } from "hono/jsx/jsx-runtime";
-import { BaseLayout } from "../theme/layouts/BaseLayout.js";
-import { SiteLayout as DefaultSiteLayout } from "../themes/minimal/MinimalSiteLayout.js";
+import { BaseLayout } from "../ui/layouts/BaseLayout.js";
+import { SiteLayout } from "../ui/layouts/SiteLayout.js";
 /**
  * Render a public page with the standard layout stack.
  *
- * Always uses the built-in BaseLayout, resolves SiteLayout from theme config.
- *
  * @param c - Hono context
  * @param options - Page rendering options
  * @returns Hono HTML response
@@ -29,18 +24,19 @@ import { SiteLayout as DefaultSiteLayout } from "../themes/minimal/MinimalSiteLa
  * ```
  */ export function renderPublicPage(c, options) {
     const { title, description, navData, content } = options;
-    const components = c.var.config?.theme?.components;
-    const Layout = components?.SiteLayout ?? DefaultSiteLayout;
     const layoutProps = {
         siteName: navData.siteName,
+        siteDescription: navData.siteDescription,
         links: navData.links,
-        currentPath: navData.currentPath
+        currentPath: navData.currentPath,
+        isAuthenticated: navData.isAuthenticated,
+        collections: navData.collections
     };
     return c.html(/*#__PURE__*/ _jsx(BaseLayout, {
         title: title,
         description: description,
         c: c,
-        children: /*#__PURE__*/ _jsx(Layout, {
+        children: /*#__PURE__*/ _jsx(SiteLayout, {
             ...layoutProps,
             children: content
         })

package/dist/lib/schemas.js

@@ -1,5 +1,5 @@
 /**
- * Shared Zod schemas for validation
+ * Shared Zod schemas for validation (v2)
  *
  * These schemas ensure type-safe validation of user input
  * from forms, API requests, and other external sources.
@@ -7,15 +7,21 @@
  * IMPORTANT: Types are defined in types.ts as the single source of truth.
  * This file only defines Zod validation schemas based on those types.
  */ import { z } from "zod";
-import { POST_TYPES, VISIBILITY_LEVELS, MAX_MEDIA_ATTACHMENTS, POST_TYPE_MEDIA_RULES } from "../types.js";
+import { FORMATS, STATUSES, SORT_ORDERS, NAV_ITEM_TYPES, MAX_MEDIA_ATTACHMENTS } from "../types.js";
 /**
- * Post type enum schema
- * Based on POST_TYPES from types.ts
- */ export const PostTypeSchema = z.enum(POST_TYPES);
+ * Post format enum schema
+ * Based on FORMATS from types.ts
+ */ export const FormatSchema = z.enum(FORMATS);
 /**
- * Visibility enum schema
- * Based on VISIBILITY_LEVELS from types.ts
- */ export const VisibilitySchema = z.enum(VISIBILITY_LEVELS);
+ * Post status enum schema
+ * Based on STATUSES from types.ts
+ */ export const StatusSchema = z.enum(STATUSES);
+/**
+ * Collection sort order enum schema
+ */ export const SortOrderSchema = z.enum(SORT_ORDERS);
+/**
+ * Navigation item type enum schema
+ */ export const NavItemTypeSchema = z.enum(NAV_ITEM_TYPES);
 /**
  * Redirect type enum schema
  * Form input validation for redirect type (stored as number in DB)
@@ -23,16 +29,29 @@ import { POST_TYPES, VISIBILITY_LEVELS, MAX_MEDIA_ATTACHMENTS, POST_TYPE_MEDIA_R
     "301",
     "302"
 ]);
+/**
+ * Rating schema (1-5 integer)
+ */ export const RatingSchema = z.coerce.number().int().min(0).max(5).optional().or(z.literal("").transform(()=>undefined)).transform((v)=>v === 0 ? undefined : v);
 /**
  * API request body schema for creating a post
  */ export const CreatePostSchema = z.object({
-    type: PostTypeSchema,
+    format: FormatSchema,
+    path: z.string().regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\/[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/).optional().or(z.literal("").transform(()=>undefined)),
     title: z.string().optional(),
-    content: z.string(),
-    visibility: VisibilitySchema,
-    sourceUrl: z.url().optional().or(z.literal("")),
-    sourceName: z.string().optional(),
-    path: z.string().regex(/^[a-z0-9-]*$/).optional().or(z.literal("")),
+    body: z.string().optional(),
+    status: StatusSchema.optional(),
+    featured: z.union([
+        z.boolean(),
+        z.literal("on").transform(()=>true)
+    ]).optional(),
+    pinned: z.union([
+        z.boolean(),
+        z.literal("on").transform(()=>true)
+    ]).optional(),
+    url: z.url().optional().or(z.literal("")),
+    quoteText: z.string().optional(),
+    rating: RatingSchema,
+    collectionId: z.coerce.number().int().min(0).optional().or(z.literal("").transform(()=>undefined)).transform((v)=>v === 0 ? undefined : v),
     replyToId: z.string().optional(),
     publishedAt: z.number().int().positive().optional(),
     mediaIds: z.array(z.string()).max(MAX_MEDIA_ATTACHMENTS).optional()
@@ -40,13 +59,53 @@ import { POST_TYPES, VISIBILITY_LEVELS, MAX_MEDIA_ATTACHMENTS, POST_TYPE_MEDIA_R
 /**
  * API request body schema for updating a post
  */ export const UpdatePostSchema = CreatePostSchema.partial();
+/**
+ * API request body schema for creating a page
+ */ export const CreatePageSchema = z.object({
+    slug: z.string().min(1).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/),
+    title: z.string().optional(),
+    body: z.string().optional(),
+    status: StatusSchema.optional()
+});
+/**
+ * API request body schema for updating a page
+ */ export const UpdatePageSchema = CreatePageSchema.partial();
+/**
+ * API request body schema for creating a navigation item
+ */ export const CreateNavItemSchema = z.object({
+    type: NavItemTypeSchema,
+    label: z.string().min(1),
+    url: z.string().min(1),
+    pageId: z.coerce.number().int().positive().optional(),
+    position: z.coerce.number().int().min(0).optional()
+});
+/**
+ * API request body schema for updating a navigation item
+ */ export const UpdateNavItemSchema = CreateNavItemSchema.partial();
+/**
+ * API request body schema for creating a collection
+ */ export const CreateCollectionSchema = z.object({
+    slug: z.string().min(1).regex(/^[a-z0-9][a-z0-9-]*[a-z0-9]$|^[a-z0-9]$/),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    sortOrder: SortOrderSchema.optional(),
+    position: z.coerce.number().int().min(0).optional(),
+    showDivider: z.union([
+        z.boolean(),
+        z.literal("on").transform(()=>true)
+    ]).optional()
+});
+/**
+ * API request body schema for updating a collection
+ */ export const UpdateCollectionSchema = CreateCollectionSchema.partial();
 /**
  * Form data helper: safely parse a FormData value with a schema
  *
  * @example
  * ```ts
- * const type = parseFormData(formData, "type", PostTypeSchema);
- * // type is PostType, throws if invalid
+ * const format = parseFormData(formData, "format", FormatSchema);
+ * // format is Format, throws if invalid
  * ```
  */ export function parseFormData(formData, key, schema) {
     const value = formData.get(key);
@@ -71,31 +130,14 @@ import { POST_TYPES, VISIBILITY_LEVELS, MAX_MEDIA_ATTACHMENTS, POST_TYPE_MEDIA_R
     return schema.parse(value);
 }
 /**
- * Validates media attachment count against post type rules.
+ * Validates media attachment count for a post.
+ * All formats allow 0-20 media attachments.
  *
- * @param type - The post type to validate against
  * @param mediaIds - Array of media IDs to attach
  * @returns null if valid, error string if invalid
- *
- * @example
- * ```ts
- * const error = validateMediaForPostType("image", []);
- * // Returns: "image posts require at least 1 media attachment"
- * ```
- */ export function validateMediaForPostType(type, mediaIds) {
-    const rules = POST_TYPE_MEDIA_RULES[type];
-    if (rules === null) {
-        if (mediaIds.length > 0) {
-            return `${type} posts do not allow media attachments`;
-        }
-        return null;
-    }
-    const [min, max] = rules;
-    if (mediaIds.length < min) {
-        return `${type} posts require at least ${min} media attachment${min !== 1 ? "s" : ""}`;
-    }
-    if (mediaIds.length > max) {
-        return `${type} posts allow at most ${max} media attachment${max !== 1 ? "s" : ""}`;
+ */ export function validateMediaCount(mediaIds) {
+    if (mediaIds.length > MAX_MEDIA_ATTACHMENTS) {
+        return `Posts allow at most ${MAX_MEDIA_ATTACHMENTS} media attachments`;
     }
     return null;
 }

package/dist/lib/theme.js

@@ -2,11 +2,11 @@
  * Theme Resolution Helpers
  *
  * Resolves the active color theme and builds CSS for injection into `<head>`.
- */ import { BUILTIN_COLOR_THEMES } from "../theme/color-themes.js";
+ */ import { BUILTIN_COLOR_THEMES } from "../ui/color-themes.js";
 /**
  * Get the list of available color themes.
  *
- * Returns `config.theme.colorThemes` if provided, otherwise the built-in list.
+ * Returns `config.colorThemes` if provided, otherwise the built-in list.
  *
  * @param config - The Jant configuration
  * @returns Array of available color themes
@@ -16,7 +16,7 @@
  * const themes = getAvailableThemes(c.var.config);
  * ```
  */ export function getAvailableThemes(config) {
-    return config.theme?.colorThemes ?? BUILTIN_COLOR_THEMES;
+    return config.colorThemes ?? BUILTIN_COLOR_THEMES;
 }
 /**
  * Build a `<style>` CSS string from a color theme and optional cssVariables overlay.
@@ -25,7 +25,7 @@
  *   BaseCoat defaults → selected theme → cssVariables
  *
  * @param theme - The active color theme (undefined = no theme overrides)
- * @param cssVariables - Extra CSS variable overrides from `createApp({ theme: { cssVariables } })`
+ * @param cssVariables - Extra CSS variable overrides from `createApp({ cssVariables })`
  * @returns CSS string to inject in `<head>`, or empty string if nothing to inject
  *
  * Uses `:root:root` and `:root.dark` selectors for higher specificity than

package/dist/lib/time.js

@@ -96,7 +96,62 @@
  * const yearMonth = formatYearMonth(1706745600);
  * // Returns: "2024-02"
  * ```
- */ export function formatYearMonth(timestamp) {
+ */ /**
+ * Formats a Unix timestamp as a 24-hour time string (HH:MM).
+ *
+ * Converts a Unix timestamp (in seconds) to a zero-padded time string in
+ * 24-hour format. Always uses UTC timezone for consistency.
+ *
+ * @param timestamp - Unix timestamp in seconds to format
+ * @returns Formatted time string in "HH:MM" format
+ *
+ * @example
+ * ```ts
+ * const time = formatTime(1706745600);
+ * // Returns: "00:00"
+ * ```
+ */ export function formatTime(timestamp) {
+    const date = new Date(timestamp * 1000);
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    return `${hours}:${minutes}`;
+}
+/**
+ * Formats a Unix timestamp as a short relative time string.
+ *
+ * Returns compact labels like "1m", "5h", "3d" for recent timestamps,
+ * and falls back to "MMM D" (e.g. "Feb 1") for anything older than 7 days.
+ *
+ * @param timestamp - Unix timestamp in seconds
+ * @returns Short relative time string
+ *
+ * @example
+ * ```ts
+ * // Assuming current time is Feb 16, 2026
+ * formatRelativeTime(now() - 30);       // "1m"  (30 seconds → rounds up)
+ * formatRelativeTime(now() - 3600);     // "1h"
+ * formatRelativeTime(now() - 86400);    // "1d"
+ * formatRelativeTime(now() - 604800);   // "7d"
+ * formatRelativeTime(now() - 864000);   // "Feb 6"
+ * ```
+ */ export function formatRelativeTime(timestamp) {
+    const seconds = now() - timestamp;
+    if (seconds < 60) return "1m";
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60) return `${minutes}m`;
+    const hours = Math.floor(seconds / 3600);
+    if (hours < 24) return `${hours}h`;
+    const days = Math.floor(seconds / 86400);
+    if (days <= 7) return `${days}d`;
+    // Older than 7 days: show "MMM D" (e.g. "Feb 1")
+    const date = new Date(timestamp * 1000);
+    return date.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        timeZone: "UTC"
+    });
+}
+export function formatYearMonth(timestamp) {
     const date = new Date(timestamp * 1000);
     const year = date.getUTCFullYear();
     const month = String(date.getUTCMonth() + 1).padStart(2, "0");

package/dist/lib/timeline.js

@@ -0,0 +1,95 @@
+/**
+ * Timeline Data Assembly
+ *
+ * Shared helper for assembling timeline items with media and thread previews.
+ * Used by page rendering with page-based pagination.
+ */ import { buildMediaMap } from "./media-helpers.js";
+import { createMediaContext, toPostView, toPostViews } from "./view.js";
+const DEFAULT_PAGE_SIZE = 20;
+/**
+ * Assembles a page of timeline items with media attachments and thread previews.
+ *
+ * Fetches posts using offset-based pagination, batch-loads media, identifies
+ * threads, and returns render-ready `TimelineItemView[]` with page info.
+ *
+ * @param c - Hono context (provides services + env)
+ * @param options - Optional page number (1-indexed, defaults to 1)
+ * @returns Assembled timeline items with pagination info
+ *
+ * @example
+ * ```ts
+ * const { items, currentPage, totalPages } = await assembleTimeline(c);
+ * const { items, currentPage, totalPages } = await assembleTimeline(c, { page: 2 });
+ * ```
+ */ export async function assembleTimeline(c, options) {
+    const pageSize = parseInt(c.env.PAGE_SIZE ?? String(DEFAULT_PAGE_SIZE), 10) || DEFAULT_PAGE_SIZE;
+    const page = Math.max(1, options?.page ?? 1);
+    const offset = (page - 1) * pageSize;
+    // Get total count for pagination
+    const totalCount = await c.var.services.posts.count({
+        status: "published",
+        excludeReplies: true
+    });
+    const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
+    // Fetch posts for the current page
+    const posts = await c.var.services.posts.list({
+        status: "published",
+        excludeReplies: true,
+        limit: pageSize,
+        offset
+    });
+    if (posts.length === 0) {
+        return {
+            items: [],
+            currentPage: page,
+            totalPages
+        };
+    }
+    // Batch load media attachments
+    const postIds = posts.map((p)=>p.id);
+    const rawMediaMap = await c.var.services.media.getByPostIds(postIds);
+    const mediaCtx = createMediaContext(c);
+    const mediaMap = buildMediaMap(rawMediaMap, mediaCtx.r2PublicUrl, mediaCtx.imageTransformUrl, mediaCtx.s3PublicUrl);
+    // Get reply counts to identify thread roots
+    const replyCounts = await c.var.services.posts.getReplyCounts(postIds);
+    const threadRootIds = postIds.filter((id)=>(replyCounts.get(id) ?? 0) > 0);
+    // Batch load thread previews
+    const threadPreviews = await c.var.services.posts.getThreadPreviews(threadRootIds, 3);
+    // Batch load media for preview replies
+    const previewReplyIds = [];
+    for (const replies of threadPreviews.values()){
+        for (const reply of replies){
+            previewReplyIds.push(reply.id);
+        }
+    }
+    const previewMediaMap = previewReplyIds.length > 0 ? buildMediaMap(await c.var.services.media.getByPostIds(previewReplyIds), mediaCtx.r2PublicUrl, mediaCtx.imageTransformUrl, mediaCtx.s3PublicUrl) : new Map();
+    // Assemble timeline items with View Models
+    const items = posts.map((post)=>{
+        const postView = toPostView({
+            ...post,
+            mediaAttachments: mediaMap.get(post.id) ?? []
+        }, mediaCtx);
+        const replyCount = replyCounts.get(post.id) ?? 0;
+        const previewReplies = threadPreviews.get(post.id);
+        if (replyCount > 0 && previewReplies) {
+            return {
+                post: postView,
+                threadPreview: {
+                    replies: toPostViews(previewReplies.map((r)=>({
+                            ...r,
+                            mediaAttachments: previewMediaMap.get(r.id) ?? []
+                        })), mediaCtx),
+                    totalReplyCount: replyCount
+                }
+            };
+        }
+        return {
+            post: postView
+        };
+    });
+    return {
+        items,
+        currentPage: page,
+        totalPages
+    };
+}