@airmark/quiver 0.33.0 → 0.35.0

package/quills/classic_resume/{0.0.1 → 0.1.0}/packages/ttq-classic-resume/src/components.typ

@@ -22,24 +22,63 @@
 }
 
 // Shared skeleton of `entry`: a grid of left/right aligned header cells
-// followed by an optional bulleted body, kept together on one page.
+// followed by an optional bulleted body, kept together on one page. The gutter
+// keeps a left cell that wraps off the right one. An entry taller than a page
+// cannot be kept together, so it breaks where it must rather than running off
+// the foot of one.
 #let _entry(cfg, cells, body) = {
-  v(cfg.entry-spacing)
-  block(breakable: false, {
-    grid(columns: (1fr, auto), row-gutter: cfg.leading, ..cells)
+  let inner = {
+    grid(columns: (1fr, auto), column-gutter: 1em, row-gutter: cfg.leading, ..cells)
     if body != none {
       _bulleted(cfg, body)
     }
-  })
+  }
+  block(
+    above: cfg.leading + cfg.rule-spacing,
+    below: cfg.leading + cfg.entry-spacing,
+    layout(region => block(
+      breakable: measure(block(width: region.width, inner)).height > region.height,
+      inner,
+    )),
+  )
 }
 
+// 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.
-/// Contacts are separated by a diamond and, with `link-contacts` left on, email
-/// addresses, web addresses and phone numbers among them become links. Pass
-/// ready-made content instead of a string to opt a single contact out.
+/// 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: (),
@@ -48,28 +87,28 @@
   author: auto,
 ) = {
   // Only the metadata that resolves to something is set, so that passing
-  // `none` leaves Typst's own default in place.
+  // `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 author not in (none, "") { metadata.author = author }
+  if type(author) == str and author != "" { metadata.author = author }
   set document(..metadata)
 
-  with-config(cfg => {
-    heading(level: 1, name)
-    v(cfg.entry-spacing)
-
-    // A box rather than spaces, so that the padding is a real length and the
-    // separator still cannot be split from the contacts on either side.
-    let separator = box(
-      inset: (x: cfg.contact-separator-padding),
-      text(size: cfg.contact-separator-size, cfg.contact-separator),
-    )
-    contacts
-      .map(contact => if link-contacts { auto-link(contact) } else { contact })
-      .join(separator)
-  })
+  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) <ttq-classic-resume-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`.
@@ -85,8 +124,9 @@
 ///
 /// `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. `body` is ordinary Typst markup —
-/// most often a `- item` list, which picks up the square bullet of the template.
+/// 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",
@@ -109,7 +149,7 @@
         style: "italic",
         url,
       )
-      if type(url) == str and url.starts-with("http") { link(url, label) } else { label }
+      auto-link(url, body: label)
     }
     (align(left, text(weight: "bold", heading)), align(right, annotation))
   } else {
@@ -131,7 +171,7 @@
 ///
 /// 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.
+/// the label in bold above its text. A `none` or empty label prints no line.
 #let item-grid(items: (), columns: 2) = {
   if items.len() == 0 {
     return
@@ -150,8 +190,10 @@
         + "when the first one is, found " + repr(item),
     )
     block({
-      text(weight: "bold", item.label)
-      linebreak()
+      if item.label not in (none, "", []) {
+        text(weight: "bold", item.label)
+        linebreak()
+      }
       item.text
     })
   } else {
@@ -163,8 +205,8 @@
     item
   }
 
-  with-config(cfg => {
-    v(cfg.entry-spacing)
+  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,
@@ -176,6 +218,6 @@
         column-gutter: 1em,
         ..items.map(cell),
       ),
-    )
-  })
+    ),
+  ))
 }

package/quills/classic_resume/{0.0.1 → 0.1.0}/packages/ttq-classic-resume/src/config.typ

@@ -15,35 +15,44 @@
   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.
-  name-size: 18pt,
+  // 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. Sizes in `em` follow the body size: at 12pt, the name is set
+  // at 18pt and the separator at 7pt.
+  name-size: 1.5em,
   contact-separator: "❖",
-  contact-separator-size: 7pt,
-  contact-separator-padding: 0.5em,
+  contact-separator-size: 7em / 12,
+  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
   // 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,
+  // x-height instead of hanging below the line. At 12pt the square is 3.5pt.
+  marker-size: 3.5em / 12,
   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.
+  // `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 → 0.1.0}/packages/ttq-classic-resume/src/layout.typ

@@ -3,6 +3,22 @@
 
 #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 heading `resume-header` labels, so a level 1
+// heading written in the body never stands in for it. 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(<ttq-classic-resume-name>)
+    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 +38,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 +68,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 → 0.1.0}/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.1.0/packages/ttq-classic-resume/src/util.typ

@@ -0,0 +1,50 @@
+// 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 _mailto = regex("^(?i:mailto):\\S+$")
+#let _tel = regex("^(?i:tel):[+(\\d][\\d\\s()./+-]*\\d$")
+#let _email = regex("^[^@\\s]+@[^@\\s]+\\.[^@\\s]+$")
+#let _scheme = regex("^(?i: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. One
+/// already written as a `mailto:`, `tel:` or `http(s)://` link keeps its
+/// target, whatever case its scheme is written in.
+///
+/// `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(_mailto) != none {
+    link("mailto:" + contact.slice(7), body)
+  } else if contact.match(_tel) != none {
+    link("tel:" + contact.slice(4).replace(regex("[^\\d+]"), ""), body)
+  } else if contact.match(_email) != none {
+    link("mailto:" + contact, body)
+  } else if contact.match(_scheme) != none {
+    let (scheme, rest) = if lower(contact).starts-with("www.") {
+      ("https://", contact)
+    } else {
+      let split = contact.position("://") + 3
+      (lower(contact.slice(0, split)), contact.slice(split))
+    }
+    link(scheme + rest, 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 → 0.1.0}/packages/ttq-classic-resume/typst.toml

@@ -19,8 +19,3 @@ keywords = [
 ]
 categories = ["cv"]
 disciplines = ["business", "computer-science", "engineering", "communication"]
-
-[template]
-path = "template"
-entrypoint = "resume.typ"
-thumbnail = "thumbnail.png"

package/quills/classic_resume/{0.0.1 → 0.1.0}/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,14 @@
   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) = {
+  let value = value.trim()
+  if value == "" { none } else { auto-link(value, body: printed) }
+}
 
 #show: resume.with(
   // An enum's blank is authorable even where the schema declares a default.
@@ -54,9 +54,9 @@
   // 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.
+  // carries itself, and wants a point less to weigh the same: 6pt at 12pt.
   contact-separator: "◆",
-  contact-separator-size: 6pt,
+  contact-separator-size: 0.5em,
 )
 
 // The package restyles lists to its square bullet inside an entry only. A
@@ -73,13 +73,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 +101,50 @@
   body: under-entry(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)
+// The rows an author filled in. A row left wholly blank, as a new one is, would
+// print as an empty gap.
+#let filled(rows) = rows.filter(row => row.values().any(value => {
+  or-none(if type(value) == str { value.trim() } else { value }) != none
+}))
 
-  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),
+// 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 filled(card.jobs) {
+    dated(job.company, job.dates, job.role, job.location, job.details)
+  },
+  education: card => for school in filled(card.schools) {
+    dated(school.school, school.dates, school.degree, school.location, school.details)
+  },
+  skills: card => item-grid(
+    items: filled(card.skills).map(row => (label: or-none(row.label), text: trim-inline(row.items))),
+    columns: calc.max(1, card.columns),
+  ),
+  projects: card => for project in filled(card.projects) {
+    entry(
+      heading: trim-inline(project.name),
+      form: "linked",
+      url: linked(project.link, ink(project).link),
+      body: under-entry(project.details),
     )
-  } else if kind == "certifications" {
-    item-grid(items: card.items.map(trim-inline), columns: calc.max(1, card.columns))
+  },
+  certifications: card => item-grid(
+    items: card.items.map(or-none).filter(item => item != none),
+    columns: calc.max(1, card.columns),
+  ),
+  other: card => for row in filled(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)
   }
 }