@anja.codes/vitakit 0.1.0 → 0.3.0

package/dist/shared/vitakit.DteA9vLy.mjs

@@ -0,0 +1,135 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+import { parse } from 'yaml';
+import { c as createRenderer, a as prefixRootRelative, l as loadPublicationsSchema, b as loadPublications } from '../chunks/bibliography.mjs';
+import { r as resolveSitePaths, a as absoluteSitePath } from './vitakit.D10HyDhF.mjs';
+import { publicationListNames, LISTS_FILE, loadPublicationLists } from '../chunks/publication-lists.mjs';
+import { findSectionFiles, loadSection, resolveSectionSchema } from '../chunks/sections.mjs';
+import { profile, page } from '../chunks/schemas.mjs';
+import { I as Issues, f as fail, a as formatZodIssues, w as whereOf, m as messageOf } from './vitakit.DCK90zq4.mjs';
+
+const FALLBACK_PROFILE = { name: "Your Name", links: [], nav: [], footerHtml: "" };
+async function loadYaml(file, where) {
+  const raw = await readFile(file, "utf8").catch(() => fail(where, "missing"));
+  try {
+    return parse(raw);
+  } catch (error) {
+    fail(where, messageOf(error));
+  }
+}
+async function loadProfile(contentDir, baseURL, renderer, target) {
+  const data = await loadYaml(join(contentDir, "profile.yml"), "content/profile.yml");
+  const parsed = profile.safeParse(data);
+  if (!parsed.success) fail("content/profile.yml", `invalid
+${formatZodIssues(parsed.error)}`);
+  const prefix = baseURL.replace(/\/$/, "");
+  const { avatar, nav, footer, ...rest } = parsed.data;
+  return resolveSitePaths({
+    ...rest,
+    ...avatar ? { avatar: prefixRootRelative(avatar, prefix) } : {},
+    nav: nav.map((item) => ({ label: item.label, url: item.to })),
+    footerHtml: footer ? renderer.inline(footer) : ""
+  }, sitePathResolver(target, baseURL, parsed.data.url));
+}
+function sitePathResolver(target, baseURL, siteUrl) {
+  const prefix = baseURL.replace(/\/$/, "");
+  return target === "pdf" ? (path) => absoluteSitePath(path, siteUrl) : (path) => prefixRootRelative(path, prefix);
+}
+function errorPage(route, where, message) {
+  const escaped = message.replace(/[&<>]/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[character]);
+  return {
+    route,
+    title: `Error in ${where}`,
+    titleHtml: `Error in <code>${where}</code>`,
+    order: -1,
+    bodyHtml: `<pre>${escaped}</pre>`,
+    error: message
+  };
+}
+async function loadPage(dir, file, renderer) {
+  const where = `content/pages/${file}`;
+  const slug = file.slice(0, -".md".length);
+  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(slug)) {
+    fail(where, "file name must be lowercase kebab-case, e.g. `research-interests.md`");
+  }
+  const { data, content } = matter(await readFile(join(dir, file), "utf8"));
+  const parsed = page.safeParse(data);
+  if (!parsed.success) fail(where, `invalid front matter
+${formatZodIssues(parsed.error)}`);
+  const route = parsed.data.route ?? (slug === "index" ? "/" : `/${slug}/`);
+  try {
+    return {
+      route,
+      title: parsed.data.title,
+      titleHtml: renderer.inline(parsed.data.title),
+      description: parsed.data.description,
+      order: parsed.data.order,
+      bodyHtml: content.trim() ? renderer.markdown(content) : ""
+    };
+  } catch (error) {
+    fail(where, messageOf(error));
+  }
+}
+async function loadPages(contentDir, renderer, issues) {
+  const dir = join(contentDir, "pages");
+  const files = (await readdir(dir).catch(() => [])).filter((name) => name.endsWith(".md")).sort();
+  const pages = await Promise.all(files.map(async (file) => {
+    try {
+      return await loadPage(dir, file, renderer);
+    } catch (error) {
+      if (issues.strict) throw error;
+      const where = whereOf(error, `content/pages/${file}`);
+      const message = messageOf(error);
+      issues.record(where, message);
+      const slug = file.slice(0, -".md".length);
+      return errorPage(slug === "index" ? "/" : `/${slug}/`, where, message);
+    }
+  }));
+  const seen = /* @__PURE__ */ new Map();
+  for (const [index, page] of pages.entries()) {
+    const previous = seen.get(page.route);
+    if (previous) issues.record(`content/pages/${files[index]}`, `route ${page.route} is already used by ${previous}`);
+    else seen.set(page.route, `content/pages/${files[index]}`);
+  }
+  return pages.sort((a, b) => a.order - b.order || a.route.localeCompare(b.route));
+}
+async function loadSections(rootDir, maxVisibility, renderer, resolvePath, issues) {
+  const { files, problems } = await issues.attempt("content/", () => findSectionFiles(rootDir), { files: [], problems: [] });
+  for (const problem of problems) issues.record(problem.where, problem.message);
+  const sections = {};
+  for (const file of files) {
+    sections[file.id] = await issues.attempt(
+      file.where,
+      async () => loadSection(await resolveSectionSchema(rootDir, file), { maxVisibility, renderer, resolvePath }),
+      []
+    );
+  }
+  return sections;
+}
+async function loadPublicationContent(rootDir, renderer, baseURL, issues) {
+  const empty = (names) => Object.fromEntries(names.map((name) => [name, { count: 0, groups: [] }]));
+  const schema = await issues.attempt("schemas/publications.ts", () => loadPublicationsSchema(rootDir), void 0);
+  if (!schema) return empty(await publicationListNames(rootDir));
+  const lists = await issues.attempt(LISTS_FILE, () => loadPublicationLists(rootDir, schema), {});
+  return issues.attempt("content/publications.bib", () => loadPublications(join(rootDir, "content", "publications.bib"), renderer, schema, lists, baseURL, issues), empty(Object.keys(lists)));
+}
+async function loadContent(rootDir, options = {}) {
+  const strict = options.strict ?? true;
+  const baseURL = options.baseURL ?? "/";
+  const maxVisibility = options.maxVisibility ?? "public";
+  const issues = new Issues(strict);
+  const renderer = createRenderer({ baseURL });
+  const contentDir = join(rootDir, "content");
+  const target = options.target ?? "website";
+  const profile = await issues.attempt("content/profile.yml", () => loadProfile(contentDir, baseURL, renderer, target), FALLBACK_PROFILE);
+  const resolvePath = sitePathResolver(target, baseURL, profile.url);
+  const [pages, sections, publications] = await Promise.all([
+    loadPages(contentDir, renderer, issues),
+    loadSections(rootDir, maxVisibility, renderer, resolvePath, issues),
+    loadPublicationContent(rootDir, renderer, baseURL, issues)
+  ]);
+  return { profile, pages, sections, publications, issues: issues.list };
+}
+
+export { loadContent as l };

package/dist/shared/vitakit.DvABWuUc.mjs

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { f as fail } from './vitakit.DCK90zq4.mjs';
+import { i as isSitePath, s as sitePathMarker, P as PATH_KEY } from './vitakit.D10HyDhF.mjs';
+
+const MARKER_KEY = "__vitakitRich";
+function isRichMarker(value) {
+  return typeof value === "object" && value !== null && MARKER_KEY in value;
+}
+function richMarker(value) {
+  return { [MARKER_KEY]: value };
+}
+function renderRichFields(value, renderer, path, where) {
+  if (isRichMarker(value)) {
+    try {
+      return { text: value[MARKER_KEY], html: renderer.inline(value[MARKER_KEY]) };
+    } catch (error) {
+      fail(where, `${path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => renderRichFields(item, renderer, `${path}[${index}]`, where));
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(
+      ([key, item]) => [key, renderRichFields(item, renderer, path ? `${path}.${key}` : key, where)]
+    ));
+  }
+  return value;
+}
+
+const text = z.string().trim().min(1);
+const richText = text.transform((value) => richMarker(value));
+const absoluteUrl = z.string().trim().refine(
+  // One check, not `.url().refine(...)`: zod runs a refinement even after
+  // `.url()` failed, and `new URL()` then throws instead of reporting.
+  (value) => URL.canParse(value) && ["http:", "https:", "mailto:"].includes(new URL(value).protocol),
+  "expected an http(s) or mailto URL"
+);
+const url = z.string().trim().transform((value, context) => {
+  if (isSitePath(value) && !/\s/.test(value)) return sitePathMarker(value);
+  const parsed = absoluteUrl.safeParse(value);
+  if (parsed.success) return parsed.data;
+  context.addIssue({ code: "custom", message: "expected an http(s) or mailto URL, or a path on the site such as /slides/talk.pdf" });
+  return z.NEVER;
+});
+const DATE = /^(\d{4})(?:-(\d{2}))?(?:-(\d{2}))?$/;
+function parseDatePoint(value, context) {
+  const match = DATE.exec(value);
+  if (!match) {
+    context.addIssue({ code: "custom", message: `expected a date like 2024, 2024-03 or 2024-03-15, got "${value}"` });
+    return void 0;
+  }
+  const [, y, m, d] = match;
+  const year = Number(y);
+  const month = m === void 0 ? void 0 : Number(m);
+  const day = d === void 0 ? void 0 : Number(d);
+  if (month !== void 0 && (month < 1 || month > 12)) {
+    context.addIssue({ code: "custom", message: `month out of range in "${value}"` });
+    return void 0;
+  }
+  if (day !== void 0) {
+    const date = new Date(Date.UTC(year, month - 1, day));
+    if (date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) {
+      context.addIssue({ code: "custom", message: `"${value}" is not a real date` });
+      return void 0;
+    }
+  }
+  return {
+    raw: value,
+    year,
+    month,
+    day,
+    // Pad missing parts so that 2024 < 2024-03 < 2024-03-15 sorts correctly.
+    sortKey: `${String(year).padStart(4, "0")}-${String(month ?? 1).padStart(2, "0")}-${String(day ?? 1).padStart(2, "0")}`
+  };
+}
+const datePoint = z.union([z.string(), z.number().int()]).transform((value) => String(value));
+const dateRange = z.union([
+  datePoint,
+  z.strictObject({
+    from: datePoint,
+    to: z.union([datePoint, z.literal("present")]).optional()
+  })
+]).transform((value, context) => {
+  const source = typeof value === "string" ? { from: value, to: void 0 } : value;
+  const from = parseDatePoint(source.from, context);
+  const ongoing = source.to === "present";
+  const to = source.to === void 0 || ongoing ? void 0 : parseDatePoint(source.to, context);
+  if (!from || source.to !== void 0 && !ongoing && !to) return z.NEVER;
+  if (to && to.sortKey < from.sortKey) {
+    context.addIssue({ code: "custom", message: `range ends (${to.raw}) before it starts (${from.raw})` });
+    return z.NEVER;
+  }
+  return { from, to, ongoing, point: typeof value === "string" };
+});
+function urlLabel(value) {
+  return typeof value === "string" ? value.replace(/^(?:https?:\/\/|mailto:)/, "").replace(/\/$/, "") : value[PATH_KEY];
+}
+const linked = z.union([
+  url.transform((value) => ({ label: urlLabel(value), url: value })),
+  text.transform((label) => ({ label })),
+  z.strictObject({ label: text, url: url.optional() }),
+  z.strictObject({ name: text, url: url.optional() }).transform(({ name, url: url2 }) => ({ label: name, url: url2 }))
+]).transform((value) => {
+  const target = "url" in value ? value.url : void 0;
+  return target === void 0 ? { label: value.label } : { label: value.label, url: target };
+});
+const requiredLink = linked.transform((value, context) => {
+  if (value.url !== void 0) return value;
+  context.addIssue({ code: "custom", message: "expected a URL, or { label, url }" });
+  return z.NEVER;
+});
+const visibility = z.enum(["public", "cv", "private"]).default("public");
+function entry(shape) {
+  return z.strictObject({ visibility, ...shape });
+}
+function section(shape) {
+  return z.array(entry(shape));
+}
+
+export { MARKER_KEY as M, richText as a, absoluteUrl as b, renderRichFields as c, dateRange as d, entry as e, linked as l, requiredLink as r, section as s, text as t, url as u, visibility as v };

package/dist/shared/vitakit.DvvUYUTS.mjs

@@ -0,0 +1,200 @@
+import { readFile, readdir } from 'node:fs/promises';
+import { join, relative, sep } from 'node:path';
+
+const posix = (path) => path.split(sep).join("/");
+async function vueFiles(dir) {
+  const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+  const files = [];
+  for (const entry of entries) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) files.push(...await vueFiles(path));
+    else if (entry.name.endsWith(".vue")) files.push(path);
+  }
+  return files.sort();
+}
+const pascal = (name) => name.split(/[-_.\s]+/).filter(Boolean).map((part) => part[0].toUpperCase() + part.slice(1)).join("");
+function componentName(pathBelowComponents) {
+  const parts = posix(pathBelowComponents).replace(/\.vue$/, "").split("/").map(pascal);
+  let name = "";
+  for (const part of parts) name = part.startsWith(name) ? part : name + part;
+  return name;
+}
+function pageRoute(pathBelowPages) {
+  const path = posix(pathBelowPages).replace(/\.vue$/, "").replace(/(^|\/)index$/, "");
+  return path ? `/${path}/` : "/";
+}
+function literal(expression) {
+  return /^\s*(['"`])([^'"`$]*)\1\s*$/.exec(expression)?.[2];
+}
+const ELEMENT = 1;
+const ATTRIBUTE = 6;
+function attribute(node, name) {
+  for (const prop of node.props ?? []) {
+    if (prop.type === ATTRIBUTE && prop.name === name) return { static: prop.value?.content ?? "" };
+    if (prop.type !== ATTRIBUTE && prop.name === "bind" && prop.arg?.content === name) {
+      return { expression: prop.exp?.content ?? "" };
+    }
+  }
+  return void 0;
+}
+function lineOf(text, offset) {
+  let line = 1;
+  for (let index = 0; index < offset; index++) if (text.charCodeAt(index) === 10) line++;
+  return line;
+}
+async function findWebPlacements(rootDir) {
+  const { parse } = await import('@vue/compiler-sfc');
+  const appDir = join(rootDir, "app");
+  const componentsDir = join(appDir, "components");
+  const pagesDir = join(appDir, "pages");
+  const components = /* @__PURE__ */ new Map();
+  for (const file of await vueFiles(componentsDir)) {
+    components.set(componentName(relative(componentsDir, file)), posix(relative(rootDir, file)));
+  }
+  const placements = [];
+  const publications = [];
+  const dynamic = [];
+  for (const path of await vueFiles(appDir)) {
+    const file = posix(relative(rootDir, path));
+    const inPages = !relative(pagesDir, path).startsWith("..");
+    const inComponents = !relative(componentsDir, path).startsWith("..");
+    const route = inPages ? pageRoute(relative(pagesDir, path)) : void 0;
+    const source = await readFile(path, "utf8");
+    const { descriptor } = parse(source, { filename: path });
+    const visit = (node) => {
+      if (node.type === ELEMENT && node.tag) {
+        const tag = node.tag.includes("-") ? pascal(node.tag) : node.tag;
+        if (tag === "VitaPublications") {
+          const list = attribute(node, "list");
+          const title = attribute(node, "title");
+          const name = list?.static ?? (list?.expression !== void 0 ? literal(list.expression) : void 0);
+          publications.push({
+            file,
+            route,
+            line: node.loc.start.line,
+            ...name !== void 0 ? { list: name } : list?.expression !== void 0 ? { expression: list.expression } : {},
+            ...title?.static !== void 0 ? { title: title.static } : {},
+            selecting: SELECTING_PROPS.filter((prop) => attribute(node, prop) !== void 0)
+          });
+        } else if (tag === "VitaSection" || components.has(tag)) {
+          const id = attribute(node, "id");
+          const section = id?.static ?? (id?.expression !== void 0 ? literal(id.expression) : void 0);
+          if (section) {
+            const title = attribute(node, "title");
+            const where = attribute(node, "where");
+            const limit = attribute(node, "limit");
+            placements.push({
+              section,
+              file,
+              route,
+              line: node.loc.start.line,
+              component: tag,
+              ...title?.static !== void 0 ? { title: title.static } : {},
+              ...where?.expression !== void 0 ? { where: where.expression } : {},
+              ...limit ? { limit: limit.static ?? limit.expression } : {}
+            });
+          } else if (id?.expression !== void 0 && !inComponents) {
+            dynamic.push({ file, line: node.loc.start.line, usage: `<${node.tag} :id="${id.expression}">` });
+          }
+        }
+      }
+      for (const child of node.children ?? []) visit(child);
+    };
+    if (descriptor.template?.ast) visit(descriptor.template.ast);
+    for (const block of [descriptor.script, descriptor.scriptSetup]) {
+      if (!block) continue;
+      const start = block.loc.start.line - 1;
+      for (const match of block.content.matchAll(/\buseSection\(\s*([^)]*?)\s*\)/g)) {
+        const line = start + lineOf(block.content, match.index);
+        const section = literal(match[1]);
+        if (section) placements.push({ section, file, route, line, component: "code" });
+        else if (!inComponents) dynamic.push({ file, line, usage: `useSection(${match[1]})` });
+      }
+    }
+  }
+  return { placements, publications, dynamic, components };
+}
+const SELECTING_PROPS = ["groups", "headings", "where", "limit", "sort", "groupBy", "group-by"];
+function publicationPlacementProblems(web, pdf, lists) {
+  const known = `the lists are ${lists.join(", ") || "(none)"} (content/publication-lists.yml)`;
+  const unknown = (name) => `no publication list "${name}"; ${known}`;
+  const migrate = "`vitakit migrate` converts it";
+  const problems = [];
+  for (const placement of web) {
+    const where = `${placement.file}:${placement.line}`;
+    const legacy = placement.selecting.filter((prop) => prop === "groups" || prop === "headings");
+    if (placement.selecting.length) {
+      problems.push({
+        where,
+        message: `VitaPublications does not take ${placement.selecting.join(", ")}: which publications a list shows is set in content/publication-lists.yml${legacy.length ? `; ${migrate}` : ""}`
+      });
+    } else if (placement.list === void 0 && placement.expression === void 0) {
+      problems.push({ where, message: `VitaPublications needs a list, e.g. <VitaPublications list="all" />; ${known}` });
+    } else if (placement.list !== void 0 && !lists.includes(placement.list)) {
+      problems.push({ where, message: unknown(placement.list) });
+    }
+  }
+  for (const placement of pdf) {
+    const where = `${placement.file}:${placement.line}`;
+    if ("list" in placement) {
+      if (!lists.includes(placement.list)) problems.push({ where, message: unknown(placement.list) });
+    } else if (placement.macro === "vitainput" && placement.section === "publications") {
+      problems.push({ where, message: `\\vitainput{publications} is now \\vitapublications[Heading]{list}, with a list from content/publication-lists.yml; ${migrate}` });
+    }
+  }
+  return problems;
+}
+function stripComment(line) {
+  const match = /(^|[^\\])%/.exec(line);
+  return match ? line.slice(0, match.index + match[1].length) : line;
+}
+function findPdfPlacements(document, file, source) {
+  const placements = [];
+  const lines = source.split("\n");
+  let inBody = false;
+  for (const [index, raw] of lines.entries()) {
+    const line = stripComment(raw);
+    if (!inBody) {
+      if (/\\begin\{document\}/.test(line)) inBody = true;
+      else continue;
+    }
+    for (const match of line.matchAll(/\\vitasection(?:\[([^\]]*)\])?\{([^}]*)\}/g)) {
+      placements.push({
+        section: match[2].trim(),
+        document,
+        file,
+        line: index + 1,
+        macro: "vitasection",
+        ...match[1] !== void 0 ? { heading: match[1] } : {}
+      });
+    }
+    for (const match of line.matchAll(/\\vitainput\{([^}]*)\}/g)) {
+      placements.push({ section: match[1].trim(), document, file, line: index + 1, macro: "vitainput" });
+    }
+  }
+  return placements;
+}
+function findPdfPublicationPlacements(document, file, source) {
+  const placements = [];
+  let inBody = false;
+  for (const [index, raw] of source.split("\n").entries()) {
+    const line = stripComment(raw);
+    if (!inBody) {
+      if (/\\begin\{document\}/.test(line)) inBody = true;
+      else continue;
+    }
+    for (const match of line.matchAll(/\\vitapublications(?:\[([^\]]*)\])?\{([^}]*)\}/g)) {
+      placements.push({ list: match[2].trim(), document, file, line: index + 1, ...match[1] !== void 0 ? { heading: match[1] } : {} });
+    }
+  }
+  return placements;
+}
+function documentDirective(source) {
+  for (const [index, raw] of source.split("\n").entries()) {
+    const match = /\\vitadocument\{([^}]*)\}/.exec(stripComment(raw));
+    if (match) return { name: match[1].trim(), line: index + 1 };
+  }
+  return void 0;
+}
+
+export { pageRoute as a, findWebPlacements as b, findPdfPublicationPlacements as c, documentDirective as d, findPdfPlacements as f, publicationPlacementProblems as p };

package/dist/shared/vitakit.TSMTC5Jl.mjs

@@ -0,0 +1,6 @@
+const LEVEL = { public: 0, cv: 1, private: 2 };
+function atMost(value, limit) {
+  return LEVEL[value ?? "public"] <= LEVEL[limit];
+}
+
+export { atMost as a };

package/dist/shared/vitakit.UfoXdL7U.mjs

@@ -0,0 +1,22 @@
+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)}`;
+}
+
+export { lineEnd as a, insertLinesAfter as b, insertLinesBefore as c, indentationAt as i, lineStart as l };