@anja.codes/vitakit 0.1.0 → 0.3.0

package/dist/shared/{vitakit.D8WRg_Xx.d.mts → vitakit.BfR_mUHm.d.mts}

@@ -31,7 +31,7 @@ interface DateRange {
  * Intermediate form of a `richText` field, before rendering.
  *
  * Internal: it exists only between validation and `renderRichFields`, never in
- * a `VitakitContent`. `vitakit-check` fails the build if one reaches the output.
+ * a `VitakitContent`. `vitakit verify` fails the build if one reaches the output.
  * Read rich fields with `richSource` / `richHtml` instead of inspecting shapes.
  */
 interface RichTextMarker {
@@ -44,14 +44,15 @@ interface RichText {
     /** Rendered inline HTML; use with `v-html`. */
     html: string;
 }
-interface Link {
+/** A label that may link: an institution, a funder, a person. See `linked`. */
+interface Linked {
     label: string;
-    url: string;
-}
-interface Institution {
-    name: string;
     url?: string;
 }
+/** A label that always links. */
+interface Link extends Linked {
+    url: string;
+}
 /** Fields every section entry has, whatever else its schema adds. */
 interface EntryBase {
     /** Stable identity for `v-for` keys: the source file plus the index. */
@@ -90,17 +91,28 @@ interface Publication {
      */
     fields: Record<string, string>;
 }
-/** One group of formatted references, e.g. all preprints. */
+/** One group of a publication list, e.g. its preprints or its 2024 papers. */
 interface PublicationGroup {
+    /** Made from the list name, `recent-1`; safe as an HTML id and in LaTeX. */
     id: string;
-    label: string;
+    /** The group's heading; none for the single group of an ungrouped list. */
+    label?: string;
     count: number;
     /**
-     * Newest first. Formatted together, so numbering and year suffixes
+     * In the list's order. Formatted together, so numbering and year suffixes
      * (2024a, 2024b) are right within the group.
      */
     entries: Publication[];
 }
+/**
+ * A list declared in `content/publication-lists.yml`, selected, sorted,
+ * grouped and formatted at build time. An ungrouped list is one group
+ * without a label.
+ */
+interface PublicationList {
+    count: number;
+    groups: PublicationGroup[];
+}
 interface Page {
     /** Route path, with leading and trailing slash: `/`, `/research/`. */
     route: string;
@@ -117,7 +129,7 @@ interface Page {
 interface Profile {
     name: string;
     title?: string;
-    affiliation?: Institution;
+    affiliation?: Linked;
     email?: string;
     links: Link[];
     /** Short plain-text description used for page metadata, not rendered. */
@@ -145,9 +157,10 @@ interface VitakitContent {
     pages: Page[];
     /** Section id -> validated, sorted, visibility-filtered entries. */
     sections: Record<string, Entry[]>;
-    publications: PublicationGroup[];
+    /** List name -> its publications, as `content/publication-lists.yml` declares. */
+    publications: Record<string, PublicationList>;
     /** Always empty in a production build, which fails instead. */
     issues: ContentIssue[];
 }
 
-export type { ContentIssue as C, DateRange as D, Entry as E, Institution as I, Link as L, Page as P, RichTextMarker as R, Visibility as V, VitakitContent as a, DatePoint as b, EntryBase as c, Profile as d, Publication as e, PublicationBadge as f, PublicationGroup as g, RichText as h };
+export type { ContentIssue as C, DateRange as D, Entry as E, Link as L, Page as P, RichTextMarker as R, Visibility as V, VitakitContent as a, DatePoint as b, EntryBase as c, Linked as d, Profile as e, Publication as f, PublicationBadge as g, PublicationGroup as h, PublicationList as i, RichText as j };

package/dist/shared/vitakit.CCTDg7pz.mjs

@@ -0,0 +1,199 @@
+import { parse } from '@babel/parser';
+
+const PACKAGE = "@anja.codes/vitakit";
+function parseModule(source) {
+  return parse(source, { sourceType: "module", plugins: ["typescript"] }).program;
+}
+function unwrap(expression) {
+  let current = expression;
+  while (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "ParenthesizedExpression" || current.type === "TSNonNullExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+function packageImports(body) {
+  const names = /* @__PURE__ */ new Map();
+  for (const statement of body) {
+    if (statement.type !== "ImportDeclaration" || statement.source.value !== PACKAGE) continue;
+    for (const specifier of statement.specifiers) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+      names.set(specifier.local.name, imported);
+    }
+  }
+  return names;
+}
+function defaultExport(body) {
+  const exported = body.find((statement) => statement.type === "ExportDefaultDeclaration");
+  if (!exported || exported.type !== "ExportDefaultDeclaration") return void 0;
+  const declaration = exported.declaration;
+  if (declaration.type === "Identifier") {
+    for (const statement of body) {
+      if (statement.type !== "VariableDeclaration" || statement.kind !== "const") continue;
+      for (const declarator of statement.declarations) {
+        if (declarator.id.type === "Identifier" && declarator.id.name === declaration.name && declarator.init) {
+          return unwrap(declarator.init);
+        }
+      }
+    }
+    return void 0;
+  }
+  if (declaration.type.endsWith("Declaration")) return void 0;
+  return unwrap(declaration);
+}
+function keyName(property) {
+  if (property.type !== "ObjectProperty" || property.computed) return void 0;
+  if (property.key.type === "Identifier") return property.key.name;
+  if (property.key.type === "StringLiteral") return property.key.value;
+  return void 0;
+}
+function recognizeSchema(source) {
+  let body;
+  try {
+    body = parseModule(source).body;
+  } catch (error) {
+    return { ok: false, reason: `cannot be parsed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const expression = defaultExport(body);
+  if (!expression || expression.type !== "CallExpression" || expression.callee.type !== "Identifier") {
+    return { ok: false, reason: "its default export is not a section(...) or extendSection(...) call" };
+  }
+  const call = expression;
+  const kind = packageImports(body).get(call.callee.name);
+  const object = kind === "section" ? call.arguments[0] : kind === "extendSection" ? call.arguments[1] : void 0;
+  const expected = kind === "section" ? 1 : 2;
+  if (kind !== "section" && kind !== "extendSection" || call.arguments.length !== expected || !object || object.type !== "ObjectExpression") {
+    return { ok: false, reason: `its default export is not section({ ... }) or extendSection(base, { ... }) from ${PACKAGE}` };
+  }
+  const fields = [];
+  for (const property of object.properties) {
+    const name = keyName(property);
+    if (name === void 0) return { ok: false, reason: "its fields contain a spread or a computed key" };
+    fields.push(name);
+  }
+  return {
+    ok: true,
+    value: {
+      kind,
+      fields,
+      start: object.start,
+      end: object.end,
+      properties: object.properties.map((property) => ({ start: property.start, end: property.end }))
+    }
+  };
+}
+const IDENTIFIER = /^[A-Za-z_$][\w$]*$/;
+function propertyKey(name) {
+  return IDENTIFIER.test(name) ? name : `'${name.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+function lineStart(source, offset) {
+  return source.lastIndexOf("\n", offset - 1) + 1;
+}
+function indentationAt(source, offset) {
+  return /^[ \t]*/.exec(source.slice(lineStart(source, offset)))[0];
+}
+function endOfLineContent(source, offset) {
+  let position = offset;
+  for (; ; ) {
+    while (source[position] === " " || source[position] === "	") position++;
+    if (source.startsWith("//", position)) {
+      const end = source.indexOf("\n", position);
+      return end === -1 ? source.length : end;
+    }
+    if (source.startsWith("/*", position)) {
+      const end = source.indexOf("*/", position + 2);
+      if (end === -1 || source.slice(position, end).includes("\n")) return position;
+      position = end + 2;
+      continue;
+    }
+    return position;
+  }
+}
+function addSchemaField(source, name, code) {
+  const recognized = recognizeSchema(source);
+  if (!recognized.ok) return recognized;
+  const { fields, properties, start: open, end } = recognized.value;
+  if (fields.includes(name)) return { ok: false, reason: `it already has a field "${name}"` };
+  const entry = `${propertyKey(name)}: ${code}`;
+  const close = end - 1;
+  if (!properties.length) {
+    const inner = source.slice(open + 1, close);
+    if (!inner.includes("\n")) {
+      const indent3 = indentationAt(source, open);
+      return { ok: true, value: `${source.slice(0, open)}{
+${indent3}  ${entry},
+${indent3}}${source.slice(close + 1)}` };
+    }
+    const closeLine = lineStart(source, close);
+    const indent2 = `${indentationAt(source, close)}  `;
+    if (source.slice(closeLine, close).trim() !== "") {
+      return { ok: true, value: `${source.slice(0, close)}
+${indent2}${entry},
+${source.slice(close)}` };
+    }
+    return { ok: true, value: `${source.slice(0, closeLine)}${indent2}${entry},
+${source.slice(closeLine)}` };
+  }
+  const first = properties[0];
+  const last = properties[properties.length - 1];
+  const multiline = source.slice(open, close).includes("\n") && source.slice(lineStart(source, first.start), first.start).trim() === "";
+  let afterLast = last.end;
+  while (source[afterLast] === " " || source[afterLast] === "	") afterLast++;
+  const comma = source[afterLast] === ",";
+  if (!multiline) {
+    return { ok: true, value: `${source.slice(0, last.end)}, ${entry}${source.slice(last.end)}` };
+  }
+  const indent = indentationAt(source, first.start);
+  const insertAt = endOfLineContent(source, comma ? afterLast + 1 : last.end);
+  const head = comma ? source.slice(0, insertAt) : `${source.slice(0, last.end)},${source.slice(last.end, insertAt)}`;
+  return { ok: true, value: `${head}
+${indent}${entry}${comma ? "," : ""}${source.slice(insertAt)}` };
+}
+function ensurePackageImports(source, names) {
+  let body;
+  try {
+    body = parseModule(source).body;
+  } catch (error) {
+    return { ok: false, reason: `cannot be parsed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const imported = packageImports(body);
+  const local = new Set(imported.keys());
+  const missing = names.filter((name) => !local.has(name));
+  if (!missing.length) return { ok: true, value: source };
+  const declaration = body.find((statement) => statement.type === "ImportDeclaration" && statement.source.value === PACKAGE && statement.importKind !== "type" && statement.specifiers.some((specifier) => specifier.type === "ImportSpecifier"));
+  if (declaration) {
+    const specifiers = declaration.specifiers.filter((specifier) => specifier.type === "ImportSpecifier");
+    const at2 = specifiers[specifiers.length - 1].end;
+    return { ok: true, value: `${source.slice(0, at2)}, ${missing.join(", ")}${source.slice(at2)}` };
+  }
+  const imports = body.filter((statement) => statement.type === "ImportDeclaration");
+  const line = `import { ${missing.join(", ")} } from '${PACKAGE}'
+`;
+  if (!imports.length) return { ok: true, value: line + source };
+  const at = imports[imports.length - 1].end;
+  const end = source.indexOf("\n", at);
+  const position = end === -1 ? source.length : end + 1;
+  return { ok: true, value: `${source.slice(0, position)}${end === -1 ? "\n" : ""}${line}${source.slice(position)}` };
+}
+function renamePublicationsSettings(source, renames) {
+  let body;
+  try {
+    body = parseModule(source).body;
+  } catch (error) {
+    return { ok: false, reason: `cannot be parsed: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const expression = defaultExport(body);
+  const object = expression?.type === "CallExpression" && expression.callee.type === "Identifier" && packageImports(body).get(expression.callee.name) === "publications" ? expression.arguments[0] : void 0;
+  if (!object || object.type !== "ObjectExpression") {
+    return { ok: false, reason: `its default export is not publications({ ... }) from ${PACKAGE}` };
+  }
+  let result = source;
+  for (const property of [...object.properties].reverse()) {
+    const name = keyName(property);
+    if (name === void 0 || !Object.hasOwn(renames, name) || property.type !== "ObjectProperty") continue;
+    result = result.slice(0, property.key.start) + renames[name] + result.slice(property.key.end);
+  }
+  return { ok: true, value: result };
+}
+
+export { addSchemaField as a, ensurePackageImports as e, propertyKey as p, renamePublicationsSettings as r };

package/dist/shared/vitakit.CfB3hMHl.mjs

@@ -0,0 +1,60 @@
+function formatPoint(point, { locale = "en", precision = "auto" }) {
+  if (precision === "year" || point.month === void 0) return String(point.year);
+  const date = new Date(Date.UTC(point.year, point.month - 1, point.day ?? 1));
+  return new Intl.DateTimeFormat(locale, {
+    year: "numeric",
+    month: "short",
+    ...point.day === void 0 ? {} : { day: "numeric" },
+    timeZone: "UTC"
+  }).format(date);
+}
+function formatDateRange(range, options = {}) {
+  if (!range) return "";
+  const { presentLabel = "present" } = options;
+  const from = formatPoint(range.from, options);
+  if (range.point) return from;
+  if (range.ongoing) return `${from}\u2013${presentLabel}`;
+  if (!range.to) return from;
+  const to = formatPoint(range.to, options);
+  return from === to ? from : `${from}\u2013${to}`;
+}
+function dateSortKey(range) {
+  return range?.from.sortKey ?? "";
+}
+
+const TITLE_FIELDS = ["title", "position", "degree", "role", "student"];
+const SECONDARY_FIELDS = ["student", "role", "event", "term", "degree"];
+const LINKED_FIELDS = ["institution", "issuer", "organisation"];
+function entryTitleField(entry, fields = TITLE_FIELDS) {
+  return fields.find((field) => {
+    const value = entry[field];
+    if (typeof value === "string") return value.length > 0;
+    return typeof value === "object" && value !== null && "html" in value;
+  });
+}
+function entrySecondaryParts(entry, titleField) {
+  const parts = [];
+  for (const field of SECONDARY_FIELDS) {
+    if (field === titleField) continue;
+    const value = entry[field];
+    if (typeof value === "string" && value.length > 0) parts.push({ kind: "text", text: value });
+  }
+  for (const field of LINKED_FIELDS) {
+    const value = entry[field];
+    if (value?.label) {
+      parts.push({ kind: "linked", linked: value });
+      break;
+    }
+  }
+  if (typeof entry.location === "string" && entry.location.length > 0) {
+    parts.push({ kind: "text", text: entry.location });
+  }
+  return parts;
+}
+function asLinkedList(value) {
+  const isLinked = (item) => typeof item === "object" && item !== null && typeof item.label === "string";
+  if (Array.isArray(value)) return value.filter(isLinked);
+  return isLinked(value) ? [value] : [];
+}
+
+export { LINKED_FIELDS as L, SECONDARY_FIELDS as S, TITLE_FIELDS as T, asLinkedList as a, entryTitleField as b, dateSortKey as d, entrySecondaryParts as e, formatDateRange as f };

package/dist/shared/{vitakit.BlU-p01e.mjs → vitakit.CtChKO0I.mjs}

@@ -11,4 +11,4 @@ function richHtml(value) {
   return void 0;
 }
 
-export { richHtml as a, richSource as r };
+export { richSource as a, richHtml as r };

package/dist/shared/vitakit.D-DdJaDZ.mjs

@@ -0,0 +1,20 @@
+function fieldValue(entry, field) {
+  if (field === "year" && !Object.hasOwn(entry, "year")) {
+    return entry.date?.from?.year;
+  }
+  const value = entry[field];
+  if (typeof value === "object" && value !== null && "text" in value) return value.text;
+  if (typeof value === "object" && value !== null && "label" in value) return value.label;
+  return value;
+}
+function matchesWhere(entry, where) {
+  return Object.entries(where).every(([field, expected]) => {
+    const wanted = (Array.isArray(expected) ? expected : [expected]).map(String);
+    return wanted.includes(String(fieldValue(entry, field) ?? ""));
+  });
+}
+function filterWhere(entries, where) {
+  return where && Object.keys(where).length ? entries.filter((entry) => matchesWhere(entry, where)) : [...entries];
+}
+
+export { filterWhere as a, fieldValue as f, matchesWhere as m };

package/dist/shared/vitakit.D10HyDhF.mjs

@@ -0,0 +1,19 @@
+const PATH_KEY = "__vitakitPath";
+const isSitePath = (value) => value.startsWith("/") && !value.startsWith("//");
+const sitePathMarker = (path) => ({ [PATH_KEY]: path });
+function isSitePathMarker(value) {
+  return typeof value === "object" && value !== null && PATH_KEY in value;
+}
+function resolveSitePaths(value, resolve) {
+  if (isSitePathMarker(value)) return resolve(value[PATH_KEY]);
+  if (Array.isArray(value)) return value.map((item) => resolveSitePaths(item, resolve));
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, resolveSitePaths(item, resolve)]));
+  }
+  return value;
+}
+function absoluteSitePath(path, siteUrl) {
+  return siteUrl ? `${siteUrl.replace(/\/?$/, "/")}${path.slice(1)}` : path;
+}
+
+export { PATH_KEY as P, absoluteSitePath as a, isSitePath as i, resolveSitePaths as r, sitePathMarker as s };

package/dist/shared/vitakit.DCK90zq4.mjs

@@ -0,0 +1,67 @@
+import { pathToFileURL } from 'node:url';
+
+class ContentError extends Error {
+  constructor(where, message) {
+    super(`${where}: ${message}`);
+    this.where = where;
+    this.name = "ContentError";
+  }
+}
+function fail(where, message) {
+  throw new ContentError(where, message);
+}
+function messageOf(error) {
+  if (error instanceof ContentError) return error.message.slice(error.where.length + 2);
+  return error instanceof Error ? error.message : String(error);
+}
+function whereOf(error, fallback) {
+  return error instanceof ContentError ? error.where : fallback;
+}
+async function importProjectModule(path, mtimeMs, where) {
+  try {
+    return await import(`${pathToFileURL(path).href}?mtime=${mtimeMs}`);
+  } catch (error) {
+    fail(where, importFailure(error));
+  }
+}
+function importFailure(error, node = process.versions.node) {
+  if (error?.code === "ERR_UNKNOWN_FILE_EXTENSION") {
+    return `cannot load TypeScript on Node ${node}; vitakit needs Node 22.18 or newer`;
+  }
+  const message = messageOf(error);
+  const stack = error instanceof Error ? error.stack ?? "" : "";
+  const syntax = /^[^\n]*:(\d+)\n((?:[^\n]*\n)*?[ \t]*\^+)[ \t]*\n/.exec(stack);
+  if (syntax) {
+    const hint = /^Expected ','/.test(message) ? " (often a comma missing before it)" : "";
+    return `line ${syntax[1]}: ${message}${hint}
+${syntax[2].split("\n").map((line2) => `    ${line2}`).join("\n")}`;
+  }
+  const line = /\.ts(?:\?[^:\s)]*)?:(\d+):\d+/.exec(stack)?.[1];
+  return line ? `line ${line}: ${message}` : message;
+}
+function formatZodIssues(error) {
+  return error.issues.map((issue) => `  - ${issue.path.join(".") || "(root)"}: ${issue.message}`).join("\n");
+}
+class Issues {
+  constructor(strict) {
+    this.strict = strict;
+  }
+  list = [];
+  /** Record a problem, or throw it when strict. */
+  record(where, message) {
+    if (this.strict) fail(where, message);
+    this.list.push({ where, message });
+  }
+  /** Run `run`; when lenient, record any failure and use `fallback` instead. */
+  async attempt(where, run, fallback) {
+    try {
+      return await run();
+    } catch (error) {
+      if (this.strict) throw error;
+      this.list.push({ where: whereOf(error, where), message: messageOf(error) });
+      return fallback;
+    }
+  }
+}
+
+export { Issues as I, formatZodIssues as a, fail as f, importProjectModule as i, messageOf as m, whereOf as w };

package/dist/shared/vitakit.DQ6PmGoL.mjs

@@ -0,0 +1,34 @@
+import { existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function sourcePath(asset) {
+  return asset === "styles" ? asset : join("src", asset);
+}
+let root;
+function packageRoot() {
+  if (root) return root;
+  let dir = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 6; depth += 1) {
+    if (existsSync(join(dir, "package.json"))) return root = dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("vitakit: cannot locate the package root; the installation is incomplete");
+}
+const built = /[/\\]dist[/\\]/.test(import.meta.url);
+function resolveAsset(asset) {
+  const base = packageRoot();
+  const order = built ? ["dist", void 0] : [void 0, "dist"];
+  const candidates = order.map((prefix) => prefix ? join(base, prefix, asset) : join(base, sourcePath(asset)));
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(
+    `vitakit: missing bundled asset "${asset}"; looked in
+` + candidates.map((candidate) => `  ${candidate}`).join("\n") + "\nRun `pnpm build` in the package, or reinstall it."
+  );
+}
+
+export { packageRoot as p, resolveAsset as r };

package/dist/shared/vitakit.DcQOdM4I.mjs

@@ -0,0 +1,57 @@
+const REPLACEMENTS = {
+  "\\": "\\textbackslash{}",
+  "&": "\\&",
+  "%": "\\%",
+  $: "\\$",
+  "#": "\\#",
+  _: "\\_",
+  "{": "\\{",
+  "}": "\\}",
+  "~": "\\textasciitilde{}",
+  "^": "\\textasciicircum{}"
+};
+const TYPOGRAPHY = [
+  // Directional quotes: "..." -> ``...''
+  [/"([^"]*)"/g, "``$1''"],
+  // An en dash written literally
+  [/\u2013/g, "--"],
+  [/\u2014/g, "---"],
+  [/\u2026/g, "\\ldots{}"],
+  [/\u00a0/g, "~"]
+];
+function escapeTex(value, { typography = true, source } = {}) {
+  if (source !== void 0 && /(?<!\\)\$/.test(value)) {
+    throw new Error(`unbalanced math delimiters in: ${source}`);
+  }
+  let result = value.replace(/[\\&%$#_{}~^]/g, (character) => REPLACEMENTS[character]);
+  if (typography) {
+    for (const [pattern, replacement] of TYPOGRAPHY) result = result.replace(pattern, replacement);
+  }
+  return result;
+}
+function escapeProse(prose, source) {
+  if (/(?<!\\)\$/.test(prose)) throw new Error(`unbalanced math delimiters in: ${source}`);
+  return escapeTex(prose.replace(/\\([!-/:-@[-`{-~])/g, "$1"));
+}
+function escapeRichTex(value) {
+  const parts = [];
+  const pattern = /(?<!\\)\$\$[\s\S]*?\$\$|(?<!\\)\$(?:\\.|[^$\\])*\$/g;
+  let index = 0;
+  for (const match of value.matchAll(pattern)) {
+    const start = match.index;
+    parts.push(escapeProse(value.slice(index, start), value));
+    parts.push(match[0]);
+    index = start + match[0].length;
+  }
+  parts.push(escapeProse(value.slice(index), value));
+  return parts.join("");
+}
+const URL_SPECIAL = /%[0-9A-Fa-f]{2}|[%\\{}^ #&]/g;
+function escapeUrl(value) {
+  return value.replace(URL_SPECIAL, (match) => {
+    if (match.length === 3 || match === "#" || match === "&") return `\\${match}`;
+    return `\\%${match.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`;
+  });
+}
+
+export { escapeTex as a, escapeUrl as b, escapeRichTex as e };