@jant/core 0.3.24 → 0.3.25

package/dist/lib/timeline.js

@@ -2,44 +2,51 @@
  * Timeline Data Assembly
  *
  * Shared helper for assembling timeline items with media and thread previews.
- * Used by both full-page rendering and load-more SSE responses.
+ * 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, batch-loads media, identifies threads, and returns
- * render-ready `TimelineItemView[]` with pagination info.
+ * 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 cursor for pagination
+ * @param options - Optional page number (1-indexed, defaults to 1)
  * @returns Assembled timeline items with pagination info
  *
  * @example
  * ```ts
- * const { items, hasMore, nextCursor } = await assembleTimeline(c);
- * const { items, hasMore, nextCursor } = await assembleTimeline(c, { cursor: 42 });
+ * 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;
-    // Fetch one extra to determine if there are more
+    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 + 1,
-        cursor: options?.cursor
+        limit: pageSize,
+        offset
     });
-    const hasMore = posts.length > pageSize;
-    const displayPosts = hasMore ? posts.slice(0, pageSize) : posts;
-    if (displayPosts.length === 0) {
+    if (posts.length === 0) {
         return {
             items: [],
-            hasMore: false
+            currentPage: page,
+            totalPages
         };
     }
     // Batch load media attachments
-    const postIds = displayPosts.map((p)=>p.id);
+    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);
@@ -57,7 +64,7 @@ const DEFAULT_PAGE_SIZE = 20;
     }
     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 = displayPosts.map((post)=>{
+    const items = posts.map((post)=>{
         const postView = toPostView({
             ...post,
             mediaAttachments: mediaMap.get(post.id) ?? []
@@ -80,40 +87,9 @@ const DEFAULT_PAGE_SIZE = 20;
             post: postView
         };
     });
-    // Determine next cursor
-    const lastPost = displayPosts[displayPosts.length - 1];
-    const nextCursor = hasMore && lastPost ? lastPost.id : undefined;
     return {
         items,
-        hasMore,
-        nextCursor
+        currentPage: page,
+        totalPages
     };
 }
-/**
- * Groups timeline items by their publication date (YYYY-MM-DD).
- *
- * @param items - Timeline items to group
- * @returns Array of date groups, each containing items published on the same day
- *
- * @example
- * ```ts
- * const groups = groupByDate(items);
- * // [{ dateKey: "2024-02-01", label: "Feb 1, 2024", items: [...] }, ...]
- * ```
- */ export function groupByDate(items) {
-    const groups = [];
-    let current = null;
-    for (const item of items){
-        const dateKey = item.post.publishedAt.slice(0, 10);
-        if (!current || current.dateKey !== dateKey) {
-            current = {
-                dateKey,
-                label: item.post.publishedAtFormatted,
-                items: []
-            };
-            groups.push(current);
-        }
-        current.items.push(item);
-    }
-    return groups;
-}

package/dist/lib/view.js

@@ -58,7 +58,7 @@ import { getHtmlExcerpt } from "./excerpt.js";
  * @param _ctx - Media context with URL configuration
  * @returns Render-ready PostView with pre-computed fields
  */ export function toPostView(post, _ctx) {
-    const permalink = post.slug ? `/${post.slug}` : `/p/${encode(post.id)}`;
+    const permalink = post.path ? `/${post.path}` : `/p/${encode(post.id)}`;
     // Pre-compute excerpt from raw body
     let excerpt;
     if (post.body) {
@@ -85,7 +85,7 @@ import { getHtmlExcerpt } from "./excerpt.js";
     return {
         id: post.id,
         permalink,
-        slug: post.slug ?? undefined,
+        path: post.path ?? undefined,
         title: post.title ?? undefined,
         bodyHtml: post.bodyHtml ?? undefined,
         excerpt,

package/dist/routes/api/collections.js

@@ -0,0 +1,124 @@
+/**
+ * Collections API Routes
+ */ import { Hono } from "hono";
+import { requireAuthApi } from "../../middleware/auth.js";
+import { z } from "zod";
+import { SORT_ORDERS } from "../../types.js";
+export const collectionsApiRoutes = new Hono();
+const SortOrderSchema = z.enum(SORT_ORDERS);
+const CreateCollectionSchema = z.object({
+    slug: z.string().min(1),
+    title: z.string().min(1),
+    description: z.string().optional(),
+    icon: z.string().optional(),
+    sortOrder: SortOrderSchema.optional(),
+    position: z.number().int().min(0).optional(),
+    showDivider: z.boolean().optional()
+});
+const UpdateCollectionSchema = z.object({
+    slug: z.string().min(1).optional(),
+    title: z.string().min(1).optional(),
+    description: z.string().nullable().optional(),
+    icon: z.string().nullable().optional(),
+    sortOrder: SortOrderSchema.optional(),
+    position: z.number().int().min(0).optional(),
+    showDivider: z.boolean().optional()
+});
+const ReorderSchema = z.object({
+    ids: z.array(z.number().int().positive())
+});
+// List collections (includes post counts)
+collectionsApiRoutes.get("/", async (c)=>{
+    const collections = await c.var.services.collections.list();
+    const postCounts = await c.var.services.collections.getPostCounts();
+    return c.json({
+        collections: collections.map((col)=>({
+                ...col,
+                postCount: postCounts.get(col.id) ?? 0
+            }))
+    });
+});
+// Get single collection
+collectionsApiRoutes.get("/:id", async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const collection = await c.var.services.collections.getById(id);
+    if (!collection) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json(collection);
+});
+// Reorder collections (requires auth) — must be before /:id
+collectionsApiRoutes.put("/reorder", requireAuthApi(), async (c)=>{
+    const rawBody = await c.req.json();
+    const parseResult = ReorderSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    await c.var.services.collections.reorder(parseResult.data.ids);
+    const collections = await c.var.services.collections.list();
+    return c.json({
+        collections
+    });
+});
+// Create collection (requires auth)
+collectionsApiRoutes.post("/", requireAuthApi(), async (c)=>{
+    const rawBody = await c.req.json();
+    const parseResult = CreateCollectionSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    const body = parseResult.data;
+    const collection = await c.var.services.collections.create({
+        slug: body.slug,
+        title: body.title,
+        description: body.description,
+        icon: body.icon,
+        sortOrder: body.sortOrder,
+        position: body.position,
+        showDivider: body.showDivider
+    });
+    return c.json(collection, 201);
+});
+// Update collection (requires auth)
+collectionsApiRoutes.put("/:id", requireAuthApi(), async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const rawBody = await c.req.json();
+    const parseResult = UpdateCollectionSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    const collection = await c.var.services.collections.update(id, parseResult.data);
+    if (!collection) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json(collection);
+});
+// Delete collection (requires auth)
+collectionsApiRoutes.delete("/:id", requireAuthApi(), async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const success = await c.var.services.collections.delete(id);
+    if (!success) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json({
+        success: true
+    });
+});

package/dist/routes/api/nav-items.js

@@ -0,0 +1,104 @@
+/**
+ * Nav Items API Routes
+ */ import { Hono } from "hono";
+import { requireAuthApi } from "../../middleware/auth.js";
+import { z } from "zod";
+export const navItemsApiRoutes = new Hono();
+const NavItemTypeSchema = z.enum([
+    "link",
+    "page"
+]);
+const CreateNavItemSchema = z.object({
+    type: NavItemTypeSchema,
+    label: z.string().min(1),
+    url: z.string().min(1),
+    pageId: z.number().int().positive().optional(),
+    position: z.number().int().min(0).optional()
+});
+const UpdateNavItemSchema = z.object({
+    type: NavItemTypeSchema.optional(),
+    label: z.string().min(1).optional(),
+    url: z.string().min(1).optional(),
+    pageId: z.number().int().positive().nullable().optional(),
+    position: z.number().int().min(0).optional()
+});
+const ReorderSchema = z.object({
+    ids: z.array(z.number().int().positive())
+});
+// List nav items
+navItemsApiRoutes.get("/", async (c)=>{
+    const items = await c.var.services.navItems.list();
+    return c.json({
+        navItems: items
+    });
+});
+// Reorder nav items (requires auth) — must be before /:id
+navItemsApiRoutes.put("/reorder", requireAuthApi(), async (c)=>{
+    const rawBody = await c.req.json();
+    const parseResult = ReorderSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    await c.var.services.navItems.reorder(parseResult.data.ids);
+    const items = await c.var.services.navItems.list();
+    return c.json({
+        navItems: items
+    });
+});
+// Create nav item (requires auth)
+navItemsApiRoutes.post("/", requireAuthApi(), async (c)=>{
+    const rawBody = await c.req.json();
+    const parseResult = CreateNavItemSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    const body = parseResult.data;
+    const item = await c.var.services.navItems.create({
+        type: body.type,
+        label: body.label,
+        url: body.url,
+        pageId: body.pageId,
+        position: body.position
+    });
+    return c.json(item, 201);
+});
+// Update nav item (requires auth)
+navItemsApiRoutes.put("/:id", requireAuthApi(), async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const rawBody = await c.req.json();
+    const parseResult = UpdateNavItemSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    const item = await c.var.services.navItems.update(id, parseResult.data);
+    if (!item) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json(item);
+});
+// Delete nav item (requires auth)
+navItemsApiRoutes.delete("/:id", requireAuthApi(), async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const success = await c.var.services.navItems.delete(id);
+    if (!success) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json({
+        success: true
+    });
+});

package/dist/routes/api/pages.js

@@ -0,0 +1,91 @@
+/**
+ * Pages API Routes
+ */ import { Hono } from "hono";
+import { requireAuthApi } from "../../middleware/auth.js";
+import { z } from "zod";
+import { StatusSchema } from "../../lib/schemas.js";
+export const pagesApiRoutes = new Hono();
+const CreatePageSchema = z.object({
+    slug: z.string().min(1),
+    title: z.string().optional(),
+    body: z.string().optional(),
+    status: StatusSchema.optional()
+});
+const UpdatePageSchema = z.object({
+    slug: z.string().min(1).optional(),
+    title: z.string().nullable().optional(),
+    body: z.string().nullable().optional(),
+    status: StatusSchema.optional()
+});
+// List pages
+pagesApiRoutes.get("/", async (c)=>{
+    const pages = await c.var.services.pages.list();
+    return c.json({
+        pages
+    });
+});
+// Get single page
+pagesApiRoutes.get("/:id", async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const page = await c.var.services.pages.getById(id);
+    if (!page) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json(page);
+});
+// Create page (requires auth)
+pagesApiRoutes.post("/", requireAuthApi(), async (c)=>{
+    const rawBody = await c.req.json();
+    const parseResult = CreatePageSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    const body = parseResult.data;
+    const page = await c.var.services.pages.create({
+        slug: body.slug,
+        title: body.title,
+        body: body.body,
+        status: body.status
+    });
+    return c.json(page, 201);
+});
+// Update page (requires auth)
+pagesApiRoutes.put("/:id", requireAuthApi(), async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const rawBody = await c.req.json();
+    const parseResult = UpdatePageSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    const page = await c.var.services.pages.update(id, parseResult.data);
+    if (!page) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json(page);
+});
+// Delete page (requires auth)
+pagesApiRoutes.delete("/:id", requireAuthApi(), async (c)=>{
+    const id = parseInt(c.req.param("id"), 10);
+    if (isNaN(id)) return c.json({
+        error: "Invalid ID"
+    }, 400);
+    const success = await c.var.services.pages.delete(id);
+    if (!success) return c.json({
+        error: "Not found"
+    }, 404);
+    return c.json({
+        success: true
+    });
+});

package/dist/routes/api/posts.js

@@ -110,7 +110,7 @@ postsApiRoutes.post("/", requireAuthApi(), async (c)=>{
         format: body.format,
         title: body.title,
         body: body.body,
-        slug: body.slug || undefined,
+        path: body.path || undefined,
         status: body.status,
         featured: body.featured,
         pinned: body.pinned,
@@ -173,7 +173,7 @@ postsApiRoutes.put("/:id", requireAuthApi(), async (c)=>{
         format: body.format,
         title: body.title,
         body: body.body,
-        slug: body.slug,
+        path: body.path,
         status: body.status,
         featured: body.featured,
         pinned: body.pinned,

package/dist/routes/api/search.js

@@ -31,10 +31,10 @@ searchApiRoutes.get("/", async (c)=>{
                     id: sqid.encode(r.post.id),
                     format: r.post.format,
                     title: r.post.title,
-                    slug: r.post.slug,
+                    path: r.post.path,
                     snippet: r.snippet,
                     publishedAt: r.post.publishedAt,
-                    url: r.post.slug ? `/${r.post.slug}` : `/p/${sqid.encode(r.post.id)}`
+                    url: r.post.path ? `/${r.post.path}` : `/p/${sqid.encode(r.post.id)}`
                 })),
             count: results.length
         });

package/dist/routes/api/settings.js

@@ -0,0 +1,68 @@
+/**
+ * Settings API Routes
+ */ import { Hono } from "hono";
+import { requireAuthApi } from "../../middleware/auth.js";
+import { CONFIG_FIELDS } from "../../types.js";
+import { z } from "zod";
+export const settingsApiRoutes = new Hono();
+/** Config keys that can be modified via the settings API */ const editableKeys = Object.entries(CONFIG_FIELDS).filter(([, field])=>!field.envOnly).map(([key])=>key);
+const UpdateSettingsSchema = z.record(z.string(), z.string());
+// Get all settings (requires auth)
+settingsApiRoutes.get("/", requireAuthApi(), async (c)=>{
+    const allSettings = await c.var.services.settings.getAll();
+    // Include default values for editable keys not yet stored in DB
+    const result = {};
+    for (const key of editableKeys){
+        result[key] = allSettings[key] ?? CONFIG_FIELDS[key].defaultValue;
+    }
+    return c.json({
+        settings: result
+    });
+});
+// Update settings (requires auth)
+settingsApiRoutes.put("/", requireAuthApi(), async (c)=>{
+    const rawBody = await c.req.json();
+    const parseResult = UpdateSettingsSchema.safeParse(rawBody);
+    if (!parseResult.success) {
+        return c.json({
+            error: "Validation failed",
+            details: parseResult.error.flatten()
+        }, 400);
+    }
+    const updates = parseResult.data;
+    // Filter to only editable keys
+    const filteredUpdates = {};
+    const rejectedKeys = [];
+    for (const [key, value] of Object.entries(updates)){
+        if (editableKeys.includes(key)) {
+            filteredUpdates[key] = value;
+        } else {
+            rejectedKeys.push(key);
+        }
+    }
+    if (rejectedKeys.length > 0 && Object.keys(filteredUpdates).length === 0) {
+        return c.json({
+            error: "None of the provided keys are editable",
+            rejectedKeys
+        }, 400);
+    }
+    if (Object.keys(filteredUpdates).length > 0) {
+        // Settings service expects SettingsKey, but our ConfigKeys that are
+        // editable (SITE_NAME, SITE_DESCRIPTION, SITE_LANGUAGE) are valid SettingsKeys
+        for (const [key, value] of Object.entries(filteredUpdates)){
+            await c.var.services.settings.set(key, value);
+        }
+    }
+    // Return updated state
+    const allSettings = await c.var.services.settings.getAll();
+    const result = {};
+    for (const key of editableKeys){
+        result[key] = allSettings[key] ?? CONFIG_FIELDS[key].defaultValue;
+    }
+    return c.json({
+        settings: result,
+        ...rejectedKeys.length > 0 && {
+            rejectedKeys
+        }
+    });
+});

package/dist/routes/compose.js

@@ -0,0 +1,48 @@
+/**
+ * Compose Route
+ *
+ * Handles post creation from the public-site compose dialog.
+ * Returns dsRedirect to the new post's permalink (Datastar form pattern).
+ */ import { Hono } from "hono";
+import { requireAuth } from "../middleware/auth.js";
+import { CreatePostSchema, validateMediaCount } from "../lib/schemas.js";
+import * as sqid from "../lib/sqid.js";
+import { dsRedirect, dsToast } from "../lib/sse.js";
+export const composeRoutes = new Hono();
+// All compose routes require authentication
+composeRoutes.use("*", requireAuth());
+composeRoutes.post("/", async (c)=>{
+    const raw = await c.req.json();
+    const result = CreatePostSchema.safeParse(raw);
+    if (!result.success) {
+        const firstError = result.error.issues[0]?.message ?? "Invalid input";
+        return dsToast(firstError, "error");
+    }
+    const data = result.data;
+    // Validate media count
+    if (data.mediaIds) {
+        const mediaError = validateMediaCount(data.mediaIds);
+        if (mediaError) {
+            return dsToast(mediaError, "error");
+        }
+    }
+    const post = await c.var.services.posts.create({
+        format: data.format,
+        title: data.title || undefined,
+        body: data.body || undefined,
+        status: data.status ?? "published",
+        featured: data.featured,
+        pinned: data.pinned,
+        url: data.url || undefined,
+        quoteText: data.quoteText || undefined,
+        rating: data.rating || undefined,
+        collectionId: data.collectionId || undefined
+    });
+    // Attach media if provided
+    if (data.mediaIds && data.mediaIds.length > 0) {
+        await c.var.services.media.attachToPost(post.id, data.mediaIds);
+    }
+    // Redirect to the new post's permalink
+    const permalink = post.path ? `/${post.path}` : `/p/${sqid.encode(post.id)}`;
+    return dsRedirect(permalink);
+});

package/dist/routes/dash/collections.js

@@ -4,8 +4,8 @@ import { getSiteName } from "../../lib/config.js";
  * Dashboard Collections Routes
  */ import { Hono } from "hono";
 import { useLingui as $_useLingui } from "@jant/core/i18n";
-import { DashLayout } from "../../theme/layouts/index.js";
-import { EmptyState, ListItemRow, ActionButtons, CrudPageHeader, DangerZone } from "../../theme/components/index.js";
+import { DashLayout } from "../../ui/layouts/DashLayout.js";
+import { EmptyState, ListItemRow, ActionButtons, CrudPageHeader, DangerZone } from "../../ui/dash/index.js";
 import * as sqid from "../../lib/sqid.js";
 import { dsRedirect } from "../../lib/sse.js";
 export const collectionsRoutes = new Hono();

package/dist/routes/dash/index.js

@@ -6,7 +6,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
  */ import { Hono } from "hono";
 import { useLingui as $_useLingui } from "@jant/core/i18n";
 import { Trans as Trans_ } from "@jant/core/i18n";
-import { DashLayout } from "../../theme/layouts/index.js";
+import { DashLayout } from "../../ui/layouts/DashLayout.js";
 import { getSiteName } from "../../lib/config.js";
 export const dashIndexRoutes = new Hono();
 /**

package/dist/routes/dash/media.js

@@ -7,8 +7,8 @@ import { getSiteName } from "../../lib/config.js";
  * Uses SSE for real-time UI updates without page reloads.
  */ import { Hono } from "hono";
 import { useLingui as $_useLingui } from "@jant/core/i18n";
-import { DashLayout } from "../../theme/layouts/index.js";
-import { EmptyState, DangerZone } from "../../theme/components/index.js";
+import { DashLayout } from "../../ui/layouts/DashLayout.js";
+import { EmptyState, DangerZone } from "../../ui/dash/index.js";
 import * as time from "../../lib/time.js";
 import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "../../lib/image.js";
 import { dsRedirect } from "../../lib/sse.js";