@airmark/quiver 0.32.2 → 0.34.0

package/quills/classic_resume/0.0.1/packages/ttq-classic-resume/src/components.typ

@@ -0,0 +1,214 @@
+// components.typ
+// The building blocks a resume is written with.
+
+#import "config.typ": with-config
+#import "util.typ": auto-link
+
+// Restyles native `- item` lists to the square bullet of the template. It is a
+// show rule rather than a custom list component so that the body of an entry
+// stays ordinary Typst markup.
+#let _bulleted(cfg, body) = {
+  show list: set list(
+    marker: box(
+      fill: black,
+      width: cfg.marker-size,
+      height: cfg.marker-size,
+      baseline: cfg.marker-baseline,
+    ),
+    body-indent: cfg.marker-indent,
+    indent: 0em,
+  )
+  body
+}
+
+// Shared skeleton of `entry`: a grid of left/right aligned header cells
+// followed by an optional bulleted body, kept together on one page. The gutter
+// keeps a left cell that wraps off the right one.
+#let _entry(cfg, cells, body) = block(
+  above: cfg.leading + cfg.rule-spacing,
+  below: cfg.leading + cfg.entry-spacing,
+  breakable: false,
+  {
+    grid(columns: (1fr, auto), column-gutter: 1em, row-gutter: cfg.leading, ..cells)
+    if body != none {
+      _bulleted(cfg, body)
+    }
+  },
+)
+
+// Sets the contacts on as few lines as hold them, a separator between two on
+// one line. A line therefore breaks only between contacts, and never starts or
+// ends on a separator. The spaces around the separator are real ones, so text
+// copied out of the PDF keeps the contacts apart.
+#let _contact-lines(cfg, contacts) = layout(region => {
+  // The separator's ink is centred on the x-height, where a middle dot sits,
+  // whatever glyph and size it is set in.
+  let glyph = text(size: cfg.contact-separator-size, cfg.contact-separator)
+  let extent(top, bottom, body) = measure(text(top-edge: top, bottom-edge: bottom, body)).height
+  let centre = extent("bounds", "baseline", glyph) - extent("bounds", "bounds", glyph) / 2
+  let separator = [ #box(
+      baseline: centre - extent("x-height", "baseline", [x]) / 2,
+      inset: (x: cfg.contact-separator-padding),
+      glyph,
+    ) ]
+  let lines = ()
+  let current = ()
+  for contact in contacts {
+    if current.len() > 0 and measure((..current, contact).join(separator)).width > region.width {
+      lines.push(current)
+      current = ()
+    }
+    current.push(contact)
+  }
+  lines.push(current)
+  lines.map(it => it.join(separator)).join(linebreak())
+})
+
+/// Name and contact line at the top of the resume.
+///
+/// The name becomes the level 1 heading of the document, and — unless `title`
+/// and `author` say otherwise — the title and author of the exported PDF. A
+/// `none` or empty name prints no heading and leaves both unset. With
+/// `link-contacts` left on, email addresses, web addresses and phone numbers
+/// among the contacts become links. Pass ready-made content instead of a
+/// string to opt a single contact out.
+#let resume-header(
+  name: "",
+  contacts: (),
+  link-contacts: true,
+  title: auto,
+  author: auto,
+) = {
+  // Only the metadata that resolves to something is set, so that passing
+  // `none` leaves Typst's own default in place. An author is text only.
+  let metadata = (:)
+  let title = if title == auto { name } else { title }
+  let author = if author == auto { name } else { author }
+  if title not in (none, "") { metadata.title = title }
+  if type(author) == str and author != "" { metadata.author = author }
+  set document(..metadata)
+
+  let named = name not in (none, "")
+  if named or contacts.len() > 0 {
+    with-config(cfg => block(below: cfg.leading + cfg.header-spacing, {
+      if named {
+        heading(level: 1, name)
+      }
+      if contacts.len() > 0 {
+        block(
+          above: cfg.leading + cfg.entry-spacing,
+          _contact-lines(cfg, contacts.map(contact => if link-contacts { auto-link(contact) } else { contact })),
+        )
+      }
+    }))
+  }
+}
+
+/// Section title with a rule underneath it, such as `Work Experience`.
+///
+/// `extra` is appended to the title in the same weight, for a qualifier like a
+/// date range. The section becomes a level 2 heading, so `== Work Experience`
+/// renders identically.
+#let section-header(title, extra: none) = {
+  heading(level: 2, if extra == none { title } else { [#title #extra] })
+}
+
+/// A resume row: dated (a job, a degree, an award) or linked (a project).
+///
+/// `dated` puts `dates` opposite `heading` and an optional italic second line
+/// (`subtitle` / `location`). `linked` puts `url` opposite `heading`, small
+/// and italic, and drops the second line; a `url` given as a string becomes a
+/// link where a contact would. `body` is ordinary Typst markup — most often a
+/// `- item` list, which picks up the square bullet of the template.
+#let entry(
+  heading: "",
+  form: "dated",
+  dates: none,
+  subtitle: none,
+  location: none,
+  url: none,
+  body: none,
+) = with-config(cfg => {
+  assert(
+    form in ("dated", "linked"),
+    message: "entry: `form` must be \"dated\" or \"linked\", found " + repr(form),
+  )
+
+  let cells = if form == "linked" {
+    let annotation = if url != none {
+      let label = text(
+        size: cfg.annotation-size,
+        font: if cfg.annotation-font == auto { cfg.font } else { cfg.annotation-font },
+        style: "italic",
+        url,
+      )
+      auto-link(url, body: label)
+    }
+    (align(left, text(weight: "bold", heading)), align(right, annotation))
+  } else {
+    let cells = (
+      align(left, text(weight: "bold", heading)),
+      align(right, text(weight: "bold", dates)),
+    )
+    if subtitle != none or location != none {
+      cells.push(align(left, text(style: "italic", subtitle)))
+      cells.push(align(right, text(style: "italic", location)))
+    }
+    cells
+  }
+
+  _entry(cfg, cells, body)
+})
+
+/// Multi-column list of short items, for certifications, skills or awards.
+///
+/// Two shapes are accepted and told apart by the first item: a flat array of
+/// content, or an array of `(label: .., text: ..)` dictionaries, which puts
+/// the label in bold above its text.
+#let item-grid(items: (), columns: 2) = {
+  if items.len() == 0 {
+    return
+  }
+  assert(
+    type(columns) == int and columns >= 1,
+    message: "item-grid: `columns` must be a positive integer, found " + repr(columns),
+  )
+
+  let labeled = type(items.at(0)) == dictionary and "label" in items.at(0)
+
+  let cell(item) = if labeled {
+    assert(
+      type(item) == dictionary and "label" in item and "text" in item,
+      message: "item-grid: every item must be a `(label: .., text: ..)` dictionary "
+        + "when the first one is, found " + repr(item),
+    )
+    block({
+      text(weight: "bold", item.label)
+      linebreak()
+      item.text
+    })
+  } else {
+    assert(
+      type(item) != dictionary,
+      message: "item-grid: a `(label: .., text: ..)` dictionary cannot be mixed with "
+        + "plain items, found " + repr(item),
+    )
+    item
+  }
+
+  with-config(cfg => block(
+    above: cfg.leading + cfg.rule-spacing,
+    pad(
+      // Line the items up with the bullets of the entries around them.
+      left: cfg.marker-size + cfg.marker-indent,
+      grid(
+        columns: (1fr,) * columns,
+        // Labeled items are two lines tall, so they need the extra gap to
+        // stay visually separated.
+        row-gutter: if labeled { cfg.leading + cfg.entry-spacing } else { cfg.leading },
+        column-gutter: 1em,
+        ..items.map(cell),
+      ),
+    ),
+  ))
+}

package/quills/classic_resume/0.0.1/packages/ttq-classic-resume/src/config.typ

@@ -0,0 +1,61 @@
+// config.typ
+// Defaults for the template, plus the state that carries them to components.
+//
+// `resume` stores the effective configuration in `config-state`; components
+// read it back through `with-config`. That way a `#show: resume.with(..)`
+// override reaches every component without threading arguments through each
+// individual call.
+
+#let default-config = (
+  // Body font. The first installed family wins, so the bundled EB Garamond is
+  // preferred while Typst's built-in serif faces act as a fallback.
+  font: ("EB Garamond", "Libertinus Serif", "New Computer Modern"),
+  size: 12pt,
+  paper: "us-letter",
+  margin: 0.5in,
+
+  // Vertical rhythm. `leading` is used for the leading inside a paragraph and
+  // for the gap between paragraphs, blocks and list items; each `*-spacing`
+  // value is added to it for one wider gap: above a section header, under its
+  // rule, between two entries, and under the name and contacts. The gap under
+  // the rule is the same whether an entry, a list of items or prose follows it,
+  // and an entry or a list of items keeps it from a paragraph above it too.
+  leading: 0.5em,
+  section-spacing: 5pt,
+  rule-spacing: 3.5pt,
+  entry-spacing: 5pt,
+  header-spacing: 10pt,
+
+  // Resume header. The separator stands between two contacts on one line,
+  // never at either end of one, with a word space and this padding on each
+  // side of it.
+  name-size: 18pt,
+  contact-separator: "❖",
+  contact-separator-size: 7pt,
+  contact-separator-padding: 0.25em,
+
+  // Rule drawn underneath a section header.
+  rule-stroke: 0.75pt,
+
+  // Square bullet used by lists inside an entry. The negative baseline lifts
+  // the square off the baseline so that it lines up with the middle of the
+  // x-height instead of hanging below the line.
+  marker-size: 3.5pt,
+  marker-baseline: -0.07em,
+  marker-indent: 0.8em,
+
+  // Right-aligned annotation of a linked entry, normally a URL. A font of
+  // `auto` keeps the body font; an `em` size follows the body size.
+  annotation-font: auto,
+  annotation-size: 0.85em,
+
+  // Name and page number over every page after the first; `false` leaves
+  // those pages bare.
+  continuation-header: true,
+)
+
+#let config-state = state("ttq-classic-resume:config", default-config)
+
+// Runs `fn` with the active configuration. Components use this instead of
+// reading `config-state` directly so that the `context` stays out of the way.
+#let with-config(fn) = context fn(config-state.get())

package/quills/classic_resume/0.0.1/packages/ttq-classic-resume/src/layout.typ

@@ -0,0 +1,86 @@
+// layout.typ
+// The document-wide show rule.
+
+#import "config.typ": config-state, default-config
+
+// The name at the left and the page count at the right, over every page after
+// the first, so a page read apart from the first still says whose it is. The
+// name is read back off the document's level 1 heading. Small and italic, it
+// reads as a running head: a 0.5in margin leaves no room to set it further off
+// the page.
+#let _continuation-header(cfg) = context {
+  if counter(page).get().first() > 1 {
+    set text(size: cfg.annotation-size, style: "italic")
+    let names = query(heading.where(level: 1))
+    if names.len() > 0 { names.first().body }
+    h(1fr)
+    counter(page).display("1 of 1", both: true)
+  }
+}
+
+/// Applies the resume styling to the whole document.
+///
+/// Use `#show: resume` for the defaults, or `#show: resume.with(size: 11pt)`
+/// to override any key of `default-config`.
+#let resume(..options, body) = {
+  assert(
+    options.pos().len() == 0,
+    message: "resume: expected named options only, found "
+      + str(options.pos().len()) + " positional argument(s)",
+  )
+  let unknown = options.named().keys().filter(key => key not in default-config)
+  assert(
+    unknown.len() == 0,
+    message: "resume: unknown option(s) " + unknown.map(repr).join(", ")
+      + "; expected one of " + default-config.keys().map(repr).join(", "),
+  )
+
+  let cfg = default-config + options.named()
+
+  set page(
+    paper: cfg.paper,
+    margin: cfg.margin,
+    header: if cfg.continuation-header { _continuation-header(cfg) },
+  )
+  set text(font: cfg.font, size: cfg.size)
+  set par(leading: cfg.leading, spacing: cfg.leading, justify: false)
+
+  // One vertical rhythm for every kind of block-level content. Block spacing
+  // collapses to the larger of two neighbours' gaps, so a gap wider than
+  // `leading` is set as a block's `above` or `below` rather than with `v`,
+  // which would add to it.
+  set block(above: cfg.leading, below: cfg.leading)
+  set list(spacing: cfg.leading)
+
+  // Hyperlinks are styled like the surrounding text: on paper the colour is
+  // noise, and the link is still live in the PDF.
+  show link: set text(fill: black)
+
+  // Headings carry the document structure into the tagged PDF. The resume look
+  // is applied here rather than inside the components, so that plain `=` and
+  // `==` markup renders the same way: the name is the level 1 heading, a
+  // section title the level 2 one. Both are set apart by weight and case
+  // rather than by size.
+  set heading(numbering: none)
+  show heading: set text(size: cfg.size, weight: "bold")
+  show heading: set block(above: cfg.leading, below: cfg.leading)
+  // The name is enlarged inside the block, not on the heading itself, so that
+  // the surrounding `em` spacing keeps resolving against the body size.
+  show heading.where(level: 1): it => block(text(size: cfg.name-size, it.body))
+  // A heading keeps with what follows it, so the section's first line is on
+  // the page its rule is. Capitals set solid crowd each other, so the title is
+  // tracked out a little.
+  show heading.where(level: 2): it => block(
+    above: cfg.leading + cfg.section-spacing,
+    below: cfg.leading + cfg.rule-spacing,
+    sticky: true,
+    {
+      text(tracking: 0.04em, upper(it.body))
+      block(above: cfg.leading, line(length: 100%, stroke: cfg.rule-stroke))
+    },
+  )
+
+  config-state.update(cfg)
+
+  body
+}

package/quills/classic_resume/0.0.1/packages/ttq-classic-resume/src/lib.typ

@@ -0,0 +1,7 @@
+// lib.typ
+// Public API of the classic resume template.
+
+#import "config.typ": default-config
+#import "layout.typ": resume
+#import "components.typ": entry, item-grid, resume-header, section-header
+#import "util.typ": auto-link

package/quills/classic_resume/0.0.1/packages/ttq-classic-resume/src/util.typ

@@ -0,0 +1,37 @@
+// util.typ
+// Helpers shared by the components.
+
+// A contact line usually holds an email address, a profile link, a phone
+// number and a city. Only the first three are worth turning into a link, and
+// they are distinguishable by shape.
+#let _email = regex("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$")
+#let _scheme = regex("^(https?://|www\\.)\\S+$")
+#let _domain = regex("^[\\w-]+(\\.[\\w-]+)*\\.[A-Za-z]{2,24}(/\\S*)?$")
+#let _phone = regex("^[+(\\d][\\d\\s()./+-]*\\d$")
+#let _digit = regex("\\d")
+
+/// Turns a contact into a link when it looks like an email address, a web
+/// address or a phone number, and returns it unchanged otherwise. A city or a
+/// clearance level is therefore left alone, and so is anything that is already
+/// content, so callers can always pass their own `link(..)` instead.
+///
+/// `body` is what prints, the contact itself unless given: a caller holding the
+/// contact as text and as content of its own reads the one and prints the
+/// other.
+#let auto-link(contact, body: auto) = {
+  let body = if body == auto { contact } else { body }
+  if type(contact) != str {
+    body
+  } else if contact.match(_email) != none {
+    link("mailto:" + contact, body)
+  } else if contact.match(_scheme) != none {
+    let href = if contact.starts-with("www.") { "https://" + contact } else { contact }
+    link(href, body)
+  } else if contact.match(_domain) != none {
+    link("https://" + contact, body)
+  } else if contact.match(_phone) != none and contact.matches(_digit).len() >= 7 {
+    link("tel:" + contact.replace(regex("[^\\d+]"), ""), body)
+  } else {
+    body
+  }
+}

package/quills/classic_resume/0.0.1/packages/ttq-classic-resume/typst.toml

@@ -0,0 +1,26 @@
+[package]
+name = "ttq-classic-resume"
+version = "0.1.0"
+compiler = "0.14.0"
+entrypoint = "src/lib.typ"
+repository = "https://github.com/nibsbin/ttq-classic-resume"
+authors = ["Nibs"]
+license = "MIT"
+description = "A clean and modern resume."
+
+keywords = [
+    "resume",
+    "cv",
+    "curriculum vitae",
+    "job",
+    "career",
+    "professional",
+    "template",
+]
+categories = ["cv"]
+disciplines = ["business", "computer-science", "engineering", "communication"]
+
+[template]
+path = "template"
+entrypoint = "resume.typ"
+thumbnail = "thumbnail.png"

package/quills/classic_resume/0.0.1/plate.typ

@@ -0,0 +1,143 @@
+#import "@local/quillmark-helper:0.1.0": data, ink
+#import "@local/ttq-classic-resume:0.1.0": (
+  auto-link, default-config, entry, item-grid, resume, resume-header, section-header,
+)
+
+// `plaintext`/`richtext` fields lower to content carrying a space element on
+// each side, so a filled one would print its padding inside a bold run or an
+// italic one. A blank one lowers to "".
+#let trim-inline(v) = {
+  if type(v) != content { return v }
+  let kids = v.at("children", default: none)
+  if kids == none { return v }
+  let padding(c) = c == [ ] or c.func() == parbreak
+  while kids.len() > 0 and padding(kids.first()) { kids = kids.slice(1) }
+  while kids.len() > 0 and padding(kids.last()) { kids = kids.slice(0, -1) }
+  kids.sum(default: [])
+}
+
+// `none` for a field the author left blank, so the components can drop what it
+// would have occupied: a dated `entry` omits its whole second line when both
+// halves are none, a linked one its annotation, an entry what is under it, and
+// a section its heading.
+#let or-none(v) = {
+  let trimmed = trim-inline(v)
+  if trimmed == [] or trimmed == "" { none } else { trimmed }
+}
+
+// The quillmark helper leaves an unset or whitespace-only markdown body as the
+// empty string; only a non-empty body is eval'd into content.
+#let body-of(card) = {
+  let body = card.at("$body", default: "")
+  if type(body) == str { none } else { body }
+}
+
+// A `string` field is text to compute with: a contact or a project link is read
+// to find its target, and the name reaches `set document(author:)`, which takes
+// no content. What prints is the field's ink twin, `printed`, which keeps the
+// click target a value computed with loses.
+#let linked(value, printed) = {
+  if value.trim() == "" { none } else { auto-link(value, body: printed) }
+}
+
+#show: resume.with(
+  // An enum's blank is authorable even where the schema declares a default.
+  paper: if data.paper != "" { data.paper } else { "us-letter" },
+  size: data.font_size * 1pt,
+  margin: data.margin * 1in,
+
+  // The package's stack names two families to fall back to; only the one this
+  // quill bundles is in the render's font book, and naming the absent two
+  // warns once per render.
+  font: "EB Garamond",
+  // EB Garamond has no ❖ (U+2756), the package's default separator: it prints
+  // only where a second family is installed to lend the glyph, and draws from
+  // that family rather than this one. ◆ is the nearest diamond EB Garamond
+  // carries itself, and wants a point less to weigh the same.
+  contact-separator: "◆",
+  contact-separator-size: 6pt,
+)
+
+// The package restyles lists to its square bullet inside an entry only. A
+// section body is the other place a resume holds one, and a list that changed
+// marker with its surroundings would read as two templates.
+#show list: set list(
+  marker: box(
+    fill: black,
+    width: default-config.marker-size,
+    height: default-config.marker-size,
+    baseline: default-config.marker-baseline,
+  ),
+  body-indent: default-config.marker-indent,
+  indent: 0em,
+)
+
+#resume-header(
+  name: if data.name.trim() != "" { ink(data).name },
+  title: data.name.trim(),
+  author: data.name.trim(),
+  contacts: data.contacts.zip(ink(data).contacts)
+    .map(((contact, printed)) => linked(contact, printed))
+    .filter(contact => contact != none),
+)
+
+// The section titles are the PDF's outline, and a `details` cell cannot decline a
+// heading as a body does, so one written there sets as a bold line outside it.
+#let under-entry(details) = {
+  let body = or-none(details)
+  if body == none { return none }
+  set heading(outlined: false, bookmarked: false)
+  show heading: it => block(strong(it.body))
+  body
+}
+
+#let dated(heading, dates, subtitle, location, details) = entry(
+  heading: trim-inline(heading),
+  form: "dated",
+  dates: trim-inline(dates),
+  subtitle: or-none(subtitle),
+  location: or-none(location),
+  body: under-entry(details),
+)
+
+// What each declared kind sets under its heading and body. A card of a kind
+// the quill does not declare is warned on and left off the page: its fields
+// are not this quill's to read.
+#let rows = (
+  summary: card => none,
+  experience: card => for job in card.jobs {
+    dated(job.company, job.dates, job.role, job.location, job.details)
+  },
+  education: card => for school in card.schools {
+    dated(school.school, school.dates, school.degree, school.location, school.details)
+  },
+  skills: card => item-grid(
+    items: card.skills.map(row => (label: trim-inline(row.label), text: trim-inline(row.items))),
+    columns: calc.max(1, card.columns),
+  ),
+  projects: card => for project in card.projects {
+    entry(
+      heading: trim-inline(project.name),
+      form: "linked",
+      url: linked(project.link, ink(project).link),
+      body: under-entry(project.details),
+    )
+  },
+  certifications: card => item-grid(
+    items: card.items.map(trim-inline),
+    columns: calc.max(1, card.columns),
+  ),
+  other: card => for row in card.entries {
+    dated(row.heading, row.dates, row.subtitle, row.location, row.details)
+  },
+)
+
+#for card in data.at("$cards") {
+  let kind = card.at("$kind", default: none)
+  if type(kind) == str and kind in rows {
+    let title = or-none(card.title)
+    if title != none { section-header(title) }
+    body-of(card)
+    rows.at(kind)(card)
+  }
+}