@jant/core 0.3.35 → 0.3.37

package/src/lib/storage.ts

@@ -6,6 +6,18 @@
 
 import type { Bindings } from "../types.js";
 
+/** Tracks an in-progress multipart upload */
+export interface MultipartUploadSession {
+  uploadId: string;
+  key: string;
+}
+
+/** Represents a successfully uploaded part */
+export interface UploadedPart {
+  partNumber: number;
+  etag: string;
+}
+
 /**
  * Common interface for storage operations.
  *
@@ -20,13 +32,68 @@ export interface StorageDriver {
     opts?: { contentType?: string },
   ): Promise<void>;
 
-  /** Retrieve a file from storage. Returns null if not found. */
+  /** Retrieve a file (or byte range) from storage. Returns null if not found. */
   get(
     key: string,
-  ): Promise<{ body: ReadableStream; contentType?: string } | null>;
+    opts?: { range?: { offset: number; length: number } },
+  ): Promise<{
+    body: ReadableStream;
+    contentType?: string;
+    size?: number;
+  } | null>;
 
   /** Delete a file from storage */
   delete(key: string): Promise<void>;
+
+  /** Start a multipart upload (optional — R2 only) */
+  createMultipartUpload?(
+    key: string,
+    opts?: { contentType?: string },
+  ): Promise<MultipartUploadSession>;
+
+  /** Upload a single part of a multipart upload */
+  uploadPart?(
+    key: string,
+    uploadId: string,
+    partNumber: number,
+    body: ReadableStream | ArrayBuffer | Uint8Array,
+  ): Promise<UploadedPart>;
+
+  /** Finalize a multipart upload by combining all parts */
+  completeMultipartUpload?(
+    key: string,
+    uploadId: string,
+    parts: UploadedPart[],
+  ): Promise<void>;
+
+  /** Cancel a multipart upload and discard uploaded parts */
+  abortMultipartUpload?(key: string, uploadId: string): Promise<void>;
+}
+
+/**
+ * Type guard that checks whether a storage driver supports multipart uploads.
+ *
+ * @param driver - The storage driver to check
+ * @returns true if all multipart methods are present
+ */
+export function supportsMultipart(
+  driver: StorageDriver,
+): driver is StorageDriver &
+  Required<
+    Pick<
+      StorageDriver,
+      | "createMultipartUpload"
+      | "uploadPart"
+      | "completeMultipartUpload"
+      | "abortMultipartUpload"
+    >
+  > {
+  return (
+    typeof driver.createMultipartUpload === "function" &&
+    typeof driver.uploadPart === "function" &&
+    typeof driver.completeMultipartUpload === "function" &&
+    typeof driver.abortMultipartUpload === "function"
+  );
 }
 
 /**
@@ -45,18 +112,47 @@ export function createR2Driver(r2: R2Bucket): StorageDriver {
       });
     },
 
-    async get(key) {
-      const object = await r2.get(key);
+    async get(key, opts) {
+      const object = await r2.get(
+        key,
+        opts?.range ? { range: opts.range } : undefined,
+      );
       if (!object) return null;
       return {
         body: object.body,
         contentType: object.httpMetadata?.contentType ?? undefined,
+        size: object.size,
       };
     },
 
     async delete(key) {
       await r2.delete(key);
     },
+
+    async createMultipartUpload(key, opts) {
+      const upload = await r2.createMultipartUpload(key, {
+        httpMetadata: opts?.contentType
+          ? { contentType: opts.contentType }
+          : undefined,
+      });
+      return { uploadId: upload.uploadId, key: upload.key };
+    },
+
+    async uploadPart(key, uploadId, partNumber, body) {
+      const upload = r2.resumeMultipartUpload(key, uploadId);
+      const part = await upload.uploadPart(partNumber, body);
+      return { partNumber: part.partNumber, etag: part.etag };
+    },
+
+    async completeMultipartUpload(key, uploadId, parts) {
+      const upload = r2.resumeMultipartUpload(key, uploadId);
+      await upload.complete(parts);
+    },
+
+    async abortMultipartUpload(key, uploadId) {
+      const upload = r2.resumeMultipartUpload(key, uploadId);
+      await upload.abort();
+    },
   };
 }
 
@@ -84,7 +180,14 @@ interface PutObjectInput {
   ContentType?: string;
 }
 
-/** Input for GetObject / DeleteObject */
+/** Input for GetObject */
+interface GetObjectInput {
+  Bucket: string;
+  Key: string;
+  Range?: string;
+}
+
+/** Input for DeleteObject */
 interface ObjectKeyInput {
   Bucket: string;
   Key: string;
@@ -94,13 +197,14 @@ interface ObjectKeyInput {
 interface S3GetObjectOutput {
   Body?: { transformToWebStream(): ReadableStream };
   ContentType?: string;
+  ContentLength?: number;
 }
 
 /** Lazy-loaded S3 client bundle */
 interface S3ClientBundle {
   send: (command: unknown) => Promise<unknown>;
   PutObjectCommand: S3CommandCtor<PutObjectInput>;
-  GetObjectCommand: S3CommandCtor<ObjectKeyInput>;
+  GetObjectCommand: S3CommandCtor<GetObjectInput>;
   DeleteObjectCommand: S3CommandCtor<ObjectKeyInput>;
   bucket: string;
 }
@@ -178,18 +282,22 @@ export function createS3Driver(config: S3DriverConfig): StorageDriver {
       await s3.send(command);
     },
 
-    async get(key) {
+    async get(key, opts) {
       const s3 = await getClient();
       try {
         const command = new s3.GetObjectCommand({
           Bucket: s3.bucket,
           Key: key,
+          Range: opts?.range
+            ? `bytes=${opts.range.offset}-${opts.range.offset + opts.range.length - 1}`
+            : undefined,
         });
         const response = (await s3.send(command)) as S3GetObjectOutput;
         if (!response.Body) return null;
         return {
           body: response.Body.transformToWebStream(),
           contentType: response.ContentType ?? undefined,
+          size: response.ContentLength ?? undefined,
         };
       } catch (err: unknown) {
         // NoSuchKey → return null instead of throwing

package/src/lib/summary.ts

@@ -0,0 +1,158 @@
+/**
+ * Summary Extraction from Tiptap JSON
+ *
+ * Extracts a plain-text summary from a Tiptap JSON document for use
+ * in feeds, meta descriptions, and article previews.
+ */
+
+interface TiptapNode {
+  type: string;
+  content?: TiptapNode[];
+  text?: string;
+  marks?: unknown[];
+  attrs?: Record<string, unknown>;
+}
+
+/**
+ * Recursively extracts plain text from a Tiptap node, ignoring marks.
+ */
+function extractPlainText(node: TiptapNode): string {
+  if (node.type === "text") return node.text ?? "";
+  if (node.type === "hardBreak") return "\n";
+  if (!node.content) return "";
+  return node.content.map(extractPlainText).join("");
+}
+
+/**
+ * Extracts a plain-text summary from a Tiptap JSON body string.
+ *
+ * Algorithm:
+ * 1. If a `moreBreak` node is found, collect all paragraph text before it
+ * 2. Otherwise, accumulate paragraph nodes until limits are reached
+ * 3. Skip headings, images, code blocks, blockquotes, lists, horizontal rules
+ *
+ * @param bodyJson - Tiptap JSON string
+ * @param maxParagraphs - Maximum number of paragraphs to include
+ * @param maxChars - Maximum total character count
+ * @returns Plain text summary, or null if no paragraphs found
+ *
+ * @example
+ * ```ts
+ * const summary = extractSummary(body, 5, 500);
+ * ```
+ */
+/**
+ * Content-bearing TipTap node types whose text should be indexed for search.
+ * Block-level containers (bulletList, orderedList, table, etc.) are included
+ * because they recurse into child nodes that carry text.
+ */
+const SEARCHABLE_TYPES = new Set([
+  "doc",
+  "paragraph",
+  "heading",
+  "codeBlock",
+  "bulletList",
+  "orderedList",
+  "listItem",
+  "blockquote",
+  "table",
+  "tableRow",
+  "tableCell",
+  "tableHeader",
+  "text",
+  "hardBreak",
+]);
+
+/**
+ * Recursively extracts all searchable plain text from a TipTap JSON body string.
+ *
+ * Used for FTS indexing — includes text from paragraphs, headings, code blocks,
+ * lists, blockquotes, and tables. Skips non-textual nodes (image, moreBreak,
+ * horizontalRule). Block-level nodes are joined with spaces for better trigram
+ * matching.
+ *
+ * @param bodyJson - TipTap JSON string (the `body` column)
+ * @returns Plain text for FTS indexing, or null if parsing fails or doc is empty
+ *
+ * @example
+ * ```ts
+ * const text = extractBodyText(body);
+ * // "Hello world Some code here"
+ * ```
+ */
+export function extractBodyText(bodyJson: string): string | null {
+  let doc: TiptapNode;
+  try {
+    doc = JSON.parse(bodyJson) as TiptapNode;
+  } catch {
+    return null;
+  }
+
+  if (doc.type !== "doc" || !doc.content) return null;
+
+  function collectText(node: TiptapNode): string {
+    if (!SEARCHABLE_TYPES.has(node.type)) return "";
+    if (node.type === "text") return node.text ?? "";
+    if (node.type === "hardBreak") return " ";
+    if (!node.content) return "";
+    return node.content.map(collectText).join(" ");
+  }
+
+  const parts: string[] = [];
+  for (const child of doc.content) {
+    const text = collectText(child).trim();
+    if (text) parts.push(text);
+  }
+
+  return parts.length > 0 ? parts.join(" ") : null;
+}
+
+export function extractSummary(
+  bodyJson: string,
+  maxParagraphs: number,
+  maxChars: number,
+): string | null {
+  let doc: TiptapNode;
+  try {
+    doc = JSON.parse(bodyJson) as TiptapNode;
+  } catch {
+    return null;
+  }
+
+  if (doc.type !== "doc" || !doc.content) return null;
+
+  const nodes = doc.content;
+
+  // Check for moreBreak — collect paragraph text before it
+  const moreBreakIdx = nodes.findIndex((n) => n.type === "moreBreak");
+  if (moreBreakIdx !== -1) {
+    const paragraphs: string[] = [];
+    for (let i = 0; i < moreBreakIdx; i++) {
+      const node = nodes[i];
+      if (!node) continue;
+      if (node.type === "paragraph") {
+        const text = extractPlainText(node).trim();
+        if (text) paragraphs.push(text);
+      }
+    }
+    return paragraphs.length > 0 ? paragraphs.join("\n\n") : null;
+  }
+
+  // No moreBreak — accumulate paragraphs up to limits
+  const paragraphs: string[] = [];
+  let totalChars = 0;
+
+  for (const node of nodes) {
+    if (node.type !== "paragraph") continue;
+
+    const text = extractPlainText(node).trim();
+    if (!text) continue;
+
+    if (paragraphs.length >= maxParagraphs || totalChars >= maxChars) break;
+
+    paragraphs.push(text);
+    totalChars += text.length;
+  }
+
+  return paragraphs.length > 0 ? paragraphs.join("\n\n") : null;
+}

package/src/lib/theme.ts

@@ -33,15 +33,16 @@ export function getAvailableThemes(): ColorTheme[] {
  * @param cssVariables - Extra CSS variable overrides
  * @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
- * BaseCoat defaults (`:root` and `.dark`). This ensures theme overrides win
- * regardless of source order — important because Vite dev mode injects CSS
- * as `<style>` tags after the theme `<style>`.
+ * Uses `:root:root` for light mode and `@media (prefers-color-scheme: dark)`
+ * with `:root:root` for dark mode, giving higher specificity than BaseCoat
+ * defaults (`:root`). This ensures theme overrides win regardless of source
+ * order — important because Vite dev mode injects CSS as `<style>` tags
+ * after the theme `<style>`.
  *
  * @example
  * ```typescript
  * const css = buildThemeStyle(blueTheme, { "--radius": "0.5rem" });
- * // => ":root:root { --primary: oklch(...); ... }\n:root.dark { ... }"
+ * // => ":root:root { ... }\n@media (prefers-color-scheme: dark) { :root:root { ... } }"
  * ```
  */
 export function buildThemeStyle(
@@ -74,10 +75,12 @@ export function buildThemeStyle(
 
   if (hasDark) {
     const declarations = Object.entries(darkVars)
-      .map(([k, v]) => `  ${k}: ${v};`)
+      .map(([k, v]) => `    ${k}: ${v};`)
       .join("\n");
-    // :root.dark has specificity (0,1,1) > BaseCoat's .dark (0,1,0)
-    parts.push(`:root.dark {\n${declarations}\n}`);
+    // :root:root inside @media has specificity (0,0,2) > preset fallback :root (0,0,1)
+    parts.push(
+      `@media (prefers-color-scheme: dark) {\n  :root:root {\n${declarations}\n  }\n}`,
+    );
   }
 
   return parts.join("\n");

package/src/lib/timeline.ts

@@ -9,7 +9,7 @@ import type { Context } from "hono";
 import type { Bindings, TimelineItemView } from "../types.js";
 import type { AppVariables } from "../types/app-context.js";
 import { buildMediaMap } from "./media-helpers.js";
-import { createMediaContext, toPostView, toPostViews } from "./view.js";
+import { createMediaContext, toPostView } from "./view.js";
 
 type Env = { Bindings: Bindings; Variables: AppVariables };
 
@@ -40,17 +40,21 @@ export interface TimelineResult {
  */
 export async function assembleTimeline(
   c: Context<Env>,
-  options?: { page?: number },
+  options?: { page?: number; isAuthenticated?: boolean },
 ): Promise<TimelineResult> {
   const pageSize = c.var.appConfig.pageSize;
 
   const page = Math.max(1, options?.page ?? 1);
   const offset = (page - 1) * pageSize;
 
+  const excludePrivate = !(options?.isAuthenticated ?? false);
+
   // Get total count for pagination
   const totalCount = await c.var.services.posts.count({
     status: "published",
     excludeReplies: true,
+    excludeUnlisted: true,
+    excludePrivate,
   });
   const totalPages = Math.max(1, Math.ceil(totalCount / pageSize));
 
@@ -58,6 +62,8 @@ export async function assembleTimeline(
   const posts = await c.var.services.posts.list({
     status: "published",
     excludeReplies: true,
+    excludeUnlisted: true,
+    excludePrivate,
     limit: pageSize,
     offset,
   });
@@ -66,7 +72,7 @@ export async function assembleTimeline(
     return { items: [], currentPage: page, totalPages };
   }
 
-  // Batch load media attachments
+  // Batch load media
   const postIds = posts.map((p) => p.id);
   const rawMediaMap = await c.var.services.media.getByPostIds(postIds);
   const mediaCtx = createMediaContext(c.var.appConfig);
@@ -77,55 +83,91 @@ export async function assembleTimeline(
     mediaCtx.s3PublicUrl,
   );
 
+  // Batch load collections for main posts
+  const collectionsMap =
+    await c.var.services.collections.getCollectionsByPostIds(postIds);
+
   // 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 thread timeline context (latest reply + parent)
+  const threadContexts =
+    await c.var.services.posts.getThreadTimelineContext(threadRootIds);
 
-  // Batch load media for preview replies
-  const previewReplyIds: number[] = [];
-  for (const replies of threadPreviews.values()) {
-    for (const reply of replies) {
-      previewReplyIds.push(reply.id);
+  // Batch load media for context posts (latestReply + parentReply)
+  const contextPostIds: string[] = [];
+  for (const ctx of threadContexts.values()) {
+    contextPostIds.push(ctx.latestReply.id);
+    if (ctx.parentReply) {
+      contextPostIds.push(ctx.parentReply.id);
     }
   }
-  const previewMediaMap =
-    previewReplyIds.length > 0
-      ? buildMediaMap(
-          await c.var.services.media.getByPostIds(previewReplyIds),
-          mediaCtx.r2PublicUrl,
-          mediaCtx.imageTransformUrl,
-          mediaCtx.s3PublicUrl,
-        )
-      : new Map();
+  const [contextMediaMap, contextCollectionsMap] =
+    contextPostIds.length > 0
+      ? await Promise.all([
+          c.var.services.media
+            .getByPostIds(contextPostIds)
+            .then((raw) =>
+              buildMediaMap(
+                raw,
+                mediaCtx.r2PublicUrl,
+                mediaCtx.imageTransformUrl,
+                mediaCtx.s3PublicUrl,
+              ),
+            ),
+          c.var.services.collections.getCollectionsByPostIds(contextPostIds),
+        ])
+      : [new Map(), new Map()];
 
   // Assemble timeline items with View Models
   const items: TimelineItemView[] = posts.map((post) => {
     const postView = toPostView(
-      { ...post, mediaAttachments: mediaMap.get(post.id) ?? [] },
+      {
+        ...post,
+        mediaAttachments: mediaMap.get(post.id) ?? [],
+      },
       mediaCtx,
+      collectionsMap.get(post.id),
     );
 
-    const replyCount = replyCounts.get(post.id) ?? 0;
-    const previewReplies = threadPreviews.get(post.id);
+    const threadCtx = threadContexts.get(post.id);
+
+    if (threadCtx) {
+      // Thread root is not the last post — hide reply button on it
+      postView.isLastInThread = false;
+
+      const latestReplyView = toPostView(
+        {
+          ...threadCtx.latestReply,
+          mediaAttachments: contextMediaMap.get(threadCtx.latestReply.id) ?? [],
+        },
+        mediaCtx,
+        contextCollectionsMap.get(threadCtx.latestReply.id),
+        undefined,
+        true, // latestReply is the last post in the thread
+      );
+
+      const parentReplyView = threadCtx.parentReply
+        ? toPostView(
+            {
+              ...threadCtx.parentReply,
+              mediaAttachments:
+                contextMediaMap.get(threadCtx.parentReply.id) ?? [],
+            },
+            mediaCtx,
+            contextCollectionsMap.get(threadCtx.parentReply.id),
+            undefined,
+            false, // parentReply is not the last post
+          )
+        : undefined;
 
-    if (replyCount > 0 && previewReplies) {
       return {
         post: postView,
         threadPreview: {
-          replies: toPostViews(
-            previewReplies.map((r) => ({
-              ...r,
-              mediaAttachments: previewMediaMap.get(r.id) ?? [],
-            })),
-            mediaCtx,
-          ),
-          totalReplyCount: replyCount,
+          latestReply: latestReplyView,
+          parentReply: parentReplyView,
+          totalReplyCount: threadCtx.totalReplyCount,
         },
       };
     }