@jant/core 0.6.16 → 0.7.0

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__/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"]);
+  });
 });

package/src/lib/__tests__/resolve-config.test.ts

@@ -31,9 +31,9 @@ describe("resolveConfig", () => {
     expect(config.publicApiEnabled).toBe(true);
     expect(config.rssFeedsEnabled).toBe(true);
     expect(config.demoMode).toBe(false);
-    expect(config.pageSize).toBe(50);
-    expect(config.searchPageSize).toBe(50);
-    expect(config.archivePageSize).toBe(50);
+    expect(config.pageSize).toBe(25);
+    expect(config.searchPageSize).toBe(25);
+    expect(config.archivePageSize).toBe(25);
     expect(config.rssFeedLimit).toBe(50);
     expect(config.rssPublishDelaySeconds).toBe(300);
   });
@@ -81,6 +81,34 @@ describe("resolveConfig", () => {
     expect(config.mainRssFeed).toBe("featured");
   });
 
+  it("resolves archiveDefaultLayout from DB, env, and defaults", () => {
+    const defaultConfig = resolveConfig(makeEnv(), {});
+    expect(defaultConfig.archiveDefaultLayout).toBe("list");
+
+    const envConfig = resolveConfig(
+      makeEnv({ ARCHIVE_DEFAULT_LAYOUT: "grid" }),
+      {},
+    );
+    expect(envConfig.archiveDefaultLayout).toBe("grid");
+
+    const dbConfig = resolveConfig(
+      makeEnv({ ARCHIVE_DEFAULT_LAYOUT: "list" }),
+      {
+        ARCHIVE_DEFAULT_LAYOUT: "grid",
+      },
+    );
+    expect(dbConfig.archiveDefaultLayout).toBe("grid");
+  });
+
+  it("falls back when the archive layout setting is invalid", () => {
+    const config = resolveConfig(
+      makeEnv({ ARCHIVE_DEFAULT_LAYOUT: "carousel" }),
+      {},
+    );
+
+    expect(config.archiveDefaultLayout).toBe("list");
+  });
+
   it("normalizes legacy time zone values from the database", () => {
     const config = resolveConfig(makeEnv(), { TIME_ZONE: "Beijing" });
 
@@ -172,6 +200,39 @@ describe("resolveConfig", () => {
     expect(config.siteAvatarUrl).toBe(
       "https://r2.example.com/media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
     );
+    // Without a transform there is nothing to size it down with, so the
+    // header falls back to the canonical asset.
+    expect(config.siteAvatarThumbUrl).toBe(config.siteAvatarUrl);
+  });
+
+  it("sizes the header avatar down when an image transform is configured", () => {
+    const config = resolveConfig(
+      makeEnv({
+        R2_PUBLIC_URL: "https://r2.example.com",
+        IMAGE_TRANSFORM_URL: "https://r2.example.com/cdn-cgi/image",
+        STORAGE_DRIVER: "r2",
+      }),
+      {
+        SITE_AVATAR:
+          "media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
+      },
+    );
+
+    // The canonical URL stays full-resolution: it is what the social card and
+    // the settings editor need.
+    expect(config.siteAvatarUrl).toBe(
+      "https://r2.example.com/media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
+    );
+    expect(config.siteAvatarThumbUrl).toBe(
+      "https://r2.example.com/cdn-cgi/image/width=128,quality=80,format=auto,fit=scale-down/https://r2.example.com/media/sit_test00000000000000000000000/assets/avatar/avatar.jpg",
+    );
+  });
+
+  it("leaves both avatar URLs empty without a stored avatar", () => {
+    const config = resolveConfig(makeEnv({}), {});
+
+    expect(config.siteAvatarUrl).toBe("");
+    expect(config.siteAvatarThumbUrl).toBe("");
   });
 
   it("returns empty siteAvatarUrl when no avatar set", () => {

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

@@ -9,11 +9,12 @@ import {
   CreatePostApiSchema,
   UpdatePostSchema,
   UpdatePostApiSchema,
-  SetupSchema,
+  SetupAccountSchema,
   SigninSchema,
   UpdateSiteSettingsSchema,
   normalizeEmail,
   parseFormData,
+  PostFilterSelectionSchema,
   parseFormDataOptional,
   validateAttachmentCount,
 } from "../schemas.js";
@@ -75,10 +76,9 @@ describe("normalizeEmail", () => {
   });
 });
 
-describe("SetupSchema", () => {
+describe("SetupAccountSchema", () => {
   it("normalizes email before returning parsed data", () => {
-    const result = SetupSchema.parse({
-      siteName: "Jant",
+    const result = SetupAccountSchema.parse({
       email: "  Admin@Example.COM ",
       password: "password123",
     });
@@ -816,3 +816,41 @@ describe("validateAttachmentCount", () => {
     );
   });
 });
+
+describe("PostFilterSelectionSchema", () => {
+  it("accepts a selection a smart collection may store", () => {
+    const result = PostFilterSelectionSchema.safeParse({
+      format: "note",
+      media: "any",
+      visibility: "featured",
+      collection: ["col_01m0f291t3fzvte3vj2g8d611z"],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it("accepts the empty selection, which means every post", () => {
+    expect(PostFilterSelectionSchema.safeParse({}).success).toBe(true);
+  });
+
+  it("refuses the private visibility a smart collection can never name", () => {
+    expect(
+      PostFilterSelectionSchema.safeParse({ visibility: "private" }).success,
+    ).toBe(false);
+  });
+
+  it("refuses a key that is not a dimension", () => {
+    expect(
+      PostFilterSelectionSchema.safeParse({ language: "en" }).success,
+    ).toBe(false);
+  });
+
+  it("names the condition it rejected", () => {
+    const result = PostFilterSelectionSchema.safeParse({ year: 1970 });
+    expect(result.success).toBe(false);
+    if (result.success) return;
+    expect(result.error.issues[0]?.path).toEqual(["year"]);
+    expect(result.error.issues[0]?.message).toBe(
+      "Invalid value for the year condition",
+    );
+  });
+});

package/src/lib/__tests__/site-unavailable-page.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { renderSiteUnavailablePage } from "../site-unavailable-page.js";
+
+describe("renderSiteUnavailablePage", () => {
+  it("links back to the configured hosting provider", () => {
+    const html = renderSiteUnavailablePage({
+      HOSTED_CONTROL_PLANE_BASE_URL: "https://cloud-jant.localtest.me",
+      HOSTED_CONTROL_PLANE_PROVIDER_NAME: "Jant Cloud",
+      SITE_RESOLUTION_MODE: "host-based",
+    });
+
+    expect(html).toContain("This site is offline");
+    expect(html).toContain(
+      '<a href="https://cloud-jant.localtest.me/app">Jant Cloud</a>',
+    );
+  });
+
+  it("stays provider-neutral when no control plane is configured", () => {
+    const html = renderSiteUnavailablePage({});
+
+    expect(html).toContain("There's nothing to read here right now");
+    expect(html).toContain("sign in to your hosting provider");
+    expect(html).not.toContain("<a ");
+  });
+});