@jant/core 0.6.15 → 0.7.0

package/src/lib/__tests__/slug.test.ts

@@ -95,6 +95,24 @@ describe("generatePostSlug", () => {
         }),
       ).rejects.toThrow("Could not generate a unique slug");
     });
+
+    it("romanizes Korean titles", async () => {
+      const slug = await generatePostSlug({
+        title: "개발 일지",
+        idLength: 5,
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toBe("gaebal-ilji");
+    });
+
+    it("falls back to random IDs for kanji-heavy Japanese titles", async () => {
+      const slug = await generatePostSlug({
+        title: "日本語のタイトルです",
+        idLength: 5,
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toMatch(/^[a-z0-9]{5}-[a-z0-9]{5}$/);
+    });
   });
 
   describe("random slug (no title, no slug)", () => {
@@ -123,4 +141,74 @@ describe("generatePostSlug", () => {
       ).rejects.toThrow("Could not generate a unique slug");
     });
   });
+
+  describe("language suffix", () => {
+    /** Every slug is taken except the ones listed. */
+    const onlyAvailable = (...free: string[]) => {
+      const allowed = new Set(free);
+      return async (slug: string) => allowed.has(slug);
+    };
+
+    it("is not used when the base slug is free", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: alwaysAvailable,
+      });
+      expect(slug).toBe("book-review");
+    });
+
+    it("is tried before a random suffix when the base collides", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: onlyAvailable("book-review-en"),
+      });
+      expect(slug).toBe("book-review-en");
+    });
+
+    it("keeps the multi-part tag intact", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "zh-hant",
+        isAvailable: onlyAvailable("book-review-zh-hant"),
+      });
+      expect(slug).toBe("book-review-zh-hant");
+    });
+
+    it("falls back to a random suffix when the language slug is taken too", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: async (candidate: string) =>
+          candidate !== "book-review" && candidate !== "book-review-en",
+      });
+      expect(slug).toMatch(/^book-review-[a-z0-9]{5}$/);
+    });
+
+    it("goes straight to a random suffix without one", async () => {
+      const slug = await generatePostSlug({
+        title: "Book Review",
+        idLength: 5,
+        isAvailable: async (candidate: string) => candidate !== "book-review",
+      });
+      expect(slug).toMatch(/^book-review-[a-z0-9]{5}$/);
+    });
+
+    it("skips a language candidate that lands on a reserved path", async () => {
+      const slug = await generatePostSlug({
+        title: "feed",
+        idLength: 5,
+        languageSuffix: "en",
+        isAvailable: alwaysAvailable,
+      });
+      // "feed" is reserved, so the base is never offered and the language
+      // candidate is never reached — the random fallback owns this case.
+      expect(slug).toMatch(/^feed-[a-z0-9]{5}$/);
+    });
+  });
 });

package/src/lib/__tests__/slugify.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "vitest";
+import { slugify } from "../slugify.js";
+
+describe("slugify", () => {
+  it("converts text to lowercase hyphenated slug", () => {
+    expect(slugify("Hello World")).toBe("hello-world");
+  });
+
+  it("removes special characters", () => {
+    expect(slugify("Hello World! This is a Test.")).toBe(
+      "hello-world-this-is-a-test",
+    );
+  });
+
+  it("collapses multiple spaces", () => {
+    expect(slugify("Multiple   Spaces")).toBe("multiple-spaces");
+  });
+
+  it("trims leading/trailing whitespace and hyphens", () => {
+    expect(slugify("  Multiple   Spaces  ")).toBe("multiple-spaces");
+  });
+
+  it("replaces underscores with hyphens", () => {
+    expect(slugify("hello_world")).toBe("hello-world");
+  });
+
+  it("handles already-slugified text", () => {
+    expect(slugify("already-a-slug")).toBe("already-a-slug");
+  });
+
+  it("handles empty string", () => {
+    expect(slugify("")).toBe("");
+  });
+
+  it("transliterates accented characters", () => {
+    expect(slugify("café & résumé")).toBe("cafe-and-resume");
+  });
+
+  it("converts Chinese characters to pinyin", () => {
+    expect(slugify("书评")).toBe("shu-ping");
+  });
+
+  it("handles mixed Chinese and English text", () => {
+    expect(slugify("我的 Blog")).toBe("wo-de-blog");
+  });
+
+  it("handles CJK characters with spaces", () => {
+    expect(slugify("电影 评论")).toBe("dian-ying-ping-lun");
+  });
+
+  it("romanizes Korean titles", () => {
+    expect(slugify("안녕하세요 세계")).toBe("annyeonghaseyo-segye");
+    expect(slugify("개발 일지 3일차")).toBe("gaebal-ilji-3ilcha");
+  });
+
+  it("romanizes kana-only Japanese titles", () => {
+    expect(slugify("カタカナタイトル")).toBe("katakanataitoru");
+    expect(slugify("ハンバーガー")).toBe("hanbaga");
+  });
+
+  it("keeps Latin words in mostly-kana Japanese titles", () => {
+    expect(slugify("React入門ガイド")).toBe("react-gaido");
+  });
+
+  it("returns empty for kanji-heavy Japanese titles instead of garbling them", () => {
+    // Kanji carries the meaning; without a reading dictionary any output
+    // would be gibberish, so callers should fall back to a random ID.
+    expect(slugify("日本語のタイトルです")).toBe("");
+    expect(slugify("東京タワーに行った")).toBe("");
+    expect(slugify("こんにちは世界")).toBe("");
+  });
+
+  it("returns empty for scripts with no usable transliteration", () => {
+    expect(slugify("שלום עולם")).toBe("");
+    expect(slugify("สวัสดีชาวโลก")).toBe("");
+  });
+
+  it("returns empty when most of the title is untransliterable", () => {
+    expect(slugify("שלום world")).toBe("");
+  });
+
+  it("returns empty for emoji-only titles", () => {
+    expect(slugify("🎉🎉")).toBe("");
+  });
+});

package/src/lib/__tests__/storage.test.ts

@@ -210,6 +210,38 @@ describe("createS3Driver", () => {
       "x-amz-checksum-sha256": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=",
     });
   });
+
+  it("omits a request checksum when the caller did not supply one", async () => {
+    const driver = createS3Driver({
+      endpoint: "https://s3.example.com",
+      bucket: "jant-media",
+      accessKeyId: "access-key",
+      secretAccessKey: "secret-key",
+      region: "auto",
+    });
+
+    const presigned = await driver.presignPut?.("media/test.webp", {
+      contentType: "image/webp",
+      contentDisposition: "inline",
+      cacheControl: "public, max-age=31536000, immutable",
+      expiresInSeconds: 900,
+    });
+
+    if (!presigned) {
+      throw new Error("Expected presigned PUT target");
+    }
+
+    // Presigning runs with an empty body, so a default request checksum would
+    // pin CRC32-of-nothing to the URL and every real upload would 400.
+    const params = new URL(presigned.url).searchParams;
+    expect(params.has("x-amz-checksum-crc32")).toBe(false);
+    expect(params.has("x-amz-sdk-checksum-algorithm")).toBe(false);
+    expect(presigned.headers).toEqual({
+      "Content-Type": "image/webp",
+      "Content-Disposition": "inline",
+      "Cache-Control": "public, max-age=31536000, immutable",
+    });
+  });
 });
 
 describe("createR2Driver", () => {

package/src/lib/__tests__/thread-fold.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, it } from "vitest";
+import {
+  foldThreadReplies,
+  getThreadHiddenCount,
+  THREAD_LEADING_REPLIES,
+  THREAD_TRAILING_REPLIES,
+} from "../thread-fold.js";
+
+const reply = (n: number) => ({ id: `reply-${n}` });
+const replies = (count: number) =>
+  Array.from({ length: count }, (_unused, index) => reply(index + 1));
+
+const ids = (list: { id: string }[]) => list.map((item) => item.id);
+
+describe("foldThreadReplies", () => {
+  it("has no fold for a thread with no replies", () => {
+    expect(foldThreadReplies([])).toBeNull();
+  });
+
+  // The window is the first two plus the last three, so anything up to six
+  // posts arrives whole and there is nothing for a gap link to stand for.
+  it.each([1, 2, 3, 4, 5])("hides nothing with %i replies", (count) => {
+    const fold = foldThreadReplies(replies(count));
+
+    expect(fold?.hiddenCount).toBe(0);
+    expect(fold?.firstHiddenReply).toBeNull();
+    // Every reply is shown exactly once, the hero included.
+    const shown = [
+      ...ids(fold?.leadingReplies ?? []),
+      ...ids(fold?.trailingReplies ?? []),
+      fold?.latestReply.id,
+    ];
+    expect(new Set(shown).size).toBe(shown.length);
+    expect(shown.length).toBe(count);
+  });
+
+  // The shortest thread puts one reply in every role at once. It must still
+  // be rendered once, not three times.
+  it("shows a lone reply once, as the hero", () => {
+    const fold = foldThreadReplies(replies(1));
+
+    expect(fold?.latestReply.id).toBe("reply-1");
+    expect(fold?.leadingReplies).toEqual([]);
+    expect(fold?.trailingReplies).toEqual([]);
+  });
+
+  it("folds the middle out of a long thread", () => {
+    const fold = foldThreadReplies(replies(7));
+
+    expect(ids(fold?.leadingReplies ?? [])).toEqual(["reply-1", "reply-2"]);
+    expect(ids(fold?.trailingReplies ?? [])).toEqual(["reply-5", "reply-6"]);
+    expect(fold?.latestReply.id).toBe("reply-7");
+    expect(fold?.hiddenCount).toBe(2);
+  });
+
+  // The gap stands for a run of posts and opens the first of them, so a reader
+  // following it lands where the missing stretch starts.
+  it("points the gap at the earliest post it hides", () => {
+    expect(foldThreadReplies(replies(20))?.firstHiddenReply?.id).toBe(
+      "reply-3",
+    );
+  });
+
+  it("keeps the window fixed however long the thread runs", () => {
+    const fold = foldThreadReplies(replies(50));
+    const shown =
+      (fold?.leadingReplies.length ?? 0) +
+      (fold?.trailingReplies.length ?? 0) +
+      1;
+
+    expect(shown).toBe(THREAD_LEADING_REPLIES + THREAD_TRAILING_REPLIES);
+    expect(fold?.hiddenCount).toBe(50 - shown);
+  });
+});
+
+describe("getThreadHiddenCount", () => {
+  // The site selects its buckets in SQL and they overlap on short threads, so
+  // the count has to dedupe rather than subtract two lengths.
+  it("counts a reply in two buckets once", () => {
+    expect(
+      getThreadHiddenCount({
+        leadingReplies: [reply(1), reply(2)],
+        trailingReplies: [reply(1)],
+        latestReply: reply(2),
+        totalReplyCount: 2,
+      }),
+    ).toBe(0);
+  });
+
+  it("counts what a long thread leaves out", () => {
+    expect(
+      getThreadHiddenCount({
+        leadingReplies: [reply(1), reply(2)],
+        trailingReplies: [reply(6), reply(7)],
+        latestReply: reply(8),
+        totalReplyCount: 8,
+      }),
+    ).toBe(3);
+  });
+
+  // A reply published between the count and the selection would otherwise
+  // report a negative number of hidden posts.
+  it("never goes below zero", () => {
+    expect(
+      getThreadHiddenCount({
+        leadingReplies: [reply(1), reply(2)],
+        trailingReplies: [],
+        latestReply: reply(3),
+        totalReplyCount: 1,
+      }),
+    ).toBe(0);
+  });
+});

package/src/lib/__tests__/translit.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect } from "vitest";
+import { hangulToLatin, kanaToRomaji } from "../translit.js";
+
+describe("hangulToLatin", () => {
+  it("romanizes basic syllables", () => {
+    expect(hangulToLatin("안녕하세요")).toBe("annyeonghaseyo");
+  });
+
+  it("applies liaison before silent-ㅇ syllables", () => {
+    expect(hangulToLatin("한국어")).toBe("hangugeo");
+    expect(hangulToLatin("일지")).toBe("ilji");
+  });
+
+  it("drops carried ㅎ in liaison", () => {
+    expect(hangulToLatin("좋아")).toBe("joa");
+  });
+
+  it("splits compound finals in liaison", () => {
+    expect(hangulToLatin("읽어")).toBe("ilgeo");
+    expect(hangulToLatin("값이")).toBe("gapsi");
+  });
+
+  it("keeps final ㅇ as ng before vowels", () => {
+    expect(hangulToLatin("강아지")).toBe("gangaji");
+  });
+
+  it("uses phonetic finals", () => {
+    expect(hangulToLatin("옷")).toBe("ot");
+    expect(hangulToLatin("부엌")).toBe("bueok");
+  });
+
+  it("preserves spaces and non-hangul characters", () => {
+    expect(hangulToLatin("개발 일지 3일차")).toBe("gaebal ilji 3ilcha");
+    expect(hangulToLatin("React 공부")).toBe("React gongbu");
+  });
+
+  it("romanizes standalone compatibility jamo", () => {
+    expect(hangulToLatin("ㅋㅋㅋ")).toBe("kkk");
+    expect(hangulToLatin("ㅠㅠ")).toBe("yuyu");
+  });
+});
+
+describe("kanaToRomaji", () => {
+  it("romanizes hiragana", () => {
+    expect(kanaToRomaji("こんにちは")).toBe("konnichiha");
+  });
+
+  it("romanizes katakana", () => {
+    expect(kanaToRomaji("カタカナタイトル")).toBe("katakanataitoru");
+  });
+
+  it("drops the chōonpu long-vowel mark", () => {
+    expect(kanaToRomaji("ハンバーガー")).toBe("hanbaga");
+    expect(kanaToRomaji("ラーメン")).toBe("ramen");
+  });
+
+  it("geminates consonants after sokuon", () => {
+    expect(kanaToRomaji("がっこう")).toBe("gakkou");
+    expect(kanaToRomaji("きっぷ")).toBe("kippu");
+  });
+
+  it("uses tch for sokuon before chi", () => {
+    expect(kanaToRomaji("まっちゃ")).toBe("matcha");
+  });
+
+  it("handles digraphs", () => {
+    expect(kanaToRomaji("きょうと")).toBe("kyouto");
+    expect(kanaToRomaji("しゃしん")).toBe("shashin");
+    expect(kanaToRomaji("じゅんび")).toBe("junbi");
+  });
+
+  it("handles extended katakana combos", () => {
+    expect(kanaToRomaji("ファン")).toBe("fan");
+    expect(kanaToRomaji("パーティー")).toBe("pati");
+    expect(kanaToRomaji("チェック")).toBe("chekku");
+    expect(kanaToRomaji("ヴァイオリン")).toBe("vaiorin");
+  });
+
+  it("passes non-kana characters through unchanged", () => {
+    expect(kanaToRomaji("東京タワー")).toBe("東京tawa");
+    expect(kanaToRomaji("abc カフェ")).toBe("abc kafe");
+  });
+
+  it("ignores a dangling sokuon", () => {
+    expect(kanaToRomaji("あっ")).toBe("a");
+  });
+});

package/src/lib/__tests__/upload-sideload.test.ts

@@ -64,6 +64,20 @@ describe("sniffImageMimeType", () => {
     expect(sniffImageMimeType(bytes)).toBe("image/avif");
   });
 
+  it.each(["heic", "heix", "hevc", "hevx", "mif1", "msf1"])(
+    "detects HEIC/HEIF via the %s ftyp brand",
+    (brand) => {
+      const bytes = new Uint8Array(16);
+      bytes.set([...new TextEncoder().encode("ftyp")], 4);
+      bytes.set([...new TextEncoder().encode(brand)], 8);
+      expect(sniffImageMimeType(bytes)).toBe("image/heic");
+    },
+  );
+
+  it("keeps HEIC out of the sideload formats", () => {
+    expect(isAllowedSideloadImageType("image/heic")).toBe(false);
+  });
+
   it("detects SVG from an <svg> root", () => {
     const svg = new TextEncoder().encode(
       '<?xml version="1.0"?>\n<svg xmlns="http://www.w3.org/2000/svg"></svg>',

package/src/lib/__tests__/url-fetch.test.ts

@@ -83,8 +83,7 @@ describe("fetchImageBytes", () => {
     );
 
     const headers = fetchMock.mock.calls[0]?.[1]?.headers as
-      | Record<string, string>
-      | undefined;
+      Record<string, string> | undefined;
     expect(headers?.Referer).toBe("https://img9.doubanio.com/");
   });
 

package/src/lib/__tests__/url.test.ts

@@ -4,9 +4,12 @@ import {
   extractDisplayDomain,
   isFullUrl,
   isSafeAbsoluteUrl,
+  looksLikeAddress,
   normalizePath,
+  sanitizeRichTextHref,
+  sanitizeUrl,
   stripSitePathPrefix,
-  slugify,
+  toInternalPath,
   toSameSitePath,
 } from "../url.js";
 
@@ -211,62 +214,118 @@ describe("isSafeAbsoluteUrl", () => {
   });
 });
 
-describe("slugify", () => {
-  it("converts text to lowercase hyphenated slug", () => {
-    expect(slugify("Hello World")).toBe("hello-world");
+describe("URL sanitizers", () => {
+  it("keeps action protocols scoped to rich-text links", () => {
+    expect(sanitizeRichTextHref("tel:+15551234567")).toBe("tel:+15551234567");
+    expect(sanitizeRichTextHref("sms:xxxxx@xx.com")).toBe("sms:xxxxx@xx.com");
+
+    expect(sanitizeUrl("tel:+15551234567")).toBe("");
+    expect(sanitizeUrl("sms:xxxxx@xx.com")).toBe("");
   });
 
-  it("removes special characters", () => {
-    expect(slugify("Hello World! This is a Test.")).toBe(
-      "hello-world-this-is-a-test",
-    );
+  it("rejects executable protocols in every context", () => {
+    expect(sanitizeRichTextHref("javascript:alert(1)")).toBe("");
+    expect(sanitizeRichTextHref("data:text/html,<h1>Hi</h1>")).toBe("");
+    expect(sanitizeUrl("javascript:alert(1)")).toBe("");
   });
+});
 
-  it("collapses multiple spaces", () => {
-    expect(slugify("Multiple   Spaces")).toBe("multiple-spaces");
+describe("stripSitePathPrefix", () => {
+  it("rewrites prefixed asset paths into the internal asset namespace", () => {
+    expect(stripSitePathPrefix("/blog/_assets/client.css", "/blog")).toBe(
+      "/_assets/client.css",
+    );
   });
 
-  it("trims leading/trailing whitespace and hyphens", () => {
-    expect(slugify("  Multiple   Spaces  ")).toBe("multiple-spaces");
+  it("rejects paths outside the configured site prefix", () => {
+    expect(stripSitePathPrefix("/_assets/client.css", "/blog")).toBe(null);
   });
+});
 
-  it("replaces underscores with hyphens", () => {
-    expect(slugify("hello_world")).toBe("hello-world");
+describe("looksLikeAddress", () => {
+  it("recognizes what a browser would have produced", () => {
+    expect(looksLikeAddress("/about")).toBe(true);
+    expect(looksLikeAddress("  https://example.com/about  ")).toBe(true);
   });
 
-  it("handles already-slugified text", () => {
-    expect(slugify("already-a-slug")).toBe("already-a-slug");
+  it("leaves search words alone", () => {
+    // The line that keeps a picker's search box a search box: "about" is a
+    // word someone is looking for, not the page /about.
+    expect(looksLikeAddress("about")).toBe(false);
+    expect(looksLikeAddress("coffee notes")).toBe(false);
+    expect(looksLikeAddress("example.com")).toBe(false);
   });
+});
 
-  it("handles empty string", () => {
-    expect(slugify("")).toBe("");
+describe("toInternalPath", () => {
+  const SITE = {
+    siteOrigins: ["https://example.com"],
+    sitePathPrefix: "/blog",
+    languagePrefixes: ["zh-hans", "en"],
+  };
+
+  it("reads a path, a full URL, and a prefixed URL as the same page", () => {
+    expect(toInternalPath("/about", SITE)).toBe("/about");
+    expect(toInternalPath("about", SITE)).toBe("/about");
+    expect(toInternalPath("https://example.com/blog/about", SITE)).toBe(
+      "/about",
+    );
+    expect(toInternalPath("/blog/about", SITE)).toBe("/about");
+    // A typed path without the deployment prefix still means this site.
+    expect(toInternalPath("/about", SITE)).toBe("/about");
   });
 
-  it("transliterates accented characters", () => {
-    expect(slugify("café & résumé")).toBe("cafe-and-resume");
+  it("strips a language prefix, because a view is not another page", () => {
+    expect(toInternalPath("/en/about", SITE)).toBe("/about");
+    expect(toInternalPath("https://example.com/blog/zh-hans/about", SITE)).toBe(
+      "/about",
+    );
+    // The prefix alone is that view's home.
+    expect(toInternalPath("/en", SITE)).toBe("/");
   });
 
-  it("converts Chinese characters to pinyin", () => {
-    expect(slugify("书评")).toBe("shu-ping");
+  it("keeps a first segment that only looks like a language", () => {
+    // A single-language site is free to have a post at /en — nothing is
+    // serving a view there.
+    expect(toInternalPath("/en/about", { sitePathPrefix: "" })).toBe(
+      "/en/about",
+    );
   });
 
-  it("handles mixed Chinese and English text", () => {
-    expect(slugify("我的 Blog")).toBe("wo-de-blog");
+  it("matches any host the site answers on", () => {
+    const origins = {
+      siteOrigins: ["https://example.com", "https://alias.dev"],
+    };
+    expect(toInternalPath("https://alias.dev/about", origins)).toBe("/about");
+    // Scheme and port differ in dev; the host is what decides.
+    expect(toInternalPath("http://example.com:8787/about", origins)).toBe(
+      "/about",
+    );
   });
 
-  it("handles CJK characters with spaces", () => {
-    expect(slugify("电影 评论")).toBe("dian-ying-ping-lun");
+  it("refuses everything that is not a page on this site", () => {
+    expect(toInternalPath("https://other.com/about", SITE)).toBeNull();
+    expect(toInternalPath("mailto:hi@example.com", SITE)).toBeNull();
+    expect(toInternalPath("tel:+15551234567", SITE)).toBeNull();
+    expect(toInternalPath("//other.com/about", SITE)).toBeNull();
+    expect(toInternalPath("#section", SITE)).toBeNull();
+    expect(toInternalPath("   ", SITE)).toBeNull();
+    // A full URL inside our host but outside the deployment.
+    expect(
+      toInternalPath("https://example.com/other-app/about", SITE),
+    ).toBeNull();
   });
-});
 
-describe("stripSitePathPrefix", () => {
-  it("rewrites prefixed asset paths into the internal asset namespace", () => {
-    expect(stripSitePathPrefix("/blog/_assets/client.css", "/blog")).toBe(
-      "/_assets/client.css",
-    );
+  it("drops the query unless the caller is navigating", () => {
+    expect(toInternalPath("/about?ref=x#top", SITE)).toBe("/about");
+    expect(
+      toInternalPath("/about?ref=x#top", { ...SITE, keepQuery: true }),
+    ).toBe("/about?ref=x#top");
   });
 
-  it("rejects paths outside the configured site prefix", () => {
-    expect(stripSitePathPrefix("/_assets/client.css", "/blog")).toBe(null);
+  it("normalizes trailing slashes and relative steps", () => {
+    expect(toInternalPath("/about/", SITE)).toBe("/about");
+    expect(toInternalPath("/collections/../about", SITE)).toBe("/about");
+    expect(toInternalPath("/", SITE)).toBe("/");
   });
 });