@jant/core 0.3.35 → 0.3.37

package/src/lib/icons.ts

@@ -93,7 +93,8 @@ export function parseCollectionIcon(
     if (
       typeof parsed.name === "string" &&
       typeof parsed.svg === "string" &&
-      typeof parsed.color === "string"
+      typeof parsed.color === "string" &&
+      /^#[0-9a-f]{3,6}$/i.test(parsed.color)
     ) {
       return parsed as unknown as CollectionIcon;
     }
@@ -186,7 +187,7 @@ function applyIconSize(svg: string, size: number, color?: string): string {
   let result = svg
     .replace(/width="24"/, `width="${size}"`)
     .replace(/height="24"/, `height="${size}"`);
-  if (color) {
+  if (color && /^#[0-9a-f]{3,6}$/i.test(color)) {
     result = result.replace("<svg", `<svg style="color: ${color}"`);
   }
   return result;

package/src/lib/index.ts

@@ -3,7 +3,6 @@
  */
 
 export * from "./constants.js";
-export * as sqid from "./sqid.js";
 export * as time from "./time.js";
 export * as url from "./url.js";
 export * as markdown from "./markdown.js";

package/src/lib/markdown-to-tiptap.ts

@@ -0,0 +1,286 @@
+/**
+ * Markdown → TipTap JSON Conversion
+ *
+ * Converts Markdown strings to TipTap JSON documents using `marked.lexer()`
+ * for tokenization. Enables the API to accept Markdown while the internal
+ * pipeline (renderTiptapJson / extractBodyText / extractSummary) continues
+ * to operate on TipTap JSON.
+ */
+
+import { marked, type Token, type Tokens } from "marked";
+
+interface TiptapMark {
+  type: string;
+  attrs?: Record<string, unknown>;
+}
+
+interface TiptapNode {
+  type: string;
+  content?: TiptapNode[];
+  text?: string;
+  marks?: TiptapMark[];
+  attrs?: Record<string, unknown>;
+}
+
+/**
+ * Converts a Markdown string to a TipTap JSON document string.
+ *
+ * Uses `marked.lexer()` to tokenize, then maps each token to the
+ * corresponding TipTap node structure that `renderTiptapJson()` expects.
+ *
+ * @param markdown - Markdown source text
+ * @returns Stringified TipTap JSON document
+ *
+ * @example
+ * ```ts
+ * const json = markdownToTiptapJson("Hello **world**");
+ * // '{"type":"doc","content":[{"type":"paragraph","content":[...]}]}'
+ * ```
+ */
+export function markdownToTiptapJson(markdown: string): string {
+  const tokens = marked.lexer(markdown, { gfm: true, breaks: true });
+  const content = tokens.flatMap(blockTokenToNodes);
+  // Ensure at least one node so the doc is valid
+  if (content.length === 0) {
+    content.push({ type: "paragraph" });
+  }
+  const doc: TiptapNode = { type: "doc", content };
+  return JSON.stringify(doc);
+}
+
+// ---------------------------------------------------------------------------
+// Block-level token → TipTap node mapping
+// ---------------------------------------------------------------------------
+
+function blockTokenToNodes(token: Token): TiptapNode[] {
+  switch (token.type) {
+    case "paragraph":
+      return [
+        {
+          type: "paragraph",
+          content: inlineTokensToNodes(
+            (token as Tokens.Paragraph).tokens ?? [],
+            [],
+          ),
+        },
+      ];
+
+    // Tight list items use "text" instead of "paragraph" as the block wrapper
+    case "text": {
+      const t = token as Tokens.Text;
+      return [
+        {
+          type: "paragraph",
+          content: inlineTokensToNodes(t.tokens ?? [], []),
+        },
+      ];
+    }
+
+    case "heading": {
+      const t = token as Tokens.Heading;
+      return [
+        {
+          type: "heading",
+          attrs: { level: t.depth },
+          content: inlineTokensToNodes(t.tokens ?? [], []),
+        },
+      ];
+    }
+
+    case "code": {
+      const t = token as Tokens.Code;
+      const node: TiptapNode = {
+        type: "codeBlock",
+        content: [{ type: "text", text: t.text }],
+      };
+      if (t.lang) {
+        node.attrs = { language: t.lang };
+      }
+      return [node];
+    }
+
+    case "blockquote": {
+      const t = token as Tokens.Blockquote;
+      const inner = (t.tokens ?? []).flatMap(blockTokenToNodes);
+      return [{ type: "blockquote", content: inner }];
+    }
+
+    case "list": {
+      const t = token as Tokens.List;
+      const listType = t.ordered ? "orderedList" : "bulletList";
+      const items = t.items.map(listItemToNode);
+      const node: TiptapNode = { type: listType, content: items };
+      if (t.ordered && t.start !== undefined && t.start !== 1) {
+        node.attrs = { start: t.start };
+      }
+      return [node];
+    }
+
+    case "hr":
+      return [{ type: "horizontalRule" }];
+
+    case "html": {
+      const t = token as Tokens.HTML;
+      if (t.text.trim() === "<!--more-->") {
+        return [{ type: "moreBreak" }];
+      }
+      // Other raw HTML: wrap in a paragraph as plain text
+      return [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: t.text.trim() }],
+        },
+      ];
+    }
+
+    case "table": {
+      const t = token as Tokens.Table;
+      const rows: TiptapNode[] = [];
+
+      // Header row
+      const headerCells = t.header.map(
+        (cell): TiptapNode => ({
+          type: "tableHeader",
+          content: [
+            {
+              type: "paragraph",
+              content: inlineTokensToNodes(cell.tokens, []),
+            },
+          ],
+        }),
+      );
+      rows.push({ type: "tableRow", content: headerCells });
+
+      // Body rows
+      for (const row of t.rows) {
+        const cells = row.map(
+          (cell): TiptapNode => ({
+            type: "tableCell",
+            content: [
+              {
+                type: "paragraph",
+                content: inlineTokensToNodes(cell.tokens, []),
+              },
+            ],
+          }),
+        );
+        rows.push({ type: "tableRow", content: cells });
+      }
+
+      return [{ type: "table", content: rows }];
+    }
+
+    case "space":
+      return [];
+
+    default:
+      return [];
+  }
+}
+
+function listItemToNode(item: Tokens.ListItem): TiptapNode {
+  // A list item's tokens can be block-level (loose list) or inline
+  const children = (item.tokens ?? []).flatMap(blockTokenToNodes);
+  return { type: "listItem", content: children };
+}
+
+// ---------------------------------------------------------------------------
+// Inline token → TipTap node mapping (flattened marks model)
+// ---------------------------------------------------------------------------
+
+function inlineTokensToNodes(
+  tokens: Token[],
+  marks: TiptapMark[],
+): TiptapNode[] {
+  const nodes: TiptapNode[] = [];
+
+  for (const token of tokens) {
+    switch (token.type) {
+      case "text": {
+        const t = token as Tokens.Text;
+        // marked may nest inline tokens inside text tokens
+        if (t.tokens && t.tokens.length > 0) {
+          nodes.push(...inlineTokensToNodes(t.tokens, marks));
+        } else {
+          const textNode: TiptapNode = { type: "text", text: t.text };
+          if (marks.length > 0) textNode.marks = [...marks];
+          nodes.push(textNode);
+        }
+        break;
+      }
+
+      case "strong": {
+        const t = token as Tokens.Strong;
+        const newMarks = [...marks, { type: "bold" }];
+        nodes.push(...inlineTokensToNodes(t.tokens ?? [], newMarks));
+        break;
+      }
+
+      case "em": {
+        const t = token as Tokens.Em;
+        const newMarks = [...marks, { type: "italic" }];
+        nodes.push(...inlineTokensToNodes(t.tokens ?? [], newMarks));
+        break;
+      }
+
+      case "codespan": {
+        const t = token as Tokens.Codespan;
+        const textNode: TiptapNode = { type: "text", text: t.text };
+        textNode.marks = [...marks, { type: "code" }];
+        nodes.push(textNode);
+        break;
+      }
+
+      case "del": {
+        const t = token as Tokens.Del;
+        const newMarks = [...marks, { type: "strike" }];
+        nodes.push(...inlineTokensToNodes(t.tokens ?? [], newMarks));
+        break;
+      }
+
+      case "link": {
+        const t = token as Tokens.Link;
+        const linkMark: TiptapMark = {
+          type: "link",
+          attrs: { href: t.href, target: "_blank" },
+        };
+        const newMarks = [...marks, linkMark];
+        nodes.push(...inlineTokensToNodes(t.tokens ?? [], newMarks));
+        break;
+      }
+
+      case "image": {
+        const t = token as Tokens.Image;
+        const imgAttrs: Record<string, unknown> = { src: t.href };
+        if (t.text) imgAttrs.alt = t.text;
+        if (t.title) imgAttrs.title = t.title;
+        const imgNode: TiptapNode = { type: "image", attrs: imgAttrs };
+        nodes.push(imgNode);
+        break;
+      }
+
+      case "br":
+        nodes.push({ type: "hardBreak" });
+        break;
+
+      case "escape": {
+        const t = token as Tokens.Escape;
+        const textNode: TiptapNode = { type: "text", text: t.text };
+        if (marks.length > 0) textNode.marks = [...marks];
+        nodes.push(textNode);
+        break;
+      }
+
+      default:
+        // For any unhandled inline token with raw text, emit as text
+        if ("text" in token && typeof token.text === "string") {
+          const textNode: TiptapNode = { type: "text", text: token.text };
+          if (marks.length > 0) textNode.marks = [...marks];
+          nodes.push(textNode);
+        }
+        break;
+    }
+  }
+
+  return nodes;
+}

package/src/lib/media-helpers.ts

@@ -28,12 +28,12 @@ import { getMediaUrl, getImageUrl, getPublicUrlForProvider } from "./image.js";
  * ```
  */
 export function buildMediaMap(
-  rawMediaMap: Map<number, Media[]>,
+  rawMediaMap: Map<string, Media[]>,
   r2PublicUrl?: string,
   imageTransformUrl?: string,
   s3PublicUrl?: string,
-): Map<number, MediaAttachment[]> {
-  const mediaMap = new Map<number, MediaAttachment[]>();
+): Map<string, MediaAttachment[]> {
+  const mediaMap = new Map<string, MediaAttachment[]>();
   for (const [postId, mediaList] of rawMediaMap) {
     mediaMap.set(
       postId,
@@ -43,26 +43,36 @@ export function buildMediaMap(
           r2PublicUrl,
           s3PublicUrl,
         );
-        return {
-          id: m.id,
-          url: getMediaUrl(m.storageKey, publicUrl),
-          previewUrl: getImageUrl(
-            getMediaUrl(m.storageKey, publicUrl),
-            imageTransformUrl,
-            {
+        const mediaUrl = getMediaUrl(m.storageKey, publicUrl);
+        // Only apply image transforms for image MIME types
+        const previewUrl = m.mimeType.startsWith("image/")
+          ? getImageUrl(mediaUrl, imageTransformUrl, {
               width: 1200,
               height: 768,
               quality: 80,
               format: "auto",
               fit: "scale-down",
-            },
-          ),
+            })
+          : mediaUrl;
+        const posterUrl = m.posterKey
+          ? getMediaUrl(m.posterKey, publicUrl)
+          : null;
+        return {
+          id: m.id,
+          url: mediaUrl,
+          previewUrl,
           alt: m.alt,
           blurhash: m.blurhash,
+          waveform: m.waveform,
+          posterUrl,
           width: m.width,
           height: m.height,
           position: m.position,
           mimeType: m.mimeType,
+          originalName: m.originalName,
+          size: m.size,
+          summary: m.summary,
+          chars: m.chars,
         };
       }),
     );

package/src/lib/nanoid.ts

@@ -0,0 +1,29 @@
+/**
+ * Random ID Generation
+ *
+ * Wraps nanoid's `customAlphabet` to produce short, URL-safe random IDs
+ * using a lowercase alphanumeric alphabet (0-9, a-z).
+ */
+
+import { customAlphabet } from "nanoid";
+
+const ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+
+/**
+ * Generates a random ID of the given length using lowercase alphanumeric characters.
+ *
+ * Uses nanoid's `customAlphabet` for uniform distribution.
+ *
+ * @param length - Number of characters in the generated ID
+ * @returns Random alphanumeric string
+ *
+ * @example
+ * ```ts
+ * generateRandomId(5); // e.g. "a3k9m"
+ * generateRandomId(8); // e.g. "b7x2q4fn"
+ * ```
+ */
+export function generateRandomId(length: number): string {
+  const generate = customAlphabet(ALPHABET, length);
+  return generate();
+}

package/src/lib/navigation.ts

@@ -83,7 +83,7 @@ export async function getNavigationData(c: Context): Promise<NavigationData> {
 
   // Only load collections when authenticated (for compose dialog)
   if (isAuthenticated) {
-    collections = await c.var.services.collections.list();
+    collections = await c.var.services.collections.listByRecentActivity();
   }
 
   return {

package/src/lib/render.tsx

@@ -8,7 +8,7 @@
 import type { Context } from "hono";
 import type { Child } from "hono/jsx";
 import type { SiteLayoutProps } from "../types.js";
-import { BaseLayout } from "../ui/layouts/BaseLayout.js";
+import { BaseLayout, type ToastProps } from "../ui/layouts/BaseLayout.js";
 import { SiteLayout } from "../ui/layouts/SiteLayout.js";
 import type { NavigationData } from "./navigation.js";
 
@@ -23,6 +23,12 @@ export interface RenderPublicPageOptions {
   content: Child;
   /** Optional sidebar content for sidebar layout */
   sidebar?: Child;
+  /** Optional toast notification */
+  toast?: ToastProps;
+  /** Whether to render the shared compose dialog shell */
+  showComposeDialog?: boolean;
+  /** Whether to render the site header */
+  showHeader?: boolean;
 }
 
 /**
@@ -43,11 +49,23 @@ export interface RenderPublicPageOptions {
  * ```
  */
 export function renderPublicPage(c: Context, options: RenderPublicPageOptions) {
-  const { title, description, navData, content, sidebar } = options;
+  const {
+    title,
+    description,
+    navData,
+    content,
+    sidebar,
+    toast,
+    showComposeDialog,
+    showHeader,
+  } = options;
 
   // Use siteDescription as meta description fallback when not explicitly provided
   const metaDescription = description || navData.siteDescription || undefined;
 
+  // Read favicon, version, and noindex from appConfig
+  const appConfig = c.get("appConfig");
+
   const layoutProps: SiteLayoutProps = {
     siteName: navData.siteName,
     links: navData.links,
@@ -60,10 +78,10 @@ export function renderPublicPage(c: Context, options: RenderPublicPageOptions) {
     showHeaderAvatar: navData.showHeaderAvatar,
     siteFooterHtml: navData.siteFooterHtml,
     sidebar,
+    uploadMaxFileSize: appConfig.uploadMaxFileSize,
+    showComposeDialog,
+    showHeader,
   };
-
-  // Read favicon, version, and noindex from appConfig
-  const appConfig = c.get("appConfig");
   const faviconUrl = appConfig.siteAvatarUrl || undefined;
   const faviconVersion = appConfig.faviconVersion || undefined;
   const noindex = appConfig.noindex;
@@ -77,6 +95,7 @@ export function renderPublicPage(c: Context, options: RenderPublicPageOptions) {
       faviconVersion={faviconVersion}
       noindex={noindex}
       isAuthenticated={navData.isAuthenticated}
+      toast={toast}
     >
       <SiteLayout {...layoutProps}>{content}</SiteLayout>
     </BaseLayout>,

package/src/lib/resolve-config.ts

@@ -117,7 +117,7 @@ export function resolveConfig(
         resolve("HEADER_NAV_MAX_VISIBLE", allSettings, env),
         10,
       );
-      return Math.max(0, Math.min(5, isNaN(parsed) ? 3 : parsed));
+      return Math.max(0, Math.min(5, isNaN(parsed) ? 2 : parsed));
     })(),
     timeZone: resolve("TIME_ZONE", allSettings, env),
     siteFooter: resolve("SITE_FOOTER", allSettings, env),
@@ -133,6 +133,17 @@ export function resolveConfig(
     s3PublicUrl,
     imageTransformUrl,
 
+    // Upload (ENV only)
+    uploadMaxFileSize:
+      parseInt(env.UPLOAD_MAX_FILE_SIZE_MB ?? "500", 10) || 500,
+
+    // Summary extraction (ENV only)
+    summaryMaxParagraphs: parseInt(env.SUMMARY_MAX_PARAGRAPHS ?? "5", 10) || 5,
+    summaryMaxChars: parseInt(env.SUMMARY_MAX_CHARS ?? "500", 10) || 500,
+
+    // Slug (ENV only)
+    slugIdLength: parseInt(env.SLUG_ID_LENGTH ?? "5", 10) || 5,
+
     // Pagination/Feed (ENV only)
     pageSize: parseInt(env.PAGE_SIZE ?? "20", 10) || 20,
     rssFeedLimit: parseInt(env.RSS_FEED_LIMIT ?? "50", 10) || 50,
@@ -154,7 +165,7 @@ export function resolveConfig(
     siteAvatarUrl,
     faviconVersion: allSettings["SITE_FAVICON_VERSION"] ?? "",
 
-    // Dashboard form placeholders (ENV > Default, without DB)
+    // Settings form placeholders (ENV > Default, without DB)
     fallbacks: {
       siteName: resolveFallback("SITE_NAME", env),
       siteDescription: resolveFallback("SITE_DESCRIPTION", env),