@jant/core 0.6.14 → 0.6.16

package/src/lib/__tests__/post-body-html.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "vitest";
+import {
+  POST_BODY_HTML_VERSION,
+  renderPostBodyHtml,
+  resolvePostBodyHtml,
+  tryPreparePostBodyHtml,
+  tryRenderPostBodyHtml,
+} from "../post-body-html.js";
+
+const body = JSON.stringify({
+  type: "doc",
+  content: [
+    {
+      type: "paragraph",
+      content: [
+        { type: "text", text: "Body" },
+        { type: "footnoteReference", attrs: { label: "note" } },
+      ],
+    },
+    {
+      type: "footnoteDefinition",
+      attrs: { label: "note" },
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Definition" }],
+        },
+      ],
+    },
+  ],
+});
+
+const legacyBody = JSON.stringify({
+  type: "doc",
+  content: [
+    {
+      type: "paragraph",
+      content: [
+        { type: "text", text: "Body " },
+        {
+          type: "text",
+          text: "[1]",
+          marks: [{ type: "link", attrs: { href: "#fn-1" } }],
+        },
+      ],
+    },
+    { type: "horizontalRule" },
+    {
+      type: "orderedList",
+      content: [
+        {
+          type: "listItem",
+          content: [
+            {
+              type: "paragraph",
+              content: [
+                { type: "text", text: "Definition " },
+                {
+                  type: "text",
+                  text: "↩︎",
+                  marks: [{ type: "link", attrs: { href: "#fnref-1" } }],
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  ],
+});
+
+describe("post body HTML projection", () => {
+  it("uses the immutable post ID as the footnote namespace", () => {
+    const html = renderPostBodyHtml("pst_example", body);
+
+    expect(html).toContain('id="fn-19lnbd7xufphl-1"');
+    expect(html).toContain('id="fnref-19lnbd7xufphl-1-1"');
+    expect(html).not.toContain("pst_example");
+  });
+
+  it("returns current stored bytes without rendering", () => {
+    expect(
+      resolvePostBodyHtml({
+        id: "pst_example",
+        body,
+        bodyHtml: "<p>already current</p>",
+        bodyHtmlVersion: POST_BODY_HTML_VERSION,
+      }),
+    ).toBe("<p>already current</p>");
+  });
+
+  it("renders stale stored HTML to the current contract", () => {
+    const html = resolvePostBodyHtml({
+      id: "pst_example",
+      body,
+      bodyHtml: '<span class="sidenote">legacy</span>',
+      bodyHtmlVersion: 1,
+    });
+
+    expect(html).toContain('role="doc-noteref"');
+    expect(html).toContain('role="doc-endnotes"');
+    expect(html).not.toContain("legacy");
+  });
+
+  it("re-renders the short-lived v2 layout protocol as canonical v3 HTML", () => {
+    const html = resolvePostBodyHtml({
+      id: "pst_example",
+      body,
+      bodyHtml:
+        '<div class="footnote-document"><div class="footnote-main"><p>v2</p></div></div>',
+      bodyHtmlVersion: 2,
+    });
+
+    expect(html).toContain(
+      '<section class="footnote-endnotes" role="doc-endnotes"><ol class="footnote-list">',
+    );
+    expect(html).not.toMatch(/footnote-document|footnote-main|data-footnote-/);
+  });
+
+  it("upgrades legacy generic footnotes before rendering the projection", () => {
+    const prepared = tryPreparePostBodyHtml("pst_example", legacyBody);
+
+    expect(prepared).toMatchObject({
+      ok: true,
+      upgradedLegacyFootnotes: true,
+    });
+    if (!prepared.ok) throw new Error(prepared.error);
+
+    expect(prepared.body).toContain('"type":"footnoteReference"');
+    expect(prepared.body).toContain('"type":"footnoteDefinition"');
+    expect(prepared.body).not.toContain("#fnref-1");
+    expect(prepared.html).toContain('role="doc-noteref"');
+    expect(prepared.html).toContain('role="doc-endnotes"');
+  });
+
+  it("treats v3 generic footnotes as stale until canonical migration", () => {
+    const html = resolvePostBodyHtml({
+      id: "pst_example",
+      body: legacyBody,
+      bodyHtml: '<p>Body <a href="#fn-1">[1]</a></p>',
+      bodyHtmlVersion: 3,
+    });
+
+    expect(html).toContain('role="doc-noteref"');
+    expect(html).toContain('role="doc-endnotes"');
+    expect(html).not.toContain('href="#fn-1"');
+  });
+
+  it("falls back to stored HTML when historical canonical JSON is invalid", () => {
+    expect(
+      resolvePostBodyHtml({
+        id: "pst_example",
+        body: "not json",
+        bodyHtml: "<p>legacy fallback</p>",
+        bodyHtmlVersion: 1,
+      }),
+    ).toBe("<p>legacy fallback</p>");
+  });
+
+  it("returns null when the canonical body is null", () => {
+    expect(
+      resolvePostBodyHtml({
+        id: "pst_example",
+        body: null,
+        bodyHtml: "<p>stale</p>",
+        bodyHtmlVersion: 1,
+      }),
+    ).toBeNull();
+  });
+
+  it("strict rendering reports malformed canonical JSON", () => {
+    expect(tryRenderPostBodyHtml("pst_example", "not json")).toMatchObject({
+      ok: false,
+    });
+  });
+});

package/src/lib/__tests__/post-display.test.ts

@@ -97,4 +97,68 @@ describe("post display assembly", () => {
     expect(display?.threadPostViews).toHaveLength(2);
     expect(display?.threadPostViews?.[1]?.id).toBe(reply.id);
   });
+
+  it("includes draft thread members only for an authenticated preview", async () => {
+    const root = await postService.create({
+      format: "note",
+      bodyMarkdown: "Draft root",
+      status: "draft",
+    });
+    const reply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Draft reply",
+      status: "draft",
+      replyToId: root.id,
+    });
+
+    const preview = await assemblePostPageDisplay(createContext(), root.id, {
+      isAuthenticated: true,
+      allowDraft: true,
+      includeDraftThread: true,
+    });
+    const normal = await assemblePostPageDisplay(createContext(), root.id, {
+      isAuthenticated: true,
+    });
+
+    expect(preview?.threadPostViews?.map((post) => post.id)).toEqual([
+      root.id,
+      reply.id,
+    ]);
+    expect(normal).toBeNull();
+  });
+
+  it("keeps draft replies out of a published permalink outside preview", async () => {
+    const root = await postService.create({
+      format: "note",
+      bodyMarkdown: "Published root",
+      status: "published",
+    });
+    const draftReply = await postService.create({
+      format: "note",
+      bodyMarkdown: "Draft reply",
+      status: "draft",
+      replyToId: root.id,
+    });
+
+    const publicDisplay = await assemblePostPageDisplay(
+      createContext(),
+      root.id,
+      { isAuthenticated: true },
+    );
+    const previewDisplay = await assemblePostPageDisplay(
+      createContext(),
+      draftReply.id,
+      {
+        isAuthenticated: true,
+        allowDraft: true,
+        includeDraftThread: true,
+      },
+    );
+
+    expect(publicDisplay?.threadPostViews).toBeUndefined();
+    expect(previewDisplay?.threadPostViews?.map((post) => post.id)).toEqual([
+      root.id,
+      draftReply.id,
+    ]);
+  });
 });

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { resolveConfig } from "../resolve-config.js";
+import { resolveConfig, resolveSummaryConfig } from "../resolve-config.js";
 import type { Bindings } from "../../types/bindings.js";
 
 function makeEnv(overrides: Partial<Bindings> = {}): Bindings {
@@ -28,11 +28,14 @@ describe("resolveConfig", () => {
     expect(config.timeZone).toBe("UTC");
     expect(config.showJantBrandingOnHome).toBe(false);
     expect(config.noindex).toBe(false);
+    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.rssFeedLimit).toBe(50);
+    expect(config.rssPublishDelaySeconds).toBe(300);
   });
 
   it("DB settings override ENV and defaults", () => {
@@ -49,6 +52,16 @@ describe("resolveConfig", () => {
     expect(config.siteName).toBe("FromEnv");
   });
 
+  it("lets an explicit empty DB value override an environment fallback", () => {
+    const config = resolveConfig(
+      makeEnv({ SITE_DESCRIPTION: "From environment" }),
+      { SITE_DESCRIPTION: "" },
+    );
+
+    expect(config.siteDescription).toBe("");
+    expect(config.siteDescriptionExplicit).toBe(false);
+  });
+
   it("resolves mainRssFeed from DB, env, and defaults", () => {
     const defaultConfig = resolveConfig(makeEnv(), {});
     expect(defaultConfig.mainRssFeed).toBe("featured");
@@ -196,11 +209,15 @@ describe("resolveConfig", () => {
   it("resolves boolean fields correctly", () => {
     const config = resolveConfig(makeEnv(), {
       NOINDEX: "true",
+      PUBLIC_API_ENABLED: "false",
+      RSS_FEEDS_ENABLED: "false",
       SHOW_HEADER_AVATAR: "true",
       SHOW_JANT_BRANDING_ON_HOME: "true",
     });
 
     expect(config.noindex).toBe(true);
+    expect(config.publicApiEnabled).toBe(false);
+    expect(config.rssFeedsEnabled).toBe(false);
     expect(config.showHeaderAvatar).toBe(true);
     expect(config.showJantBrandingOnHome).toBe(true);
   });
@@ -232,6 +249,7 @@ describe("resolveConfig", () => {
         SEARCH_PAGE_SIZE: 7,
         ARCHIVE_PAGE_SIZE: "9",
         RSS_FEED_LIMIT: 25,
+        RSS_PUBLISH_DELAY_SECONDS: "600",
       }),
       {},
     );
@@ -239,6 +257,13 @@ describe("resolveConfig", () => {
     expect(config1.searchPageSize).toBe(7);
     expect(config1.archivePageSize).toBe(9);
     expect(config1.rssFeedLimit).toBe(25);
+    expect(config1.rssPublishDelaySeconds).toBe(600);
+
+    const configWithNoDelay = resolveConfig(
+      makeEnv({ RSS_PUBLISH_DELAY_SECONDS: 0 }),
+      {},
+    );
+    expect(configWithNoDelay.rssPublishDelaySeconds).toBe(0);
 
     const config2 = resolveConfig(
       makeEnv({
@@ -246,6 +271,7 @@ describe("resolveConfig", () => {
         SEARCH_PAGE_SIZE: 0,
         ARCHIVE_PAGE_SIZE: false,
         RSS_FEED_LIMIT: "invalid",
+        RSS_PUBLISH_DELAY_SECONDS: "-1",
       }),
       {},
     );
@@ -253,6 +279,92 @@ describe("resolveConfig", () => {
     expect(config2.searchPageSize).toBe(50);
     expect(config2.archivePageSize).toBe(50);
     expect(config2.rssFeedLimit).toBe(50);
+    expect(config2.rssPublishDelaySeconds).toBe(300);
+
+    const configWithBlankDelay = resolveConfig(
+      makeEnv({ RSS_PUBLISH_DELAY_SECONDS: "   " }),
+      {},
+    );
+    expect(configWithBlankDelay.rssPublishDelaySeconds).toBe(300);
+  });
+
+  it("resolves runtime numeric settings from DB before environment values", () => {
+    const config = resolveConfig(
+      makeEnv({
+        PAGE_SIZE: "20",
+        SEARCH_PAGE_SIZE: "25",
+        ARCHIVE_PAGE_SIZE: "30",
+        SUMMARY_MAX_PARAGRAPHS: "6",
+        SUMMARY_MAX_CHARS: "600",
+        RSS_FEED_LIMIT: "60",
+        RSS_PUBLISH_DELAY_SECONDS: "600",
+      }),
+      {
+        PAGE_SIZE: "80",
+        SUMMARY_MAX_PARAGRAPHS: "12",
+        SUMMARY_MAX_CHARS: "1200",
+        RSS_FEED_LIMIT: "120",
+        RSS_PUBLISH_DELAY_SECONDS: "0",
+      },
+    );
+
+    expect(config.pageSize).toBe(80);
+    expect(config.searchPageSize).toBe(25);
+    expect(config.archivePageSize).toBe(30);
+    expect(config.summaryMaxParagraphs).toBe(12);
+    expect(config.summaryMaxChars).toBe(1200);
+    expect(config.rssFeedLimit).toBe(120);
+    expect(config.rssPublishDelaySeconds).toBe(0);
+  });
+
+  it("inherits runtime page size and rejects out-of-range numeric values", () => {
+    const config = resolveConfig(
+      makeEnv({
+        PAGE_SIZE: "101",
+        SEARCH_PAGE_SIZE: "0",
+        ARCHIVE_PAGE_SIZE: "1.5",
+        SUMMARY_MAX_PARAGRAPHS: "51",
+        SUMMARY_MAX_CHARS: "1501",
+        RSS_FEED_LIMIT: "201",
+        RSS_PUBLISH_DELAY_SECONDS: "7201",
+      }),
+      { PAGE_SIZE: "75" },
+    );
+
+    expect(config.pageSize).toBe(75);
+    expect(config.searchPageSize).toBe(75);
+    expect(config.archivePageSize).toBe(75);
+    expect(config.summaryMaxParagraphs).toBe(5);
+    expect(config.summaryMaxChars).toBe(500);
+    expect(config.rssFeedLimit).toBe(50);
+    expect(config.rssPublishDelaySeconds).toBe(300);
+  });
+
+  it("resolves summary limits without the full app config", () => {
+    expect(
+      resolveSummaryConfig(
+        makeEnv({
+          SUMMARY_MAX_PARAGRAPHS: "3",
+          SUMMARY_MAX_CHARS: 240,
+        }),
+      ),
+    ).toEqual({ maxParagraphs: 3, maxChars: 240 });
+
+    expect(
+      resolveSummaryConfig(
+        makeEnv({
+          SUMMARY_MAX_PARAGRAPHS: 0,
+          SUMMARY_MAX_CHARS: "invalid",
+        }),
+      ),
+    ).toEqual({ maxParagraphs: 5, maxChars: 500 });
+
+    expect(
+      resolveSummaryConfig(makeEnv({ SUMMARY_MAX_CHARS: "240" }), {
+        SUMMARY_MAX_PARAGRAPHS: "8",
+        SUMMARY_MAX_CHARS: "900",
+      }),
+    ).toEqual({ maxParagraphs: 8, maxChars: 900 });
   });
 
   it("resolves fallbacks without DB values", () => {

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)", () => {

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

@@ -801,6 +801,88 @@ describe("extractSummaryHtml", () => {
     expect(result!.html).toContain(">Link text</a>");
   });
 
+  it("includes referenced footnote definitions with the requested namespace", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "Visible" },
+            { type: "footnoteReference", attrs: { label: "note" } },
+          ],
+        },
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Hidden tail" }],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "note" },
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Definition" }],
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = extractSummaryHtml(doc, 1, 500, 0, {
+      namespace: "pst_summary",
+    });
+
+    expect(result?.hasMore).toBe(true);
+    expect(result?.html).toContain('id="fn-0pba1ne36oeor-1"');
+    expect(result?.html).toContain('role="doc-endnotes"');
+    expect(result?.html.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(result?.html).not.toMatch(
+      /footnote-document|footnote-main|data-footnote-|--footnote-/,
+    );
+    expect(result?.html).not.toContain("Hidden tail");
+    expect(result!.html.indexOf("Definition")).toBeGreaterThan(
+      result!.html.indexOf("Visible"),
+    );
+  });
+
+  it("omits a footnote when its first reference is beyond the summary boundary", () => {
+    const doc = JSON.stringify({
+      type: "doc",
+      content: [
+        {
+          type: "paragraph",
+          content: [{ type: "text", text: "Visible summary" }],
+        },
+        {
+          type: "paragraph",
+          content: [
+            { type: "text", text: "Hidden reference" },
+            { type: "footnoteReference", attrs: { label: "note" } },
+          ],
+        },
+        {
+          type: "footnoteDefinition",
+          attrs: { label: "note" },
+          content: [
+            {
+              type: "paragraph",
+              content: [{ type: "text", text: "Hidden definition" }],
+            },
+          ],
+        },
+      ],
+    });
+
+    const result = extractSummaryHtml(doc, 1, 500);
+
+    expect(result?.hasMore).toBe(true);
+    expect(result?.html).toContain("Visible summary");
+    expect(result?.html).not.toContain("Hidden reference");
+    expect(result?.html).not.toContain("Hidden definition");
+    expect(result?.html).not.toContain('role="doc-endnotes"');
+  });
+
   function paragraphsDoc(...texts: string[]): string {
     return JSON.stringify({
       type: "doc",