@hutusi/amytis 1.13.0 → 1.15.0

package/src/layouts/SimpleLayout.tsx

@@ -1,6 +1,7 @@
 import { Suspense } from 'react';
 import { PostData } from '@/lib/markdown';
 import MarkdownRenderer from '@/components/MarkdownRenderer';
+import RstRenderer from '@/components/RstRenderer';
 import SimpleLayoutHeader from '@/components/SimpleLayoutHeader';
 import LocaleSwitch from '@/components/LocaleSwitch';
 import PostSidebar from '@/components/PostSidebar';
@@ -28,6 +29,12 @@ export default function SimpleLayout({ post, titleKey, subtitleKey }: SimpleLayo
       )
     : undefined;
 
+  const renderContent = (content: string) => (
+    post.sourceFormat === 'rst'
+      ? <RstRenderer content={content} html={content === post.content ? post.renderedHtml : undefined} latex={post.latex} slug={post.imageBaseSlug} />
+      : <MarkdownRenderer content={content} latex={post.latex} slug={post.imageBaseSlug} />
+  );
+
   const articleContent = (
     <>
       <SimpleLayoutHeader
@@ -40,16 +47,16 @@ export default function SimpleLayout({ post, titleKey, subtitleKey }: SimpleLayo
       {localeEntries.length > 0 ? (
         <LocaleSwitch>
           <div data-locale={defaultLocale}>
-            <MarkdownRenderer content={post.content} latex={post.latex} slug={post.imageBaseSlug} />
+            {renderContent(post.content)}
           </div>
           {localeEntries.map(([locale, data]) => (
             <div key={locale} data-locale={locale} style={{ display: 'none' }}>
-              <MarkdownRenderer content={data.content} latex={post.latex} slug={post.imageBaseSlug} />
+              {renderContent(data.content)}
             </div>
           ))}
         </LocaleSwitch>
       ) : (
-        <MarkdownRenderer content={post.content} latex={post.latex} slug={post.imageBaseSlug} />
+        renderContent(post.content)
       )}
     </>
   );

package/src/lib/feed-utils.ts

@@ -7,6 +7,7 @@ import rehypeStringify from 'rehype-stringify';
 import { getAllPosts, getAllFlows } from './markdown';
 import { siteConfig } from '../../site.config';
 import { getPostUrl, getFlowUrl } from './urls';
+import { resolveLocale } from './i18n';
 
 export interface FeedItem {
   title: string;
@@ -30,39 +31,178 @@ function markdownToHtml(markdown: string): string {
   return String(result);
 }
 
+export type FeedType = 'main' | 'posts' | 'flows' | 'all';
+
 /**
  * Returns feed items for RSS/Atom generation.
- * Includes all published posts (converted to HTML) and optionally flow notes
- * when `siteConfig.feed.includeFlows` is enabled. Results are sorted by date
- * descending and capped at `siteConfig.feed.maxItems` (0 = unlimited).
+ * - 'main': Respects `siteConfig.feed.includeFlows`
+ * - 'posts': Only posts
+ * - 'flows': Only flows
+ * - 'all': Both posts and flows, ignoring `includeFlows`
  */
-export function getFeedItems(): FeedItem[] {
+export function getFeedItems(feedType: FeedType = 'main', includeFullContent: boolean = false): FeedItem[] {
   const { maxItems, includeFlows } = siteConfig.feed;
   const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
 
-  const postItems: FeedItem[] = getAllPosts().map((post) => ({
+  let items: FeedItem[] = [];
+
+  const getPostItems = () => getAllPosts().map((post) => ({
     title: post.title,
     url: `${baseUrl}${getPostUrl(post)}`,
     date: new Date(post.date),
     excerpt: post.excerpt,
-    content: markdownToHtml(post.content),
+    content: includeFullContent ? markdownToHtml(post.content) : '',
     tags: post.tags || [],
     authors: post.authors,
   }));
 
-  let items: FeedItem[] = postItems;
-
-  if (includeFlows) {
-    const flowItems: FeedItem[] = getAllFlows().map((flow) => ({
-      title: flow.title,
-      url: `${baseUrl}${getFlowUrl(flow.slug)}`,
-      date: new Date(flow.date),
-      excerpt: flow.excerpt,
-      content: markdownToHtml(flow.content),
-      tags: flow.tags || [],
-    }));
-    items = [...postItems, ...flowItems].sort((a, b) => b.date.getTime() - a.date.getTime());
+  const getFlowItems = () => getAllFlows().map((flow) => ({
+    title: flow.title,
+    url: `${baseUrl}${getFlowUrl(flow.slug)}`,
+    date: new Date(flow.date),
+    excerpt: flow.excerpt,
+    content: includeFullContent ? markdownToHtml(flow.content) : '',
+    tags: flow.tags || [],
+  }));
+
+  if (feedType === 'posts') {
+    items = getPostItems();
+  } else if (feedType === 'flows') {
+    items = getFlowItems();
+  } else if (feedType === 'all') {
+    items = [...getPostItems(), ...getFlowItems()];
+  } else {
+    // main
+    items = includeFlows ? [...getPostItems(), ...getFlowItems()] : getPostItems();
   }
 
+  // Sort descending by date
+  items.sort((a, b) => b.date.getTime() - a.date.getTime());
+
   return maxItems > 0 ? items.slice(0, maxItems) : items;
 }
+
+const escapeXml = (v: string) =>
+  v.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+   .replace(/"/g, '&quot;').replace(/'/g, '&apos;');
+
+const escapeCdata = (v: string) => v.replace(/]]>/g, ']]]]><![CDATA[>');
+
+export function generateRssFeed(feedType: FeedType, selfUrlPath: string): Response {
+  const { format, content: contentMode } = siteConfig.feed;
+  if (format === 'atom') {
+    return new Response('Not Found', { status: 404 });
+  }
+
+  const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
+  const useFullContent = contentMode === 'full';
+  const items = getFeedItems(feedType, useFullContent);
+  const contentNs = useFullContent ? ' xmlns:content="http://purl.org/rss/modules/content/"' : '';
+  const siteTitle = resolveLocale(siteConfig.title);
+  const lastBuildDate = items[0]?.date.toUTCString() ?? new Date().toUTCString();
+
+  const selfUrl = `${baseUrl}${selfUrlPath}`;
+
+  const imageXml = siteConfig.ogImage
+    ? `\n    <image>\n      <url>${escapeXml(baseUrl + siteConfig.ogImage)}</url>\n      <title>${escapeXml(siteTitle)}</title>\n      <link>${escapeXml(baseUrl)}</link>\n    </image>`
+    : '';
+
+  const rssItemsXml = items
+    .map((item) => {
+      const fullContentXml = useFullContent
+        ? `\n          <content:encoded><![CDATA[${escapeCdata(item.content)}]]></content:encoded>`
+        : '';
+      const authorsXml = item.authors?.length
+        ? item.authors.map((a) => `\n          <dc:creator><![CDATA[${escapeCdata(a)}]]></dc:creator>`).join('')
+        : '';
+      return `
+        <item>
+          <title><![CDATA[${escapeCdata(item.title)}]]></title>
+          <link>${escapeXml(item.url)}</link>
+          <guid isPermaLink="true">${escapeXml(item.url)}</guid>
+          <pubDate>${item.date.toUTCString()}</pubDate>
+          <description><![CDATA[${escapeCdata(item.excerpt)}]]></description>${fullContentXml}${authorsXml}
+          ${item.tags.map((tag) => `<category><![CDATA[${escapeCdata(tag)}]]></category>`).join('')}
+        </item>`;
+    })
+    .join('');
+
+  const rssXml = `<?xml version="1.0" encoding="UTF-8" ?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/"${contentNs}>
+  <channel>
+    <title><![CDATA[${escapeCdata(siteTitle)}]]></title>
+    <link>${escapeXml(baseUrl)}</link>
+    <description><![CDATA[${escapeCdata(resolveLocale(siteConfig.description))}]]></description>
+    <language>${siteConfig.i18n.defaultLocale}</language>
+    <lastBuildDate>${lastBuildDate}</lastBuildDate>
+    <atom:link href="${escapeXml(selfUrl)}" rel="self" type="application/rss+xml" />${imageXml}
+    ${rssItemsXml}
+  </channel>
+</rss>`;
+
+  return new Response(rssXml, {
+    headers: {
+      'Content-Type': 'application/rss+xml; charset=utf-8',
+      'Cache-Control': 'public, max-age=3600',
+    },
+  });
+}
+
+export function generateAtomFeed(feedType: FeedType, selfUrlPath: string): Response {
+  const { format, content: contentMode } = siteConfig.feed;
+  if (format === 'rss') {
+    return new Response('Not Found', { status: 404 });
+  }
+
+  const baseUrl = siteConfig.baseUrl.replace(/\/+$/, '');
+  const useFullContent = contentMode === 'full';
+  const items = getFeedItems(feedType, useFullContent);
+  const feedUpdated = items[0]?.date.toISOString() ?? new Date().toISOString();
+
+  const selfUrl = `${baseUrl}${selfUrlPath}`;
+
+  const hasAllAuthors = items.every(item => item.authors && item.authors.length > 0);
+  const siteTitle = resolveLocale(siteConfig.title);
+  const defaultAuthor = siteConfig.posts?.authors?.default?.[0];
+  const feedAuthorName = defaultAuthor ? defaultAuthor : siteTitle;
+  const feedAuthorXml = hasAllAuthors ? '' : `\n  <author><name>${escapeXml(feedAuthorName)}</name></author>`;
+
+  const entriesXml = items
+    .map((item) => {
+      const contentXml = useFullContent
+        ? `<content type="html"><![CDATA[${escapeCdata(item.content)}]]></content>\n    <summary><![CDATA[${escapeCdata(item.excerpt)}]]></summary>`
+        : `<summary><![CDATA[${escapeCdata(item.excerpt)}]]></summary>`;
+      const authorsXml = item.authors?.map((a) => `<author><name>${escapeXml(a)}</name></author>`).join('') ?? '';
+      const categoriesXml = item.tags.map((tag) => `<category term="${escapeXml(tag)}" />`).join('');
+      return `
+  <entry>
+    <title><![CDATA[${escapeCdata(item.title)}]]></title>
+    <link href="${escapeXml(item.url)}" />
+    <id>${escapeXml(item.url)}</id>
+    <published>${item.date.toISOString()}</published>
+    <updated>${item.date.toISOString()}</updated>
+    ${contentXml}
+    ${authorsXml}
+    ${categoriesXml}
+  </entry>`;
+    })
+    .join('');
+
+  const atomXml = `<?xml version="1.0" encoding="UTF-8" ?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <title><![CDATA[${escapeCdata(resolveLocale(siteConfig.title))}]]></title>
+  <link href="${escapeXml(baseUrl)}" />
+  <link href="${escapeXml(selfUrl)}" rel="self" type="application/atom+xml" />
+  <id>${escapeXml(selfUrl)}</id>
+  <updated>${feedUpdated}</updated>
+  <subtitle><![CDATA[${escapeCdata(resolveLocale(siteConfig.description))}]]></subtitle>${feedAuthorXml}
+${entriesXml}
+</feed>`;
+
+  return new Response(atomXml, {
+    headers: {
+      'Content-Type': 'application/atom+xml; charset=utf-8',
+      'Cache-Control': 'public, max-age=3600',
+    },
+  });
+}

package/src/lib/image-utils.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, test } from "bun:test";
+import { getCdnImageUrl, shouldBypassImageOptimization } from "./image-utils";
+
+describe("image-utils", () => {
+  test("getCdnImageUrl leaves external and special URLs unchanged", () => {
+    expect(getCdnImageUrl("https://example.com/image.jpg", "https://cdn.example.com")).toBe("https://example.com/image.jpg");
+    expect(getCdnImageUrl("text:Cover", "https://cdn.example.com")).toBe("text:Cover");
+    expect(getCdnImageUrl("data:image/png;base64,abc", "https://cdn.example.com")).toBe("data:image/png;base64,abc");
+  });
+
+  test("shouldBypassImageOptimization skips avif and webp sources", () => {
+    expect(shouldBypassImageOptimization("/images/background-new-wave.avif")).toBe(true);
+    expect(shouldBypassImageOptimization("/images/already-optimized.webp")).toBe(true);
+    expect(shouldBypassImageOptimization("/images/already-optimized.WEBP?version=1")).toBe(true);
+    expect(shouldBypassImageOptimization("/images/already-optimized.webp?version=1#hero")).toBe(true);
+    expect(shouldBypassImageOptimization("/images/photo.jpg")).toBe(false);
+    expect(shouldBypassImageOptimization("/images/photo.png#fragment")).toBe(false);
+  });
+});

package/src/lib/image-utils.ts

@@ -10,3 +10,14 @@ export function getCdnImageUrl(src: string, cdnBaseUrl: string): string {
   const path = src.startsWith('/') ? src : `/${src}`;
   return `${base}${path}`;
 }
+
+/**
+ * Certain source formats should bypass next-image-export-optimizer entirely.
+ * AVIF currently has an upstream path-generation bug when WEBP output is enabled,
+ * and user-supplied WEBP files are often already optimized enough to serve directly.
+ */
+export function shouldBypassImageOptimization(src: string): boolean {
+  if (!src) return false;
+  const pathWithoutQuery = src.split('#')[0]?.split('?')[0] ?? src;
+  return /\.(avif|webp)$/i.test(pathWithoutQuery);
+}

package/src/lib/markdown.test.ts

@@ -1,5 +1,37 @@
-import { describe, expect, test } from "bun:test";
-import { generateExcerpt, calculateReadingTime, getHeadings, getAuthorSlug } from "./markdown";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+import { RstParseError } from "./rst";
+import {
+  generateExcerpt,
+  calculateReadingTime,
+  getHeadings,
+  getAuthorSlug,
+  getPythonRstRendererAvailabilityForTests,
+  parseMarkdownFileForTests,
+  parseRstFileForTests,
+  resetPythonRstRendererAvailabilityForTests,
+} from "./markdown";
+
+const previousEnablePythonRst = process.env.AMYTIS_ENABLE_PYTHON_RST;
+const previousRstPython = process.env.AMYTIS_RST_PYTHON;
+
+afterEach(() => {
+  if (previousEnablePythonRst === undefined) {
+    delete process.env.AMYTIS_ENABLE_PYTHON_RST;
+  } else {
+    process.env.AMYTIS_ENABLE_PYTHON_RST = previousEnablePythonRst;
+  }
+
+  if (previousRstPython === undefined) {
+    delete process.env.AMYTIS_RST_PYTHON;
+  } else {
+    process.env.AMYTIS_RST_PYTHON = previousRstPython;
+  }
+
+  resetPythonRstRendererAvailabilityForTests();
+});
 
 describe("markdown utils", () => {
   describe("generateExcerpt", () => {
@@ -124,4 +156,110 @@ describe("markdown utils", () => {
       expect(getAuthorSlug(" John Hu ")).toBe("john-hu");
     });
   });
+
+  describe("rST parsing fallbacks", () => {
+    test("uses markdown file mtime when frontmatter date and slug date are missing", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "amytis-md-"));
+      const filePath = path.join(tempDir, "legacy.mdx");
+      fs.writeFileSync(
+        filePath,
+        [
+          "---",
+          'title: "Legacy Markdown"',
+          "---",
+          "",
+          "Body",
+          "",
+        ].join("\n"),
+        "utf8",
+      );
+
+      const expectedDate = "2021-03-17";
+      const expectedTime = new Date(`${expectedDate}T12:00:00Z`);
+      fs.utimesSync(filePath, expectedTime, expectedTime);
+
+      try {
+        const post = parseMarkdownFileForTests(filePath, "legacy");
+        expect(post.date).toBe(expectedDate);
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    test("includes the source file path in rst parse errors", () => {
+      process.env.AMYTIS_ENABLE_PYTHON_RST = "0";
+
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "amytis-rst-"));
+      const filePath = path.join(tempDir, "broken.rst");
+      fs.writeFileSync(
+        filePath,
+        [
+          ":Date: 2021-16-15",
+          "",
+          "Broken Title",
+          "************",
+          "",
+          "Body",
+          "",
+        ].join("\n"),
+        "utf8",
+      );
+
+      try {
+        expect(() => parseRstFileForTests(filePath, "broken")).toThrow(
+          new RstParseError(`Invalid date: 2021-16-15 (${filePath})`)
+        );
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+
+    test("falls back to the legacy rst parser when python runtime is unavailable", () => {
+      process.env.AMYTIS_ENABLE_PYTHON_RST = "1";
+      process.env.AMYTIS_RST_PYTHON = "python-does-not-exist";
+      resetPythonRstRendererAvailabilityForTests();
+
+      const post = parseRstFileForTests(
+        path.join(process.cwd(), "content/series/rst-legacy/getting-started.rst"),
+        "getting-started",
+        undefined,
+        "rst-legacy",
+      );
+
+      expect(post.title).toBe("Getting Started With rST");
+      expect(post.renderedHtml).toBeUndefined();
+      expect(post.content).toContain("Overview\n--------");
+      expect(post.content).toContain(".. code-block:: ts");
+      expect(getPythonRstRendererAvailabilityForTests()).toBe(false);
+    });
+
+    test("uses rst file mtime when metadata date and slug date are missing", () => {
+      process.env.AMYTIS_ENABLE_PYTHON_RST = "0";
+
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "amytis-rst-"));
+      const filePath = path.join(tempDir, "legacy.rst");
+      fs.writeFileSync(
+        filePath,
+        [
+          "Legacy rST",
+          "**********",
+          "",
+          "Body",
+          "",
+        ].join("\n"),
+        "utf8",
+      );
+
+      const expectedDate = "2020-04-09";
+      const expectedTime = new Date(`${expectedDate}T12:00:00Z`);
+      fs.utimesSync(filePath, expectedTime, expectedTime);
+
+      try {
+        const post = parseRstFileForTests(filePath, "legacy");
+        expect(post.date).toBe(expectedDate);
+      } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    });
+  });
 });