@anja.codes/vitakit 0.1.0

package/dist/runtime/components/VitaPublication.vue

@@ -0,0 +1,30 @@
+<script setup lang="ts">
+/**
+ * One reference in a publication list: the reference as the citation style
+ * formats it, then its badges.
+ *
+ * `entry.html` is formatted at build time (title linked, formulas typeset);
+ * the badges are data, so a copy of this component can put them anywhere -- a
+ * row of buttons, icons, "arXiv:2301.00001" from `badge.value` -- without
+ * parsing HTML. `VitaPublications` renders one of these per entry, so ejecting
+ * this component alone changes every entry and keeps the grouping.
+ */
+import type { Publication } from '@anja.codes/vitakit/shared'
+
+defineProps<{ entry: Publication }>()
+</script>
+
+<template>
+  <li class="csl-entry" :data-csl-entry-id="entry.key">
+    <!-- eslint-disable-next-line vue/no-v-html -- build-time formatted, sanitized citation -->
+    <span class="vita-bib__text" v-html="entry.html" />
+    <!-- Spaces are explicit: the template compiler drops whitespace between lines. -->
+    <template v-if="entry.badges.length">
+      {{ ' ' }}<span class="bib-links">
+        <template v-for="(badge, index) in entry.badges" :key="badge.url">
+          {{ index ? ' ' : '' }}<a :class="badge.className" :href="badge.url">{{ badge.label }}</a>
+        </template>
+      </span>
+    </template>
+  </li>
+</template>

package/dist/runtime/components/VitaPublications.vue

@@ -0,0 +1,39 @@
+<script setup lang="ts">
+/**
+ * Publication groups formatted from `content/publications.bib` at build time.
+ *
+ * This component lays out the groups; each entry is a `VitaPublication`, which
+ * can be ejected on its own to change how a reference looks. Grouping, style
+ * and badge fields are configured in `nuxt.config.ts` and
+ * `content/publications.csl`.
+ */
+import { computed } from 'vue'
+import { usePublications } from '#imports'
+
+// `withDefaults` is required for the boolean: Vue casts an absent Boolean prop
+// to `false`, so `headings` would silently default to off.
+const props = withDefaults(defineProps<{
+  /** Restrict to these group ids, in this order. */
+  groups?: string[]
+  /** Show the group label above each list. */
+  headings?: boolean
+}>(), { groups: undefined, headings: true })
+
+const all = usePublications()
+const shown = computed(() => props.groups
+  ? props.groups.map(id => all.find(group => group.id === id)).filter(group => group !== undefined)
+  : all)
+</script>
+
+<template>
+  <div class="vita-publications">
+    <section v-for="group in shown" :key="group.id" class="vita-publications__group">
+      <h2 v-if="headings" class="vita-publications__heading">
+        {{ group.label }}
+      </h2>
+      <ol class="vita-bib csl-bib-body">
+        <VitaPublication v-for="entry in group.entries" :key="entry.key" :entry="entry" />
+      </ol>
+    </section>
+  </div>
+</template>

package/dist/runtime/components/VitaSection.vue

@@ -0,0 +1,60 @@
+<script setup lang="ts">
+/**
+ * Renders any section without a dedicated component.
+ *
+ * It shows the fields a vitakit schema is built from -- a date, something
+ * title-like, an institution, a note, a link -- and ignores what it does not
+ * understand. That is enough to make a newly added `content/<name>.yml` visible
+ * immediately; write your own component (or eject one) when you want control.
+ */
+import { computed } from 'vue'
+import { useSection } from '#imports'
+import { entrySecondaryParts, entryTitleField, richHtml, type Entry } from '@anja.codes/vitakit/shared'
+
+const props = defineProps<{
+  /** Section id; ignored when `entries` is given. */
+  id?: string
+  entries?: Entry[]
+  /** Fields to try, in order, for the main line. */
+  titleFields?: string[]
+  limit?: number
+}>()
+
+const items = computed(() => {
+  const source = props.entries ?? (props.id ? useSection(props.id) : [])
+  return props.limit ? source.slice(0, props.limit) : source
+})
+
+// Which fields are the headline and the context line is decided in
+// `@anja.codes/vitakit/shared`, the same code the LaTeX emitter uses; only the
+// separator and the markup are decided here.
+const titleFieldOf = (entry: Entry): string | undefined =>
+  entryTitleField(entry, props.titleFields)
+
+const titleOf = (entry: Entry): string => {
+  const field = titleFieldOf(entry)
+  return (field && richHtml(entry[field])) || ''
+}
+
+const secondaryOf = (entry: Entry): string =>
+  entrySecondaryParts(entry, titleFieldOf(entry))
+    .map(part => (part.kind === 'institution' ? part.institution.name : part.text))
+    .join(' · ')
+
+const linkOf = (entry: Entry): string | undefined =>
+  typeof entry.url === 'string' ? entry.url : undefined
+</script>
+
+<template>
+  <ul v-if="items.length" class="vita-section">
+    <VitaEntry v-for="item in items" :key="item.id" :date="item.date as never">
+      <p class="vita-entry__title">
+        <!-- eslint-disable vue/no-v-html -- build-time rendered Markdown -->
+        <a v-if="linkOf(item)" :href="linkOf(item)" v-html="titleOf(item)" />
+        <span v-else v-html="titleOf(item)" />
+      </p>
+      <p v-if="secondaryOf(item)" class="vita-entry__meta">{{ secondaryOf(item) }}</p>
+      <p v-if="typeof item.note === 'string'" class="vita-entry__note">{{ item.note }}</p>
+    </VitaEntry>
+  </ul>
+</template>

package/dist/runtime/composables/useVitakit.ts

@@ -0,0 +1,47 @@
+/**
+ * Access to the content compiled by the vitakit Nuxt module.
+ *
+ * These are plain imports of a build-time generated module: fully typed, no
+ * loading state, no network request, and only what a page uses ends up in its
+ * chunk.
+ */
+import content from '#vitakit/content'
+import type { Entry, Page, Profile, PublicationGroup, VitakitContent } from '@anja.codes/vitakit/shared'
+
+export function useVitakit(): VitakitContent {
+  return content
+}
+
+export function useProfile(): Profile {
+  return content.profile
+}
+
+/**
+ * Entries of one section, already validated, visibility-filtered and sorted
+ * newest first.
+ *
+ * Unknown ids return an empty list rather than throwing, so deleting a content
+ * file cannot break a page that still mentions it.
+ */
+export function useSection(id: string): Entry[] {
+  return content.sections[id] ?? []
+}
+
+/** All section ids that have content. */
+export function useSectionIds(): string[] {
+  return Object.keys(content.sections)
+}
+
+export function usePublications(): PublicationGroup[] {
+  return content.publications
+}
+
+/** The page for a route, or `undefined`. Routes always end with a slash. */
+export function usePage(route: string): Page | undefined {
+  const normalised = route.endsWith('/') ? route : `${route}/`
+  return content.pages.find((page: Page) => page.route === normalised)
+}
+
+export function usePages(): Page[] {
+  return content.pages
+}

package/dist/schemas/education.ts

@@ -0,0 +1,21 @@
+/**
+ * Shape of `content/education.yml`.
+ *
+ * Also the file `vitakit eject education` copies into a project, with the import
+ * rewritten to `@anja.codes/vitakit`; it is therefore the single definition of
+ * this section, not a copy of one.
+ */
+import { dateRange, institution, link, richText, section, text, url, z } from '../primitives'
+
+export default section({
+  date: dateRange,
+  degree: text,
+  institution,
+  thesis: z.strictObject({
+    title: richText,
+    type: text.optional(),
+    supervisor: z.union([text, link]).optional(),
+    url: url.optional(),
+  }).optional(),
+  note: text.optional(),
+})

package/dist/schemas/employment.ts

@@ -0,0 +1,21 @@
+/**
+ * Shape of `content/employment.yml`.
+ *
+ * Also the file `vitakit eject employment` copies into a project, with the import
+ * rewritten to `@anja.codes/vitakit`; it is therefore the single definition of
+ * this section, not a copy of one.
+ */
+import { dateRange, institution, richText, section, text, url, z } from '../primitives'
+
+export default section({
+  date: dateRange,
+  position: text,
+  institution,
+  project: z.strictObject({
+    title: richText,
+    funder: text.optional(),
+    grant: text.optional(),
+    url: url.optional(),
+  }).optional(),
+  note: text.optional(),
+})

package/dist/schemas/publications.ts

@@ -0,0 +1,48 @@
+/**
+ * How `content/publications.bib` is grouped and linked -- on the website, in
+ * `vitakit-check` and in the PDF alike.
+ *
+ * Also the file `vitakit eject publications` copies into a project, with the
+ * import rewritten to `@anja.codes/vitakit`; it is therefore the single definition
+ * of the defaults, not a copy of them. Every setting is optional: leave out
+ * what you do not change.
+ */
+import { badgePresets, publications } from '../publications'
+
+export default publications({
+  /**
+   * The values of the `status` field, in the order the groups appear. A
+   * status that is not listed here is an error, in any capitalisation.
+   */
+  groups: [
+    { id: 'published', label: 'Published' },
+    { id: 'accepted', label: 'Accepted' },
+    { id: 'preprint', label: 'Preprints' },
+    { id: 'software', label: 'Software' },
+    { id: 'other', label: 'Other' },
+  ],
+
+  /** The group of an entry without `status`; the first group if left out. */
+  defaultGroup: 'published',
+
+  /**
+   * BibTeX fields that become links after a reference on the website. The
+   * presets accept the spellings real exports use (`doi:10...`, doi.org URLs,
+   * `arXiv:...`, `MR1234567`, `Zbl 1234.56789`) and biblatex's `eprint`. A
+   * badge of your own, e.g. for slides in `public/slides/`:
+   *
+   *   { field: 'slides', label: 'Slides', url: '/slides/$1.pdf', className: 'vita-badge' }
+   */
+  badges: [
+    { ...badgePresets.doi, className: 'vita-badge' },
+    { ...badgePresets.arxiv, className: 'vita-badge' },
+    { ...badgePresets.mrnumber, className: 'vita-badge' },
+    { ...badgePresets.zbl, className: 'vita-badge' },
+  ],
+
+  /**
+   * Further BibTeX fields a component can show, as `entry.fields.<name>`,
+   * e.g. `['project']` for a copy of VitaPublication that names the project.
+   */
+  fields: [],
+})

package/dist/schemas/supervision.ts

@@ -0,0 +1,20 @@
+/**
+ * Shape of `content/supervision.yml`.
+ *
+ * Also the file `vitakit eject supervision` copies into a project, with the import
+ * rewritten to `@anja.codes/vitakit`; it is therefore the single definition of
+ * this section, not a copy of one.
+ */
+import { dateRange, institution, richText, section, text, z } from '../primitives'
+
+export default 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: institution.optional(),
+  coSupervisor: text.optional(),
+})

package/dist/schemas/talks.ts

@@ -0,0 +1,19 @@
+/**
+ * Shape of `content/talks.yml`.
+ *
+ * Also the file `vitakit eject talks` copies into a project, with the import
+ * rewritten to `@anja.codes/vitakit`; it is therefore the single definition of
+ * this section, not a copy of one.
+ */
+import { dateRange, richText, section, text, url, z } from '../primitives'
+
+export default 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(),
+})

package/dist/schemas/teaching.ts

@@ -0,0 +1,19 @@
+/**
+ * Shape of `content/teaching.yml`.
+ *
+ * Also the file `vitakit eject teaching` copies into a project, with the import
+ * rewritten to `@anja.codes/vitakit`; it is therefore the single definition of
+ * this section, not a copy of one.
+ */
+import { dateRange, institution, richText, section, text, url } from '../primitives'
+
+export default section({
+  date: dateRange,
+  title: richText,
+  role: text.optional(),
+  institution: institution.optional(),
+  /** e.g. `2024S`, `Winter 2023/24` -- free text, shown as written. */
+  term: text.optional(),
+  url: url.optional(),
+  note: text.optional(),
+})

package/dist/shared/index.d.mts

@@ -0,0 +1,68 @@
+import { D as DateRange, I as Institution, E as Entry } from './vitakit.D8WRg_Xx.mjs';
+export { C as ContentIssue, b as DatePoint, c as EntryBase, L as Link, P as Page, d as Profile, e as Publication, f as PublicationBadge, g as PublicationGroup, h as RichText, R as RichTextMarker, V as Visibility, a as VitakitContent } from './vitakit.D8WRg_Xx.mjs';
+
+/**
+ * Presentation helpers shared by the website and the LaTeX side.
+ *
+ * These live in the package because they are logic: a date rendered one way on
+ * the site and another way in the PDF is a bug, not a design choice.
+ */
+
+interface DateFormatOptions {
+    locale?: string;
+    /** `numeric` gives 2024-03, `long` gives March 2024, `year` gives 2024. */
+    precision?: 'auto' | 'year';
+    /** Text for an open-ended range. */
+    presentLabel?: string;
+}
+/** `2019–2023`, `since 2023`, `March 2024`. */
+declare function formatDateRange(range: DateRange | undefined, options?: DateFormatOptions): string;
+/** A sortable key, for user code that needs to order entries itself. */
+declare function dateSortKey(range: DateRange | undefined): string;
+
+/**
+ * Which fields of an entry are its title and its context.
+ *
+ * A generic section has no dedicated component or template, so both sides have
+ * to guess: "what is the headline here, and what belongs on the second line?"
+ * That guess lives here, once. It used to exist twice — in the TeX emitter and
+ * in `VitaSection.vue` — with different field lists and different separators,
+ * so the website and the PDF already disagreed about the same entry.
+ *
+ * Presentation stays with each side: the website joins with `·` and renders
+ * HTML, the emitter joins with `,` and escapes. Only the *selection* is shared.
+ */
+
+/** Fields tried, in order, for the headline. */
+declare const TITLE_FIELDS: readonly string[];
+/** Plain-text fields tried, in order, for the context line. */
+declare const SECONDARY_FIELDS: readonly string[];
+/** Fields that may hold an institution, in order of preference. */
+declare const INSTITUTION_FIELDS: readonly string[];
+/**
+ * The field holding the entry's headline, or `undefined` when nothing fits.
+ * Returns the field *name* so callers can render its value themselves: the
+ * website needs the rendered HTML, the emitter the LaTeX source.
+ */
+declare function entryTitleField(entry: Entry, fields?: readonly string[]): string | undefined;
+/** A piece of the context line: plain text, or an institution that may link. */
+type SecondaryPart = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'institution';
+    institution: Institution;
+};
+/**
+ * The context line, as structured parts. The field used for the title is
+ * skipped, so nothing appears twice.
+ */
+declare function entrySecondaryParts(entry: Entry, titleField?: string): SecondaryPart[];
+
+/** The plain-text form: Markdown source, for LaTeX, comparisons and `title=`. */
+declare function richSource(value: unknown): string;
+/** The rendered form, or `undefined` when there is nothing to render. */
+declare function richHtml(value: unknown): string | undefined;
+
+export { DateRange, Entry, INSTITUTION_FIELDS, Institution, SECONDARY_FIELDS, TITLE_FIELDS, dateSortKey, entrySecondaryParts, entryTitleField, formatDateRange, richHtml, richSource };
+export type { DateFormatOptions, SecondaryPart };

package/dist/shared/index.mjs

@@ -0,0 +1,57 @@
+export { a as richHtml, r as richSource } from './vitakit.BlU-p01e.mjs';
+
+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 INSTITUTION_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 INSTITUTION_FIELDS) {
+    const value = entry[field];
+    if (value?.name) {
+      parts.push({ kind: "institution", institution: value });
+      break;
+    }
+  }
+  if (typeof entry.location === "string" && entry.location.length > 0) {
+    parts.push({ kind: "text", text: entry.location });
+  }
+  return parts;
+}
+
+export { INSTITUTION_FIELDS, SECONDARY_FIELDS, TITLE_FIELDS, dateSortKey, entrySecondaryParts, entryTitleField, formatDateRange };