@hutusi/amytis 1.14.0 → 1.16.0

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,38 @@
-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,
+  calculateReadingMinutes,
+  calculateWordCount,
+  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", () => {
@@ -34,38 +67,80 @@ describe("markdown utils", () => {
     });
   });
 
-  describe("calculateReadingTime", () => {
-    test("short content returns 1 min read", () => {
+  describe("calculateReadingMinutes", () => {
+    test("short content returns 1 minute (floor)", () => {
       const text = "Hello world, this is a short post.";
-      expect(calculateReadingTime(text)).toBe("1 min read");
+      expect(calculateReadingMinutes(text)).toBe(1);
     });
 
-    test("600 words returns 3 min read", () => {
+    test("600 words returns 3 minutes", () => {
       const words = Array(600).fill("word").join(" ");
-      expect(calculateReadingTime(words)).toBe("3 min read");
+      expect(calculateReadingMinutes(words)).toBe(3);
     });
 
-    test("empty content returns 1 min read", () => {
-      expect(calculateReadingTime("")).toBe("1 min read");
+    test("empty content returns 1 (floor)", () => {
+      expect(calculateReadingMinutes("")).toBe(1);
     });
 
     test("strips markdown formatting before counting", () => {
       // 400 actual words surrounded by markdown syntax
       const words = Array(400).fill("**word**").join(" ");
-      const result = calculateReadingTime(words);
-      expect(result).toBe("2 min read");
+      expect(calculateReadingMinutes(words)).toBe(2);
     });
 
-    test("counts Chinese characters for reading time", () => {
+    test("counts Chinese characters at 300 cpm", () => {
       const han = "中".repeat(600);
-      expect(calculateReadingTime(han)).toBe("2 min read");
+      expect(calculateReadingMinutes(han)).toBe(2);
     });
 
     test("combines Latin words and Chinese characters", () => {
       const latinWords = Array(200).fill("word").join(" ");
       const han = "中".repeat(300);
       const mixed = `${latinWords} ${han}`;
-      expect(calculateReadingTime(mixed)).toBe("2 min read");
+      expect(calculateReadingMinutes(mixed)).toBe(2);
+    });
+  });
+
+  describe("calculateWordCount", () => {
+    test("empty content returns 0", () => {
+      expect(calculateWordCount("")).toBe(0);
+    });
+
+    test("Latin words: each whitespace-bounded token counts once", () => {
+      expect(calculateWordCount("Hello world, this is a short post.")).toBe(7);
+      expect(calculateWordCount(Array(600).fill("word").join(" "))).toBe(600);
+    });
+
+    test("Chinese characters count per-character", () => {
+      expect(calculateWordCount("中".repeat(600))).toBe(600);
+    });
+
+    test("mixed Latin + Chinese sums both counts", () => {
+      const latin = Array(200).fill("word").join(" ");
+      const han = "中".repeat(300);
+      expect(calculateWordCount(`${latin} ${han}`)).toBe(500);
+    });
+
+    test("strips fenced code blocks before counting", () => {
+      const src = ["pre", "```", "code line one two three", "```", "post"].join("\n");
+      // Only "pre" and "post" count.
+      expect(calculateWordCount(src)).toBe(2);
+    });
+
+    test("strips inline HTML tags before counting", () => {
+      expect(calculateWordCount("hello <span>world</span> again")).toBe(3);
+    });
+
+    test("strips markdown link syntax, keeps link text", () => {
+      expect(calculateWordCount("See [the docs](https://example.com) here")).toBe(4);
+    });
+
+    test("matches calculateReadingMinutes on the same input", () => {
+      // The two metrics share a tokenizer; both should agree on the underlying
+      // token counts. 600 Latin words → 600 wordCount, 3-minute reading time.
+      const text = Array(600).fill("word").join(" ");
+      expect(calculateWordCount(text)).toBe(600);
+      expect(calculateReadingMinutes(text)).toBe(3);
     });
   });
 
@@ -124,4 +199,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 });
+      }
+    });
+  });
 });