@jant/core 0.6.16 → 0.7.1

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

@@ -733,6 +733,93 @@ describe("Timeline data assembly", () => {
     ]);
   });
 
+  // A reply can be older than its root (a post moved into the Thread keeps
+  // its creation time; an export without `created` dates posts by
+  // publication). The Thread still opens on its root.
+  async function createThreadWithOlderReplies() {
+    const root = await postService.create({
+      format: "note",
+      bodyMarkdown: "Root",
+      featured: true,
+      publishedAt: 3000,
+    });
+    const first = await postService.create({
+      format: "note",
+      bodyMarkdown: "First reply",
+      replyToId: root.id,
+      publishedAt: 1000,
+    });
+    const second = await postService.create({
+      format: "note",
+      bodyMarkdown: "Second reply",
+      replyToId: first.id,
+      publishedAt: 2000,
+    });
+    for (const [id, createdAt] of [
+      [root.id, 3000],
+      [first.id, 1000],
+      [second.id, 2000],
+    ] as const) {
+      await db.update(postTable).set({ createdAt }).where(eq(postTable.id, id));
+    }
+    return { root, first, second };
+  }
+
+  it("keeps a Featured Thread whose replies are older than its root", async () => {
+    const { root, second } = await createThreadWithOlderReplies();
+
+    const result = await assembleFeaturedTimeline(createTimelineContext(), {
+      isAuthenticated: true,
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]?.post.id).toBe(root.id);
+    expect(result.items[0]?.curatedThread?.segments).toEqual([
+      expect.objectContaining({
+        post: expect.objectContaining({ id: root.id }),
+        hiddenBeforeCount: 0,
+        highlighted: true,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: second.id }),
+        hiddenBeforeCount: 1,
+        highlighted: false,
+      }),
+    ]);
+  });
+
+  it("renders a collected Thread whose replies are older than its root", async () => {
+    const collection = await collectionService.create({
+      slug: "older-replies",
+      title: "Older replies",
+    });
+    const { root, first, second } = await createThreadWithOlderReplies();
+    await collectionService.addThread(collection.id, root.id);
+
+    const result = await assembleCollectionTimeline(createTimelineContext(), {
+      collectionIds: [collection.id],
+      isAuthenticated: true,
+      sortOrder: "newest",
+    });
+
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0]?.post.id).toBe(root.id);
+    expect(result.items[0]?.curatedThread?.segments).toEqual([
+      expect.objectContaining({
+        post: expect.objectContaining({ id: root.id }),
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: first.id }),
+        highlighted: false,
+      }),
+      expect.objectContaining({
+        post: expect.objectContaining({ id: second.id }),
+        highlighted: true,
+      }),
+    ]);
+  });
+
   it("deduplicates Threads selected through multiple collections", async () => {
     const smart = await collectionService.create({
       slug: "smart",

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

@@ -361,6 +361,154 @@ describe("tiptapJsonToMarkdown", () => {
       );
       expect(tiptapJsonToMarkdown(json)).toBe("Line 1  \nLine 2");
     });
+
+    // Trailing spaces on a line with nothing else on it make a blank line,
+    // which ends the paragraph (or leaves a list item empty).
+    it("keeps two hard breaks in a row inside one paragraph", () => {
+      const br = { type: "hardBreak" };
+      const json = doc(p(text("A"), br, br, text("B")));
+      const markdown = tiptapJsonToMarkdown(json);
+      expect(markdown).toBe("A  \n\\\nB");
+      expect(JSON.parse(markdownToTiptapJson(markdown))).toEqual(
+        JSON.parse(json),
+      );
+    });
+
+    it("keeps a list item that opens with a hard break in the list", () => {
+      const json = doc({
+        type: "bulletList",
+        content: [
+          {
+            type: "listItem",
+            content: [p({ type: "hardBreak" }, text("Ships in 3–7 days"))],
+          },
+          { type: "listItem", content: [p(text("Next"))] },
+        ],
+      });
+      const markdown = tiptapJsonToMarkdown(json);
+      expect(JSON.parse(markdownToTiptapJson(markdown))).toEqual(
+        JSON.parse(json),
+      );
+    });
+  });
+
+  // CommonMark only closes `**` after punctuation when a space or another
+  // punctuation mark follows, so `**句子。**后文` stays literal asterisks in
+  // Hugo and in Jant. Those runs use HTML tags, which both read.
+  describe("emphasis a delimiter can't open or close", () => {
+    const bold = [{ type: "bold" }];
+
+    it.each([
+      [
+        "bold ending in CJK punctuation before a letter",
+        [text("而是："), text("固定时间，一群人。", bold), text("来的人")],
+        "而是：<strong>固定时间，一群人。</strong>来的人",
+      ],
+      [
+        "bold opening on CJK punctuation after a letter",
+        [text("说"), text("「引用」", bold), text("后")],
+        "说<strong>「引用」</strong>后",
+      ],
+      [
+        "italic ending in punctuation before a letter",
+        [text("这是"), text("强调。", [{ type: "italic" }]), text("后面")],
+        "这是<em>强调。</em>后面",
+      ],
+      [
+        "strike ending in punctuation before a letter",
+        [text("价格"), text("100元。", [{ type: "strike" }]), text("现在")],
+        "价格<s>100元。</s>现在",
+      ],
+      [
+        "English bold ending in a period before a letter",
+        [text("Say "), text("hello.", bold), text("World")],
+        "Say <strong>hello.</strong>World",
+      ],
+    ])("writes %s as HTML", (_label, content, expected) => {
+      const json = doc(p(...content));
+      expect(tiptapJsonToMarkdown(json)).toBe(expected);
+      expect(JSON.parse(markdownToTiptapJson(expected))).toEqual(
+        JSON.parse(json),
+      );
+    });
+
+    it.each([
+      [
+        "between spaces",
+        [text("a "), text("bold", bold), text(" b")],
+        "a **bold** b",
+      ],
+      [
+        "inside CJK text",
+        [text("中"), text("加粗", bold), text("文")],
+        "中**加粗**文",
+      ],
+      [
+        "ending in punctuation before punctuation",
+        [text("说"), text("好。", bold), text("」")],
+        "说**好。**」",
+      ],
+    ])("keeps Markdown delimiters %s", (_label, content, expected) => {
+      const json = doc(p(...content));
+      expect(tiptapJsonToMarkdown(json)).toBe(expected);
+      expect(JSON.parse(markdownToTiptapJson(expected))).toEqual(
+        JSON.parse(json),
+      );
+    });
+  });
+
+  // Text that happens to open a line with block syntax must come back as the
+  // same paragraph, not as a list, heading, or setext underline.
+  describe("block markers at the start of a line", () => {
+    const br = { type: "hardBreak" };
+
+    it.each([
+      ["a numbered line", [text("1986. A good year")], "1986\\. A good year"],
+      ["a parenthesized number", [text("2) Second")], "2\\) Second"],
+      ["a dash", [text("- not a list")], "\\- not a list"],
+      ["a plus", [text("+ not a list")], "\\+ not a list"],
+      ["a hash", [text("# not a heading")], "\\# not a heading"],
+      [
+        "numbered lines after hard breaks",
+        [text("Update:"), br, text("1. Pony"), br, text("2. Next")],
+        "Update:  \n1\\. Pony  \n2\\. Next",
+      ],
+      [
+        "a dash rule after a hard break",
+        [text("Title"), br, text("---")],
+        "Title  \n\\---",
+      ],
+      [
+        "an equals rule after a hard break",
+        [text("Title"), br, text("===")],
+        "Title  \n\\===",
+      ],
+    ])("escapes %s", (_label, content, expected) => {
+      const json = doc(p(...content));
+      expect(tiptapJsonToMarkdown(json)).toBe(expected);
+      expect(JSON.parse(markdownToTiptapJson(expected))).toEqual(
+        JSON.parse(json),
+      );
+    });
+
+    it("leaves markers in the middle of a line alone", () => {
+      expect(tiptapJsonToMarkdown(doc(p(text("Step 1. then 2."))))).toBe(
+        "Step 1. then 2.",
+      );
+    });
+
+    it("escapes a numbered line inside a list item", () => {
+      const json = doc({
+        type: "orderedList",
+        content: [
+          { type: "listItem", content: [p(text("1. nested-looking"))] },
+        ],
+      });
+      expect(tiptapJsonToMarkdown(json)).toBe("1. 1\\. nested-looking");
+      expect(
+        JSON.parse(markdownToTiptapJson("1. 1\\. nested-looking")),
+      ).toEqual(JSON.parse(json));
+    });
   });
 
   describe("round-trip", () => {
@@ -411,12 +559,32 @@ describe("tiptapJsonToMarkdown", () => {
   });
 
   describe("edge cases", () => {
-    it("returns empty string for invalid JSON", () => {
-      expect(tiptapJsonToMarkdown("not json")).toBe("");
+    it("throws for invalid JSON instead of returning nothing", () => {
+      expect(() => tiptapJsonToMarkdown("not json")).toThrow();
     });
 
-    it("returns empty string for non-doc node", () => {
-      expect(tiptapJsonToMarkdown('{"type":"paragraph"}')).toBe("");
+    it("throws for a root that is not a doc", () => {
+      expect(() => tiptapJsonToMarkdown('{"type":"paragraph"}')).toThrow(/doc/);
+    });
+
+    // A stored body with an empty list item made the serializer throw, and
+    // the catch-all turned the whole post into "" in the export.
+    it("fills an empty list item instead of dropping the document", () => {
+      const json = doc(
+        { type: "heading", attrs: { level: 2 }, content: [text("Setup")] },
+        {
+          type: "orderedList",
+          content: [
+            { type: "listItem", content: [] },
+            { type: "listItem", content: [p(text("Install"))] },
+          ],
+        },
+        { type: "codeBlock", content: [text("nix run")] },
+      );
+      const markdown = tiptapJsonToMarkdown(json);
+      expect(markdown).toContain("## Setup");
+      expect(markdown).toContain("Install");
+      expect(markdown).toContain("nix run");
     });
 
     it("handles empty doc", () => {

package/src/lib/__tests__/upload-sideload.test.ts

@@ -64,6 +64,20 @@ describe("sniffImageMimeType", () => {
     expect(sniffImageMimeType(bytes)).toBe("image/avif");
   });
 
+  it.each(["heic", "heix", "hevc", "hevx", "mif1", "msf1"])(
+    "detects HEIC/HEIF via the %s ftyp brand",
+    (brand) => {
+      const bytes = new Uint8Array(16);
+      bytes.set([...new TextEncoder().encode("ftyp")], 4);
+      bytes.set([...new TextEncoder().encode(brand)], 8);
+      expect(sniffImageMimeType(bytes)).toBe("image/heic");
+    },
+  );
+
+  it("keeps HEIC out of the sideload formats", () => {
+    expect(isAllowedSideloadImageType("image/heic")).toBe(false);
+  });
+
   it("detects SVG from an <svg> root", () => {
     const svg = new TextEncoder().encode(
       '<?xml version="1.0"?>\n<svg xmlns="http://www.w3.org/2000/svg"></svg>',

package/src/lib/__tests__/url-fetch.test.ts

@@ -83,8 +83,7 @@ describe("fetchImageBytes", () => {
     );
 
     const headers = fetchMock.mock.calls[0]?.[1]?.headers as
-      | Record<string, string>
-      | undefined;
+      Record<string, string> | undefined;
     expect(headers?.Referer).toBe("https://img9.doubanio.com/");
   });
 

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

@@ -4,11 +4,12 @@ import {
   extractDisplayDomain,
   isFullUrl,
   isSafeAbsoluteUrl,
+  looksLikeAddress,
   normalizePath,
   sanitizeRichTextHref,
   sanitizeUrl,
   stripSitePathPrefix,
-  slugify,
+  toInternalPath,
   toSameSitePath,
 } from "../url.js";
 
@@ -229,97 +230,102 @@ describe("URL sanitizers", () => {
   });
 });
 
-describe("slugify", () => {
-  it("converts text to lowercase hyphenated slug", () => {
-    expect(slugify("Hello World")).toBe("hello-world");
-  });
-
-  it("removes special characters", () => {
-    expect(slugify("Hello World! This is a Test.")).toBe(
-      "hello-world-this-is-a-test",
+describe("stripSitePathPrefix", () => {
+  it("rewrites prefixed asset paths into the internal asset namespace", () => {
+    expect(stripSitePathPrefix("/blog/_assets/client.css", "/blog")).toBe(
+      "/_assets/client.css",
     );
   });
 
-  it("collapses multiple spaces", () => {
-    expect(slugify("Multiple   Spaces")).toBe("multiple-spaces");
-  });
-
-  it("trims leading/trailing whitespace and hyphens", () => {
-    expect(slugify("  Multiple   Spaces  ")).toBe("multiple-spaces");
-  });
-
-  it("replaces underscores with hyphens", () => {
-    expect(slugify("hello_world")).toBe("hello-world");
-  });
-
-  it("handles already-slugified text", () => {
-    expect(slugify("already-a-slug")).toBe("already-a-slug");
-  });
-
-  it("handles empty string", () => {
-    expect(slugify("")).toBe("");
-  });
-
-  it("transliterates accented characters", () => {
-    expect(slugify("café & résumé")).toBe("cafe-and-resume");
-  });
-
-  it("converts Chinese characters to pinyin", () => {
-    expect(slugify("书评")).toBe("shu-ping");
-  });
-
-  it("handles mixed Chinese and English text", () => {
-    expect(slugify("我的 Blog")).toBe("wo-de-blog");
-  });
-
-  it("handles CJK characters with spaces", () => {
-    expect(slugify("电影 评论")).toBe("dian-ying-ping-lun");
+  it("rejects paths outside the configured site prefix", () => {
+    expect(stripSitePathPrefix("/_assets/client.css", "/blog")).toBe(null);
   });
+});
 
-  it("romanizes Korean titles", () => {
-    expect(slugify("안녕하세요 세계")).toBe("annyeonghaseyo-segye");
-    expect(slugify("개발 일지 3일차")).toBe("gaebal-ilji-3ilcha");
+describe("looksLikeAddress", () => {
+  it("recognizes what a browser would have produced", () => {
+    expect(looksLikeAddress("/about")).toBe(true);
+    expect(looksLikeAddress("  https://example.com/about  ")).toBe(true);
   });
 
-  it("romanizes kana-only Japanese titles", () => {
-    expect(slugify("カタカナタイトル")).toBe("katakanataitoru");
-    expect(slugify("ハンバーガー")).toBe("hanbaga");
+  it("leaves search words alone", () => {
+    // The line that keeps a picker's search box a search box: "about" is a
+    // word someone is looking for, not the page /about.
+    expect(looksLikeAddress("about")).toBe(false);
+    expect(looksLikeAddress("coffee notes")).toBe(false);
+    expect(looksLikeAddress("example.com")).toBe(false);
   });
+});
 
-  it("keeps Latin words in mostly-kana Japanese titles", () => {
-    expect(slugify("React入門ガイド")).toBe("react-gaido");
+describe("toInternalPath", () => {
+  const SITE = {
+    siteOrigins: ["https://example.com"],
+    sitePathPrefix: "/blog",
+    languagePrefixes: ["zh-hans", "en"],
+  };
+
+  it("reads a path, a full URL, and a prefixed URL as the same page", () => {
+    expect(toInternalPath("/about", SITE)).toBe("/about");
+    expect(toInternalPath("about", SITE)).toBe("/about");
+    expect(toInternalPath("https://example.com/blog/about", SITE)).toBe(
+      "/about",
+    );
+    expect(toInternalPath("/blog/about", SITE)).toBe("/about");
+    // A typed path without the deployment prefix still means this site.
+    expect(toInternalPath("/about", SITE)).toBe("/about");
   });
 
-  it("returns empty for kanji-heavy Japanese titles instead of garbling them", () => {
-    // Kanji carries the meaning; without a reading dictionary any output
-    // would be gibberish, so callers should fall back to a random ID.
-    expect(slugify("日本語のタイトルです")).toBe("");
-    expect(slugify("東京タワーに行った")).toBe("");
-    expect(slugify("こんにちは世界")).toBe("");
+  it("strips a language prefix, because a view is not another page", () => {
+    expect(toInternalPath("/en/about", SITE)).toBe("/about");
+    expect(toInternalPath("https://example.com/blog/zh-hans/about", SITE)).toBe(
+      "/about",
+    );
+    // The prefix alone is that view's home.
+    expect(toInternalPath("/en", SITE)).toBe("/");
   });
 
-  it("returns empty for scripts with no usable transliteration", () => {
-    expect(slugify("שלום עולם")).toBe("");
-    expect(slugify("สวัสดีชาวโลก")).toBe("");
+  it("keeps a first segment that only looks like a language", () => {
+    // A single-language site is free to have a post at /en — nothing is
+    // serving a view there.
+    expect(toInternalPath("/en/about", { sitePathPrefix: "" })).toBe(
+      "/en/about",
+    );
   });
 
-  it("returns empty when most of the title is untransliterable", () => {
-    expect(slugify("שלום world")).toBe("");
+  it("matches any host the site answers on", () => {
+    const origins = {
+      siteOrigins: ["https://example.com", "https://alias.dev"],
+    };
+    expect(toInternalPath("https://alias.dev/about", origins)).toBe("/about");
+    // Scheme and port differ in dev; the host is what decides.
+    expect(toInternalPath("http://example.com:8787/about", origins)).toBe(
+      "/about",
+    );
   });
 
-  it("returns empty for emoji-only titles", () => {
-    expect(slugify("🎉🎉")).toBe("");
+  it("refuses everything that is not a page on this site", () => {
+    expect(toInternalPath("https://other.com/about", SITE)).toBeNull();
+    expect(toInternalPath("mailto:hi@example.com", SITE)).toBeNull();
+    expect(toInternalPath("tel:+15551234567", SITE)).toBeNull();
+    expect(toInternalPath("//other.com/about", SITE)).toBeNull();
+    expect(toInternalPath("#section", SITE)).toBeNull();
+    expect(toInternalPath("   ", SITE)).toBeNull();
+    // A full URL inside our host but outside the deployment.
+    expect(
+      toInternalPath("https://example.com/other-app/about", SITE),
+    ).toBeNull();
   });
-});
 
-describe("stripSitePathPrefix", () => {
-  it("rewrites prefixed asset paths into the internal asset namespace", () => {
-    expect(stripSitePathPrefix("/blog/_assets/client.css", "/blog")).toBe(
-      "/_assets/client.css",
-    );
+  it("drops the query unless the caller is navigating", () => {
+    expect(toInternalPath("/about?ref=x#top", SITE)).toBe("/about");
+    expect(
+      toInternalPath("/about?ref=x#top", { ...SITE, keepQuery: true }),
+    ).toBe("/about?ref=x#top");
   });
 
-  it("rejects paths outside the configured site prefix", () => {
-    expect(stripSitePathPrefix("/_assets/client.css", "/blog")).toBe(null);
+  it("normalizes trailing slashes and relative steps", () => {
+    expect(toInternalPath("/about/", SITE)).toBe("/about");
+    expect(toInternalPath("/collections/../about", SITE)).toBe("/about");
+    expect(toInternalPath("/", SITE)).toBe("/");
   });
 });