app/lib/publications/listing.mjs

Functions

Imports

It imports app/lib/publications/entities.mjs, app/lib/publications/topics.mjs. Imported by app/routes/publications.tsx.

Source

1/**
2 * The publication index (docs/PUBLICATIONS.md): its fields declared once for Capsomer's catalog, so the search box, the
3 * topic and other facets, the sort menu, the year headings and the counts all come from this one declaration. Pure
4 * over the query string and the papers it is handed. The route adds the citation counts (a D1 read) and the page copy.
5 *
6 * What did not change, because search engines and the machine-readable gates hold it: `?topic=` is the address of a
7 * topic's papers, and exactly the four bare single-topic addresses canonicalise to themselves (`soleTopic`); every other
8 * address is a view of the base page.
9 */
10
11import { defineCatalog, parseCatalogParams, queryCatalog } from "capsomer/behaviour/catalog";
12
13import { decodeEntities } from "./entities.mjs";
14import { TOPICS, TOPIC_IDS } from "./topics.mjs";
15
16/** @typedef {import("./types.ts").Publication} Publication */
17/** @typedef {import("./types.ts").PublicationType} PublicationType */
18/** @typedef {import("./types.ts").TopicId} TopicId */
19
20/**
21 * Conference abstracts stay in the data file, which the CV also reads, and are excluded here.
22 *
23 * @type {Set<PublicationType>}
24 */
25export const SHOWCASE_TYPES = new Set([
26  "article",
27  "review",
28  "chapter",
29  "teaching-resource",
30]);
31
32const PUBLICATIONS_BASE = "/research/publications";
33
34const TYPE_LABELS = /** @type {Record<string, string>} */ ({
35  article: "Article",
36  review: "Review",
37  chapter: "Chapter",
38  "teaching-resource": "Teaching resource",
39});
40
41/** The journal, volume and pages as the page prints them, entities decoded (the year has its own column). @param {Publication} p */
42export function venue(p) {
43  return decodeEntities([p.journal, p.volume, p.pages].filter(Boolean).join(", "));
44}
45
46/** The papers' catalog. Newest first by default, under a heading for each year; any search or other sort is flat. */
47export const PUBLICATIONS = defineCatalog(
48  /** @type {import("capsomer/behaviour/catalog").CatalogDefinition<Publication>} */ ({
49    id: "papers",
50    noun: ["paper", "papers"],
51    basePath: PUBLICATIONS_BASE,
52    itemKey: (p) => p.id,
53    defaultSort: "-year",
54    group: { field: "year" },
55    fields: [
56      { key: "title", label: "Title", value: (p) => decodeEntities(p.title), search: 3, sort: true, column: { header: "Paper" } },
57      { key: "authors", label: "Authors", value: (p) => p.authors.map(decodeEntities), search: 1 },
58      { key: "journal", label: "Journal", value: (p) => venue(p), search: 2, column: { header: "Journal", drop: 1 } },
59      {
60        key: "year",
61        label: "Year",
62        value: (p) => p.year,
63        type: "number",
64        sort: { labels: { asc: "oldest first", desc: "newest first" } },
65        column: { header: "Year", align: "end", hideWhenGrouped: true },
66      },
67      {
68        key: "topic",
69        label: "Topic",
70        value: (p) => p.topics,
71        facet: { kind: "many", general: true, order: TOPICS.map((t) => t.id), label: (v) => TOPICS.find((t) => t.id === v)?.label ?? v },
72      },
73      { key: "type", label: "Type", value: (p) => p.type, facet: { kind: "many", label: (v) => TYPE_LABELS[v] ?? v } },
74      // Chosen with `?selected=1`, as the page's "Selected" filter always was.
75      { key: "selected", label: "Selected", value: (p) => (p.selected ? "1" : null), facet: { kind: "one", label: () => "Selected papers" } },
76      { key: "access", label: "Access", value: (p) => (p.isOpenAccess ? "open" : null), facet: { kind: "one", label: () => "Open access" } },
77    ],
78  }),
79);
80
81/**
82 * The address a request written in the old parameters should have, or null. The page used `?sort=year-desc|year-asc|title`
83 * and `?selected=1|true`; the catalog says `sort=-year|year|title` and `selected=1`. A link in the wild keeps working: it
84 * is sent, once, to the same view at its new address. A request with none of the old spellings is left alone.
85 *
86 * @param {URL} url
87 */
88export function legacyAddress(url) {
89  const params = url.searchParams;
90  const sort = params.get("sort");
91  const oldSort = sort === "year-desc" || sort === "year-asc";
92  const oldSelected = (params.get("selected") ?? "").toLowerCase() === "true";
93  if (!oldSort && !oldSelected) return null;
94  const next = new URLSearchParams(params);
95  if (sort === "year-desc") next.delete("sort");
96  if (sort === "year-asc") next.set("sort", "year");
97  if (oldSelected) next.set("selected", "1");
98  return queryCatalog(PUBLICATIONS, [], parseCatalogParams(PUBLICATIONS, next)).href();
99}
100
101/**
102 * Only the four bare single-topic URLs self-canonical: the rest are subsets or orderings, and q is unbounded.
103 *
104 * @param {URLSearchParams} params
105 * @returns {TopicId | null}
106 */
107export function soleTopic(params) {
108  const topics = params.getAll("topic").filter((t) => TOPIC_IDS.has(t));
109  const KNOWN_PARAMS = new Set(["topic", "q", "sort", "selected"]);
110  const hasUnknownParam = [...params.keys()].some((k) => !KNOWN_PARAMS.has(k));
111  return topics.length === 1 &&
112    params.getAll("topic").length === 1 &&
113    !params.has("q") &&
114    !params.has("sort") &&
115    !params.has("selected") &&
116    !hasUnknownParam
117    ? /** @type {TopicId} */ (topics[0])
118    : null;
119}
120
121/**
122 * The page's state for an address: the showcase papers run through the catalog, with the span the header states and the
123 * canonical topic. Everything shown is in `result`.
124 *
125 * @param {URLSearchParams} params
126 * @param {Publication[]} publications every published paper, newest first (app/db/publications.ts)
127 */
128export function publicationListing(params, publications) {
129  const showcase = publications.filter((p) => SHOWCASE_TYPES.has(p.type));
130  const result = queryCatalog(PUBLICATIONS, showcase, parseCatalogParams(PUBLICATIONS, params));
131  const items = result.rows;
132  const span = {
133    papers: items.length,
134    firstYear: items.length > 0 ? Math.min(...items.map((p) => p.year)) : null,
135    lastYear: items.length > 0 ? Math.max(...items.map((p) => p.year)) : null,
136    venues: new Set(items.map((p) => p.journal).filter(Boolean)).size,
137  };
138  return { items, result, span, soleTopic: soleTopic(params), total: showcase.length };
139}