app/lib/site-map.mjs

Functions

Imports

It imports no other module of this repo. Imported by app/lib/site-urls.server.ts, app/routes/site-map.tsx.

Source

1/**
2 * The site map page (/site-map), drawn from the one list of public URLs that sitemap.xml is also drawn from
3 * (app/lib/site-urls.server.ts), so the two cannot drift. Pure, and relative imports only, so
4 * test/site-map.test.mjs runs it under plain node.
5 *
6 * Grouped by the header menu's five sections, then Site. Every page is one line by its title, except the
7 * kinds of page there are many of (papers, registry items, procedures, posts and tags): those are one line,
8 * the count, linking to their index.
9 */
10
11/**
12 * @typedef {{ key: string, label: string, to: string, merge: boolean }} Tally
13 *   An item counted rather than listed. `to` is its index; with `merge`, the count goes on the index's own
14 *   line (Publications (36)). Without it, the count is a line of its own in `to`'s section, as plain text
15 *   (Tags (34)): the kind has no index of its own, and a second link to `to` under another name would make
16 *   two links with different text go to one place.
17 * @typedef {{ path: string, lastmod: Date | null, title: string, tally?: Tally, images?: string[] }} SiteUrl
18 *   `images`: the site paths of the images the page shows, for sitemap.xml's image entries.
19 * @typedef {{ to: string, label: string, count?: number, plain?: boolean }} SiteMapLine
20 *   `plain`: shown as text, not a link; `to` then only places it in its section.
21 * @typedef {{ id: string, heading: string, to: string | null, lines: SiteMapLine[] }} SiteMapSection
22 */
23
24/**
25 * The sections, in the header's order (app/lib/nav.ts, NAV), then Site. `roots` are the address prefixes a
26 * section owns; the first match wins, and a path no section owns is Site's. The System map sits under
27 * Software, where the header's Software panel links it; the CV and the recipes sit under About, where the
28 * About panel links them.
29 */
30const SITE_MAP_SECTIONS = /** @type {const} */ ([
31  { id: "research", heading: "Research", to: "/research", roots: ["/research"] },
32  { id: "teaching", heading: "Teaching", to: "/teaching", roots: ["/teaching"] },
33  { id: "software", heading: "Software", to: "/software", roots: ["/software", "/systems"] },
34  { id: "writing", heading: "Writing", to: "/writing", roots: ["/writing"] },
35  { id: "about", heading: "About", to: "/about", roots: ["/about", "/cv", "/recipes"] },
36  { id: "site", heading: "Site", to: null, roots: [] },
37]);
38
39/** The page's own address. */
40export const SITE_MAP_PATH = "/site-map";
41
42/** @param {string} path @param {string} root */
43const under = (path, root) => path === root || path.startsWith(`${root}/`);
44
45/** The id of the section a path belongs to. @param {string} path */
46export function sectionOf(path) {
47  const found = SITE_MAP_SECTIONS.find((section) => section.roots.some((root) => under(path, root)));
48  return found ? found.id : "site";
49}
50
51/**
52 * The page's sections, from the URL list. Lines keep the list's order, except that a section's own hub
53 * comes first. A section with no line is left out.
54 *
55 * @param {SiteUrl[]} urls
56 * @returns {SiteMapSection[]}
57 */
58export function siteMapSections(urls) {
59  /** @type {Map<string, { tally: Tally, count: number }>} */
60  const tallies = new Map();
61  /** @type {SiteMapLine[]} */
62  const lines = [];
63  for (const url of urls) {
64    if (url.tally) {
65      const seen = tallies.get(url.tally.key);
66      if (seen) seen.count += 1;
67      else tallies.set(url.tally.key, { tally: url.tally, count: 1 });
68      continue;
69    }
70    lines.push({ to: url.path, label: url.title });
71  }
72  for (const { tally, count } of tallies.values()) {
73    const index = tally.merge ? lines.find((line) => line.to === tally.to && line.count === undefined && !line.plain) : undefined;
74    if (index) index.count = count;
75    else lines.push({ to: tally.to, label: tally.label, count, ...(tally.merge ? {} : { plain: true }) });
76  }
77  return SITE_MAP_SECTIONS.map(({ id, heading, to }) => {
78    const own = lines.filter((line) => sectionOf(line.to) === id);
79    const isHub = (/** @type {SiteMapLine} */ line) => line.to === to && !line.plain;
80    return { id, heading, to, lines: [...own.filter(isHub), ...own.filter((line) => !isHub(line))] };
81  }).filter((section) => section.lines.length > 0);
82}
83
84/** A line's text: its label, and its count in brackets when it has one. @param {SiteMapLine} line */
85export function lineText(line) {
86  return line.count === undefined ? line.label : `${line.label} (${line.count})`;
87}