app/lib/content/corpus.mjs

Functions

Imports

It imports app/lib/search/visibility.mjs. Imported by app/lib/content/pipeline.mjs.

Source

1// Corpus-wide passes, run over every post at once in both writers: related posts and backlinks.
2
3import { isPubliclyVisible, statusForDraft } from "../search/visibility.mjs";
4
5const RELATED_LIMIT = 3;
6
7/**
8 * Newest first, then by slug: a total order, so a tie is never left to array order.
9 *
10 * @param {{ publishAt: string, slug: string }} a
11 * @param {{ publishAt: string, slug: string }} b
12 */
13function newestThenSlug(a, b) {
14  return (a.publishAt < b.publishAt ? 1 : a.publishAt > b.publishAt ? -1 : 0) || (a.slug < b.slug ? -1 : 1);
15}
16
17/**
18 * Must run over the whole corpus in both writers: relatedness is a property of the set.
19 * isPubliclyVisible, not !draft, because a scheduled post is not a draft. blog.$slug.tsx filters
20 * again because a listed post can be unpublished after this list is stored.
21 *
22 * @param {any[]} posts
23 */
24export function withRelated(posts) {
25  const now = Date.now();
26  return posts.map((post) => {
27    const tags = new Set(post.tags);
28    const scored = posts
29      .filter(
30        (other) =>
31          other.slug !== post.slug &&
32          isPubliclyVisible(
33            { status: statusForDraft(other.draft), publishAt: other.publishAt },
34            now,
35          ),
36      )
37      .map((other) => ({
38        slug: other.slug,
39        title: other.title,
40        description: other.description ?? null,
41        shared: other.tags.filter((/** @type {string} */ t) => tags.has(t)).length,
42        publishAt: other.publishAt,
43      }))
44      .filter((other) => other.shared > 0);
45
46    scored.sort(
47      (a, b) =>
48        b.shared - a.shared || newestThenSlug(a, b),
49    );
50
51    return {
52      ...post,
53      related: scored
54        .slice(0, RELATED_LIMIT)
55        .map(({ slug, title, description, shared }) => ({ slug, title, description, shared })),
56    };
57  });
58}
59
60/**
61 * Read from rendered HTML, which unifies inline, reference and raw links. Deliberately loose: the
62 * corpus in withBacklinks is the filter.
63 *
64 * @param {string} html
65 * @returns {Set<string>}
66 */
67function outgoingPostLinks(html) {
68  const found = new Set();
69  for (const match of html.matchAll(/href="\/writing\/([^"#?]+)(?:[#?][^"]*)?"/g)) {
70    found.add(match[1]);
71  }
72  return found;
73}
74
75/**
76 * Whole corpus, like withRelated. The SOURCE is filtered for visibility so a draft cannot put its title
77 * on a public page; blog.$slug.tsx re-checks. No limit: a cap would silently drop real links.
78 *
79 * @param {any[]} posts
80 */
81export function withBacklinks(posts) {
82  const now = Date.now();
83  const isPost = new Set(posts.map((post) => post.slug));
84  /** @type {Map<string, Array<{ slug: string, title: string, publishAt: string }>>} */
85  const incoming = new Map();
86
87  for (const post of posts) {
88    if (
89      !isPubliclyVisible(
90        { status: statusForDraft(post.draft), publishAt: post.publishAt },
91        now,
92      )
93    ) {
94      continue;
95    }
96    for (const target of outgoingPostLinks(post.html ?? "")) {
97      // A post linking to itself is a table of contents, not a backlink.
98      if (target === post.slug || !isPost.has(target)) continue;
99      const list = incoming.get(target) ?? [];
100      list.push({ slug: post.slug, title: post.title, publishAt: post.publishAt });
101      incoming.set(target, list);
102    }
103  }
104
105  return posts.map((post) => {
106    // Never leave a tie to array order, which is not stable input.
107    const list = (incoming.get(post.slug) ?? []).sort(newestThenSlug);
108    return {
109      ...post,
110      backlinks: list.map(({ slug, title }) => ({ slug, title })),
111    };
112  });
113}