webtranslateit-payday 1.7.4 → 2.0.0

data/lib/payday/pdf_renderer.rb

@@ -2,361 +2,92 @@
 
 module Payday
 
-  # The PDF renderer. We use this internally in Payday to render pdfs, but really you should just need to call
-  # {{Payday::Invoiceable#render_pdf}} to render pdfs yourself.
-  class PdfRenderer # rubocop:todo Metrics/ClassLength
+  # Renders an invoice to PDF by feeding a presented Hash to the Typst template.
+  #
+  # Invoice data crosses into the template only as sys_inputs JSON, where Typst treats every
+  # string as literal text. Never interpolate invoice data into the template source.
+  class PdfRenderer
+
+    TEMPLATE = File.expand_path('templates/invoice.typ', __dir__)
+    FONT_DIR = File.expand_path('../../fonts', __dir__)
+    FONTS = %w[NotoSans-Regular.ttf NotoSans-Bold.ttf].freeze
 
     # Renders the given invoice as a pdf on disk
     def self.render_to_file(invoice, path)
-      pdf(invoice).render_file(path)
+      File.binwrite(path, render(invoice))
     end
 
     # Renders the given invoice as a pdf, returning a string
     def self.render(invoice)
-      pdf(invoice).render
-    end
-
-    def self.pdf(invoice) # rubocop:todo Metrics/MethodLength, Metrics/AbcSize
-      pdf = Prawn::Document.new(page_size: invoice_or_default(invoice, :page_size))
-
-      font_dir = File.join(File.dirname(__dir__), '..', 'fonts')
-      pdf.font_families.update(
-        'NotoSans' => {normal: File.join(font_dir, 'NotoSans-Regular.ttf'),
-                       bold: File.join(font_dir, 'NotoSans-Bold.ttf')}
-      )
-
-      # set up some default styling
-      pdf.font_size(10)
-      pdf.font 'NotoSans'
-
-      stamp(invoice, pdf)
-      company_banner(invoice, pdf)
-      bill_to_ship_to(invoice, pdf)
-      invoice_details(invoice, pdf)
-      line_items_table(invoice, pdf)
-      totals_lines(invoice, pdf)
-      notes(invoice, pdf)
-      render_qr_code(invoice, pdf) unless defined?(invoice.notes) && invoice.notes
-
-      page_numbers(pdf)
-
-      pdf
+      new(invoice).render
     end
 
-    def self.stamp(invoice, pdf) # rubocop:todo Metrics/MethodLength
-      stamp = nil
-      if invoice.refunded?
-        stamp = I18n.t 'payday.status.refunded', default: 'REFUNDED'
-      elsif invoice.paid?
-        stamp = I18n.t 'payday.status.paid', default: 'PAID'
-      elsif invoice.overdue?
-        stamp = I18n.t 'payday.status.overdue', default: 'OVERDUE'
-      end
-
-      if stamp
-        pdf.bounding_box([150, pdf.cursor - 50], width: pdf.bounds.width - 300) do
-          pdf.font('NotoSans') do
-            pdf.fill_color 'cc0000'
-            pdf.text stamp, align: :center, size: 25, rotate: 15, style: :bold
-          end
-        end
-      end
-
-      pdf.fill_color '000000'
-    end
-
-    # rubocop:todo Metrics/MethodLength
-    def self.company_banner(invoice, pdf) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      # render the logo
-      image = invoice_or_default(invoice, :invoice_logo)
-      height = nil
-      width = nil
-
-      # Handle images defined with a hash of options
-      if image.is_a?(Hash)
-        data = image
-        image = data[:filename]
-        width, height = data[:size].split('x').map(&:to_f)
-      end
-
-      if File.extname(image) == '.svg'
-        # Logos are read from local files, so there is nothing to fetch over the network.
-        # Passing this explicitly also silences prawn-svg's deprecation warning and keeps
-        # behaviour stable when prawn-svg 1.0 flips the default to false.
-        logo_info = pdf.svg(File.read(image), at: pdf.bounds.top_left, width: width, height: height,
-                                              enable_web_requests: false)
-        logo_height = logo_info[:height]
-      else
-        logo_info = pdf.image(image, at: pdf.bounds.top_left, width: width, height: height)
-        logo_height = logo_info.scaled_height
-      end
-
-      # render the company details
-      table_data = []
-      table_data << [bold_cell(pdf, invoice_or_default(invoice, :company_name).strip, size: 12)]
-
-      invoice_or_default(invoice, :company_details).lines.each { |line| table_data << [line] }
-
-      table = pdf.make_table(table_data, cell_style: {borders: [], padding: 0})
-      pdf.bounding_box([pdf.bounds.width - table.width, pdf.bounds.top], width: table.width,
-                                                                         height: table.height + 5) do
-        table.draw
-      end
-
-      pdf.move_cursor_to(pdf.bounds.top - logo_height - 20)
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    # rubocop:todo Metrics/MethodLength
-    def self.bill_to_ship_to(invoice, pdf) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      bill_to_cell_style = {borders: [], padding: [2, 0]}
-      bill_to_ship_to_bottom = 0
-
-      # render bill to
-      pdf.float do
-        pdf.table([[bold_cell(pdf, I18n.t('payday.invoice.bill_to', default: 'Bill To'))],
-                   [invoice.bill_to]], column_widths: [200], cell_style: bill_to_cell_style)
-        bill_to_ship_to_bottom = pdf.cursor
-      end
-
-      # render ship to
-      if defined?(invoice.ship_to) && !invoice.ship_to.nil?
-        table = pdf.make_table([[bold_cell(pdf, I18n.t('payday.invoice.ship_to', default: 'Ship To'))],
-                                [invoice.ship_to]], column_widths: [200], cell_style: bill_to_cell_style)
-
-        pdf.bounding_box([pdf.bounds.width - table.width, pdf.cursor], width: table.width, height: table.height + 2) do
-          table.draw
-        end
-      end
-
-      # make sure we start at the lower of the bill_to or ship_to details
-      bill_to_ship_to_bottom = pdf.cursor if pdf.cursor < bill_to_ship_to_bottom
-      pdf.move_cursor_to(bill_to_ship_to_bottom - 20)
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    # rubocop:todo Metrics/PerceivedComplexity
-    # rubocop:todo Metrics/MethodLength
-    # rubocop:todo Metrics/AbcSize
-    def self.invoice_details(invoice, pdf) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
-      # invoice details
-      table_data = []
-
-      # invoice number
-      if defined?(invoice.invoice_number) && invoice.invoice_number
-        table_data << if invoice.paid?
-          [bold_cell(pdf, I18n.t('payday.invoice.receipt_no', default: 'Receipt #:')),
-           bold_cell(pdf, invoice.invoice_number.to_s, align: :right)]
-        else
-          [bold_cell(pdf, I18n.t('payday.invoice.invoice_no', default: 'Invoice #:')),
-           bold_cell(pdf, invoice.invoice_number.to_s, align: :right)]
-        end
-      end
-
-      # Due on
-      if defined?(invoice.due_at) && invoice.due_at
-        due_date = if invoice.due_at.is_a?(Date) || invoice.due_at.is_a?(Time)
-          invoice.due_at.strftime(Payday::Config.default.date_format)
-        else
-          invoice.due_at.to_s
-        end
-
-        table_data << [bold_cell(pdf, I18n.t('payday.invoice.due_date', default: 'Due Date:')),
-                       bold_cell(pdf, due_date, align: :right)]
-      end
-
-      # Paid on
-      if defined?(invoice.paid_at) && invoice.paid_at
-        paid_date = if invoice.paid_at.is_a?(Date) || invoice.due_at.is_a?(Time)
-          invoice.paid_at.strftime(Payday::Config.default.date_format)
-        else
-          invoice.paid_at.to_s
-        end
-
-        table_data << [bold_cell(pdf, I18n.t('payday.invoice.paid_date', default: 'Paid Date:')),
-                       bold_cell(pdf, paid_date, align: :right)]
-      end
-
-      # loop through invoice_details and include them
-      invoice.each_detail do |key, value|
-        table_data << [bold_cell(pdf, key),
-                       bold_cell(pdf, value, align: :right)]
-      end
-
-      return unless table_data.length.positive?
-
-      pdf.table(table_data, cell_style: {borders: [], padding: [1, 10, 1, 1]})
+    # Converts this number to a formatted currency string
+    def self.number_to_currency(number, invoice)
+      Money.locale_backend = :currency
+      Money.rounding_mode = BigDecimal::ROUND_HALF_UP
+      currency = Money::Currency.wrap(currency_for(invoice))
+      number *= currency.subunit_to_unit
+      number = number.round unless Money.default_infinite_precision
+      Money.new(number, currency).format
     end
-    # rubocop:enable Metrics/AbcSize
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/PerceivedComplexity
 
-    # rubocop:todo Metrics/MethodLength
-    def self.line_items_table(invoice, pdf) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      table_data = []
-      table_data << [bold_cell(pdf, I18n.t('payday.line_item.description', default: 'Description'), borders: []),
-                     bold_cell(pdf, I18n.t('payday.line_item.unit_price', default: 'Unit Price'), align: :center,
-                                                                                                  borders: []),
-                     bold_cell(pdf, I18n.t('payday.line_item.quantity', default: 'Quantity'), align: :center,
-                                                                                              borders: []),
-                     bold_cell(pdf, I18n.t('payday.line_item.amount', default: 'Amount'), align: :center, borders: [])]
-      invoice.line_items.each do |line|
-        table_data << if line.predefined_amount
-          [line.description, '', '', number_to_currency(line.predefined_amount, invoice)]
-        else
-          [line.description,
-           line.display_price || number_to_currency(line.price, invoice),
-           line.display_quantity || BigDecimal(line.quantity.to_s).to_s('F'),
-           number_to_currency(line.amount, invoice)]
-        end
-      end
+    def self.currency_for(invoice)
+      return invoice.currency if invoice.respond_to?(:currency) && invoice.currency
 
-      pdf.move_cursor_to(pdf.cursor - 20)
-      pdf.table(table_data, width: pdf.bounds.width, header: true,
-                            cell_style: {border_width: 0.5, border_left_color: 'FFFFFF', border_right_color: 'FFFFFF',
-                                         border_top_color: 'F6F9FC', border_bottom_color: 'BCC6D0', padding: [5, 10],
-                                         inline_format: true},
-                            row_colors: %w[F6F9FC ffffff]) do
-        # left align the number columns
-        columns(1..3).rows(1..(row_length - 1)).style(align: :right)
-
-        # set the column widths correctly
-        natural = natural_column_widths
-        natural[0] = width - natural[1] - natural[2] - natural[3]
-      end
+      Payday::Config.default.currency
     end
-    # rubocop:enable Metrics/MethodLength
-
-    # rubocop:todo Metrics/PerceivedComplexity
-    # rubocop:todo Metrics/MethodLength
-    def self.totals_lines(invoice, pdf) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity
-      table_data = []
-      table_data << [
-        bold_cell(pdf, I18n.t('payday.invoice.subtotal', default: 'Subtotal:')),
-        cell(pdf, number_to_currency(invoice.subtotal, invoice), align: :right)
-      ]
-
-      tax_description = if invoice.tax_description.nil?
-        I18n.t('payday.invoice.tax', default: 'Tax:')
-      else
-        invoice.tax_description
-      end
-
-      table_data << [
-        bold_cell(pdf, tax_description),
-        cell(pdf, number_to_currency(invoice.tax, invoice), align: :right)
-      ]
-
-      if invoice.shipping_rate.positive?
-        shipping_description = if invoice.shipping_description.nil?
-          I18n.t('payday.invoice.shipping', default: 'Shipping:')
-        else
-          invoice.shipping_description
-        end
+    private_class_method :currency_for
 
-        table_data << [
-          bold_cell(pdf, shipping_description),
-          cell(pdf, number_to_currency(invoice.shipping, invoice),
-               align: :right)
-        ]
-      end
-
-      if invoice.retention_rate.positive?
-        retention_description = if invoice.retention_description.nil?
-          I18n.t('payday.invoice.retention', default: 'Retention:')
-        else
-          invoice.retention_description
-        end
-
-        table_data << [
-          bold_cell(pdf, retention_description),
-          cell(pdf, number_to_currency(-invoice.retention, invoice),
-               align: :right)
-        ]
-      end
-
-      table_data << [
-        bold_cell(pdf, I18n.t('payday.invoice.total', default: 'Total:'),
-                  size: 12),
-        cell(pdf, number_to_currency(invoice.total, invoice),
-             size: 12, align: :right)
-      ]
-      table = pdf.make_table(table_data, cell_style: {borders: []})
-      pdf.bounding_box([pdf.bounds.width - table.width, pdf.cursor],
-                       width: table.width, height: table.height + 2) do
-        table.draw
-      end
+    def initialize(invoice)
+      @invoice = invoice
+      @dependencies = {}
     end
-    # rubocop:enable Metrics/MethodLength
-    # rubocop:enable Metrics/PerceivedComplexity
-
-    def self.notes(invoice, pdf) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
-      return unless defined?(invoice.notes) && invoice.notes
 
-      pdf.move_cursor_to(pdf.cursor - 30)
-      pdf.font('NotoSans') do
-        pdf.text(I18n.t('payday.invoice.notes', default: 'Notes'), style: :bold)
-      end
-      pdf.line_width = 0.5
-      pdf.stroke_color = 'cccccc'
-      pdf.stroke_line([0, pdf.cursor - 3, pdf.bounds.width, pdf.cursor - 3])
-      pdf.move_cursor_to(pdf.cursor - 10)
-      pdf.text(invoice.notes.to_s, inline_format: true)
+    def render
+      data = InvoicePresenter.new(@invoice).to_h
+      register_qr_code(data[:qr_code])
+      data[:logo] = logo
 
-      render_qr_code(invoice, pdf)
+      Typst(body: File.read(TEMPLATE), dependencies: @dependencies, fonts: fonts,
+            sys_inputs: {'invoice' => data.to_json})
+        .compile(:pdf).bytes.flatten.pack('C*')
     end
 
-    def self.render_qr_code(invoice, pdf)
-      return unless defined?(invoice.qr_code) && invoice.qr_code.to_s.strip.present?
+    private
 
-      require 'rqrcode'
-
-      pdf.move_cursor_to(pdf.cursor - 10)
-      qr = RQRCode::QRCode.new(invoice.qr_code.to_s)
-      png = qr.as_png(size: 200)
-
-      pdf.image(StringIO.new(png.to_s), width: 100, position: :left)
+    def fonts
+      FONTS.to_h { |name| [name, File.binread(File.join(FONT_DIR, name))] }
     end
 
-    def self.page_numbers(pdf)
-      return unless pdf.page_count > 1
+    # Config#invoice_logo is either a path or a {filename:, size: "WxH"} Hash.
+    def logo
+      setting = invoice_logo
+      return nil if setting.nil?
 
-      pdf.number_pages('<page> / <total>', at: [pdf.bounds.right - 25, -10])
+      path, width, height = logo_parts(setting)
+      name = "logo#{File.extname(path.to_s)}"
+      @dependencies[name] = File.binread(path.to_s)
+      {name: name, width: width, height: height}
     end
 
-    def self.invoice_or_default(invoice, property)
-      if invoice.respond_to?(property) && invoice.send(property)
-        invoice.send(property)
-      else
-        Payday::Config.default.send(property)
-      end
-    end
+    def invoice_logo
+      return @invoice.invoice_logo if @invoice.respond_to?(:invoice_logo) && @invoice.invoice_logo
 
-    def self.cell(pdf, text, options = {})
-      Prawn::Table::Cell::Text.make(pdf, text, options)
+      Payday::Config.default.invoice_logo
     end
 
-    def self.bold_cell(pdf, text, options = {})
-      cell(pdf, "<b>#{text}</b>", options.merge(inline_format: true))
-    end
+    def logo_parts(setting)
+      return [setting, nil, nil] unless setting.is_a?(Hash)
 
-    # Converts this number to a formatted currency string
-    def self.number_to_currency(number, invoice)
-      Money.locale_backend = :currency
-      Money.rounding_mode = BigDecimal::ROUND_HALF_UP
-      currency = Money::Currency.wrap(invoice_or_default(invoice, :currency))
-      number *= currency.subunit_to_unit
-      number = number.round unless Money.default_infinite_precision
-      Money.new(number, currency).format
+      width, height = setting[:size].to_s.split('x').map(&:to_f)
+      [setting[:filename], width, height]
     end
 
-    def self.max_cell_width(cell_proxy)
-      max = 0
-      cell_proxy.each do |cell|
-        max = cell.natural_content_width if cell.natural_content_width > max
-      end
+    def register_qr_code(data)
+      return if data.nil?
 
-      max
+      @dependencies['qr.svg'] = QrCode.new(data).to_svg
     end
 
   end

data/lib/payday/qr_code.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'rqrcode'
+
+module Payday
+
+  # Draws a QR code as an SVG.
+  #
+  # The matrix comes straight from RQRCode, so the payload and its error correction level are
+  # untouched and the code carries exactly the same data it always did. Only the drawing
+  # changes: vector instead of a 200px raster, lightly rounded modules, and the three finder
+  # patterns drawn as rounded frames.
+  #
+  # Rounding is kept deliberately slight. These codes are scanned off paper, sometimes off a
+  # bad photocopy, and on a Verifactu invoice a code that will not scan is a compliance
+  # problem rather than a cosmetic one. Modules keep their full square footprint apart from a
+  # softened corner, so a scanner sees the same geometry the old raster produced.
+  class QrCode
+
+    QUIET_ZONE = 4    # modules of clear space; the QR spec's minimum
+    UNIT = 10         # user units per module
+    RADIUS = 1.5      # corner radius of a data module, out of UNIT
+    FINDER = 7        # finder patterns are 7 modules square
+    # Corner radius of a finder frame. Above roughly 1.2 modules the curve starts cutting the
+    # corner module out of the ring, which changes what a scanner reads.
+    EYE_RADIUS = 10
+    DARK = '#111111'
+    LIGHT = '#ffffff'
+
+    def initialize(data)
+      @modules = RQRCode::QRCode.new(data.to_s).modules
+    end
+
+    def to_svg
+      <<~SVG
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 #{side} #{side}" shape-rendering="geometricPrecision">
+        <rect width="#{side}" height="#{side}" fill="#{LIGHT}"/>
+        #{(data_modules + finders).join("\n")}
+        </svg>
+      SVG
+    end
+
+    private
+
+    def size
+      @modules.length
+    end
+
+    def side
+      (size + (QUIET_ZONE * 2)) * UNIT
+    end
+
+    def data_modules
+      @modules.each_with_index.flat_map do |cells, row|
+        cells.each_with_index.filter_map do |dark, col|
+          module_rect(row, col) if dark && !finder?(row, col)
+        end
+      end
+    end
+
+    def module_rect(row, col)
+      %(<rect class="m" x="#{x(col)}" y="#{x(row)}" width="#{UNIT}" height="#{UNIT}" ) +
+        %(rx="#{RADIUS}" fill="#{DARK}"/>)
+    end
+
+    # A finder is a 7x7 ring with a 3x3 centre. Drawing it as two rounded rects rather than 33
+    # separate modules is what gives the code its softer corners.
+    def finders
+      finder_origins.flat_map { |row, col| [ring(row, col), pupil(row, col)] }
+    end
+
+    def ring(row, col)
+      %(<rect class="f" x="#{x(col) + (UNIT / 2)}" y="#{x(row) + (UNIT / 2)}" ) +
+        %(width="#{UNIT * 6}" height="#{UNIT * 6}" rx="#{EYE_RADIUS}" ) +
+        %(fill="none" stroke="#{DARK}" stroke-width="#{UNIT}"/>)
+    end
+
+    def pupil(row, col)
+      %(<rect class="p" x="#{x(col + 2)}" y="#{x(row + 2)}" ) +
+        %(width="#{UNIT * 3}" height="#{UNIT * 3}" rx="#{UNIT}" fill="#{DARK}"/>)
+    end
+
+    def finder_origins
+      [[0, 0], [0, size - FINDER], [size - FINDER, 0]]
+    end
+
+    def finder?(row, col)
+      finder_origins.any? do |r, c|
+        row.between?(r, r + FINDER - 1) && col.between?(c, c + FINDER - 1)
+      end
+    end
+
+    def x(index)
+      (index + QUIET_ZONE) * UNIT
+    end
+
+  end
+
+end

data/lib/payday/templates/invoice.typ

@@ -0,0 +1,171 @@
+// Payday's invoice layout.
+//
+// All data arrives as JSON through sys.inputs, where Typst inserts string values as literal
+// text rather than markup. Never interpolate invoice data into this file's source, and never
+// call eval() on a value that came from an invoice.
+
+#let d = json(bytes(sys.inputs.invoice))
+
+// Gaps between the major blocks, calibrated so the rendered invoice keeps the vertical
+// rhythm the prawn renderer produced. Every within-block gap falls out of the table insets.
+#let gap-after-header = 15pt
+#let gap-after-addresses = 13.2pt
+#let gap-after-details = 8pt
+#let gap-before-totals = -12pt
+#let gap-before-notes = 22.3pt
+#let gap-notes-label-to-rule = -7.1pt
+#let gap-after-notes-rule = -0.4pt
+#let gap-before-qr = -0.6pt
+
+// Prawn page-size names mapped onto Typst paper names.
+#let papers = ("LETTER": "us-letter", "A4": "a4", "LEGAL": "us-legal")
+
+#set document(title: "Invoice", date: none)
+#set page(
+  paper: papers.at(d.page_size, default: "a4"),
+  margin: 36pt,  // prawn's default half-inch page margin
+  numbering: none,
+  // Page numbers appear only when the invoice runs to more than one page. This has to be a
+  // footer rather than a trailing `set page`, which would only affect the final page.
+  footer: context {
+    if counter(page).final().first() > 1 {
+      align(right, text(size: 9pt, counter(page).display("1 / 1", both: true)))
+    }
+  },
+)
+#set text(font: "Noto Sans", size: 10pt)
+
+// Renders the styled runs produced by Payday::Markup.
+#let render-runs(runs) = {
+  if runs == none { return }
+  for r in runs {
+    let body = text(
+      size: if "size" in r { r.size * 1pt } else { 1em },
+      fill: if "color" in r { rgb(r.color) } else { black },
+      weight: if r.at("bold", default: false) { "bold" } else { "regular" },
+      style: if r.at("italic", default: false) { "italic" } else { "normal" },
+      r.text,
+    )
+    if r.at("underline", default: false) { body = underline(body) }
+    if r.at("strike", default: false) { body = strike(body) }
+    if r.at("sub", default: false) { body = sub(body) }
+    if r.at("sup", default: false) { body = super(body) }
+    if "link" in r { link(r.link, body) } else { body }
+  }
+}
+
+// --- status stamp ------------------------------------------------------------------
+// Drawn before anything else so it stays at a fixed offset from the top of the page, the way
+// prawn stamped it, rather than drifting with the height of the logo.
+#if d.stamp != none {
+  place(top + center, dx: 5.1pt, dy: 33pt, rotate(15deg,
+    text(fill: rgb("cc0000"), size: 25pt, weight: "bold")[#d.stamp]))
+}
+
+// --- logo and company identity ---------------------------------------------------
+#grid(
+  columns: (1fr, auto),
+  align: (left + top, right + top),
+  if d.logo != none {
+    image(
+      d.logo.name,
+      width: if d.logo.width != none { d.logo.width * 1pt } else { auto },
+      height: if d.logo.height != none { d.logo.height * 1pt } else { auto },
+      fit: "contain",
+    )
+  },
+  align(left, pad(top: 5.7pt)[
+    #text(weight: "bold", size: 12pt)[#d.company_name] \
+    #d.company_details
+  ]),
+)
+
+#v(gap-after-header)
+
+// --- bill to / ship to -------------------------------------------------------------
+#grid(
+  columns: (1fr, 200pt),
+  align: (left + top, left + top),
+  [#text(weight: "bold")[#d.labels.bill_to]#v(10.4pt, weak: true)#d.bill_to],
+  if d.ship_to != none {
+    [#text(weight: "bold")[#d.labels.ship_to]#v(10.4pt, weak: true)#d.ship_to]
+  },
+)
+
+// prawn drew the ship-to box 2pt taller than its contents, so invoices carrying a ship-to
+// address pushed the details block down by that much.
+#v(gap-after-addresses + if d.ship_to != none { 2pt } else { 0pt })
+
+// --- invoice details ---------------------------------------------------------------
+#if d.details.len() > 0 {
+  table(
+    columns: 2,
+    stroke: none,
+    inset: (left: 1pt, right: 0pt, y: 4.25pt),
+    column-gutter: 10pt,
+    align: (left, right),
+    ..d.details.map(row => (
+      text(weight: "bold")[#row.at(0)],
+      text(weight: "bold")[#row.at(1)],
+    )).flatten()
+  )
+}
+
+#v(gap-after-details)
+
+// --- line items ---------------------------------------------------------------------
+#table(
+  columns: (1fr, auto, auto, auto),
+  align: (left, right, right, right),
+  inset: (x: 10pt, y: 8.25pt),
+  stroke: (x, y) => (
+    left: none,
+    right: none,
+    top: 0.5pt + rgb("F6F9FC"),
+    bottom: 0.5pt + rgb("BCC6D0"),
+  ),
+  fill: (x, y) => if y == 0 { white } else if calc.odd(y) { rgb("F6F9FC") } else { white },
+  table.header(
+    text(weight: "bold")[#d.labels.description],
+    text(weight: "bold")[#d.labels.unit_price],
+    text(weight: "bold")[#d.labels.quantity],
+    text(weight: "bold")[#d.labels.amount],
+  ),
+  ..d.line_items.map(li => (
+    render-runs(li.description), [#li.price], [#li.quantity], [#li.amount],
+  )).flatten()
+)
+
+#v(gap-before-totals)
+
+// --- totals ---------------------------------------------------------------------------
+#align(right, table(
+  columns: 2,
+  stroke: none,
+  // The total is set 12pt, whose taller glyph box would otherwise pull the row up.
+  inset: (x, y) => (
+    left: 5pt, right: 5pt, bottom: 8.25pt,
+    top: if y == d.totals.len() - 1 { 8.95pt } else { 8.25pt },
+  ),
+  align: (left, right),
+  ..d.totals.map(row => {
+    let size = if row.at(2) { 12pt } else { 10pt }
+    (text(weight: "bold", size: size)[#row.at(0)], text(size: size)[#row.at(1)])
+  }).flatten()
+))
+
+// --- notes ------------------------------------------------------------------------------
+#if d.notes != none {
+  v(gap-before-notes)
+  text(weight: "bold")[#d.labels.notes]
+  v(gap-notes-label-to-rule)
+  line(length: 100%, stroke: 0.5pt + rgb("cccccc"))
+  v(gap-after-notes-rule)
+  render-runs(d.notes)
+}
+
+// --- QR code ------------------------------------------------------------------------------
+#if d.qr_code != none {
+  v(gap-before-qr)
+  image("qr.svg", width: 100pt)
+}