@anja.codes/vitakit 0.1.0 → 0.2.0

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.BerUaxtF.mjs';
+import { z } from 'zod';
+import '../shared/vitakit.DbSeENVS.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.DbSeENVS.mjs';
+import { c as renderRichFields } from '../shared/vitakit.BerUaxtF.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"]);
+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 };

package/dist/chunks/validate.mjs

@@ -0,0 +1,124 @@
+import { join, sep, isAbsolute, relative } from 'node:path';
+import { parseExpression } from '@babel/parser';
+import { l as loadContent } from '../shared/vitakit.By5VWQ1n.mjs';
+import { inventory } from './inventory.mjs';
+import { m as messageOf, w as whereOf } from '../shared/vitakit.DbSeENVS.mjs';
+import { assertTemplatesAreUsed, renderPublications, renderSection } from './emit.mjs';
+import 'node:fs/promises';
+import 'gray-matter';
+import 'yaml';
+import 'unified';
+import 'remark-parse';
+import 'remark-gfm';
+import 'remark-math';
+import 'remark-rehype';
+import 'rehype-katex';
+import 'rehype-raw';
+import 'rehype-stringify';
+import 'unist-util-visit';
+import '../shared/vitakit.D10HyDhF.mjs';
+import 'node:fs';
+import '../shared/vitakit.DQ6PmGoL.mjs';
+import 'node:url';
+import '@behackl/citation-js-extras';
+import 'rehype-parse';
+import 'rehype-sanitize';
+import 'zod';
+import './sections.mjs';
+import './schemas.mjs';
+import '../shared/vitakit.BerUaxtF.mjs';
+import '../shared/vitakit.TSMTC5Jl.mjs';
+import './fields.mjs';
+import './documents.mjs';
+import '../shared/vitakit.D-DdJaDZ.mjs';
+import '../shared/vitakit.Do5HC_MD.mjs';
+import 'eta';
+import '../shared/vitakit.DcQOdM4I.mjs';
+import '../shared/vitakit.CfB3hMHl.mjs';
+
+function literalKeys(expression) {
+  try {
+    const node = parseExpression(expression, { plugins: ["typescript"] });
+    if (node.type !== "ObjectExpression") return void 0;
+    const keys = [];
+    for (const property of node.properties) {
+      if (property.type !== "ObjectProperty" || property.computed) return void 0;
+      if (property.key.type === "Identifier") keys.push(property.key.name);
+      else if (property.key.type === "StringLiteral") keys.push(property.key.value);
+      else return void 0;
+    }
+    return keys;
+  } catch {
+    return void 0;
+  }
+}
+async function validateProject(rootDir, { sections: only } = {}) {
+  const inv = await inventory(rootDir);
+  const problems = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (problem) => {
+    const key = `${problem.where}
+${problem.message}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    problems.push(problem);
+  };
+  const local = (where) => isAbsolute(where) ? relative(rootDir, where) : where;
+  for (const problem of inv.problems) {
+    const section = inv.sections.find((candidate) => candidate.problems.includes(problem));
+    add({ ...problem, ...section ? { section: section.id } : {} });
+  }
+  const valid = new Map(inv.sections.filter((section) => !section.problems.length).map((section) => [section.id, section]));
+  const known = new Set(inv.sections.map((section) => section.id));
+  for (const placement of inv.web.placements) {
+    const where = `${placement.file}:${placement.line}`;
+    if (!known.has(placement.section)) {
+      add({ where, section: placement.section, message: `no section called "${placement.section}" (no content/${placement.section}.yml)` });
+      continue;
+    }
+    const fields = valid.get(placement.section)?.fields;
+    if (placement.where === void 0 || !fields) continue;
+    const keys = literalKeys(placement.where);
+    if (!keys) continue;
+    const names = /* @__PURE__ */ new Set(["year", ...fields.map((field) => field.path)]);
+    for (const key of keys.filter((key2) => !names.has(key2))) {
+      add({ where, section: placement.section, message: `where.${key}: ${placement.section} has no field "${key}"; its fields are ${[...names].join(", ")}` });
+    }
+  }
+  if (inv.documents.length) {
+    const templateDir = join(rootDir, "cv-tex", "templates");
+    try {
+      await assertTemplatesAreUsed(templateDir, [...known]);
+    } catch (error) {
+      add({ where: local(whereOf(error, "cv-tex/templates/")), message: messageOf(error) });
+    }
+    const content = await loadContent(rootDir, { strict: false, maxVisibility: "private", target: "pdf" });
+    for (const document of inv.documents) {
+      for (const placement of document.placements) {
+        try {
+          if (placement.section === "publications") {
+            await renderPublications(content.publications, document.options, templateDir, content.profile.url);
+          } else if (valid.has(placement.section)) {
+            await renderSection(placement.section, content.sections[placement.section] ?? [], document.options, templateDir);
+          }
+        } catch (error) {
+          add({
+            where: local(whereOf(error, `cv-tex/templates/${placement.section}.eta`)),
+            section: placement.section,
+            message: `${messageOf(error)} (in ${document.tex})`
+          });
+        }
+      }
+    }
+  }
+  const { realpath } = await import('node:fs/promises');
+  const roots = [.../* @__PURE__ */ new Set([rootDir, await realpath(rootDir).catch(() => rootDir)])];
+  for (const problem of problems) {
+    for (const root of roots) problem.message = problem.message.replaceAll(`${root}${sep}`, "");
+    problem.message = problem.message.replace(/^(template [\w-]+\.eta: )cv-tex\/templates\/[\w-]+\.eta: /, "$1");
+  }
+  const relevant = only?.length ? problems.filter((problem) => problem.section !== void 0 && only.includes(problem.section) || problem.where === "content/profile.yml") : problems;
+  return { problems: relevant, inventory: inv };
+}
+
+export { validateProject };

package/dist/chunks/vue.mjs

@@ -0,0 +1,116 @@
+import { parse } from '@vue/compiler-sfc';
+
+function lineStart(source, offset) {
+  return source.lastIndexOf("\n", offset - 1) + 1;
+}
+function lineEnd(source, offset) {
+  const end = source.indexOf("\n", offset);
+  return end === -1 ? source.length : end;
+}
+function indentationAt(source, offset) {
+  return /^[ \t]*/.exec(source.slice(lineStart(source, offset)))[0];
+}
+function insertLinesAfter(source, offset, lines) {
+  const end = lineEnd(source, offset);
+  return `${source.slice(0, end)}
+${lines.join("\n")}${source.slice(end)}`;
+}
+function insertLinesBefore(source, offset, lines) {
+  const start = lineStart(source, offset);
+  return `${source.slice(0, start)}${lines.join("\n")}
+${source.slice(start)}`;
+}
+
+const ELEMENT = 1;
+const ATTRIBUTE = 6;
+const pascal = (name) => name.split("-").map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+function literalId(node) {
+  for (const prop of node.props ?? []) {
+    if (prop.type === ATTRIBUTE && prop.name === "id") return prop.value?.content;
+    if (prop.type !== ATTRIBUTE && prop.name === "bind" && prop.arg?.content === "id") {
+      return /^\s*(['"`])([^'"`$]*)\1\s*$/.exec(prop.exp?.content ?? "")?.[2];
+    }
+  }
+  return void 0;
+}
+function sectionElements(source, components = []) {
+  const known = /* @__PURE__ */ new Set(["VitaSection", ...components]);
+  let ast;
+  try {
+    const { descriptor, errors } = parse(source);
+    if (errors.length) return { ok: false, reason: `cannot be parsed: ${String(errors[0])}` };
+    ast = descriptor.template?.ast;
+  } catch (error) {
+    return { ok: false, reason: `cannot be parsed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  if (!ast) return { ok: false, reason: "it has no <template>" };
+  const elements = [];
+  const visit = (node) => {
+    if (node.type === ELEMENT && node.tag) {
+      const tag = node.tag.includes("-") ? pascal(node.tag) : node.tag;
+      const id = known.has(tag) ? literalId(node) : void 0;
+      if (id) {
+        const hasContent = (node.children ?? []).some((child) => child.type !== 3 && !(child.type === 2 && !child.content.trim()));
+        elements.push({ id, tag: node.tag, start: node.loc.start.offset, end: node.loc.end.offset, line: node.loc.start.line, hasContent });
+      }
+    }
+    for (const child of node.children ?? []) visit(child);
+  };
+  visit(ast);
+  const roots = (ast.children ?? []).filter((node) => node.type === ELEMENT);
+  return { ok: true, value: { elements, ...roots.length === 1 ? { root: roots[0] } : {} } };
+}
+function attribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function sectionElementSource(placement) {
+  return `<${placement.component ?? "VitaSection"} id="${placement.id}"${placement.title ? ` title="${attribute(placement.title)}"` : ""} />`;
+}
+function addSectionToPage(source, placement, components = []) {
+  const found = sectionElements(source, components);
+  if (!found.ok) return found;
+  const { elements, root } = found.value;
+  if (elements.some((element2) => element2.id === placement.id)) return { ok: false, reason: `it already shows ${placement.id}` };
+  const element = sectionElementSource(placement);
+  const anchor = (placement.after && elements.find((existing) => existing.id === placement.after)) ?? elements[elements.length - 1];
+  if (anchor) {
+    const indent2 = indentationAt(source, anchor.start);
+    return { ok: true, value: { source: insertLinesAfter(source, anchor.end - 1, [`${indent2}${element}`]), afterSection: anchor.id } };
+  }
+  if (!root || !root.tag) return { ok: false, reason: "its template has no single root element to add to" };
+  const close = source.lastIndexOf(`</${root.tag}`, root.loc.end.offset);
+  if (close === -1 || close < root.loc.start.offset || source.slice(lineStart(source, close), close).trim() !== "") {
+    return { ok: false, reason: `its <${root.tag}> does not end on a line of its own` };
+  }
+  const indent = `${indentationAt(source, close)}  `;
+  return { ok: true, value: { source: insertLinesBefore(source, close, ["", `${indent}${element}`]) } };
+}
+function useComponentForSection(source, id, component, components = []) {
+  const found = sectionElements(source, components);
+  if (!found.ok) return found;
+  const elements = found.value.elements.filter((element) => element.id === id);
+  if (!elements.length) return { ok: false, reason: `it does not show ${id}` };
+  const blocked = elements.find((element) => element.hasContent);
+  if (blocked) return { ok: false, reason: `line ${blocked.line} has content of its own, such as slots; move it into the component` };
+  const changed = [];
+  let result = source;
+  for (const element of [...elements].reverse()) {
+    if (element.tag === component) continue;
+    let text = result.slice(element.start, element.end);
+    text = `<${component}${text.slice(element.tag.length + 1)}`;
+    if (text.endsWith(`</${element.tag}>`)) text = `${text.slice(0, -(element.tag.length + 3))}</${component}>`;
+    result = result.slice(0, element.start) + text + result.slice(element.end);
+    changed.unshift(element.line);
+  }
+  return { ok: true, value: { source: result, changed } };
+}
+
+const vue = {
+  __proto__: null,
+  addSectionToPage: addSectionToPage,
+  sectionElementSource: sectionElementSource,
+  sectionElements: sectionElements,
+  useComponentForSection: useComponentForSection
+};
+
+export { indentationAt as a, insertLinesBefore as b, lineEnd as c, addSectionToPage as d, insertLinesAfter as i, lineStart as l, sectionElementSource as s, vue as v };