@airmark/quiver 0.1.0

package/quills/usaf_memo/0.2.0/packages/tonguetoquill-usaf-memo/src/body.typ

@@ -0,0 +1,344 @@
+// body.typ: Paragraph body rendering for USAF memorandum sections
+//
+// This module implements the visual rendering of AFH 33-337 compliant
+// paragraph bodies with proper numbering, nesting, and formatting.
+
+#import "config.typ": *
+#import "utils.typ": *
+#import "primitives.typ": render-memo-table
+
+// =============================================================================
+// PARAGRAPH NUMBERING UTILITIES
+// =============================================================================
+
+/// Gets the numbering format for a specific paragraph level.
+///
+/// - level (int): Paragraph nesting level (0-based)
+/// -> str | function
+#let get-paragraph-numbering-format(level) = {
+  paragraph-config.numbering-formats.at(level, default: "i.")
+}
+
+/// Calculates indentation for USAF-style paragraphs from explicit counter values.
+///
+/// - level (int): Paragraph nesting level (0-based)
+/// - level-counts (dictionary): Maps level index strings to their current counter values
+/// -> length
+#let calculate-indent-from-counts(level, level-counts) = {
+  if level == 0 {
+    return 0pt
+  }
+  let total-indent = 0pt
+  for ancestor-level in range(level) {
+    let ancestor-value = level-counts.at(str(ancestor-level), default: 1)
+    let ancestor-format = get-paragraph-numbering-format(ancestor-level)
+    let ancestor-number = numbering(ancestor-format, ancestor-value)
+    total-indent += measure([#ancestor-number#"  "]).width
+  }
+  total-indent
+}
+
+/// Calculates fixed indentation for DAF paragraph levels.
+///
+/// First nested level starts at `nested-first-level-indent` (1in); deeper levels
+/// add `nested-step` (0.5in) per additional depth.
+///
+/// - level (int): Paragraph nesting level (0-based)
+/// -> length
+#let calculate-daf-indent(level) = {
+  if level <= 0 {
+    return 0pt
+  }
+  daf-paragraph.nested-first-level-indent + (level - 1) * daf-paragraph.nested-step
+}
+
+/// Resets counter entries from `start` upward to 1 in the level-counts dictionary.
+#let reset-levels-from(level-counts, start, max-levels) = {
+  for child in range(start, max-levels) {
+    level-counts.insert(str(child), 1)
+  }
+  level-counts
+}
+
+/// Formats a paragraph (or continuation) with a given indent strategy.
+///
+/// - body (content): Paragraph content
+/// - level (int): Nesting level (0-based)
+/// - level-counts (dictionary): Current counter values per level
+/// - indent-fn (function): `(level, level-counts) -> length`
+/// - continuation (bool): If true, adds number-label width to alignment
+/// -> content
+#let format-par(body, level, level-counts, indent-fn, continuation: false) = {
+  let indent-width = indent-fn(level, level-counts)
+  if continuation {
+    let current-value = level-counts.at(str(level), default: 1)
+    let number-text = numbering(get-paragraph-numbering-format(level), current-value)
+    [#h(indent-width + measure([#number-text#"  "]).width)#body]
+  } else {
+    let current-value = level-counts.at(str(level), default: 1)
+    let number-text = numbering(get-paragraph-numbering-format(level), current-value)
+    [#h(indent-width)#number-text#"  "#body]
+  }
+}
+
+// =============================================================================
+// PARAGRAPH BODY RENDERING
+// =============================================================================
+// AFH 33-337 "The Text of the Official Memorandum" §1-12 specifies:
+// - Single-space text, double-space between paragraphs
+// - Number and letter each paragraph and subparagraph
+// - "A single paragraph is not numbered" (§2)
+// - First paragraph flush left, never indented
+// - Indent sub-paragraphs to align with first character of parent paragraph text
+#let render-body(content, auto-numbering: true, memo-style: "usaf") = {
+  let PAR_BUFFER = state("PAR_BUFFER")
+  PAR_BUFFER.update(())
+  let NEST_DOWN = counter("NEST_DOWN")
+  NEST_DOWN.update(0)
+  let NEST_UP = counter("NEST_UP")
+  NEST_UP.update(0)
+  let IS_HEADING = state("IS_HEADING")
+  IS_HEADING.update(false)
+  // Tracks whether the next paragraph is the first block in a list item.
+  // When true, the next `show par` captures a numbered item; subsequent
+  // paragraphs within the same item are continuations (no new number).
+  let ITEM_FIRST_PAR = state("ITEM_FIRST_PAR")
+  ITEM_FIRST_PAR.update(false)
+
+  // The first pass parses paragraphs, list items, etc. into standardized arrays
+  let first_pass = {
+    // Collect pars with nesting level
+    show par: p => context {
+      let nest_level = NEST_DOWN.get().at(0) - NEST_UP.get().at(0)
+      let is_heading = IS_HEADING.get()
+      let is_first_par = ITEM_FIRST_PAR.get()
+
+      // Determine if this is a continuation block within a multi-block list item.
+      // A continuation is a non-first paragraph inside a list item (nest_level > 0).
+      let is_continuation = nest_level > 0 and not is_first_par
+
+      PAR_BUFFER.update(pars => {
+        pars.push((
+          content: text([#p.body]),
+          nest_level: nest_level,
+          kind: if is_heading { "heading" } else if is_continuation { "continuation" } else { "par" },
+        ))
+        pars
+      })
+
+      // After the first paragraph of a list item, mark subsequent ones as continuations
+      if nest_level > 0 and is_first_par {
+        ITEM_FIRST_PAR.update(false)
+      }
+
+      p
+    }
+    // Collect tables — captured as-is without paragraph numbering
+    show table: t => context {
+      PAR_BUFFER.update(pars => {
+        pars.push((
+          content: t,
+          nest_level: -1,
+          kind: "table",
+        ))
+        pars
+      })
+      t
+    }
+    {
+      show heading: h => {
+        IS_HEADING.update(true)
+        [#parbreak()#h.body#parbreak()]
+        IS_HEADING.update(false)
+      }
+
+      // Convert list/enum items to pars
+      // Note: No context wrapper here - state updates don't need it and cause
+      // layout convergence issues with many list items
+      show enum.item: it => {
+        NEST_DOWN.step()
+        ITEM_FIRST_PAR.update(true)
+        [#parbreak()#it.body#parbreak()]
+        NEST_UP.step()
+      }
+      show list.item: it => {
+        NEST_DOWN.step()
+        ITEM_FIRST_PAR.update(true)
+        [#parbreak()#it.body#parbreak()]
+        NEST_UP.step()
+      }
+
+      {
+        // Typst bug bandaid:
+        // `show par` will not collect wrappers unless there is content outside
+        // Add zero width space to always have content outside of wrapper
+        show strong: it => {
+          [#it#sym.zws]
+        }
+        show emph: it => {
+          [#it#sym.zws]
+        }
+        show underline: it => {
+          [#it#sym.zws]
+        }
+        show raw: it => {
+          [#it#sym.zws]
+        }
+        [#content#parbreak()]
+      }
+    }
+  }
+  // Use place() to prevent hidden content from affecting layout flow
+  place(hide(first_pass))
+
+  // Second pass: consume par buffer
+  //
+  // PAR_BUFFER item dictionary layout:
+  //   item.content    — the paragraph body or table element
+  //   item.nest_level — nesting depth (−1 for tables)
+  //   item.kind       — "par", "heading", "table", or "continuation"
+  context {
+    let heading_buffer = none
+    // Only top-level paragraphs count for AFH 33-337 §2 numbering purposes
+    let par_count = PAR_BUFFER.get().filter(item => item.kind == "par").len()
+    let items = PAR_BUFFER.get()
+    let total_count = items.len()
+
+    // Track paragraph numbers per level manually to avoid nested-context
+    // counter propagation issues.  Dictionary maps level index (as string)
+    // to the current counter value at that level.
+    let max-levels = paragraph-config.numbering-formats.len()
+    let level-counts = (:)
+    for lvl in range(max-levels) {
+      level-counts.insert(str(lvl), 1)
+    }
+
+    let i = 0
+    for item in items {
+      i += 1
+      let kind = item.kind
+      let item_content = item.content
+
+      // Buffer headings for prepend to the next rendered element
+      if kind == "heading" {
+        heading_buffer = item_content
+        continue
+      }
+
+      // Prepend buffered heading to the next non-heading element
+      if heading_buffer != none {
+        if kind == "table" {
+          // Tables cannot have inline text prepended; emit heading as
+          // a standalone bold line above the table
+          blank-line()
+          strong[#heading_buffer.]
+          heading_buffer = none
+        } else {
+          item_content = [#strong[#heading_buffer.] #item_content]
+          heading_buffer = none
+        }
+      }
+
+      // Format based on element kind
+      let nest_level = item.nest_level
+      let indent-fn = if memo-style == "daf" {
+        (level, _counts) => calculate-daf-indent(level)
+      } else {
+        (level, counts) => calculate-indent-from-counts(level, counts)
+      }
+      let final_par = {
+        if kind == "table" {
+          render-memo-table(item_content)
+        } else if kind == "continuation" {
+          // Continuation block within a multi-block list item:
+          // indent to align with preceding numbered paragraph's text, no new number.
+          // level-counts still holds the value of the preceding numbered paragraph.
+          if memo-style == "daf" {
+            if nest_level > 0 {
+              format-par(item_content, nest_level, level-counts, indent-fn, continuation: true)
+            } else {
+              item_content
+            }
+          } else if auto-numbering {
+            format-par(item_content, nest_level, level-counts, indent-fn, continuation: true)
+          } else if nest_level > 0 {
+            format-par(item_content, nest_level - 1, level-counts, indent-fn, continuation: true)
+          } else {
+            item_content
+          }
+        } else if memo-style == "daf" {
+          if nest_level > 0 {
+            let par = format-par(item_content, nest_level, level-counts, indent-fn)
+            level-counts.insert(str(nest_level), level-counts.at(str(nest_level), default: 1) + 1)
+            level-counts = reset-levels-from(level-counts, nest_level + 1, max-levels)
+            par
+          } else {
+            // DAF top-level paragraphs are unnumbered and first-line indented.
+            // Reset nested counters so each new top-level paragraph restarts children.
+            level-counts = reset-levels-from(level-counts, 0, max-levels)
+            [#h(daf-paragraph.top-first-line-indent)#item_content]
+          }
+        } else if auto-numbering {
+          if par_count > 1 {
+            // Apply paragraph numbering per AFH 33-337 §2
+            let par = format-par(item_content, nest_level, level-counts, indent-fn)
+            level-counts.insert(str(nest_level), level-counts.at(str(nest_level)) + 1)
+            level-counts = reset-levels-from(level-counts, nest_level + 1, max-levels)
+            par
+          } else {
+            // AFH 33-337 §2: "A single paragraph is not numbered"
+            item_content
+          }
+        } else {
+          // Unnumbered mode: only explicitly nested items (enum/list) get numbered
+          if nest_level > 0 {
+            let effective_level = nest_level - 1
+            let par = format-par(item_content, effective_level, level-counts, indent-fn)
+            level-counts.insert(str(effective_level), level-counts.at(str(effective_level)) + 1)
+            level-counts = reset-levels-from(level-counts, effective_level + 1, max-levels)
+            par
+          } else {
+            // Base-level paragraphs are flush left with no numbering.
+            // Reset all child level counters so subsequent list items restart at 1.
+            level-counts = reset-levels-from(level-counts, 0, max-levels)
+            item_content
+          }
+        }
+      }
+
+      // If this is the final item, apply AFH 33-337 §11 rule:
+      // "Avoid dividing a paragraph of less than four lines between two pages"
+      blank-line()
+      if i == total_count {
+        let available_width = page.width - spacing.margin * 2
+
+        // Use the shared measured line stride used by blank-line spacing.
+        let line_height = {
+          let cached = LINE_STRIDE.get()
+          if cached != none {
+            cached
+          } else {
+            let one-line = measure(par(spacing: 0pt)[x]).height
+            measure(par(spacing: 0pt)[x#linebreak()x]).height - one-line
+          }
+        }
+        // Calculate last item's height
+        let par_height = measure(final_par, width: available_width).height
+
+        let estimated_lines = calc.ceil(par_height / line_height)
+
+        if estimated_lines < 4 {
+          // Short content (< 4 lines): make sticky to keep with signature
+          block(sticky: true)[#final_par]
+        } else {
+          // Longer content (≥ 4 lines): use default breaking behavior
+          block(breakable: true)[#final_par]
+        }
+      } else {
+        final_par
+      }
+    }
+  }
+}
+
+

package/quills/usaf_memo/0.2.0/packages/tonguetoquill-usaf-memo/src/config.typ

@@ -0,0 +1,73 @@
+// config.typ: Configuration constants and defaults for USAF memorandum template
+//
+// This module defines core configuration values that implement AFH 33-337 Chapter 14
+// formatting requirements for official USAF memorandums.
+
+// =============================================================================
+// SPACING CONSTANTS
+// =============================================================================
+// AFH 33-337 specifies precise spacing requirements throughout Chapter 14
+
+#let spacing = (
+  // Legacy exported field retained for compatibility with downstream imports.
+  // Internal blank-line spacing now uses measured line stride from utils.typ.
+  vertical: 19.05pt,
+  line: .5em, // Internal line spacing for readability (`par.leading`; gap between line boxes)
+  line-height: .7em, // Base height of text lines for pagination estimates
+  tab: 0.5in, // Tab stop for multi-column recipient alignment
+  margin: 1in, // AFH 33-337 §4: "Use 1-inch margins on the left, right and bottom"
+)
+
+// =============================================================================
+// TYPOGRAPHY DEFAULTS
+// =============================================================================
+// AFH 33-337 §5: "Use 12 point Times New Roman font for text"
+
+#let DEFAULT_LETTERHEAD_FONTS = ("NimbusRomNo9L", "times new roman")
+#let DEFAULT_BODY_FONTS = ("NimbusRomNo9L", "times new roman")  // AFH 33-337 §5: Times New Roman required
+#let LETTERHEAD_COLOR = rgb("#204093")  // Faded USAF blue for letterhead
+
+// =============================================================================
+// PARAGRAPH CONFIGURATION
+// =============================================================================
+// AFH 33-337 "The Text of the Official Memorandum" §2:
+// "Number and letter each paragraph and subparagraph"
+// Hierarchical numbering: 1., a., (1), (a), etc.
+
+#let paragraph-config = (
+  counter-prefix: "par-counter-",
+  // AFH 33-337 §2: Hierarchical paragraph numbering format
+  // Level 0: 1., 2., 3. | Level 1: a., b., c. | Level 2: (1), (2), (3) | Level 3: (a), (b), (c)
+  numbering-formats: ("1.", "a.", "(1)", "(a)", n => underline(str(n)), n => underline(str(n))),
+)
+
+// DAF (Headquarters) memo body: first-line indent for unnumbered paragraphs; nested
+// items start at 1in, then +0.5in per additional nesting depth.
+#let daf-paragraph = (
+  top-first-line-indent: 0.5in,
+  nested-first-level-indent: 1in,
+  nested-step: 0.5in,
+)
+
+// =============================================================================
+// COUNTERS
+// =============================================================================
+
+#let counters = (
+  indorsement: counter("indorsement"),
+)
+
+// =============================================================================
+// CLASSIFICATION COLORS
+// =============================================================================
+// AFH 33-337 §3: "Follow AFI 31-401, Information Security Program Management,
+// applicable executive orders and DoD guidance for the necessary markings on
+// classified correspondence."
+// Color values follow DoD standard classification marking colors
+// Source: https://security.stackexchange.com/questions/161829
+
+#let CLASSIFICATION_COLORS = (
+  "UNCLASSIFIED": rgb(0, 122, 51), // Forest green (#007A33)
+  "SECRET": rgb(200, 16, 46), // Crimson red (#C8102E)
+  "TOP SECRET": rgb(255, 103, 31), // Burnt orange (#FF671F)
+)

package/quills/usaf_memo/0.2.0/packages/tonguetoquill-usaf-memo/src/frontmatter.typ

@@ -0,0 +1,137 @@
+// frontmatter.typ: Frontmatter show rule for USAF memorandum
+//
+// This module implements the frontmatter (heading section) of a USAF memorandum
+// per AFH 33-337 Chapter 14 "The Heading Section". It handles:
+// - Page setup with proper margins
+// - Letterhead rendering
+// - Date, MEMORANDUM FOR, FROM, SUBJECT, and References placement
+// - Classification markings in headers/footers
+
+#import "primitives.typ": *
+
+#let frontmatter(
+  subject: none,
+  memo_for: none,
+  memo_from: none,
+  date: none,
+  references: none,
+  letterhead_title: "DEPARTMENT OF THE AIR FORCE",
+  letterhead_caption: "[YOUR SQUADRON/UNIT NAME]",
+  letterhead_seal: none,
+  letterhead_seal_subtitle: none, // optional line under seal (9pt bold caps); ignored if no seal
+  letterhead_font: DEFAULT_LETTERHEAD_FONTS,
+  body_font: DEFAULT_BODY_FONTS,
+  font_size: 12pt,
+  memo_for_cols: 3,
+  classification_level: none,
+  footer_tag_line: none,
+  auto_numbering: true,
+  memo_style: "usaf",
+  it,
+) = {
+  assert(subject != none, message: "subject is required")
+  assert(memo_for != none, message: "memo_for is required")
+  assert(memo_from != none, message: "memo_from is required")
+  assert(
+    memo_style in ("usaf", "daf"),
+    message: "memo_style must be \"usaf\" or \"daf\"",
+  )
+
+  let actual_date = if date == none { datetime.today() } else { date }
+  let classification_color = get-classification-level-color(classification_level)
+
+  // Document-wide typography settings (inlined from configure())
+  set par(leading: spacing.line, spacing: spacing.line, justify: false)
+  set block(above: spacing.line, below: 0em, spacing: 0em)
+  set text(font: body_font, size: font_size, fallback: true)
+
+  set page(
+    paper: "us-letter",
+    // AFH 33-337 §4: "Use 1-inch margins on the left, right and bottom"
+    margin: (
+      left: spacing.margin,
+      right: spacing.margin,
+      top: spacing.margin,
+      bottom: spacing.margin,
+    ),
+    header: {
+      // AFH 33-337 "Page numbering" §12: "The first page of a memorandum is never numbered.
+      // Number the succeeding pages starting with page 2. Place page numbers 0.5-inch from
+      // the top of the page, flush with the right margin."
+      context if counter(page).get().first() > 1 {
+        place(
+          dy: +.5in,
+          block(
+            width: 100%,
+            align(right, text(12pt)[#counter(page).display()]),
+          ),
+        )
+      }
+
+      if classification_level != none {
+        place(
+          top + center,
+          dy: 0.375in,
+          text(12pt, font: DEFAULT_BODY_FONTS, fill: classification_color)[#strong(classification_level)],
+        )
+      }
+    },
+    footer: {
+      place(
+        bottom + center,
+        dy: -.375in,
+        text(12pt, font: DEFAULT_BODY_FONTS, fill: classification_color)[#strong(classification_level)],
+      )
+
+      if not falsey(footer_tag_line) {
+        place(
+          bottom + center,
+          dy: -0.625in,
+          align(center)[
+            #text(fill: LETTERHEAD_COLOR, font: "cinzel", size: 15pt)[#footer_tag_line]
+          ],
+        )
+      }
+    },
+  )
+
+  render-letterhead(
+    letterhead_title,
+    letterhead_caption,
+    letterhead_font,
+    letterhead-seal: letterhead_seal,
+    letterhead-seal-subtitle: letterhead_seal_subtitle,
+  )
+
+  // AFH 33-337 "Date": "Place the date 1 inch from the right edge, 1.75 inches from the top"
+  // Since we have a 1-inch top margin, we need (1.75in - margin) vertical space
+  v(1.75in - spacing.margin)
+
+  // Measure and cache body line stride once for downstream spacing logic.
+  context {
+    let one-line = measure(par(spacing: 0pt)[x]).height
+    let line-stride = measure(par(spacing: 0pt)[x#linebreak()x]).height - one-line
+    let em-size = measure(box(width: 1em)[]).width
+    let legacy-scaled = spacing.vertical * (em-size / 12pt)
+    LINE_STRIDE.update(line-stride)
+    BLANK_LINE_STEP.update(calc.max(line-stride, legacy-scaled))
+  }
+
+  metadata((
+    subject: subject,
+    original_date: actual_date,
+    original_from: first-or-value(memo_from),
+    body_font: body_font,
+    font_size: font_size,
+    auto_numbering: auto_numbering,
+    memo_style: memo_style,
+  ))
+
+  render-date-section(actual_date, memo-style: memo_style)
+  render-for-section(memo_for, memo_for_cols)
+  render-from-section(memo_from)
+  render-subject-section(subject)
+  render-references-section(references)
+
+  it
+}

package/quills/usaf_memo/0.2.0/packages/tonguetoquill-usaf-memo/src/indorsement.typ

@@ -0,0 +1,111 @@
+// indorsement.typ: Indorsement rendering for USAF memorandum
+//
+// This module implements indorsements (endorsements) per AFH 33-337 Chapter 14.
+// Indorsements are used to forward memorandums with additional commentary.
+// They follow the format: "1st Ind", "2d Ind", "3d Ind", etc.
+// Each indorsement includes its own body text and signature block.
+//
+// Note: When using #show: indorsement.with(...), the indorsement wraps the
+// entire remainder of the document. This works for a single indorsement at
+// the end of a file. For multiple indorsements, use the function call syntax:
+// #indorsement(...)[Body text...]
+
+#import "primitives.typ": *
+#import "body.typ": *
+
+#let indorsement(
+  from: none,
+  to: none,
+  signature_block: none,
+  signature_blank_lines: 4,
+  attachments: none,
+  cc: none,
+  date: none,
+  // Format of indorsement: "standard" (same page), "informal" (no header), or "separate_page" (starts on new page)
+  format: "standard",
+  // Approval action: none (default, no action line displayed), "undecided", "approve", or "disapprove".
+  // When set to "undecided", the action line is displayed with neither option circled.
+  // When set to "approve" or "disapprove", the action line is displayed with the selected option circled.
+  action: none,
+  content,
+) = {
+  // Validate format parameter
+  assert(
+    format in ("standard", "informal", "separate_page"),
+    message: "format must be \"standard\", \"informal\", or \"separate_page\"",
+  )
+
+  if format != "informal" {
+    assert(from != none, message: "from is required")
+    assert(to != none, message: "to is required")
+  }
+
+
+  let actual_date = if date == none { datetime.today() } else { date }
+  let ind_from = first-or-value(from)
+  let ind_for = to
+
+  if format != "informal" {
+    // Step the counter BEFORE the context block to avoid read-then-update loop
+    counters.indorsement.step()
+
+    context {
+      let config = query(metadata).last().value
+      let memo-style = config.at("memo_style", default: "usaf")
+      let original_subject = config.subject
+      let original_date = config.original_date
+      let original_from = config.original_from
+
+      // Read the counter value (already stepped above)
+      let indorsement_number = counters.indorsement.get().at(0, default: 1)
+      let indorsement_label = format-indorsement-number(indorsement_number)
+
+      if format == "separate_page" {
+        pagebreak()
+        [#indorsement_label to #original_from, #display-date(original_date, memo-style: memo-style), #original_subject]
+
+        blank-line()
+        grid(
+          columns: (auto, 1fr),
+          ind_from, align(right)[#display-date(actual_date, memo-style: memo-style)],
+        )
+
+        blank-line()
+        grid(
+          columns: (auto, auto, 1fr),
+          "MEMORANDUM FOR", "  ", ind_for,
+        )
+      } else {
+        blank-line()
+        grid(
+          columns: (auto, 1fr),
+          [#indorsement_label, #ind_from], align(right)[#display-date(actual_date, memo-style: memo-style)],
+        )
+
+        blank-line()
+        grid(
+          columns: (auto, auto, 1fr),
+          "MEMORANDUM FOR", "  ", ind_for,
+        )
+      }
+    }
+    blank-line()
+  }
+
+  // Show action line only when an action decision is set (not `none`)
+  if action != none {
+    render-action-line(action)
+  }
+
+  context {
+    let memo-style = {
+      let items = query(metadata)
+      if items.len() > 0 { items.last().value.at("memo_style", default: "usaf") } else { "usaf" }
+    }
+    render-body(content, memo-style: memo-style)
+  }
+
+  render-signature-block(signature_block, signature-blank-lines: signature_blank_lines)
+
+  render-backmatter-sections(attachments: attachments, cc: cc)
+}