@jant/core 0.6.16 → 0.7.1

package/src/lib/__tests__/lang-detect.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Content language detection.
+ *
+ * The detector is a suggestion engine, so these tests care about two things:
+ * that it is right on the cases it claims to be reliable on (Hangul, kana,
+ * Simplified vs Traditional over a sentence), and that it refuses rather than
+ * guesses everywhere else — a wrong confident answer costs the author an edit
+ * they may never notice they need.
+ */
+
+import { describe, expect, it } from "vitest";
+import {
+  detectContentLanguage,
+  detectScript,
+  readContentLanguage,
+  suggestPostLanguage,
+} from "../lang-detect.js";
+
+describe("detectScript", () => {
+  it("reads Hangul as Korean", () => {
+    expect(detectScript("안녕하세요, 반갑습니다")).toBe("ko");
+  });
+
+  it("reads Korean mixed with hanja as Korean", () => {
+    // Korean borrows Han characters but never kana, so Hangul settles it.
+    expect(detectScript("韓國語 문법 정리")).toBe("ko");
+  });
+
+  it("reads kana as Japanese", () => {
+    expect(detectScript("これはテストです")).toBe("ja");
+    expect(detectScript("日本語の文章を書く")).toBe("ja");
+  });
+
+  it("reads Simplified-only characters as Simplified", () => {
+    expect(detectScript("国学说这时会对后")).toBe("zh-Hans");
+  });
+
+  it("reads Traditional-only characters as Traditional", () => {
+    expect(detectScript("國學說這時會對後")).toBe("zh-Hant");
+  });
+
+  it("decides a mixed passage by majority", () => {
+    // A Traditional post that quotes a short Simplified phrase.
+    expect(detectScript("這篇文章談的是國學說法，裡頭引了一句「这个」")).toBe(
+      "zh-Hant",
+    );
+  });
+
+  it("names the script but not the variant when the two sides tie", () => {
+    // Three distinctive characters each. Which variant is a coin toss; that
+    // the text is Chinese is not in doubt.
+    expect(detectScript("這個說这个说")).toBe("han");
+  });
+
+  it("names the script but not the variant for characters shared by both", () => {
+    // "我今天很好" is identical in Simplified and Traditional.
+    expect(detectScript("我今天很好")).toBe("han");
+    // Repetition across paragraphs adds length, never a distinguishing
+    // character — the case that first showed this up.
+    expect(detectScript("哈哈哈哈哈哈哈啊哈哈哈\n\n".repeat(5))).toBe("han");
+  });
+
+  it("reads Latin script as Latin, accents included", () => {
+    expect(detectScript("Hello there")).toBe("latin");
+    expect(detectScript("Café crème à Paris")).toBe("latin");
+  });
+
+  it("refuses text with no letters at all", () => {
+    expect(detectScript("123 — !!! 🙂")).toBeNull();
+    expect(detectScript("")).toBeNull();
+  });
+
+  it("refuses a fragment, whichever script it is in", () => {
+    // The first few characters of a post decide nothing — an answer here would
+    // change on the next keystroke, which is worse than no answer.
+    expect(detectScript("H")).toBeNull();
+    expect(detectScript("Hello")).toBeNull();
+    expect(detectScript("这会")).toBeNull();
+    expect(detectScript("こん")).toBeNull();
+  });
+
+  it("answers once there are a couple of words", () => {
+    expect(detectScript("Hello there")).toBe("latin");
+    expect(detectScript("这是中文")).toBe("zh-Hans");
+  });
+
+  it("reads a passage by what it is mostly in", () => {
+    // A Han character used to speak for the whole post no matter how much
+    // English surrounded it.
+    expect(
+      detectScript(
+        "The word 说 comes up in every other sentence of this chapter.",
+      ),
+    ).toBe("latin");
+    // ...and the reverse still holds: a Chinese passage quoting a English
+    // word is Chinese.
+    expect(detectScript("这篇讲的是国学时间，里头引了 React")).toBe("zh-Hans");
+  });
+});
+
+describe("detectContentLanguage", () => {
+  const zhEn = { languages: ["zh-Hans", "en"], fallback: "zh-Hans" };
+
+  it("picks the language matching the detected script", () => {
+    expect(detectContentLanguage("这是中文", zhEn)).toBe("zh-Hans");
+    expect(detectContentLanguage("This is English", zhEn)).toBe("en");
+  });
+
+  it("matches Simplified and Traditional as distinct languages", () => {
+    const both = {
+      languages: ["zh-Hans", "zh-Hant", "en"],
+      fallback: "zh-Hans",
+    };
+
+    expect(detectContentLanguage("國學說這時會對後", both)).toBe("zh-Hant");
+    expect(detectContentLanguage("国学说这时会对后", both)).toBe("zh-Hans");
+  });
+
+  it("matches a language tag that only implies its script", () => {
+    // The site configured zh-TW, not zh-Hant.
+    expect(
+      detectContentLanguage("國學說這時", {
+        languages: ["en", "zh-TW"],
+        fallback: "en",
+      }),
+    ).toBe("zh-TW");
+  });
+
+  it("will not choose between two non-CJK languages", () => {
+    // The Latin alphabet does not distinguish English from French.
+    expect(
+      detectContentLanguage("Bonjour tout le monde", {
+        languages: ["en", "fr", "ja"],
+        fallback: "en",
+      }),
+    ).toBe("en");
+  });
+
+  it("reads shared Han as the site's one Chinese language", () => {
+    // Text written the same way in both variants. With one of the two
+    // published there is nothing left to be ambiguous about.
+    expect(detectContentLanguage("哈哈哈哈哈哈哈啊哈哈哈", zhEn)).toBe(
+      "zh-Hans",
+    );
+    expect(
+      detectContentLanguage("我今天很好", {
+        languages: ["zh-TW", "en"],
+        fallback: "en",
+      }),
+    ).toBe("zh-TW");
+  });
+
+  it("reads shared Han as Simplified when that is the only language", () => {
+    // Nothing to weigh it against: every candidate the site has is Simplified
+    // Chinese, so text that is certainly Chinese is certainly that.
+    expect(
+      readContentLanguage("哈哈哈哈哈哈哈啊哈哈哈", {
+        languages: ["zh-Hans"],
+      }),
+    ).toBe("zh-Hans");
+  });
+
+  it("will not choose between Simplified and Traditional", () => {
+    // Both published, and the text distinguishes neither: the fallback is the
+    // only honest answer.
+    expect(
+      readContentLanguage("我今天很好", {
+        languages: ["zh-Hans", "zh-Hant", "en"],
+      }),
+    ).toBeNull();
+  });
+
+  it("falls back when the site does not publish the detected script", () => {
+    expect(
+      detectContentLanguage("これは日本語です", {
+        languages: ["zh-Hans", "en"],
+        fallback: "zh-Hans",
+      }),
+    ).toBe("zh-Hans");
+  });
+
+  it("never returns a language outside the configured set", () => {
+    const samples = [
+      "안녕하세요",
+      "これはテスト",
+      "國學說這時",
+      "国学说这时",
+      "Hello",
+      "12345",
+      "",
+    ];
+
+    for (const sample of samples) {
+      expect(zhEn.languages, sample).toContain(
+        detectContentLanguage(sample, zhEn),
+      );
+    }
+  });
+});
+
+describe("suggestPostLanguage", () => {
+  const site = { languages: ["zh-Hans", "en"], primary: "zh-Hans" };
+
+  it("reads the language out of the text", () => {
+    expect(suggestPostLanguage({ ...site, text: "Hello there" })).toBe("en");
+    expect(suggestPostLanguage({ ...site, text: "这是中文" })).toBe("zh-Hans");
+  });
+
+  it("falls back to the primary language for empty text", () => {
+    expect(suggestPostLanguage({ ...site, text: "   " })).toBe("zh-Hans");
+    expect(suggestPostLanguage(site)).toBe("zh-Hans");
+  });
+
+  it("keeps the primary language until the text says otherwise", () => {
+    // Half a word in: the composer shows the language of the page the author
+    // is writing from, and stays there until there is something to read.
+    expect(suggestPostLanguage({ ...site, text: "Hel" })).toBe("zh-Hans");
+    expect(suggestPostLanguage({ ...site, text: "Hello there" })).toBe("en");
+  });
+
+  it("returns null on a site that is not multilingual", () => {
+    // Nothing is stamped before the author turns the feature on.
+    expect(
+      suggestPostLanguage({
+        languages: [],
+        primary: "zh-Hans",
+        text: "Hello there",
+      }),
+    ).toBeNull();
+  });
+});

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

@@ -90,6 +90,111 @@ describe("markdownToTiptapJson", () => {
       expect(doc.content[0].content).toHaveLength(3);
     });
 
+    // Tiptap's own tokenizer gave an empty item no content at all, which the
+    // schema rejects and the Markdown serializer threw on.
+    it("gives an empty list item the paragraph the schema requires", () => {
+      const doc = parse("1. First\n2.\n3. Third");
+      expect(doc.content[0].type).toBe("orderedList");
+      expect(doc.content[0].content).toHaveLength(3);
+      expect(doc.content[0].content[1].type).toBe("listItem");
+      expect(doc.content[0].content[1].content).toMatchObject([
+        { type: "paragraph" },
+      ]);
+    });
+
+    it.each([
+      ["<strong>粗</strong>", "bold"],
+      ["<b>粗</b>", "bold"],
+      ["<em>斜</em>", "italic"],
+      ["<i>斜</i>", "italic"],
+      ["<s>删</s>", "strike"],
+      ["<del>删</del>", "strike"],
+    ])("reads %s as a %s mark", (html, mark) => {
+      const doc = parse(`前${html}后`);
+      const marked = doc.content[0].content.find(
+        (node: TiptapNode) => node.marks?.length,
+      );
+      expect(marked.marks).toEqual([{ type: mark }]);
+      expect(
+        doc.content[0].content.map((n: TiptapNode) => n.text).join(""),
+      ).toBe(`前${html.replace(/<[^>]+>/g, "")}后`);
+    });
+
+    it("parses Markdown inside an HTML emphasis tag", () => {
+      const doc = parse("<strong>[链接](https://example.com)。</strong>后");
+      const first = doc.content[0].content[0];
+      expect(first.text).toBe("链接");
+      expect(first.marks.map((mark: TiptapMark) => mark.type).sort()).toEqual([
+        "bold",
+        "link",
+      ]);
+    });
+
+    it.each([
+      '<strong onclick="alert(1)">x</strong>',
+      "<span>x</span>",
+      "<script>x</script>",
+    ])("keeps %j as text", (html) => {
+      const doc = parse(html);
+      expect(doc.content[0].content).toEqual([{ type: "text", text: html }]);
+    });
+
+    it("keeps an ordered list's start number", () => {
+      const doc = parse("3. Third\n4. Fourth");
+      expect(doc.content[0].type).toBe("orderedList");
+      expect(doc.content[0].attrs).toEqual({ start: 3 });
+    });
+
+    // CommonMark list markers are digits. Tiptap's own tokenizer also takes
+    // letters and roman numerals, which ate the first word of these lines.
+    it.each([
+      "Ps. 今天发现苹果尼日利亚区的终身会员",
+      "PS. 补充一句",
+      "Mr. Smith went to Washington.",
+      "No. 5 is here.",
+      "OK. Fine.",
+      "I. Introduction",
+      "a. first",
+      "mix. of words",
+    ])("keeps %j a paragraph", (line) => {
+      const doc = parse(line);
+      expect(doc.content).toEqual([
+        { type: "paragraph", content: [{ type: "text", text: line }] },
+      ]);
+    });
+
+    it("keeps a code block inside a list item exactly as written", () => {
+      const doc = parse(
+        [
+          "1. Create the project:",
+          "   ```bash",
+          "   ├── .github",
+          "   │   └── workflows",
+          "   └── package.json",
+          "   ```",
+          "2. Clone it",
+        ].join("\n"),
+      );
+      const list = doc.content[0];
+      expect(list.type).toBe("orderedList");
+      expect(list.content).toHaveLength(2);
+      const codeBlock = list.content[0].content.find(
+        (node: TiptapNode) => node.type === "codeBlock",
+      );
+      expect(codeBlock.content[0].text).toBe(
+        "├── .github\n│   └── workflows\n└── package.json",
+      );
+    });
+
+    it("keeps a wide marker's continuation lines intact", () => {
+      const doc = parse("10. Run:\n\n    ```sh\n    ls -la\n    ```");
+      const codeBlock = doc.content[0].content[0].content.find(
+        (node: TiptapNode) => node.type === "codeBlock",
+      );
+      expect(doc.content[0].attrs).toEqual({ start: 10 });
+      expect(codeBlock.content[0].text).toBe("ls -la");
+    });
+
     it("converts horizontal rules", () => {
       const doc = parse("Above\n\n---\n\nBelow");
       const hr = doc.content.find(

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

@@ -2,6 +2,16 @@ import { describe, it, expect } from "vitest";
 import { render, toPlainText, extractTitle } from "../markdown.js";
 
 describe("render", () => {
+  it("renders the HTML emphasis tags the serializer writes for CJK text", () => {
+    expect(render("而是：<strong>固定时间。</strong>来的人")).toBe(
+      "<p>而是：<strong>固定时间。</strong>来的人</p>",
+    );
+  });
+
+  it("escapes HTML tags outside the emphasis allowlist", () => {
+    expect(render("<span>x</span>")).toBe("<p>&lt;span&gt;x&lt;/span&gt;</p>");
+  });
+
   it("renders a heading", () => {
     const html = render("# Hello");
     expect(html).toContain("<h1>");

package/src/lib/__tests__/media-helpers.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from "vitest";
+import type { Media } from "../../types.js";
+import { buildMediaMap } from "../media-helpers.js";
+
+const R2_PUBLIC_URL = "https://cdn.example.com";
+const IMAGE_TRANSFORM_URL = "https://example.com/cdn-cgi/image";
+
+function makeMedia(overrides: Partial<Media> = {}): Media {
+  return {
+    id: "med_01j0000000000000000000000",
+    siteId: "sit_test00000000000000000000000",
+    postId: "pst_01j0000000000000000000000",
+    filename: "clip.mp4",
+    originalName: "clip.mp4",
+    mimeType: "video/mp4",
+    size: 4_000_000,
+    storageKey: "media/clip.mp4",
+    provider: "r2",
+    width: 1920,
+    height: 1080,
+    durationSeconds: 12,
+    alt: null,
+    position: "a0",
+    blurhash: null,
+    waveform: null,
+    posterKey: "posters/clip-poster.png",
+    summary: null,
+    chars: null,
+    mediaKind: "video",
+    createdAt: 1706745600,
+    updatedAt: 1706745600,
+    ...overrides,
+  };
+}
+
+function firstAttachment(media: Media) {
+  const map = buildMediaMap(
+    new Map([["pst_01j0000000000000000000000", [media]]]),
+    R2_PUBLIC_URL,
+    IMAGE_TRANSFORM_URL,
+  );
+  const list = map.get("pst_01j0000000000000000000000");
+  expect(list).toHaveLength(1);
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- length checked above
+  return list![0]!;
+}
+
+describe("buildMediaMap", () => {
+  it("sizes a video poster through the image transform", () => {
+    // A poster is a still frame at the source video's resolution, so an
+    // untransformed one puts the full-size original in the timeline. This is
+    // the same treatment `toMediaView` gives the field.
+    expect(firstAttachment(makeMedia()).posterUrl).toBe(
+      "https://example.com/cdn-cgi/image/width=640,quality=80,format=auto,fit=scale-down/https://cdn.example.com/posters/clip-poster.png",
+    );
+  });
+
+  it("leaves the poster URL untransformed when no transform is configured", () => {
+    const map = buildMediaMap(
+      new Map([["pst_01j0000000000000000000000", [makeMedia()]]]),
+      R2_PUBLIC_URL,
+    );
+    expect(map.get("pst_01j0000000000000000000000")?.[0]?.posterUrl).toBe(
+      "https://cdn.example.com/posters/clip-poster.png",
+    );
+  });
+
+  it("has no poster URL without a poster key", () => {
+    expect(
+      firstAttachment(makeMedia({ posterKey: null })).posterUrl,
+    ).toBeNull();
+  });
+
+  it("leaves a video's own URL alone", () => {
+    // Only images go through the transform; asking it to resize an mp4
+    // returns nothing useful.
+    expect(firstAttachment(makeMedia()).previewUrl).toBe(
+      "https://cdn.example.com/media/clip.mp4",
+    );
+  });
+});

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

@@ -1,6 +1,10 @@
 import type { Context } from "hono";
 import { describe, expect, it } from "vitest";
-import { getNavigationData } from "../navigation.js";
+import type { NavItemView } from "../../types.js";
+import {
+  collectNavigationCollectionIds,
+  getNavigationData,
+} from "../navigation.js";
 
 describe("getNavigationData", () => {
   it("renders site footer markdown through the shared pipeline", async () => {
@@ -99,6 +103,61 @@ describe("getNavigationData", () => {
     expect(result.links[1]?.url).toBe("/");
   });
 
+  it("hides the built-in Subscribe item when feeds are disabled", async () => {
+    const context = {
+      var: {
+        publicPath: "/",
+        appConfig: {
+          siteName: "Jant",
+          sitePathPrefix: "",
+          siteOrigin: "https://example.com",
+          siteDescription: "",
+          siteDescriptionExplicit: false,
+          siteAvatarUrl: "",
+          showHeaderAvatar: false,
+          siteFooter: "",
+          rssFeedsEnabled: false,
+        },
+        services: {
+          navItems: {
+            list: async () => [
+              {
+                id: "nav_subscribe",
+                type: "system",
+                systemKey: "subscribe",
+                label: "Subscribe",
+                url: "/subscribe",
+                placement: "header",
+                position: "a0",
+                createdAt: 1,
+                updatedAt: 1,
+              },
+              {
+                id: "nav_archive",
+                type: "system",
+                systemKey: "archive",
+                label: "All",
+                url: "/archive",
+                placement: "header",
+                position: "a1",
+                createdAt: 1,
+                updatedAt: 1,
+              },
+            ],
+          },
+          collections: { list: async () => [] },
+        },
+        isAuthenticated: false,
+        session: null,
+      },
+    } as unknown as Context;
+
+    const result = await getNavigationData(context);
+
+    // The page it addresses 404s without feeds, so the entry has to go too.
+    expect(result.links.map((link) => link.url)).toEqual(["/archive"]);
+  });
+
   it("hides only the built-in RSS item when feeds are disabled", async () => {
     const context = {
       var: {
@@ -153,4 +212,79 @@ describe("getNavigationData", () => {
 
     expect(result.links.map((link) => link.id)).toEqual(["nav_custom"]);
   });
+
+  // A post page's URL carries no language prefix, so its chrome is scoped by
+  // the post's language instead of the request path.
+  it("scopes the base path to an explicit language", async () => {
+    const makeContext = (languageScope: string) =>
+      ({
+        var: {
+          publicPath: "/some-post",
+          appConfig: {
+            siteName: "Jant",
+            sitePathPrefix: "",
+            siteDescription: "",
+            siteDescriptionExplicit: false,
+            siteAvatarUrl: "",
+            showHeaderAvatar: false,
+            siteFooter: "",
+            siteLanguage: "zh-Hans",
+            additionalLanguages: ["ja"],
+            multilingualEnabled: true,
+            rssFeedsEnabled: true,
+          },
+          services: {
+            navItems: {
+              list: async () => [
+                {
+                  id: "nav_latest",
+                  type: "system",
+                  systemKey: "latest",
+                  label: "Latest",
+                  url: "/",
+                  placement: "header",
+                  position: "a0",
+                  createdAt: 1,
+                  updatedAt: 1,
+                },
+              ],
+            },
+            collections: {
+              listByRecentActivity: async () => [],
+            },
+          },
+          isAuthenticated: false,
+          session: null,
+        },
+      }) as unknown as Context;
+
+    const japanese = await getNavigationData(makeContext("ja"), {
+      languageScope: "ja",
+    });
+    expect(japanese.basePath).toBe("/ja");
+    expect(japanese.links[0]?.url).toBe("/ja");
+
+    const primary = await getNavigationData(makeContext("zh-Hans"), {
+      languageScope: "zh-Hans",
+    });
+    expect(primary.basePath).toBe("");
+    expect(primary.links[0]?.url).toBe("/");
+  });
+});
+
+describe("collectNavigationCollectionIds", () => {
+  // The directory used to read only `collection` items, so a smart collection
+  // already in the navigation still offered "Add to Navigation".
+  it("names both kinds of collection and ignores everything else", () => {
+    const links = [
+      { id: "nav_1", type: "system", systemKey: "home" },
+      { id: "nav_2", type: "collection", collectionId: "col_1" },
+      { id: "nav_3", type: "smart_collection", smartCollectionId: "smc_1" },
+      { id: "nav_4", type: "link", url: "https://example.com" },
+      { id: "nav_5", type: "collection" },
+      { id: "nav_6", type: "smart_collection" },
+    ] as unknown as NavItemView[];
+
+    expect(collectNavigationCollectionIds(links)).toEqual(["col_1", "smc_1"]);
+  });
 });