@airmark/quiver 0.33.0 → 0.34.0

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

@@ -15,22 +15,26 @@
   margin: 0.5in,
 
   // Vertical rhythm. `leading` is used for the leading inside a paragraph and
-  // for the gap between paragraphs, blocks and list items; the two `*-spacing`
-  // values are the extra breathing room above a section header and above an
-  // entry.
+  // 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 keeps its own padding so that the space
-  // around it does not change when its size does.
+  // 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.5em,
+  contact-separator-padding: 0.25em,
 
-  // Rule drawn underneath a section header. The gap between the rule and the
-  // first entry of the section comes from that entry's `entry-spacing`.
+  // Rule drawn underneath a section header.
   rule-stroke: 0.75pt,
 
   // Square bullet used by lists inside an entry. The negative baseline lifts
@@ -41,9 +45,13 @@
   marker-indent: 0.8em,
 
   // Right-aligned annotation of a linked entry, normally a URL. A font of
-  // `auto` keeps the body font.
+  // `auto` keeps the body font; an `em` size follows the body size.
   annotation-font: auto,
-  annotation-size: 8pt,
+  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)

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

@@ -3,6 +3,21 @@
 
 #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)`
@@ -22,11 +37,18 @@
 
   let cfg = default-config + options.named()
 
-  set page(paper: cfg.paper, margin: cfg.margin)
+  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.
+  // 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)
 
@@ -45,11 +67,18 @@
   // 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))
-  show heading.where(level: 2): it => {
-    v(cfg.section-spacing)
-    block(upper(it.body))
-    block(above: cfg.leading, line(length: 100%, stroke: cfg.rule-stroke))
-  }
+  // 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)
 

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

@@ -4,3 +4,4 @@
 #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

@@ -10,23 +10,28 @@
 #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.
-#let auto-link(contact) = {
+/// 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 {
-    contact
+    body
   } else if contact.match(_email) != none {
-    link("mailto:" + contact, contact)
+    link("mailto:" + contact, body)
   } else if contact.match(_scheme) != none {
     let href = if contact.starts-with("www.") { "https://" + contact } else { contact }
-    link(href, contact)
+    link(href, body)
   } else if contact.match(_domain) != none {
-    link("https://" + contact, contact)
+    link("https://" + contact, body)
   } else if contact.match(_phone) != none and contact.matches(_digit).len() >= 7 {
-    link("tel:" + contact.replace(regex("[^\\d+]"), ""), contact)
+    link("tel:" + contact.replace(regex("[^\\d+]"), ""), body)
   } else {
-    contact
+    body
   }
 }

package/quills/classic_resume/0.0.1/plate.typ

@@ -1,11 +1,11 @@
-#import "@local/quillmark-helper:0.1.0": data
+#import "@local/quillmark-helper:0.1.0": data, ink
 #import "@local/ttq-classic-resume:0.1.0": (
-  default-config, entry, item-grid, resume, resume-header, section-header,
+  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 blank one is not `[]` and a filled one would print its
-// padding inside a bold run or an italic one.
+// 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)
@@ -32,14 +32,13 @@
   if type(body) == str { none } else { body }
 }
 
-#let stock-title = (
-  summary: "Summary",
-  experience: "Work Experience",
-  education: "Education",
-  projects: "Projects",
-  skills: "Skills",
-  certifications: "Certifications",
-)
+// 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.
@@ -73,13 +72,13 @@
   indent: 0em,
 )
 
-// `name` and `contacts` are read as `string` rather than `plaintext`, which
-// lowers to content: the name reaches `set document(author:)`, which takes no
-// content, and `link-contacts` linkifies a str while passing content through.
 #resume-header(
-  name: data.name,
-  contacts: data.contacts,
-  link-contacts: data.link_contacts,
+  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
@@ -101,43 +100,44 @@
   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)
-  let title = or-none(card.title)
-  if title == none { title = stock-title.at(kind, default: none) }
-  let extra = or-none(card.extra)
-  if title != none or extra != none {
-    section-header(if title != none { title } else { [] }, extra: extra)
-  }
-  body-of(card)
-
-  if kind == "experience" {
-    for job in card.jobs {
-      dated(job.company, job.dates, job.role, job.location, job.details)
-    }
-  } else if kind == "education" {
-    for school in card.schools {
-      dated(school.school, school.dates, school.degree, school.location, school.details)
-    }
-  } else if kind == "other" {
-    for row in card.entries {
-      dated(row.heading, row.dates, row.subtitle, row.location, row.details)
-    }
-  } else if kind == "projects" {
-    for project in card.projects {
-      entry(
-        heading: trim-inline(project.name),
-        form: "linked",
-        url: if project.url != "" { project.url } else { none },
-        body: under-entry(project.details),
-      )
-    }
-  } else if kind == "skills" {
-    item-grid(
-      items: card.skills.map(row => (label: trim-inline(row.label), text: trim-inline(row.text))),
-      columns: calc.max(1, card.columns),
-    )
-  } else if kind == "certifications" {
-    item-grid(items: card.items.map(trim-inline), columns: calc.max(1, card.columns))
+  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)
   }
 }