@jant/core 0.6.14 → 0.6.15

package/src/lib/__tests__/footnotes-upgrade.test.ts

@@ -0,0 +1,181 @@
+import type { JSONContent } from "@tiptap/core";
+import { describe, expect, it } from "vitest";
+import { upgradeLegacyFootnotes } from "../footnotes.js";
+import { markdownToTiptapJson } from "../markdown-to-tiptap.js";
+import { renderTiptapDocument } from "../tiptap-render.js";
+
+function linkedText(text: string, href: string): JSONContent {
+  return {
+    type: "text",
+    text,
+    marks: [
+      {
+        type: "link",
+        attrs: { href, target: "_blank", rel: "noopener noreferrer" },
+      },
+    ],
+  };
+}
+
+function legacyDocument(): JSONContent {
+  return {
+    type: "doc",
+    content: [
+      {
+        type: "paragraph",
+        content: [
+          { type: "text", text: "First" },
+          linkedText("[1]", "#fn-1"),
+          { type: "text", text: " and repeated" },
+          linkedText("[1]", "#fn-1"),
+          { type: "text", text: ". Second" },
+          linkedText("[2]", "#fn-2"),
+        ],
+      },
+      { type: "horizontalRule" },
+      {
+        type: "orderedList",
+        attrs: { start: 1, type: null },
+        content: [
+          {
+            type: "listItem",
+            content: [
+              {
+                type: "paragraph",
+                content: [
+                  { type: "text", text: "Rich definition with " },
+                  linkedText("source", "https://example.com"),
+                  linkedText("↩︎", "#fnref-1"),
+                ],
+              },
+              {
+                type: "bulletList",
+                content: [
+                  {
+                    type: "listItem",
+                    content: [
+                      {
+                        type: "paragraph",
+                        content: [{ type: "text", text: "Nested detail" }],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+          {
+            type: "listItem",
+            content: [
+              {
+                type: "paragraph",
+                content: [
+                  { type: "text", text: "Second definition" },
+                  linkedText("↩︎", "#fnref-2"),
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  };
+}
+
+describe("upgradeLegacyFootnotes", () => {
+  it("upgrades the historical link, rule, list, and backlink shape", () => {
+    const result = upgradeLegacyFootnotes(legacyDocument());
+
+    expect(result.upgraded).toBe(true);
+    expect(result.doc.content?.map((node) => node.type)).toEqual([
+      "paragraph",
+      "footnoteDefinition",
+      "footnoteDefinition",
+    ]);
+    expect(
+      result.doc.content?.[0]?.content?.filter(
+        (node) => node.type === "footnoteReference",
+      ),
+    ).toEqual([
+      { type: "footnoteReference", attrs: { label: "1" } },
+      { type: "footnoteReference", attrs: { label: "1" } },
+      { type: "footnoteReference", attrs: { label: "2" } },
+    ]);
+
+    const serialized = JSON.stringify(result.doc);
+    expect(serialized).not.toContain("#fn-");
+    expect(serialized).not.toContain("#fnref-");
+    expect(serialized).not.toContain("↩");
+    expect(serialized).toContain("https://example.com");
+    expect(serialized).toContain("Nested detail");
+
+    const html = renderTiptapDocument(result.doc, {
+      namespace: "pst_legacy",
+    });
+    expect(html).toContain('role="doc-noteref"');
+    expect(html).toContain('role="doc-endnotes"');
+    expect(html).toContain('role="doc-backlink"');
+    expect(html).not.toContain("<hr>");
+  });
+
+  it("is idempotent after the canonical nodes have been created", () => {
+    const first = upgradeLegacyFootnotes(legacyDocument());
+    const second = upgradeLegacyFootnotes(first.doc);
+
+    expect(second).toEqual({ doc: first.doc, upgraded: false });
+  });
+
+  it("upgrades the Markdown round-trip shape observed on historical posts", () => {
+    const body = markdownToTiptapJson(
+      [
+        "Codex[\\[1\\]](#fn-1) and Claude[\\[2\\]](#fn-2).",
+        "",
+        "---",
+        "",
+        "1. First definition.[↩︎](#fnref-1)",
+        "2. Second definition.[↩︎](#fnref-2)",
+      ].join("\n"),
+    );
+    const result = upgradeLegacyFootnotes(JSON.parse(body) as JSONContent);
+
+    expect(result.upgraded).toBe(true);
+    expect(JSON.stringify(result.doc)).toContain('"type":"footnoteReference"');
+    expect(JSON.stringify(result.doc)).toContain('"type":"footnoteDefinition"');
+  });
+
+  it.each([
+    {
+      name: "has no separator",
+      mutate(doc: JSONContent) {
+        doc.content?.splice(-2, 1);
+      },
+    },
+    {
+      name: "has an unmatched backlink",
+      mutate(doc: JSONContent) {
+        const list = doc.content?.at(-1);
+        const backlink = list?.content?.[0]?.content?.[0]?.content?.at(-1);
+        if (backlink?.marks?.[0]?.attrs) {
+          backlink.marks[0].attrs.href = "#fnref-99";
+        }
+      },
+    },
+    {
+      name: "has an ordinary numbered list",
+      mutate(doc: JSONContent) {
+        const list = doc.content?.at(-1);
+        const paragraph = list?.content?.[0]?.content?.[0];
+        paragraph?.content?.pop();
+      },
+    },
+  ])("leaves a document unchanged when it $name", ({ mutate }) => {
+    const doc = legacyDocument();
+    mutate(doc);
+    const original = globalThis.structuredClone(doc);
+
+    expect(upgradeLegacyFootnotes(doc)).toEqual({
+      doc: original,
+      upgraded: false,
+    });
+  });
+});

package/src/lib/__tests__/markdown-roundtrip-embed.test.ts

@@ -8,6 +8,8 @@ interface TiptapNode {
   type: string;
   attrs?: Record<string, unknown>;
   content?: TiptapNode[];
+  marks?: Array<{ type: string; attrs?: Record<string, unknown> }>;
+  text?: string;
 }
 
 function findNode(node: TiptapNode, type: string): TiptapNode | null {
@@ -86,3 +88,62 @@ describe("markdown round-trip: htmlBlock", () => {
     expect(out).toContain(inner);
   });
 });
+
+describe("markdown manager integration", () => {
+  it("round-trips ordered-list numbering and nested inline formatting", () => {
+    const markdown = [
+      "5. **Five**",
+      "6. Six",
+      "   1. *Nested one*",
+      "   2. Nested two",
+    ].join("\n");
+
+    const parsed = parseMarkdownDocument(markdown) as TiptapNode;
+    const outerList = findNode(parsed, "orderedList");
+    expect(outerList?.attrs?.start).toBe(5);
+    expect(outerList?.content).toHaveLength(2);
+    const nestedList = findNode(
+      outerList?.content?.[1] ?? parsed,
+      "orderedList",
+    );
+    expect(nestedList?.attrs?.start ?? 1).toBe(1);
+    expect(nestedList?.content).toHaveLength(2);
+
+    const serialized = serializeMarkdownDocument(parsed);
+    expect(serialized).toContain("5. **Five**");
+    expect(serialized).toContain("6. Six");
+    expect(parseMarkdownDocument(serialized)).toEqual(parsed);
+  });
+
+  it("round-trips table, image, link, and footnote integrations", () => {
+    const markdown = [
+      "[Source](https://example.com)",
+      "",
+      "| Name | Value |",
+      "| --- | --- |",
+      "| Jant | 1 |",
+      "",
+      '![Alt text](https://example.com/image.png "Title")',
+      "",
+      "Body[^note]",
+      "",
+      "[^note]: Footnote body",
+    ].join("\n");
+
+    const parsed = parseMarkdownDocument(markdown) as TiptapNode;
+    expect(findNode(parsed, "table")).not.toBeNull();
+    expect(findNode(parsed, "image")?.attrs).toMatchObject({
+      src: "https://example.com/image.png",
+      alt: "Alt text",
+      title: "Title",
+    });
+    expect(findNode(parsed, "footnoteReference")?.attrs?.label).toBe("note");
+    expect(findNode(parsed, "footnoteDefinition")?.attrs?.label).toBe("note");
+    const linkedText = findNode(parsed, "text");
+    expect(linkedText?.marks?.[0]?.type).toBe("link");
+    expect(linkedText?.marks?.[0]?.attrs?.href).toBe("https://example.com");
+
+    const serialized = serializeMarkdownDocument(parsed);
+    expect(parseMarkdownDocument(serialized)).toEqual(parsed);
+  });
+});

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

@@ -128,6 +128,29 @@ describe("markdownToTiptapJson", () => {
       expect(doc.content[1].content[0].type).toBe("paragraph");
       expect(doc.content[1].content[0].content[0].text).toBe("Footnote body");
     });
+
+    it("normalizes inline footnotes into paired structural nodes", () => {
+      const doc = parse("Body^[Inline **bold** note.]");
+
+      expect(doc.content[0].content).toEqual([
+        { type: "text", text: "Body" },
+        { type: "footnoteReference", attrs: { label: "1" } },
+      ]);
+      expect(doc.content[1]).toMatchObject({
+        type: "footnoteDefinition",
+        attrs: { label: "1" },
+        content: [
+          {
+            type: "paragraph",
+            content: [
+              { type: "text", text: "Inline " },
+              { type: "text", text: "bold", marks: [{ type: "bold" }] },
+              { type: "text", text: " note." },
+            ],
+          },
+        ],
+      });
+    });
   });
 
   describe("inline elements", () => {
@@ -398,15 +421,20 @@ describe("end-to-end: Markdown → markdownToTiptapJson → renderTiptapJson", (
     expect(html).toContain("<figcaption>Caption</figcaption>");
   });
 
-  it("renders footnotes as inline sidenotes through the shared document renderer", () => {
+  it("renders semantic footnotes through the shared document renderer", () => {
     const json = markdownToTiptapJson("Body[^1]\n\n[^1]: Footnote body");
     const html = renderTiptapJson(json);
 
+    expect(html).toContain('role="doc-noteref"');
     expect(html).toContain(
-      '<label for="sn-1" class="margin-toggle sidenote-number footref">',
+      '<section class="footnote-endnotes" role="doc-endnotes">',
     );
-    expect(html).toContain('<span class="sidenote">Footnote body</span>');
-    expect(html).not.toContain('<section class="footnotes"');
+    expect(html).toContain('<ol class="footnote-list">');
+    expect(html).toContain('<li id="fn-1" class="footnote">');
+    expect(html).toMatch(/<p>Footnote body <span class="footnote-backlinks">/);
+    expect(html).toContain('role="doc-backlink"');
+    expect(html).not.toMatch(/footnote-document|footnote-main|footnote-body/);
+    expect(html).not.toMatch(/data-footnote-|--footnote-|tabindex=/);
   });
 
   it("renders a complex document", () => {

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

@@ -62,14 +62,16 @@ describe("render", () => {
     expect(html).toBe("<p>Intro</p><!--more--><p>Rest</p>");
   });
 
-  it("renders footnote references as inline sidenotes", () => {
+  it("renders semantic footnote references and definitions", () => {
     const html = render("Body copy[^1]\n\n[^1]: Footnote body");
 
-    expect(html).toContain(
-      '<label for="sn-1" class="margin-toggle sidenote-number footref">',
-    );
-    expect(html).toContain('<span class="sidenote">Footnote body</span>');
-    expect(html).not.toContain('<section class="footnotes"');
+    expect(html).toContain('role="doc-noteref"');
+    expect(html).toContain('role="doc-endnotes"');
+    expect(html).toContain('class="footnote-list"');
+    expect(html).toContain("Footnote body");
+    expect(html).toContain('role="doc-backlink"');
+    expect(html.match(/<ol class="footnote-list">/g)).toHaveLength(1);
+    expect(html).not.toMatch(/footnote-document|data-footnote-|--footnote-/);
   });
 
   it("escapes raw HTML outside the supported markdown schema", () => {

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

@@ -7,6 +7,7 @@ describe("getNavigationData", () => {
     const context = {
       var: {
         publicPath: "/",
+        currentSite: { id: "sit_navigation" },
         appConfig: {
           siteName: "Jant",
           sitePathPrefix: "",
@@ -34,8 +35,9 @@ describe("getNavigationData", () => {
 
     expect(result.isAuthenticated).toBe(false);
     expect(result.collections).toEqual([]);
-    expect(result.siteFooterHtml).toContain('<label for="sn-');
-    expect(result.siteFooterHtml).toContain('<span class="sidenote">');
+    expect(result.siteFooterHtml).toContain('role="doc-noteref"');
+    expect(result.siteFooterHtml).toContain('role="doc-endnotes"');
+    expect(result.siteFooterHtml).toContain("fn-2wpij13sz70fe-1");
     expect(result.siteFooterHtml).toContain("<strong>note</strong>");
     expect(result.siteFooterHtml).toContain(
       "&lt;script&gt;alert(1)&lt;/script&gt;",
@@ -96,4 +98,59 @@ describe("getNavigationData", () => {
     expect(result.links[0]?.url).toBe("/featured");
     expect(result.links[1]?.url).toBe("/");
   });
+
+  it("hides only the built-in RSS 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_rss",
+                type: "system",
+                systemKey: "rss",
+                label: "Feed",
+                url: "/feed",
+                placement: "header",
+                position: "a0",
+                createdAt: 1,
+                updatedAt: 1,
+              },
+              {
+                id: "nav_custom",
+                type: "link",
+                label: "Custom feed link",
+                url: "/feed",
+                placement: "header",
+                position: "a1",
+                createdAt: 1,
+                updatedAt: 1,
+              },
+            ],
+          },
+          collections: {
+            listByRecentActivity: async () => [],
+          },
+        },
+        isAuthenticated: false,
+        session: null,
+      },
+    } as unknown as Context;
+
+    const result = await getNavigationData(context);
+
+    expect(result.links.map((link) => link.id)).toEqual(["nav_custom"]);
+  });
 });

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,
+    ]);
+  });
 });