@anja.codes/vitakit 0.1.0 → 0.3.0

package/dist/chunks/prompt.mjs

@@ -0,0 +1,33 @@
+async function choose(io, question, choices, defaultIndex = 0) {
+  io.out(`
+${question}
+`);
+  choices.forEach((choice, index) => io.out(`  ${index + 1}  ${choice.label}${index === defaultIndex ? "   (Enter)" : ""}
+`));
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const answer = (await io.ask("> ")).trim();
+    if (answer === "") return choices[defaultIndex].value;
+    const number = Number(answer);
+    if (Number.isInteger(number) && number >= 1 && number <= choices.length) return choices[number - 1].value;
+    const named = choices.find((choice) => choice.label.toLowerCase() === answer.toLowerCase());
+    if (named) return named.value;
+    io.out(`  A number from 1 to ${choices.length}, please.
+`);
+  }
+  return choices[defaultIndex].value;
+}
+async function confirm(io, question, yes = true) {
+  const answer = (await io.ask(`${question} ${yes ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+  if (answer === "") return yes;
+  return answer === "y" || answer === "yes";
+}
+async function input(io, question, fallback) {
+  const answer = (await io.ask(`${question}${fallback ? ` [${fallback}]` : ""}: `)).trim();
+  return answer || fallback || "";
+}
+function headingFor(id) {
+  const words = id.split("-").join(" ");
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+
+export { choose, confirm, headingFor, input };

package/dist/chunks/publication-lists.mjs

@@ -0,0 +1,202 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+import { z } from 'zod';
+import { f as fail, m as messageOf, a as formatZodIssues } from '../shared/vitakit.DCK90zq4.mjs';
+import 'node:url';
+
+const LISTS_FILE = "content/publication-lists.yml";
+const LISTS_HEADER = `# Publication lists: which publications of publications.bib a list shows,
+# in what order and in which groups. A page shows one with
+#   <VitaPublications list="recent" title="Recent publications" />
+# and a PDF with
+#   \\vitapublications[Recent publications]{recent}
+#
+# Settings, all optional:
+#   where:    { status: preprint }, { keywords: selected }, { year: 2024 } --
+#             fields of the entries in publications.bib; [a, b] means a or b
+#   keys:     [doe2024, roe2023] -- exactly these, in this order
+#   since, until: years
+#   sort:     date (newest first), year, title, source (as in publications.bib),
+#             or a field; order: asc or desc
+#   limit:    at most this many
+#   groupBy:  status, year or a field; otherLabel: the heading for the entries
+#             without it (Other)
+# \`vitakit explain publications\` shows what each list contains and where.
+`;
+const DERIVED = /* @__PURE__ */ new Set(["key", "status", "year"]);
+const NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const field = z.string().regex(/^[A-Za-z][\w-]*$/, "expected a BibTeX field name").transform((name) => name.toLowerCase());
+const scalar = z.union([z.string(), z.number(), z.boolean()]);
+const listInput = z.strictObject({
+  where: z.record(z.string(), z.union([scalar, z.array(scalar).min(1)])).default({}),
+  keys: z.array(z.string().min(1)).min(1).optional(),
+  since: z.number().int().optional(),
+  until: z.number().int().optional(),
+  sort: field.optional(),
+  order: z.enum(["asc", "desc"]).optional(),
+  limit: z.number().int().positive().optional(),
+  groupBy: field.optional(),
+  otherLabel: z.string().trim().min(1).optional()
+});
+function resolveList(name, value, schema) {
+  const at = (option) => `${name}.${option}`;
+  if (!NAME.test(name)) fail(LISTS_FILE, `${name}: a list name is lowercase kebab-case, e.g. recent-papers`);
+  const parsed = listInput.safeParse(value ?? {});
+  if (!parsed.success) fail(LISTS_FILE, `${name}: invalid
+${formatZodIssues(parsed.error)}`);
+  const input = parsed.data;
+  const where = {};
+  for (const [key, wanted] of Object.entries(input.where)) {
+    const parsedField = field.safeParse(key);
+    if (!parsedField.success) fail(LISTS_FILE, `${at(`where.${key}`)}: expected a BibTeX field name`);
+    where[parsedField.data] = wanted;
+  }
+  const statuses = schema.statuses.map((status) => status.id);
+  for (const status of where.status === void 0 ? [] : [where.status].flat()) {
+    if (!statuses.includes(String(status).toLowerCase())) {
+      fail(LISTS_FILE, `${at("where.status")}: no status "${status}"; the statuses are ${statuses.join(", ")} (schemas/publications.ts)`);
+    }
+  }
+  if (input.keys && input.sort) fail(LISTS_FILE, `${at("sort")}: a list of keys is shown in the order of its keys; remove sort or keys`);
+  if (input.order && (input.keys || input.sort === "source")) fail(LISTS_FILE, `${at("order")}: only applies when sorting by a field`);
+  if (input.groupBy === "keywords") fail(LISTS_FILE, `${at("groupBy")}: an entry can have several keywords; group by another field`);
+  if (input.otherLabel && (!input.groupBy || input.groupBy === "status")) {
+    fail(LISTS_FILE, `${at("otherLabel")}: only applies when grouping by year or by a field`);
+  }
+  const sort = input.sort ?? "date";
+  return {
+    where,
+    ...input.keys ? { keys: input.keys } : {},
+    ...input.since !== void 0 ? { since: input.since } : {},
+    ...input.until !== void 0 ? { until: input.until } : {},
+    sort,
+    order: input.order ?? (sort === "date" || sort === "year" ? "desc" : "asc"),
+    ...input.limit !== void 0 ? { limit: input.limit } : {},
+    ...input.groupBy ? { groupBy: input.groupBy } : {},
+    otherLabel: input.otherLabel ?? "Other"
+  };
+}
+async function publicationListNames(rootDir) {
+  try {
+    const data = parse(await readFile(join(rootDir, LISTS_FILE), "utf8"));
+    return data && typeof data === "object" && !Array.isArray(data) ? Object.keys(data) : [];
+  } catch {
+    return [];
+  }
+}
+async function loadPublicationLists(rootDir, schema) {
+  const raw = await readFile(join(rootDir, LISTS_FILE), "utf8").catch((error) => {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  });
+  if (raw === void 0) return {};
+  let data;
+  try {
+    data = parse(raw);
+  } catch (error) {
+    fail(LISTS_FILE, messageOf(error));
+  }
+  if (data === null || data === void 0) return {};
+  if (typeof data !== "object" || Array.isArray(data)) fail(LISTS_FILE, "expected one list per name, e.g. `recent: { limit: 3 }`");
+  return Object.fromEntries(Object.entries(data).map(([name, value]) => [name, resolveList(name, value, schema)]));
+}
+function publicationStatus(entry, schema) {
+  return (entry.custom.status?.trim() || schema.defaultStatus).toLowerCase();
+}
+const plain = (value) => {
+  const text = typeof value === "string" ? value.replace(/[{}]/g, "").trim() : void 0;
+  return text || void 0;
+};
+function valueOf(entry, name, schema) {
+  if (name === "key") return entry.key;
+  if (name === "status") return publicationStatus(entry, schema);
+  if (name === "year") return entry.year === null ? void 0 : String(entry.year);
+  return plain(entry.raw[name]);
+}
+function matches(entry, name, wanted, schema) {
+  const value = valueOf(entry, name, schema);
+  const actual = name === "keywords" ? value?.split(/[,;]/).map((keyword) => keyword.trim()) ?? [] : value === void 0 ? [] : [value];
+  return [wanted].flat().map(String).some((candidate) => actual.includes(name === "status" ? candidate.toLowerCase() : candidate));
+}
+const collator = new Intl.Collator(void 0, { numeric: true, sensitivity: "base" });
+function sortByText(entries, value, order) {
+  const keyed = entries.map((entry) => ({ entry, value: value(entry) }));
+  const sign = order === "asc" ? 1 : -1;
+  return keyed.sort((a, b) => a.value === void 0 ? b.value === void 0 ? 0 : 1 : b.value === void 0 ? -1 : sign * collator.compare(a.value, b.value)).map((item) => item.entry);
+}
+function sortEntries(bib, entries, list, schema) {
+  if (list.keys || list.sort === "source") return entries;
+  if (list.sort === "date" || list.sort === "year") {
+    const dated = entries.filter((entry) => entry.year !== null);
+    return [...bib.sort(dated, { by: list.sort, order: list.order }), ...entries.filter((entry) => entry.year === null)];
+  }
+  return sortByText(entries, (entry) => valueOf(entry, list.sort, schema), list.order);
+}
+function group(entries, list, schema) {
+  const by = list.groupBy;
+  if (!by) return entries.length ? [{ entries }] : [];
+  if (by === "status") {
+    return schema.statuses.map((status) => ({ label: status.label, entries: entries.filter((entry) => publicationStatus(entry, schema) === status.id) })).filter((selected) => selected.entries.length);
+  }
+  const values = [...new Set(entries.map((entry) => valueOf(entry, by, schema)).filter((value) => value !== void 0))];
+  values.sort(by === "year" ? (a, b) => Number(b) - Number(a) : collator.compare);
+  const groups = values.map((value) => ({ label: value, entries: entries.filter((entry) => valueOf(entry, by, schema) === value) }));
+  const other = entries.filter((entry) => valueOf(entry, by, schema) === void 0);
+  return other.length ? [...groups, { label: list.otherLabel, entries: other }] : groups;
+}
+function selectionSteps(bib, name, list, schema) {
+  const fields = [...Object.keys(list.where), list.sort, list.groupBy].filter((candidate) => !!candidate && !DERIVED.has(candidate) && !["date", "source"].includes(candidate));
+  for (const candidate of new Set(fields)) {
+    if (bib.entries.length && !bib.entries.some((entry) => plain(entry.raw[candidate]) !== void 0)) {
+      fail(LISTS_FILE, `${name}: no publication has a field "${candidate}"`);
+    }
+  }
+  const steps = [];
+  if (list.keys) {
+    const byKey = new Map(bib.entries.map((entry) => [entry.key, entry]));
+    const missing = list.keys.filter((key) => !byKey.has(key));
+    if (missing.length) fail(LISTS_FILE, `${name}.keys: no publication ${missing.join(", ")} in content/publications.bib`);
+    steps.push({ rule: `keys: ${list.keys.length}`, apply: () => list.keys.map((key) => byKey.get(key)) });
+  }
+  for (const [field2, wanted] of Object.entries(list.where)) {
+    steps.push({ rule: `where ${field2}: ${[wanted].flat().join(", ")}`, apply: (entries) => entries.filter((entry) => matches(entry, field2, wanted, schema)) });
+  }
+  if (list.since !== void 0) steps.push({ rule: `since: ${list.since}`, apply: (entries) => entries.filter((entry) => entry.year !== null && entry.year >= list.since) });
+  if (list.until !== void 0) steps.push({ rule: `until: ${list.until}`, apply: (entries) => entries.filter((entry) => entry.year !== null && entry.year <= list.until) });
+  steps.push({ rule: "sort", apply: (entries) => sortEntries(bib, entries, list, schema) });
+  if (list.limit !== void 0) steps.push({ rule: `limit: ${list.limit}`, apply: (entries) => entries.slice(0, list.limit) });
+  return steps;
+}
+function selectPublications(bib, name, list, schema) {
+  let entries = bib.entries;
+  for (const step of selectionSteps(bib, name, list, schema)) entries = step.apply(entries);
+  return group(entries, list, schema);
+}
+function explainListSelection(bib, name, list, schema) {
+  let entries = bib.entries;
+  const steps = [];
+  for (const step of selectionSteps(bib, name, list, schema)) {
+    const next = step.apply(entries);
+    steps.push({ rule: step.rule, removed: entries.length - next.length });
+    entries = next;
+  }
+  return { total: bib.entries.length, steps: steps.filter((step) => step.removed > 0), keys: group(entries, list, schema).flatMap((selected) => selected.entries.map((entry) => entry.key)) };
+}
+function describeList(list) {
+  const parts = [];
+  if (list.keys) parts.push(`${list.keys.length} chosen by key`);
+  for (const [name, wanted] of Object.entries(list.where)) parts.push(`${name} ${[wanted].flat().join(" or ")}`);
+  if (list.since !== void 0) parts.push(`since ${list.since}`);
+  if (list.until !== void 0) parts.push(`until ${list.until}`);
+  if (!list.keys) {
+    if (list.sort === "source") parts.push("in .bib order");
+    else if (list.sort === "date" || list.sort === "year") parts.push(list.order === "desc" ? "newest first" : "oldest first");
+    else parts.push(`by ${list.sort}${list.order === "desc" ? ", descending" : ""}`);
+  }
+  if (list.limit !== void 0) parts.push(`at most ${list.limit}`);
+  if (list.groupBy) parts.push(`grouped by ${list.groupBy}`);
+  return parts.join(" \xB7 ");
+}
+
+export { LISTS_FILE, LISTS_HEADER, describeList, explainListSelection, loadPublicationLists, publicationListNames, publicationStatus, resolveList, selectPublications };

package/dist/chunks/schema-source.mjs

@@ -0,0 +1,12 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { r as resolveAsset } from '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:fs';
+import 'node:url';
+
+async function builtinSchemaSource(id) {
+  const source = await readFile(join(resolveAsset("schemas"), `${id}.ts`), "utf8");
+  return source.replace(/from '\.\.\/[\w-]+'/g, "from '@anja.codes/vitakit'");
+}
+
+export { builtinSchemaSource };

package/dist/chunks/schemas.mjs

@@ -0,0 +1,109 @@
+import { s as section, t as text, a as richText, u as url, l as linked, d as dateRange, b as absoluteUrl, r as requiredLink } from '../shared/vitakit.DvABWuUc.mjs';
+import { z } from 'zod';
+import '../shared/vitakit.DCK90zq4.mjs';
+import 'node:url';
+import '../shared/vitakit.D10HyDhF.mjs';
+
+const education = section({
+  date: dateRange,
+  degree: text,
+  institution: linked,
+  thesis: z.strictObject({
+    title: richText,
+    type: text.optional(),
+    supervisor: linked.optional(),
+    url: url.optional()
+  }).optional(),
+  note: text.optional()
+});
+
+const employment = section({
+  date: dateRange,
+  position: text,
+  institution: linked,
+  project: z.strictObject({
+    title: richText,
+    funder: text.optional(),
+    grant: text.optional(),
+    url: url.optional()
+  }).optional(),
+  note: text.optional()
+});
+
+const teaching = section({
+  date: dateRange,
+  title: richText,
+  role: text.optional(),
+  institution: linked.optional(),
+  /** e.g. `2024S`, `Winter 2023/24` -- free text, shown as written. */
+  term: text.optional(),
+  url: url.optional(),
+  note: text.optional()
+});
+
+const talks = section({
+  date: dateRange,
+  /** Markdown, math allowed. */
+  title: richText,
+  event: text.optional(),
+  location: text.optional(),
+  kind: z.enum(["invited", "contributed", "seminar", "poster", "outreach"]).optional(),
+  url: url.optional(),
+  slides: url.optional()
+});
+
+const supervision = section({
+  date: dateRange,
+  student: text,
+  /** A thesis still in progress; shown as such instead of as completed. */
+  ongoing: z.boolean().default(false),
+  /** Markdown, math allowed. */
+  title: richText,
+  degree: text.optional(),
+  institution: linked.optional(),
+  coSupervisor: text.optional()
+});
+
+const profile = z.strictObject({
+  name: text,
+  title: text.optional(),
+  affiliation: linked.optional(),
+  email: z.string().trim().email().optional(),
+  links: z.array(requiredLink).default([]),
+  /**
+   * One or two sentences for metadata: the page description and social
+   * previews. Prose belongs in `content/pages/index.md`, which is where a
+   * reader sees it -- this is deliberately not rendered on the page.
+   */
+  summary: text.optional(),
+  /**
+   * Where the website is published, e.g. `https://jane.example.org/` or
+   * `https://jane.github.io/site/`. The PDF needs it to link paths on the site
+   * such as `/slides/talk.pdf`; the website itself does not.
+   */
+  url: absoluteUrl.optional(),
+  /** Path below `public/`, e.g. `/img/portrait.jpg`. */
+  avatar: text.startsWith("/").optional(),
+  /** Navigation, in the order it should appear. */
+  nav: z.array(z.strictObject({ label: text, to: text })).default([]),
+  /** Footer line; inline Markdown. */
+  footer: text.optional()
+});
+const page = z.strictObject({
+  title: text,
+  description: text.optional(),
+  route: text.regex(/^\/(?:[a-z0-9-]+\/)*$/, "expected a route like /research/").optional(),
+  order: z.number().int().default(100)
+});
+const schemas = {
+  education,
+  employment,
+  teaching,
+  talks,
+  supervision
+};
+function extendSection(base, shape) {
+  return z.array(base.element.extend(shape));
+}
+
+export { education, employment, extendSection, page, profile, schemas, supervision, talks, teaching };

package/dist/chunks/sections.mjs

@@ -0,0 +1,109 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+import { schemas } from './schemas.mjs';
+import { f as fail, a as formatZodIssues, i as importProjectModule } from '../shared/vitakit.DCK90zq4.mjs';
+import { c as renderRichFields } from '../shared/vitakit.DvABWuUc.mjs';
+import { r as resolveSitePaths } from '../shared/vitakit.D10HyDhF.mjs';
+import { a as atMost } from '../shared/vitakit.TSMTC5Jl.mjs';
+import 'zod';
+import 'node:url';
+
+const RESERVED_SECTION_NAMES = /* @__PURE__ */ new Set(["site", "profile", "publication-lists"]);
+const SECTION_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function sectionNameProblem(id) {
+  if (RESERVED_SECTION_NAMES.has(id)) return `"${id}" is reserved and cannot be a section`;
+  if (!SECTION_NAME.test(id)) return `"${id}" must be lowercase kebab-case, e.g. research-stays`;
+  return void 0;
+}
+async function exists(path) {
+  return stat(path).then(() => true, () => false);
+}
+async function loadRepoSchema(path, id) {
+  const { mtimeMs } = await stat(path);
+  const module = await importProjectModule(path, mtimeMs, `schemas/${id}.ts`);
+  const schema = module.default ?? module.schema;
+  if (!schema || typeof schema.safeParse !== "function") {
+    fail(`schemas/${id}.ts`, "must export a Zod schema as its default export");
+  }
+  return schema;
+}
+const STARTER = (id) => `create schemas/${id}.ts, for example:
+
+  import { section, dateRange, richText, text } from '@anja.codes/vitakit'
+
+  export default section({
+    date: dateRange,
+    title: richText,
+    note: text.optional(),
+  })`;
+async function findSectionFiles(rootDir) {
+  const contentDir = join(rootDir, "content");
+  const names = (await readdir(contentDir).catch(() => fail("content/", "directory is missing"))).filter((name) => name.endsWith(".yml") || name.endsWith(".yaml")).sort();
+  const byId = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const id = name.replace(/\.ya?ml$/, "");
+    if (RESERVED_SECTION_NAMES.has(id)) continue;
+    byId.set(id, [...byId.get(id) ?? [], name]);
+  }
+  const files = [];
+  const problems = [];
+  for (const [id, found] of byId) {
+    const where = `content/${found[0]}`;
+    if (found.length > 1) {
+      problems.push({ where, message: `the section "${id}" exists twice (${found.join(", ")}); keep one of them` });
+      continue;
+    }
+    if (!SECTION_NAME.test(id)) {
+      problems.push({ where, message: "file name must be lowercase kebab-case, e.g. `research-stays.yml`" });
+      continue;
+    }
+    files.push({ id, file: join(contentDir, found[0]), where });
+  }
+  return { files, problems };
+}
+async function resolveSectionSchema(rootDir, file) {
+  const override = join(rootDir, "schemas", `${file.id}.ts`);
+  if (await exists(override)) {
+    return { ...file, schemaOrigin: "repo", schema: await loadRepoSchema(override, file.id) };
+  }
+  const builtin = schemas[file.id];
+  if (!builtin) fail(file.where, `no schema for this file; ${STARTER(file.id)}`);
+  return { ...file, schemaOrigin: "built-in", schema: builtin };
+}
+async function discoverSections(rootDir) {
+  const { files, problems } = await findSectionFiles(rootDir);
+  if (problems.length) fail(problems[0].where, problems[0].message);
+  const sources = [];
+  for (const file of files) sources.push(await resolveSectionSchema(rootDir, file));
+  return sources;
+}
+function byDateDesc(a, b) {
+  const left = a.date?.from?.sortKey;
+  const right = b.date?.from?.sortKey;
+  if (left === right) return 0;
+  if (!left) return 1;
+  if (!right) return -1;
+  return right.localeCompare(left);
+}
+async function loadSection(source, options) {
+  const where = source.where;
+  const raw = await readFile(source.file, "utf8");
+  let data;
+  try {
+    data = parse(raw);
+  } catch (error) {
+    fail(where, error instanceof Error ? error.message : String(error));
+  }
+  if (data === null) return [];
+  if (!Array.isArray(data)) fail(where, "expected a list of entries");
+  const parsed = source.schema.safeParse(data);
+  if (!parsed.success) {
+    const origin = source.schemaOrigin === "repo" ? ` (schema: schemas/${source.id}.ts)` : "";
+    fail(where, `invalid${origin}
+${formatZodIssues(parsed.error)}`);
+  }
+  return parsed.data.map((item, index) => ({ item: { ...item, id: `${source.id}-${index}` }, index })).filter(({ item }) => atMost(item.visibility, options.maxVisibility)).map(({ item, index }) => renderRichFields(item, options.renderer, String(index), where)).map((item) => resolveSitePaths(item, options.resolvePath ?? ((path) => path))).sort(byDateDesc);
+}
+
+export { RESERVED_SECTION_NAMES, SECTION_NAME, discoverSections, findSectionFiles, loadSection, resolveSectionSchema, sectionNameProblem };

package/dist/chunks/snippets.mjs

@@ -0,0 +1,199 @@
+import { a as escapeTex } from '../shared/vitakit.DcQOdM4I.mjs';
+
+function fieldLabel(name) {
+  if (name === "url") return "Link";
+  const words = name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").toLowerCase();
+  return words.charAt(0).toUpperCase() + words.slice(1);
+}
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+const access = (object, name) => IDENTIFIER.test(name) ? `${object}.${name}` : `${object}['${name}']`;
+function webFieldSnippet(field, className = "vita-entry__note", entry = "entry") {
+  const value = access(entry, field.path);
+  const label = fieldLabel(field.path);
+  const line = (condition, content) => `<p v-if="${condition}" class="${className}">${content}</p>`;
+  if (field.type === "link") {
+    return {
+      markup: line(`asLinkedList(${value}).length`, `${label}: <template v-for="(link, index) in asLinkedList(${value})" :key="index"><template v-if="index">, </template><a v-if="link.url" :href="link.url">{{ link.label }}</a><template v-else>{{ link.label }}</template></template>`),
+      imports: ["asLinkedList"]
+    };
+  }
+  if (field.several && ["text", "choice", "number"].includes(field.type)) {
+    return { markup: line(`Array.isArray(${value}) && ${value}.length`, `${label}: {{ (${value} as unknown[]).join(', ') }}`), imports: [] };
+  }
+  if (!field.several) {
+    switch (field.type) {
+      case "text":
+      case "choice":
+        return { markup: line(`typeof ${value} === 'string'`, `${label}: {{ ${value} }}`), imports: [] };
+      case "number":
+        return { markup: line(`typeof ${value} === 'number'`, `${label}: {{ ${value} }}`), imports: [] };
+      case "yes-no":
+        return { markup: line(`${value} === true`, label), imports: [] };
+      case "formatted-text":
+        return { markup: line(`richHtml(${value})`, `${label}: <span v-html="richHtml(${value})" />`), imports: ["richHtml"] };
+      case "date":
+        return { markup: line(`${value}`, `${label}: <VitaDate :value="${value} as DateRange" />`), imports: ["type DateRange"] };
+      case "web-address":
+        return { markup: line(`typeof ${value} === 'string'`, `<a :href="${value}">${label}</a>`), imports: [] };
+    }
+  }
+  return {
+    markup: `<!-- ${field.path}: ${field.type === "group" ? "a group of fields" : "a value of its own kind"}; show its parts, e.g. ${field.fields?.[0] ? `{{ ${value}.${field.fields[0].path.split(".").pop()} }}` : `{{ ${value} }}`} -->`,
+    imports: []
+  };
+}
+function etaFieldSnippet(field, item = "item") {
+  const value = access(item, field.path);
+  const label = escapeTex(fieldLabel(field.path));
+  if (field.type === "link") {
+    return field.several ? `<%~ it.vita.note\`${label}: \${it.join((${value} ?? []).map(value => it.linked(value)))}\` %>` : `<%~ it.vita.note\`${label}: \${it.linked(${value})}\` %>`;
+  }
+  if (field.several && ["text", "choice", "number"].includes(field.type)) {
+    return `<%~ it.vita.note\`${label}: \${it.join(${value} ?? [])}\` %>`;
+  }
+  if (!field.several) {
+    switch (field.type) {
+      case "text":
+      case "choice":
+      case "number":
+      case "formatted-text":
+        return `<%~ it.vita.note\`${label}: \${${value}}\` %>`;
+      case "yes-no":
+        return `<% if (${value} === true) { %><%~ it.vita.note('${label.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}') %><% } %>`;
+      case "date":
+        return `<%~ it.vita.note\`${label}: \${it.date(${value})}\` %>`;
+      case "web-address":
+        return `<% if (${value}) { %><%~ it.vita.note(it.linked('${label.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}', ${value})) %><% } %>`;
+    }
+  }
+  return `<%/* ${field.path}: ${field.type === "group" ? "a group of fields" : "a value of its own kind"}; e.g. it.text(${value}${field.fields?.[0] ? `.${field.fields[0].path.split(".").pop()}` : ""}) */%>`;
+}
+function sharedImport(imports) {
+  const names = [...new Set(imports)].sort((a, b) => a.replace("type ", "").localeCompare(b.replace("type ", "")));
+  if (!names.length) return [];
+  return names.every((name) => name.startsWith("type ")) ? [`import type { ${names.map((name) => name.slice(5)).join(", ")} } from '@anja.codes/vitakit/shared'`] : [`import { ${names.join(", ")} } from '@anja.codes/vitakit/shared'`];
+}
+const indent = (lines, by) => lines.map((line) => line ? by + line : line);
+function entryComponent(id, name, fields, region) {
+  const snippets = fields.map((field) => webFieldSnippet(field, region === "note" ? "vita-entry__note" : "vita-entry__meta"));
+  const imports = sharedImport(["type Entry", "type Where", ...snippets.flatMap((snippet) => snippet.imports)]);
+  const keep = region === "note" ? ['<p v-if="display.note !== undefined" class="vita-entry__note">{{ display.note }}</p>'] : [
+    '<p v-if="display.meta.length" class="vita-entry__meta">',
+    '  <template v-for="(part, index) in display.meta" :key="index">',
+    '    <template v-if="index"> \xB7 </template>',
+    `    <template v-if="part.kind === 'linked'">`,
+    '      <a v-if="part.linked.url" :href="part.linked.url">{{ part.linked.label }}</a>',
+    "      <template v-else>{{ part.linked.label }}</template>",
+    "    </template>",
+    "    <template v-else>{{ part.text }}</template>",
+    "  </template>",
+    "</p>"
+  ];
+  const body = fields.length ? [...keep, ...snippets.map((snippet) => snippet.markup)] : [...keep, `<!-- Add your own lines here, e.g. -->`, `<!-- <p v-if="typeof entry.audience === 'string'" class="vita-entry__${region}">Audience: {{ entry.audience }}</p> -->`];
+  return [
+    '<script setup lang="ts">',
+    "/**",
+    ` * How ${id} entries look on the website: vitakit's list, with your own`,
+    ` * ${region === "note" ? "note" : "secondary"} line. Use it like VitaSection, on any page:`,
+    ` *   <${name} id="${id}" title="\u2026" />`,
+    " *",
+    ` * The #${region} slot below replaces that region of each entry. Delete it to get`,
+    " * vitakit's version back; the other slots are #title, #meta, #note and the",
+    " * default slot (the whole entry). `entry` has every field of the entry,",
+    " * `display` what vitakit would show.",
+    " */",
+    ...imports,
+    "",
+    "const props = defineProps<{ id?: string, entries?: Entry[], title?: string, where?: Where, limit?: number }>()",
+    "<\/script>",
+    "",
+    "<template>",
+    '  <VitaSection v-bind="props">',
+    `    <template #${region}="{ ${region === "note" ? "entry, display" : "entry, display"} }">`,
+    ...indent(body, "      "),
+    "    </template>",
+    "  </VitaSection>",
+    "</template>",
+    ""
+  ].join("\n");
+}
+function listComponent(id, name, fields, groupBy) {
+  const titleField = fields.find((field) => ["title", "position", "degree", "role", "student", "name"].includes(field.path));
+  const rest = fields.filter((field) => field !== titleField && field.path !== "date" && field.path !== groupBy);
+  const snippets = rest.map((field) => webFieldSnippet(field));
+  const titleLine = titleField ? titleField.type === "formatted-text" ? `<p class="vita-entry__title" v-html="richHtml(${access("entry", titleField.path)})" />` : `<p class="vita-entry__title">{{ ${access("entry", titleField.path)} }}</p>` : '<!-- <p class="vita-entry__title">{{ entry.title }}</p> -->';
+  const imports = sharedImport([
+    "filterWhere",
+    "type Entry",
+    "type Where",
+    ...fields.some((field) => field.path === "date") ? ["type DateRange"] : [],
+    ...titleField?.type === "formatted-text" ? ["richHtml"] : [],
+    ...snippets.flatMap((snippet) => snippet.imports)
+  ]);
+  const hasDate = fields.some((field) => field.path === "date");
+  const row = [
+    `<VitaEntry v-for="entry in ${groupBy ? "group.entries" : "entries"}" :key="entry.id"${hasDate ? ' :date="entry.date as DateRange"' : ""}>`,
+    ...indent([titleLine, ...snippets.map((snippet) => snippet.markup)], "  "),
+    "</VitaEntry>"
+  ];
+  const grouping = groupBy ? [
+    "",
+    `// Entries in a row with the same ${groupBy} form a group, in the order`,
+    "// vitakit sorted them (newest first).",
+    "const groups = computed(() => {",
+    "  const result: { label: string, entries: Entry[] }[] = []",
+    "  for (const entry of entries.value) {",
+    `    const label = String(${access("entry", groupBy)} ?? '')`,
+    "    const last = result[result.length - 1]",
+    "    if (last?.label === label) last.entries.push(entry)",
+    "    else result.push({ label, entries: [entry] })",
+    "  }",
+    "  return result",
+    "})"
+  ] : [];
+  const list = groupBy ? [
+    '<template v-for="group in groups" :key="group.label">',
+    '  <h3 class="vita-section-group__subtitle">',
+    "    {{ group.label }}",
+    "  </h3>",
+    '  <ul class="vita-section">',
+    ...indent(row, "    "),
+    "  </ul>",
+    "</template>"
+  ] : ['<ul class="vita-section">', ...indent(row, "  "), "</ul>"];
+  return [
+    '<script setup lang="ts">',
+    "/**",
+    ` * How the ${id} section looks on the website, list and all. vitakit selects and sorts`,
+    " * the entries (newest first, `where`, `limit`); the markup below is yours:",
+    " * group them, number them, change what each one shows. Use it like",
+    ` * VitaSection, on any page: <${name} id="${id}" title="\u2026" />`,
+    " *",
+    " * Each field of the entries has a line below; delete the ones you do not",
+    " * want. The classes are styled in app/assets/css/main.css.",
+    " */",
+    `import { computed } from 'vue'`,
+    ...imports,
+    "",
+    "const props = defineProps<{ id: string, title?: string, where?: Where, limit?: number }>()",
+    "",
+    "const entries = computed<Entry[]>(() => {",
+    "  const selected = filterWhere(useSection(props.id), props.where)",
+    "  return props.limit ? selected.slice(0, props.limit) : selected",
+    "})",
+    ...grouping,
+    "<\/script>",
+    "",
+    "<template>",
+    '  <section v-if="entries.length" :id="id" class="vita-section-group">',
+    '    <h2 v-if="title" class="vita-section-group__title">',
+    "      {{ title }}",
+    "    </h2>",
+    ...indent(list, "    "),
+    "  </section>",
+    "</template>",
+    ""
+  ].join("\n");
+}
+
+export { entryComponent, etaFieldSnippet, fieldLabel, listComponent, webFieldSnippet };