@airmark/quiver 0.32.2 → 0.33.0

package/quills/classic_resume/0.0.1/packages/ttq-classic-resume/fonts/EBGaramond/OFL.txt

@@ -0,0 +1,94 @@
+Copyright 2017 The EB Garamond Project Authors (https://github.com/octaviopardo/EBGaramond12)
+Copyright 2025 Deborah Khodanovich (RCS citation glyphs)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

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

@@ -0,0 +1,181 @@
+// 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.
+#let _entry(cfg, cells, body) = {
+  v(cfg.entry-spacing)
+  block(breakable: false, {
+    grid(columns: (1fr, auto), row-gutter: cfg.leading, ..cells)
+    if body != none {
+      _bulleted(cfg, body)
+    }
+  })
+}
+
+/// 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.
+#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.
+  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 }
+  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)
+  })
+}
+
+/// 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. `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,
+      )
+      if type(url) == str and url.starts-with("http") { link(url, label) } else { 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 => {
+    v(cfg.entry-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,53 @@
+// 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; the two `*-spacing`
+  // values are the extra breathing room above a section header and above an
+  // entry.
+  leading: 0.5em,
+  section-spacing: 5pt,
+  entry-spacing: 5pt,
+
+  // Resume header. The separator keeps its own padding so that the space
+  // around it does not change when its size does.
+  name-size: 18pt,
+  contact-separator: "❖",
+  contact-separator-size: 7pt,
+  contact-separator-padding: 0.5em,
+
+  // 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-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.
+  annotation-font: auto,
+  annotation-size: 8pt,
+)
+
+#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,57 @@
+// layout.typ
+// The document-wide show rule.
+
+#import "config.typ": config-state, default-config
+
+/// 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)
+  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.
+  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))
+  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))
+  }
+
+  config-state.update(cfg)
+
+  body
+}

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

@@ -0,0 +1,6 @@
+// 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

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

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

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
+#import "@local/ttq-classic-resume:0.1.0": (
+  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.
+#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 }
+}
+
+#let stock-title = (
+  summary: "Summary",
+  experience: "Work Experience",
+  education: "Education",
+  projects: "Projects",
+  skills: "Skills",
+  certifications: "Certifications",
+)
+
+#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,
+)
+
+// `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,
+)
+
+// 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),
+)
+
+#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))
+  }
+}