@jant/core 0.6.16 → 0.7.0

package/src/__tests__/export-service.test.ts

@@ -99,6 +99,79 @@ function filesToMap(
 }
 
 describe("createExportService (Hugo)", () => {
+  // Hugo has its own summary rule and would cut somewhere else, so whether the
+  // timeline truncates a post is decided here and carried as front matter.
+  // Written only when true — a consumer reads its presence.
+  it("marks a truncated post in front matter and leaves a short one unmarked", async () => {
+    const para = (text: string) => ({
+      type: "paragraph",
+      content: [{ type: "text", text }],
+    });
+    const long = makePost({
+      id: "post-long",
+      slug: "long-read",
+      title: "A long read",
+      threadId: "post-long",
+      body: JSON.stringify({
+        type: "doc",
+        content: [
+          para("Alpha ".repeat(90).trim()),
+          para("Omega ".repeat(90).trim()),
+        ],
+      }),
+    });
+    const short = makePost({
+      id: "post-short",
+      slug: "short-note",
+      title: null,
+      threadId: "post-short",
+      body: JSON.stringify({ type: "doc", content: [para("Short enough.")] }),
+    });
+
+    const files = await createExportService(
+      {
+        posts: { list: async () => [long, short] },
+        paths: {
+          getPostSlugMap: async () =>
+            new Map([
+              ["post-long", "long-read"],
+              ["post-short", "short-note"],
+            ]),
+          getPostAliases: async () => new Map(),
+          getCollectionSlugMap: async () => new Map(),
+        },
+        collections: {
+          list: async () => [],
+          listDirectoryData: async () => ({
+            collections: [],
+            items: [],
+            directoryItems: [],
+          }),
+          getCollectionsByPostIds: async () => new Map(),
+          getCollectionEntriesByThreadIds: async () => new Map(),
+        },
+        media: { getByPostIds: async () => new Map() },
+      } as unknown as ServicesArg,
+      makeSiteConfig(),
+    ).generateHugoFiles();
+
+    const read = async (path: string) => {
+      const file = files.find((f) => f.path === path);
+      expect(file, `missing ${path}`).toBeDefined();
+      const { frontMatter } = await parseFrontMatter(
+        typeof file!.content === "string"
+          ? file!.content
+          : new TextDecoder().decode(file!.content),
+      );
+      return frontMatter;
+    };
+
+    expect((await read("content/long-read/_index.md")).truncated).toBe(true);
+    expect(
+      (await read("content/short-note/_index.md")).truncated,
+    ).toBeUndefined();
+  });
+
   it("emits a branch bundle per root post with YAML front matter in stable key order", async () => {
     const root = makePost({
       id: "post-root",
@@ -496,6 +569,164 @@ describe("createExportService (Hugo)", () => {
     expect(data).toContain('url = "/index.xml"');
   });
 
+  it("resolves the nav Subscribe link to the feed the page would recommend", async () => {
+    const service = createExportService(
+      buildServices({ posts: [] }),
+      makeSiteConfig({
+        mainRssFeed: "featured",
+        navItems: [
+          {
+            type: "system",
+            systemKey: "subscribe",
+            label: "",
+            url: "/subscribe",
+            position: 0,
+            placement: "more",
+          },
+        ],
+      }),
+    );
+    const data = filesToMap(await service.generateHugoFiles()).get(
+      "data/jant.toml",
+    ) as string;
+
+    // There is no /subscribe page in the exported site to link at.
+    expect(data).not.toContain('url = "/subscribe"');
+    expect(data).toContain('url = "/featured/index.xml"');
+    expect(data).toContain('label = "Subscribe"');
+  });
+
+  it("redirects every runtime feed address to its exported counterpart", async () => {
+    const service = createExportService(
+      buildServices({ posts: [] }),
+      makeSiteConfig({ mainRssFeed: "latest" }),
+    );
+    const redirects = filesToMap(await service.generateHugoFiles()).get(
+      "static/_redirects",
+    ) as string;
+
+    // Feed readers hold the runtime addresses; nothing in the Hugo tree
+    // answers them without these.
+    const rules = redirects
+      .split("\n")
+      .filter((l) => l.startsWith("/"))
+      .map((l) => l.split(/\s+/));
+    expect(new Map(rules.map((r) => [r[0], r[1]]))).toEqual(
+      new Map([
+        ["/feed", "/index.xml"],
+        ["/latest/feed", "/index.xml"],
+        ["/featured/feed", "/featured/index.xml"],
+        ["/archive/feed", "/archive/index.xml"],
+        // The 308 aliases the live site still answers.
+        ["/feed/latest", "/index.xml"],
+        ["/feed/all", "/index.xml"],
+        ["/feed/featured", "/featured/index.xml"],
+        ["/feed/atom.xml", "/index.xml"],
+        ["/feed/latest/atom.xml", "/index.xml"],
+        ["/feed/all/atom.xml", "/index.xml"],
+        ["/feed/featured/atom.xml", "/featured/index.xml"],
+        ["/:slug/feed", "/:slug/index.xml"],
+      ]),
+    );
+    // A feed reader follows a 301 and rewrites its stored address; a 302
+    // would leave it polling the dead one forever.
+    expect(rules.every((r) => r[2] === "301")).toBe(true);
+    // First match wins in both hosts that read this file, so the collection
+    // catch-all must not shadow the fixed sections.
+    expect(rules.at(-1)?.[0]).toBe("/:slug/feed");
+  });
+
+  it("points /feed at the featured feed when that is the site's main feed", async () => {
+    const service = createExportService(
+      buildServices({ posts: [] }),
+      makeSiteConfig({ mainRssFeed: "featured" }),
+    );
+    const redirects = filesToMap(await service.generateHugoFiles()).get(
+      "static/_redirects",
+    ) as string;
+
+    expect(redirects).toMatch(/^\/feed\s+\/featured\/index\.xml\s+301$/m);
+    expect(redirects).toMatch(
+      /^\/feed\/atom\.xml\s+\/featured\/index\.xml\s+301$/m,
+    );
+  });
+
+  it("falls back to the latest feed when no featured section was emitted", async () => {
+    // A post owning the `featured` slug takes the section's place, so
+    // /featured/index.xml is never built. Redirecting there would turn a live
+    // subscription into a 404; the latest feed is wider but real.
+    const service = createExportService(
+      buildServices({ posts: [makePost({ id: "post-1", slug: "featured" })] }),
+      makeSiteConfig({ mainRssFeed: "featured" }),
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+    const redirects = files.get("static/_redirects") as string;
+
+    // The post took the path the featured section would have used, so the
+    // section — and /featured/index.xml with it — was never built.
+    expect(files.get("content/featured/_index.md") as string).not.toContain(
+      "type: featured",
+    );
+    expect(redirects).not.toContain("/featured/index.xml");
+    expect(redirects).toMatch(/^\/feed\s+\/index\.xml\s+301$/m);
+    expect(redirects).toMatch(/^\/featured\/feed\s+\/index\.xml\s+301$/m);
+  });
+
+  it("writes no feed redirects when the site publishes no feeds", async () => {
+    const service = createExportService(
+      buildServices({ posts: [] }),
+      makeSiteConfig({ rssFeedsEnabled: false }),
+    );
+    const files = filesToMap(await service.generateHugoFiles());
+
+    expect(files.has("static/_redirects")).toBe(false);
+    expect(files.get("README.md") as string).not.toContain("## Feeds");
+  });
+
+  it("tells the README reader that feed addresses are the exception to URL continuity", async () => {
+    const service = createExportService(
+      buildServices({ posts: [] }),
+      makeSiteConfig({ mainRssFeed: "latest" }),
+    );
+    const readme = filesToMap(await service.generateHugoFiles()).get(
+      "README.md",
+    ) as string;
+
+    // The Notes list advertises that post URLs survive the move; without this
+    // it reads as a promise covering every URL.
+    expect(readme).toContain("## Feeds");
+    expect(readme).toContain("`/latest/feed`");
+    expect(readme).toContain("static/_redirects");
+    expect(readme).toContain("Feed addresses are the exception");
+    // No /subscribe page exists in the export, and the README says where the
+    // nav entry lands instead.
+    expect(readme).toContain("has no `/subscribe` page");
+  });
+
+  it("hides system Subscribe navigation when feeds are off", async () => {
+    const service = createExportService(
+      buildServices({ posts: [] }),
+      makeSiteConfig({
+        rssFeedsEnabled: false,
+        navItems: [
+          {
+            type: "system",
+            systemKey: "subscribe",
+            label: "System subscribe",
+            url: "/subscribe",
+            position: 0,
+            placement: "more",
+          },
+        ],
+      }),
+    );
+    const data = filesToMap(await service.generateHugoFiles()).get(
+      "data/jant.toml",
+    ) as string;
+
+    expect(data).not.toContain('label = "System subscribe"');
+  });
+
   it("emits last_activity_at on root post front matter so feed <updated> tracks thread bumps", async () => {
     const post = makePost({
       id: "post-1",

package/src/__tests__/helpers/component-css.ts

@@ -0,0 +1,91 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+/**
+ * `src/styles`, resolved from the working directory rather than
+ * `import.meta.url`: under the `happy-dom` environment `import.meta.url` is an
+ * `http:` URL that `readFileSync` rejects, and Vitest runs with the package
+ * root as its working directory in every environment.
+ */
+const STYLES_DIR = resolve(process.cwd(), "src/styles");
+
+/** Hand-written component CSS a signed-out visitor downloads. */
+const READER_SHEETS = ["ui.css", "components.css"] as const;
+
+/** Hand-written component CSS that only loads on an authenticated page. */
+const AUTHOR_SHEETS = ["ui-author.css", "components-author.css"] as const;
+
+function read(names: readonly string[]): string {
+  return names
+    .map((name) => readFileSync(resolve(STYLES_DIR, name), "utf8"))
+    .join("\n");
+}
+
+/**
+ * Every `@layer components` rule Jant hand-writes, both audiences together.
+ *
+ * `ui.css`/`components.css` carry what readers need; `ui-author.css` and
+ * `components-author.css` carry the composer, editor, settings, config editor
+ * and dash chrome that only load once someone is signed in. A test asserting
+ * that a rule is declared cares that it exists at all, not which half it
+ * landed in — so moving a rule between them must never break a test.
+ *
+ * @returns The concatenated contents of all four stylesheets.
+ * @example
+ * expect(readComponentCss()).toMatch(/\.compose-post-meta-panel\s*\{/);
+ */
+export function readComponentCss(): string {
+  return read([...READER_SHEETS, ...AUTHOR_SHEETS]);
+}
+
+/**
+ * Only the reader halves.
+ *
+ * Use when the point of the assertion is that a rule ships to signed-out
+ * visitors — or, with a negative matcher, that it does not.
+ *
+ * @returns The concatenated contents of `ui.css` and `components.css`.
+ * @example
+ * expect(readReaderCss()).not.toMatch(/\.compose-dialog\s*\{/);
+ */
+export function readReaderCss(): string {
+  return read(READER_SHEETS);
+}
+
+/**
+ * Only the author halves.
+ *
+ * @returns The concatenated contents of `ui-author.css` and
+ * `components-author.css`.
+ * @example
+ * expect(readAuthorCss()).toMatch(/\.settings-root\s*\{/);
+ */
+export function readAuthorCss(): string {
+  return read(AUTHOR_SHEETS);
+}
+
+/**
+ * Every stylesheet Jant hand-writes, each paired with its filename.
+ *
+ * `readComponentCss()` and friends concatenate, which is right for asking
+ * whether a rule exists. This one keeps the files apart so a failure can name
+ * the file and line it found the problem on — `tokens.css` and `preset.css`
+ * are in here too, because breakpoints live in all six.
+ *
+ * @returns One entry per stylesheet, in load order.
+ * @example
+ * for (const { name, css } of readAllStylesheets()) {
+ *   expect(css, name).not.toMatch(/@media \(max-width: 767px\)/);
+ * }
+ */
+export function readAllStylesheets(): readonly {
+  name: string;
+  css: string;
+}[] {
+  return [
+    { name: "preset.css", path: resolve(process.cwd(), "src/preset.css") },
+    ...[...READER_SHEETS, ...AUTHOR_SHEETS, "tokens.css", "site-media.css"].map(
+      (name) => ({ name, path: resolve(STYLES_DIR, name) }),
+    ),
+  ].map(({ name, path }) => ({ name, css: readFileSync(path, "utf8") }));
+}

package/src/__tests__/helpers/db.ts

@@ -134,3 +134,36 @@ export function createTestDatabase(options?: { fts?: boolean }) {
 
   return { db, sqlite };
 }
+
+/** The most bound parameters Cloudflare D1 accepts in one statement. */
+export const D1_MAX_BOUND_PARAMETERS = 100;
+
+/**
+ * Make a test database refuse what D1 refuses: a statement with more than
+ * {@link D1_MAX_BOUND_PARAMETERS} bound parameters.
+ *
+ * better-sqlite3 accepts tens of thousands, so a query that puts every id in
+ * one `IN (…)` list passes every test and fails in production once the list
+ * grows. Install this after seeding, so only the code under test is held to it.
+ *
+ * @param sqlite - The handle `createTestDatabase` or `createTestApp` returned
+ * @returns Nothing; the handle is changed in place
+ * @example
+ * ```ts
+ * const { app, sqlite } = createTestApp();
+ * await seed(app);
+ * enforceD1BoundParameterLimit(sqlite);
+ * ```
+ */
+export function enforceD1BoundParameterLimit(sqlite: Database.Database): void {
+  const prepare = sqlite.prepare.bind(sqlite);
+  sqlite.prepare = ((source: string) => {
+    const count = source.match(/\?/g)?.length ?? 0;
+    if (count > D1_MAX_BOUND_PARAMETERS) {
+      throw new Error(
+        `too many SQL variables: ${count} bound parameters, D1 allows ${D1_MAX_BOUND_PARAMETERS}`,
+      );
+    }
+    return prepare(source);
+  }) as Database.Database["prepare"];
+}

package/src/__tests__/helpers/export-fixtures.ts

@@ -87,10 +87,13 @@ export function makeSiteConfig(over: Partial<SiteConfig> = {}): SiteConfig {
     siteUrl: "https://example.com",
     siteDescription: "Export fixture",
     siteLanguage: "en",
+    multilingualEnabled: false,
+    additionalLanguages: [],
     showJantBrandingOnHome: true,
     publicApiEnabled: true,
     rssFeedsEnabled: true,
     mainRssFeed: "latest",
+    archiveDefaultLayout: "list",
     siteFooter: "",
     showHeaderAvatar: false,
     siteAvatarUrl: "",

package/src/__tests__/stylesheet-audience.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it } from "vitest";
+import {
+  readAuthorCss,
+  readComponentCss,
+  readReaderCss,
+} from "./helpers/component-css.js";
+
+/**
+ * `client.css` is what a signed-out visitor waits on before the page paints,
+ * and `styles/ui.css` plus `styles/components.css` are the hand-written half
+ * of it. Author-only component CSS belongs in `styles/ui-author.css` and
+ * `styles/components-author.css`, which `BaseLayout` links only on
+ * authenticated pages.
+ *
+ * Class families that only ever appear in authenticated markup. The editor's
+ * `.tiptap-*` chrome is here too, minus the names TipTap also writes into
+ * published post HTML — readers see those.
+ */
+const AUTHOR_ONLY = [
+  "compose",
+  "command",
+  "settings",
+  "picker",
+  "confirm",
+  "draft",
+  "theme-preview",
+  // The floating compose button on phones, and the page modifier that keeps
+  // room for it. Reader layout renders both, but only for a signed-in author.
+  "site-mobile-compose",
+  "site-page-mobile-compose-enabled",
+  // From `components.css`: the config editor, the navigation manager, the
+  // custom URL manager, the dash chrome and the form skeletons. `.nav-*` here
+  // is `jant-nav-manager`, not the site header — that is `.site-header-nav`.
+  // `.collection-picker-*` is spelled out because plain `.collection-*` is a
+  // reader family (the collection pages).
+  "config",
+  "nav",
+  "custom",
+  "dash",
+  "skel",
+  "collection-picker",
+];
+
+/** TipTap class names that land in reader-rendered post HTML. */
+const READER_TIPTAP = [
+  "tiptap-table",
+  "tiptap-html-block",
+  "tiptap-more-break",
+  "tiptap-embed-figure",
+  "tiptap-embed-frame",
+  "tiptap-embed-fallback",
+  "tiptap-footnote-reference",
+  "tiptap-footnote-definition",
+];
+
+/**
+ * `.compose-thread-layout` shares the compose rail's marker vocabulary with
+ * the reading rail's `.thread-group` in one declaration, so that the two
+ * cannot drift apart. That single grouped selector is the documented
+ * exception; see the comment on the rule in `styles/ui.css`.
+ */
+const READER_SHEET_EXCEPTIONS = [".compose-thread-layout"];
+
+/** Every class named in a selector, ignoring declaration bodies. */
+function selectorClasses(css: string): string[] {
+  const found: string[] = [];
+  // Selectors are what precedes a `{` that opens a block; declarations end in
+  // `;`, so anything after the last `;` or `}` is the selector text.
+  for (const chunk of css.split("{")) {
+    const selector = chunk.slice(
+      Math.max(chunk.lastIndexOf(";"), chunk.lastIndexOf("}")) + 1,
+    );
+    const withoutComments = selector.replace(/\/\*[\s\S]*?\*\//g, " ");
+    for (const match of withoutComments.matchAll(
+      /\.(-?[A-Za-z_][A-Za-z0-9_-]*)/g,
+    )) {
+      found.push(match[1]!);
+    }
+  }
+  return found;
+}
+
+describe("stylesheet audience", () => {
+  it("keeps author-only component CSS out of the reader stylesheet", () => {
+    const css = readReaderCss();
+    const exceptions = new Set(
+      READER_SHEET_EXCEPTIONS.map((name) => name.replace(/^\./, "")),
+    );
+
+    const leaked = [
+      ...new Set(
+        selectorClasses(css).filter(
+          (name) =>
+            !exceptions.has(name) &&
+            AUTHOR_ONLY.some(
+              (family) => name === family || name.startsWith(`${family}-`),
+            ),
+        ),
+      ),
+    ].sort();
+
+    expect(leaked).toEqual([]);
+  });
+
+  it("keeps the editor chrome out of the reader stylesheet", () => {
+    const readerTiptap = new Set(READER_TIPTAP);
+    const leaked = [
+      ...new Set(
+        selectorClasses(readReaderCss()).filter(
+          (name) =>
+            (name === "tiptap" || name.startsWith("tiptap-")) &&
+            !readerTiptap.has(name),
+        ),
+      ),
+    ].sort();
+
+    expect(leaked).toEqual([]);
+  });
+
+  it("still styles the TipTap output a published post carries", () => {
+    // `lib/embed-render.ts` and `lib/markdown-manager.ts` write these into post
+    // HTML, and they are the ones with rules of their own — a reader holding
+    // only `client.css` has to be able to style them. The rest of
+    // READER_TIPTAP reaches published posts too but is styled by element
+    // through `.prose`, so there is no rule here to keep.
+    const css = readReaderCss();
+    for (const name of [
+      "tiptap-embed-figure",
+      "tiptap-embed-frame",
+      "tiptap-embed-fallback",
+      "tiptap-more-break",
+    ]) {
+      expect(selectorClasses(css)).toContain(name);
+    }
+  });
+
+  it("moved real weight, not a handful of rules", () => {
+    // The split is only worth its complexity while the author half is
+    // substantial. If it ever shrinks to a rounding error, fold it back in.
+    expect(readAuthorCss().length).toBeGreaterThan(readReaderCss().length / 2);
+  });
+
+  it("keeps the author half of components.css out of the reader sheet", () => {
+    // `preset.css` imports `components.css` on every page, so the settings
+    // pages and the config editor must not be left in it.
+    const author = readAuthorCss();
+    expect(author).toContain(".settings-root");
+    expect(author).toContain(".config-editor-page");
+  });
+
+  it("leaves the reader-side families of components.css in place", () => {
+    // Verified against every `class=` usage in the tree: `BaseLayout` renders
+    // the toast container on every page, and `.page-intro-*` is the header of
+    // the archive and collections pages, both public.
+    const reader = readReaderCss();
+    expect(reader).toContain(".toast-container");
+    expect(reader).toContain(".page-intro");
+  });
+});