@jant/core 0.3.47 → 0.3.49

package/dist/index.js

@@ -1,5 +1,5 @@
 import { _ as url_exports } from "./url-umUptr5z.js";
-import { A as NAV_ITEM_TYPES, C as toPostView, D as MAX_MEDIA_ATTACHMENTS, E as FORMATS, M as STATUSES, N as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MAX_PINNED_POSTS, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, f as defaultFeedRenderer, j as SORT_ORDERS, k as MEDIA_KINDS, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-3REcR-3U.js";
+import { A as NAV_ITEM_TYPES, C as toPostView, D as MAX_MEDIA_ATTACHMENTS, E as FORMATS, M as STATUSES, N as TEXT_ATTACHMENT_CONTENT_FORMATS, O as MAX_PINNED_POSTS, S as toNavItemViews, T as toSearchResultView, _ as createMediaContext, b as toMediaView, f as defaultFeedRenderer, j as SORT_ORDERS, k as MEDIA_KINDS, t as createApp, v as toArchiveGroups, w as toPostViews, x as toNavItemView, y as toArchiveGroupsWithMedia } from "./app-C8bKBHtv.js";
 import { T as time_exports, a as markdown_exports } from "./export-ZBlfKSKm.js";
 import "./env-CgaH9Mut.js";
 import "./github-sync-bL1hnx3Q.js";

package/dist/node.js

@@ -1,5 +1,5 @@
 import "./url-umUptr5z.js";
-import { F as BUILTIN_COLOR_THEMES, I as getPublicAssetBasePath, L as isAssetPath, P as buildThemeStyle, a as resolveDatabaseDialect, c as resolveConfig, d as getFontThemeCssVariables, g as schema_exports, h as createNodeDatabase, i as createSiteService, l as BUILTIN_FONT_THEMES, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as getCjkSerifCssVariables } from "./app-3REcR-3U.js";
+import { F as BUILTIN_COLOR_THEMES, I as getPublicAssetBasePath, L as isAssetPath, P as buildThemeStyle, a as resolveDatabaseDialect, c as resolveConfig, d as getFontThemeCssVariables, g as schema_exports, h as createNodeDatabase, i as createSiteService, l as BUILTIN_FONT_THEMES, m as sqliteSchemaBundle, n as createNodeCliRuntime, o as getHostBasedStartupConfigurationIssues, p as pgSchemaBundle, r as createNodeRequestRuntime, s as createStorageDriver, t as createApp, u as getCjkSerifCssVariables } from "./app-C8bKBHtv.js";
 import { t as createExportService } from "./export-ZBlfKSKm.js";
 import { b as getSiteResolutionMode, i as getConfiguredSingleSitePathPrefix, l as getEnvString, r as getConfiguredSingleSiteOrigin, x as shouldTrustProxy, y as getPort } from "./env-CgaH9Mut.js";
 import "./github-sync-bL1hnx3Q.js";
@@ -474,7 +474,7 @@ async function createNodeRequestHandler(options) {
 async function start(env = process.env, app) {
 	const handler = await createNodeRequestHandler({
 		env,
-		app: async () => app ?? (await import("./app-B67XOEyo.js")).createApp()
+		app: async () => app ?? (await import("./app-DxnM9H8F.js")).createApp()
 	});
 	const hostname = resolveHost(env);
 	const port = resolvePort(env);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jant/core",
-  "version": "0.3.47",
+  "version": "0.3.49",
   "description": "A modern, open-source microblogging platform built on Cloudflare Workers",
   "type": "module",
   "exports": {

package/src/app.tsx

@@ -55,6 +55,7 @@ import {
 import { internalTextAttachmentsRoutes } from "./routes/api/internal/text-attachments.js";
 import { internalSearchReindexRoutes } from "./routes/api/internal/search-reindex.js";
 import { internalUploadsRoutes } from "./routes/api/internal/uploads.js";
+import { publicArchiveApiRoutes } from "./routes/api/public/archive.js";
 import { publicPostsApiRoutes } from "./routes/api/public/posts.js";
 // Routes - Compose
 import { composeRoutes } from "./routes/compose.js";
@@ -504,6 +505,7 @@ export function createApp(): App {
 
   // API Routes
   app.route("/api/public/posts", publicPostsApiRoutes);
+  app.route("/api/public/archive", publicArchiveApiRoutes);
   app.route("/api/posts", postsApiRoutes);
   app.route("/api/nav-items", navItemsApiRoutes);
   app.route("/api/collections", collectionsApiRoutes);

package/src/lib/api-posts.ts

@@ -42,13 +42,15 @@ export function toApiAttachment(
     };
   }
 
-  const previewUrl = getImageUrl(url, imageTransformUrl, {
-    width: 1200,
-    height: 768,
-    quality: 80,
-    format: "auto",
-    fit: "scale-down",
-  });
+  const previewUrl = media.mimeType.startsWith("image/")
+    ? getImageUrl(url, imageTransformUrl, {
+        width: 1200,
+        height: 768,
+        quality: 80,
+        format: "auto",
+        fit: "scale-down",
+      })
+    : url;
   const posterUrl = media.posterKey
     ? getMediaUrl(media.posterKey, publicUrl, sitePathPrefix)
     : null;

package/src/routes/api/public/__tests__/archive.test.ts

@@ -0,0 +1,261 @@
+import { describe, expect, it } from "vitest";
+import { createTestApp } from "../../../../__tests__/helpers/app.js";
+import { publicArchiveApiRoutes } from "../archive.js";
+
+describe("Public Archive API Routes", () => {
+  describe("GET /api/public/archive", () => {
+    it("includes latest_hidden posts but excludes private and drafts", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const publicRoot = await services.posts.create({
+        format: "note",
+        title: "Public root",
+        bodyMarkdown: "visible",
+      });
+      const hiddenRoot = await services.posts.create({
+        format: "note",
+        title: "Latest hidden root",
+        bodyMarkdown: "hidden from latest",
+        visibility: "latest_hidden",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Private root",
+        bodyMarkdown: "private",
+        visibility: "private",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Draft root",
+        bodyMarkdown: "draft",
+        status: "draft",
+      });
+      await services.posts.create({
+        format: "note",
+        bodyMarkdown: "reply",
+        replyToId: publicRoot.id,
+      });
+
+      const res = await app.request("/api/public/archive");
+      expect(res.status).toBe(200);
+
+      const body = await res.json();
+      expect(body.nextCursor).toBeNull();
+      expect(body.posts).toHaveLength(2);
+      const ids = body.posts.map((p: { id: string }) => p.id);
+      expect(ids).toContain(publicRoot.id);
+      expect(ids).toContain(hiddenRoot.id);
+      const hidden = body.posts.find(
+        (p: { id: string }) => p.id === hiddenRoot.id,
+      );
+      expect(hidden.visibility).toBe("latest_hidden");
+    });
+
+    it("supports format and limit filters with cursor", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      await services.posts.create({
+        format: "note",
+        title: "Note one",
+        bodyMarkdown: "first",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Note two",
+        bodyMarkdown: "second",
+        visibility: "latest_hidden",
+      });
+      await services.posts.create({
+        format: "link",
+        title: "Example",
+        url: "https://example.com",
+      });
+
+      const res = await app.request("/api/public/archive?format=note&limit=1");
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].format).toBe("note");
+      expect(body.nextCursor).toBeTruthy();
+
+      const next = await app.request(
+        `/api/public/archive?format=note&limit=1&cursor=${body.nextCursor}`,
+      );
+      const nextBody = await next.json();
+      expect(nextBody.posts).toHaveLength(1);
+      expect(nextBody.posts[0].id).not.toBe(body.posts[0].id);
+    });
+
+    it("filters by year using publishedAt", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const inYear = await services.posts.create({
+        format: "note",
+        title: "From 2024",
+        bodyMarkdown: "in",
+        publishedAt: Math.floor(Date.UTC(2024, 5, 1) / 1000),
+      });
+      await services.posts.create({
+        format: "note",
+        title: "From 2023",
+        bodyMarkdown: "out",
+        publishedAt: Math.floor(Date.UTC(2023, 5, 1) / 1000),
+      });
+
+      const res = await app.request("/api/public/archive?year=2024");
+      expect(res.status).toBe(200);
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].id).toBe(inYear.id);
+    });
+
+    it("filters by hasTitle and hasMedia", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const titled = await services.posts.create({
+        format: "note",
+        title: "Has title",
+        bodyMarkdown: "body",
+      });
+      const untitled = await services.posts.create({
+        format: "note",
+        bodyMarkdown: "body without title",
+      });
+
+      const withTitle = await app.request("/api/public/archive?hasTitle=1");
+      const withTitleBody = await withTitle.json();
+      expect(withTitleBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        titled.id,
+      ]);
+
+      const noTitle = await app.request("/api/public/archive?hasTitle=0");
+      const noTitleBody = await noTitle.json();
+      expect(noTitleBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        untitled.id,
+      ]);
+
+      const noMedia = await app.request("/api/public/archive?hasMedia=0");
+      const noMediaBody = await noMedia.json();
+      expect(noMediaBody.posts).toHaveLength(2);
+    });
+
+    it("filters by media kind", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const withImage = await services.posts.create({
+        format: "note",
+        title: "Image post",
+        bodyMarkdown: "image body",
+      });
+      const image = await services.media.create({
+        filename: "pic.jpg",
+        originalName: "pic.jpg",
+        mimeType: "image/jpeg",
+        size: 1024,
+        storageKey: "media/pic.jpg",
+      });
+      await services.media.attachToPost(withImage.id, [image.id]);
+
+      await services.posts.create({
+        format: "note",
+        title: "Plain post",
+        bodyMarkdown: "no media",
+      });
+
+      const res = await app.request("/api/public/archive?media=image");
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].id).toBe(withImage.id);
+
+      const hasMediaRes = await app.request("/api/public/archive?hasMedia=1");
+      const hasMediaBody = await hasMediaRes.json();
+      expect(hasMediaBody.posts).toHaveLength(1);
+      expect(hasMediaBody.posts[0].id).toBe(withImage.id);
+    });
+
+    it("filters by collection (single and aggregate)", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const tech = await services.collections.create({
+        slug: "tech",
+        title: "Tech",
+      });
+      const art = await services.collections.create({
+        slug: "art",
+        title: "Art",
+      });
+      const techPost = await services.posts.create({
+        format: "note",
+        title: "Tech",
+        bodyMarkdown: "t",
+        collectionIds: [tech.id],
+      });
+      const artPost = await services.posts.create({
+        format: "note",
+        title: "Art",
+        bodyMarkdown: "a",
+        collectionIds: [art.id],
+        visibility: "latest_hidden",
+      });
+      await services.posts.create({
+        format: "note",
+        title: "Other",
+        bodyMarkdown: "o",
+      });
+
+      const single = await app.request("/api/public/archive?collection=tech");
+      const singleBody = await single.json();
+      expect(singleBody.posts.map((p: { id: string }) => p.id)).toEqual([
+        techPost.id,
+      ]);
+
+      const aggregate = await app.request(
+        "/api/public/archive?collection=tech,art",
+      );
+      const aggregateBody = await aggregate.json();
+      const aggregateIds = aggregateBody.posts.map((p: { id: string }) => p.id);
+      expect(aggregateIds).toContain(techPost.id);
+      expect(aggregateIds).toContain(artPost.id);
+      expect(aggregateBody.posts).toHaveLength(2);
+
+      const unknown = await app.request(
+        "/api/public/archive?collection=nonexistent",
+      );
+      const unknownBody = await unknown.json();
+      expect(unknownBody.posts).toEqual([]);
+      expect(unknownBody.nextCursor).toBeNull();
+    });
+
+    it("returns markdown instead of rendered fields when content=markdown", async () => {
+      const { app, services } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      await services.posts.create({
+        format: "note",
+        title: "Markdown post",
+        bodyMarkdown: "# Hello\n\nBody",
+      });
+
+      const res = await app.request("/api/public/archive?content=markdown");
+      const body = await res.json();
+      expect(body.posts).toHaveLength(1);
+      expect(body.posts[0].bodyMarkdown).toBe("# Hello\n\nBody");
+      expect(body.posts[0]).not.toHaveProperty("bodyHtml");
+      expect(body.posts[0]).not.toHaveProperty("bodyText");
+    });
+
+    it("rejects invalid media kind", async () => {
+      const { app } = createTestApp({ authenticated: false });
+      app.route("/api/public/archive", publicArchiveApiRoutes);
+
+      const res = await app.request("/api/public/archive?media=invalid");
+      expect(res.status).toBe(400);
+    });
+  });
+});

package/src/routes/api/public/archive.ts

@@ -0,0 +1,116 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import type { Bindings } from "../../../types.js";
+import type { AppVariables } from "../../../types/app-context.js";
+import { MEDIA_KINDS } from "../../../types.js";
+import { FormatSchema, parseValidated } from "../../../lib/schemas.js";
+import { toPublicPost } from "./posts.js";
+
+type Env = { Bindings: Bindings; Variables: AppVariables };
+
+export const publicArchiveApiRoutes = new Hono<Env>();
+
+const MediaKindSchema = z.enum(MEDIA_KINDS);
+const MEDIA_KIND_LIST = MEDIA_KINDS.join(", ");
+const INVALID_MEDIA_KIND_MESSAGE =
+  "Invalid media kind. Allowed: " + MEDIA_KIND_LIST;
+
+const BoolFlagSchema = z.enum(["0", "1"]).transform((value) => value === "1");
+
+const ListPublicArchiveQuerySchema = z.object({
+  format: FormatSchema.optional(),
+  collection: z.string().optional(),
+  year: z.coerce.number().int().min(1971).optional(),
+  media: z
+    .string()
+    .optional()
+    .transform((value, ctx) => {
+      if (!value) return undefined;
+      const parts = value
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+      if (parts.length === 0) return undefined;
+      const result = z.array(MediaKindSchema).safeParse(parts);
+      if (!result.success) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: INVALID_MEDIA_KIND_MESSAGE,
+        });
+        return z.NEVER;
+      }
+      return result.data;
+    }),
+  hasMedia: BoolFlagSchema.optional(),
+  hasTitle: BoolFlagSchema.optional(),
+  cursor: z.string().optional(),
+  limit: z.coerce.number().int().min(1).max(100).optional().default(20),
+  content: z.enum(["markdown"]).optional(),
+});
+
+publicArchiveApiRoutes.get("/", async (c) => {
+  const {
+    format,
+    collection,
+    year,
+    media,
+    hasMedia,
+    hasTitle,
+    cursor,
+    limit,
+    content,
+  } = parseValidated(ListPublicArchiveQuerySchema, c.req.query());
+
+  let collectionIds: string[] | undefined;
+  if (collection) {
+    // Accept both "tech,art" and "tech+art", matching the page URL convention.
+    const slugExpression = collection.replace(/,/g, "+");
+    const selection =
+      await c.var.services.collections.resolveSelection(slugExpression);
+    if (!selection || selection.collections.length === 0) {
+      return c.json({ posts: [], nextCursor: null });
+    }
+    collectionIds = selection.collections.map((col) => col.id);
+  }
+
+  const publishedAfter =
+    year !== undefined ? Date.UTC(year, 0, 1) / 1000 : undefined;
+  const publishedBefore =
+    year !== undefined ? Date.UTC(year + 1, 0, 1) / 1000 : undefined;
+
+  const posts = await c.var.services.posts.list({
+    format,
+    collectionIds,
+    status: "published",
+    cursor: cursor ?? undefined,
+    limit,
+    excludePrivate: true,
+    excludeLatestHidden: false,
+    excludeReplies: true,
+    publishedAfter,
+    publishedBefore,
+    mediaKinds: media,
+    hasMedia,
+    hasTitle,
+  });
+
+  const postIds = posts.map((post) => post.id);
+  const [mediaMap, collectionsMap] = await Promise.all([
+    c.var.services.media.getByPostIds(postIds),
+    c.var.services.collections.getCollectionsByPostIds(postIds),
+  ]);
+
+  return c.json({
+    posts: posts.map((post) =>
+      toPublicPost(
+        post,
+        mediaMap.get(post.id) ?? [],
+        collectionsMap.get(post.id) ?? [],
+        c.var.appConfig,
+        { content },
+      ),
+    ),
+    nextCursor:
+      posts.length === limit ? (posts[posts.length - 1]?.id ?? null) : null,
+  });
+});

package/src/routes/api/public/posts.ts

@@ -39,7 +39,7 @@ const PublicPostContentQuerySchema = z.object({
   content: z.enum(["markdown"]).optional(),
 });
 
-type PublicPostBaseResponse = {
+export type PublicPostBaseResponse = {
   id: string;
   format: Post["format"];
   status: "published";
@@ -73,16 +73,16 @@ type PublicPostBaseResponse = {
   }[];
 };
 
-type PublicPostRenderedResponse = PublicPostBaseResponse & {
+export type PublicPostRenderedResponse = PublicPostBaseResponse & {
   bodyHtml: string | null;
   bodyText: string | null;
 };
 
-type PublicPostMarkdownResponse = PublicPostBaseResponse & {
+export type PublicPostMarkdownResponse = PublicPostBaseResponse & {
   bodyMarkdown: string | null;
 };
 
-type PublicPostResponse =
+export type PublicPostResponse =
   | PublicPostRenderedResponse
   | PublicPostMarkdownResponse;
 
@@ -94,7 +94,7 @@ function isPublicDetailVisible(post: Post | null): post is Post {
   );
 }
 
-function toPublicPost(
+export function toPublicPost(
   post: Post,
   mediaList: Media[],
   postCollections: Collection[],

package/src/styles/ui.css

@@ -6832,7 +6832,7 @@
   .compose-attachment-img {
     display: block;
     border-radius: var(--media-radius, 0.5rem);
-    max-height: 320px;
+    max-height: min(320px, 28dvh);
     object-fit: contain;
   }
 
@@ -6869,7 +6869,7 @@
   /* Single image: constrain to container width */
   .compose-attachment:only-child .compose-attachment-img {
     max-width: 100%;
-    max-height: 384px;
+    max-height: min(384px, 32dvh);
   }
 
   .compose-attachment:only-child .compose-attachment-preview-fallback {