archsight 0.4.3 → 0.5.0

data/lib/archsight/pdf/markdown.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require_relative "../markdown"
+require_relative "../helpers/macros"
+require_relative "../jira_settings"
+require_relative "typst"
+
+module Archsight
+  module Pdf
+    # Markdown (the dialect of Archsight::Markdown) as Typst markup.
+    #
+    # What a document refers to is resolved by the caller through hooks, so this class knows neither the database
+    # nor the file system:
+    #
+    # - `image`:   `(src, alt) -> String | nil`, Typst markup for an embedded image (nil: left out, the alt text is shown)
+    # - `diagram`: `(source) -> String`, Typst markup for an `asd` code block (default: the source as code)
+    # - `label`:   `(target) -> String`, the text of a `[[Target]]` link without label (default: the target)
+    # - `embeds`:  an object with `view_block(source)`, `requirements_block(source)` and `embed(reference)`, each
+    #   returning Typst markup (never raising: what cannot be shown is a note). It makes the live content of a page, a
+    #   ```view or ```requirements block and `![[Kind/Name]]` on a line of its own, part of the document. Without it
+    #   those blocks are shown as written and an embed is its label.
+    class Markdown
+      include Typst
+
+      SYMBOLS = {
+        ndash: "–", mdash: "—", hellip: "…", laquo: "«", raquo: "»", laquo_space: "« ", raquo_space: " »",
+        lsquo: "‘", rsquo: "’", ldquo: "“", rdquo: "”"
+      }.freeze
+      STATUS_FILL = {
+        "green" => "#d9f2e0", "yellow" => "#fff3cc", "red" => "#fde8e8", "blue" => "#ddeeff", "grey" => "#e8e8e8",
+        "gray" => "#e8e8e8", "purple" => "#eadcf8"
+      }.freeze
+      EMBED = /\A!\[\[([^\]|]+)\]\]\z/
+      # `![[Embed]]`, `[[Target|label]]` and the `{macro:arguments}` of the wiki (see Helpers::Macros)
+      INLINE = /(!)?\[\[([^\]|]+)(?:\|([^\]]+))?\]\]|\{([a-z][a-z0-9-]*)(?::([^{}|\n]*))?\}/
+      ALIGNMENT = { left: "left", center: "center", right: "right" }.freeze
+
+      # @param heading_offset [Integer] added to the level of every heading
+      def initialize(heading_offset: 0, image: nil, diagram: nil, label: nil, embeds: nil)
+        @heading_offset = heading_offset
+        @image = image
+        @diagram = diagram
+        @label = label
+        @embeds = embeds
+      end
+
+      # @param inline [Boolean] for a table cell or list item: paragraphs are joined by a line break
+      # @return [String] Typst markup
+      def render(source, inline: false)
+        out = blocks(Archsight::Markdown.document(source).root.children)
+        inline ? out.gsub(/\n\n+/, " #linebreak() ") : out
+      end
+
+      private
+
+      def blocks(elements)
+        elements.filter_map { |node| block(node) }.join("\n\n")
+      end
+
+      def block(node)
+        case node.type
+        when :p then paragraph(node)
+        when :header then "#heading(level: #{[node.options[:level] + @heading_offset, 6].min})[#{inlines(node.children)}]"
+        when :codeblock then code(node.value, node.options[:lang])
+        when :blockquote then "#quote(block: true)[#{blocks(node.children)}]"
+        when :ul then "#list(#{items(node)})"
+        when :ol then "#enum(#{items(node)})"
+        when :hr then "#line(length: 100%, stroke: 0.5pt + luma(200))"
+        when :table then table(node)
+        when :blank, :html_element, :xml_comment then nil
+        else inlines(node.children) unless node.children.empty?
+        end
+      end
+
+      # A paragraph that is only an image is a figure, centred; one that is only embeds (one per line) is their content
+      def paragraph(node)
+        content = node.children.reject { |c| c.type == :text && c.value.strip.empty? }
+        return image(content.first) if content.size == 1 && content.first.type == :img
+
+        embeds = block_embeds(content)
+        return embeds if embeds
+
+        inlines(node.children)
+      end
+
+      def block_embeds(content)
+        return nil unless @embeds && content.size == 1 && content.first.type == :text
+
+        lines = content.first.value.lines.map(&:strip).reject(&:empty?)
+        return nil unless lines.any? && lines.all? { |line| line.match?(EMBED) }
+
+        lines.map { |line| @embeds.embed(line[EMBED, 1].strip) }.join("\n\n")
+      end
+
+      def items(list)
+        list.children.map { |li| "[#{blocks(li.children)}]" }.join(", ")
+      end
+
+      def code(source, lang)
+        case lang.to_s
+        when "asd" then @diagram ? @diagram.call(source) : raw(source, lang)
+        when "view" then @embeds ? @embeds.view_block(source) : raw(source, lang)
+        when "requirements" then @embeds ? @embeds.requirements_block(source) : raw(source, lang)
+        when "mermaid" then [note("Mermaid diagram, shown as a diagram in Archsight", fill: "#f2f2f2"), raw(source, lang)].join("\n\n")
+        else raw(source, lang)
+        end
+      end
+
+      def table(node)
+        head, body = node.children.partition { |section| section.type == :thead }
+        head_rows = head.flat_map(&:children).map { |tr| cells(tr, header: true) }
+        body_rows = body.flat_map(&:children).map { |tr| cells(tr) }
+        width = (head_rows + body_rows).map(&:size).max || 1
+        header = head_rows.empty? ? "" : "table.header(#{head_rows.flatten.join(", ")}), "
+        "#table(columns: #{width}, #{align(node, width)}#{header}#{body_rows.flatten.join(", ")})"
+      end
+
+      def align(node, width)
+        alignment = Array(node.options[:alignment])
+        return "" unless alignment.any? { |a| ALIGNMENT.key?(a) }
+
+        "align: (#{Array.new(width) { |i| ALIGNMENT.fetch(alignment[i], "auto") }.join(", ")},), "
+      end
+
+      # The header cells are semibold, set on the cells (a show rule on the table header does not reach their text)
+      def cells(row, header: false)
+        row.children.map do |td|
+          content = inlines(td.children)
+          header ? "[#text(weight: \"semibold\")[#{content}]]" : "[#{content}]"
+        end
+      end
+
+      def inlines(elements)
+        elements.map { |node| inline(node) }.join
+      end
+
+      def inline(node)
+        case node.type
+        when :text then text(node.value)
+        when :em then "#emph[#{inlines(node.children)}]"
+        when :strong then "#strong[#{inlines(node.children)}]"
+        when :codespan then "#raw(#{lit(node.value)})"
+        when :a then "#link(#{lit(node.attr["href"])})[#{inlines(node.children)}]"
+        when :br then "#linebreak()"
+        when :img then image(node)
+        when :entity then str(node.value.char)
+        when :smart_quote, :typographic_sym then str(SYMBOLS.fetch(node.value, node.value.to_s))
+        when :html_element then html(node)
+        else inlines(node.children)
+        end
+      end
+
+      def html(node)
+        return "#linebreak()" if node.value == "br"
+
+        checkbox(node) || inlines(node.children)
+      end
+
+      def checkbox(node)
+        return unless node.value == "input" && node.attr["type"] == "checkbox"
+
+        str(node.attr.key?("checked") ? "☑ " : "☐ ")
+      end
+
+      def image(node)
+        src = node.attr["src"].to_s
+        alt = node.attr["alt"].to_s
+        @image&.call(src, alt) || "#emph[#{str(alt.empty? ? src : alt)}]"
+      end
+
+      # Plain text, in which wiki links, embeds and the macros of the wiki are replaced
+      def text(value)
+        out = +""
+        pos = 0
+        value.scan(INLINE) do
+          match = Regexp.last_match
+          out << str(value[pos...match.begin(0)]) if match.begin(0) > pos
+          out << (replacement(match) || str(match[0]))
+          pos = match.end(0)
+        end
+        out << str(value[pos..]) if pos < value.length
+        out
+      end
+
+      def replacement(match)
+        match[2] ? link(match) : macro(match[4], match[5])
+      end
+
+      def link(match)
+        label = match[3]&.strip || @label&.call(match[2].strip) || match[2].strip
+        match[1] ? "#emph[#{str(label)}]" : str(label)
+      end
+
+      # A registered macro with valid arguments; nil leaves the text as written. What needs the running application
+      # (`children`, `pagetree`) has no meaning on paper.
+      def macro(name, arguments)
+        handler = Helpers::Macros.handler(name)
+        return nil unless handler
+
+        value = handler.parse(arguments)
+        return nil unless value
+
+        case name
+        when "status" then badge(value.text.upcase, STATUS_FILL.fetch(value.colour.to_s.downcase, "#e8e8e8"))
+        when "jira" then jira(value)
+        when "emoticon" then str(value.char)
+        when "children", "pagetree" then ""
+        end
+      end
+
+      def jira(key)
+        url = JiraSettings.link_for(key)
+        url ? "#link(#{lit(url)})[#{str(key)}]" : "#raw(#{lit(key)})"
+      end
+    end
+  end
+end

data/lib/archsight/pdf/remote_image.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "resolv"
+require "ipaddr"
+require "uri"
+require_relative "../user_config"
+
+module Archsight
+  module Pdf
+    # Images that a page embeds by URL (`![](https://...)`), fetched by the server so they can go into the PDF.
+    #
+    # The URL comes from page content, so the server must not become a way into the network behind it: only http(s) on
+    # the default ports, only hosts that resolve to public addresses (checked for the address that is connected to, and
+    # again for every redirect), a size and time limit, and the answer must really be a png, jpeg, gif or webp image.
+    # Anything else is `nil` and the document shows the alt text. `pdf.remote_images: false`
+    # (`ARCHSIGHT_PDF_REMOTE_IMAGES`) turns fetching off.
+    module RemoteImage
+      MAX_BYTES = 10 * 1024 * 1024
+      TIMEOUT = 10
+      MAX_REDIRECTS = 3
+      CACHE_SECONDS = 3600
+      CACHE_ENTRIES = 64
+      PORTS = { "http" => 80, "https" => 443 }.freeze
+      NON_PUBLIC = %w[
+        0.0.0.0/8 10.0.0.0/8 100.64.0.0/10 127.0.0.0/8 169.254.0.0/16 172.16.0.0/12 192.0.0.0/24 192.168.0.0/16
+        198.18.0.0/15 224.0.0.0/4 240.0.0.0/4 ::/128 ::1/128 fc00::/7 fe80::/10 ff00::/8
+      ].map { |range| IPAddr.new(range) }.freeze
+      TYPES = { png: ".png", jpeg: ".jpg", gif: ".gif", webp: ".webp" }.freeze
+
+      @cache = {}
+      @lock = Mutex.new
+
+      class << self
+        # @return [Boolean] whether fetching is on
+        def enabled?(env: ENV)
+          !%w[false no 0 off].include?(UserConfig.setting("pdf", "remote_images", env: env).to_s.strip.downcase)
+        end
+
+        # @return [Array(String, String), nil] image bytes and the file extension, nil if it cannot be had
+        def fetch(url, resolver: Resolv, now: Time.now)
+          cached(url, now) { download(url, resolver) }
+        rescue StandardError
+          nil
+        end
+
+        # Public addresses only: not loopback, private, link-local (cloud metadata), multicast, reserved or unspecified
+        def public_address?(address)
+          ip = IPAddr.new(address.to_s)
+          ip = ip.native if ip.ipv4_mapped?
+          NON_PUBLIC.none? { |range| range.include?(ip) }
+        rescue IPAddr::Error
+          false
+        end
+
+        # @return [Symbol, nil] :png, :jpeg, :gif or :webp from the first bytes
+        def image_type(bytes)
+          head = bytes.byteslice(0, 12).to_s.b
+          return :png if head.start_with?("\x89PNG\r\n\x1a\n".b)
+          return :jpeg if head.start_with?("\xFF\xD8\xFF".b)
+          return :gif if head.start_with?("GIF87a", "GIF89a")
+
+          :webp if head.start_with?("RIFF") && head.byteslice(8, 4) == "WEBP"
+        end
+
+        private
+
+        def cached(url, now)
+          entry = @lock.synchronize { @cache[url] }
+          return entry[:value] if entry && now - entry[:at] < CACHE_SECONDS
+
+          value = yield
+          @lock.synchronize do
+            @cache[url] = { value: value, at: now }
+            @cache.shift while @cache.size > CACHE_ENTRIES
+          end
+          value
+        end
+
+        def download(url, resolver, redirects = 0)
+          uri = URI.parse(url)
+          return nil unless PORTS.key?(uri.scheme) && uri.host && uri.port == PORTS[uri.scheme] && uri.userinfo.nil?
+
+          addresses = resolver.getaddresses(uri.host).map(&:to_s)
+          return nil if addresses.empty? || !addresses.all? { |a| public_address?(a) }
+
+          response, body = get(uri, addresses.first)
+          case response
+          when Net::HTTPSuccess then image(body)
+          when Net::HTTPRedirection
+            redirects < MAX_REDIRECTS ? download(URI.join(url, response["location"].to_s).to_s, resolver, redirects + 1) : nil
+          end
+        end
+
+        # Connects to the address that was checked (not to a second DNS answer); the certificate is checked for the name.
+        # @return [Array(Net::HTTPResponse, String), nil] the response and its body, nil if the body is too large
+        def get(uri, address)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.ipaddr = address
+          http.use_ssl = uri.scheme == "https"
+          http.open_timeout = http.read_timeout = http.write_timeout = TIMEOUT
+          http.request(Net::HTTP::Get.new(uri.request_uri, "Accept" => "image/*", "User-Agent" => "archsight-pdf")) do |res|
+            return [res, nil] unless res.is_a?(Net::HTTPSuccess)
+            return nil if res["Content-Length"].to_i > MAX_BYTES
+
+            body = +"".b
+            res.read_body do |chunk|
+              body << chunk
+              return nil if body.bytesize > MAX_BYTES
+            end
+            return [res, body]
+          end
+        end
+
+        def image(bytes)
+          type = image_type(bytes.to_s)
+          type ? [bytes, TYPES.fetch(type)] : nil
+        end
+      end
+    end
+  end
+end

data/lib/archsight/pdf/resource_sheet.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative "typst"
+
+module Archsight
+  module Pdf
+    # The facts of a resource that is not a page, as Typst markup: its properties (annotations) and its relations in
+    # both directions. Structure comes from alignment and light rules, not from boxes: a muted label column, rows
+    # divided by hairlines, related annotations kept together, and the resources of a relation flowing in columns
+    # instead of one long comma-separated line.
+    class ResourceSheet
+      SKIP = %w[architecture/description architecture/diagram architecture/tags].freeze
+      LONG = 400 # characters; longer single-line values still sit in the table, wrapped, up to MAX
+      MAX = 2000
+      RULE = "0.4pt + theme.muted.lighten(75%)" # as the rule under the rows of every other table
+      NAMES_IN_COLUMNS = 4 # from this many resources a relation lists them in two columns
+
+      # @param markdown [#call] `(String) -> Typst`, renders markdown the way the document does
+      def initialize(resource, markdown:)
+        @resource = resource
+        @markdown = markdown
+      end
+
+      # @return [Array<String>] the sections (heading and content) of the properties, none if there are none
+      def properties
+        short, long = annotations.partition { |key, value| table_value?(key, value) }
+        parts = []
+        parts << "#heading(level: 1)[#{Typst.str("Properties")}]\n\n#{property_table(short)}" unless short.empty?
+        long.each { |key, value| parts << long_value(key, value) }
+        parts
+      end
+
+      # @return [Array<String>] the sections of the outgoing and the incoming relations
+      def relations
+        out = outgoing
+        incoming = self.incoming
+        return [] if out.empty? && incoming.empty?
+
+        parts = ["#heading(level: 1)[#{Typst.str("Relations")}]"]
+        parts << "#heading(level: 2)[#{Typst.str("Outgoing")}]\n\n#{relation_table(out)}" unless out.empty?
+        parts << "#heading(level: 2)[#{Typst.str("Incoming")}]\n\n#{caption("Resources that point to this one; the relation is read from their side.")}\n\n#{relation_table(incoming)}" unless incoming.empty?
+        parts
+      end
+
+      # `dependsOn` -> "depends on"
+      def self.humanize(verb)
+        verb.to_s.gsub(/([a-z0-9])([A-Z])/, '\1 \2').downcase
+      end
+
+      private
+
+      def klass = @resource.class
+
+      def annotations
+        @resource.annotations.reject { |key, value| SKIP.include?(key) || value.to_s.strip.empty? }
+      end
+
+      # Multi-line and markdown values are text, not table cells
+      def table_value?(key, value)
+        !value.to_s.include?("\n") && !%w[markdown multiline].include?(klass.annotation_format(key).to_s)
+      end
+
+      def display(key, value)
+        text = value.to_s
+        text = text.split(",").map(&:strip).reject(&:empty?).join(", ") if klass.annotation_matching(key)&.list?
+        text.length > MAX ? "#{text[0, MAX]}…" : text
+      end
+
+      # Annotations of one namespace (`git/...`, `lifecycle/...`) stay together, separated from the next by a gap
+      def property_table(pairs)
+        grouped = pairs.group_by { |key, _| key.split("/").first }.values
+        cells = grouped.each_with_index.flat_map do |group, index|
+          gap = index.zero? ? [] : ["table.cell(colspan: 2, stroke: none, inset: 3pt)[]"]
+          gap + group.flat_map do |key, value|
+            ["[#text(fill: theme.muted)[#{Typst.str(klass.annotation_title(key))}]]", "[#{Typst.str(display(key, value))}]"]
+          end
+        end
+        "#table(columns: (30%, 1fr), stroke: (x, y) => (bottom: #{RULE}), inset: (x: 0pt, y: 5pt), #{cells.join(", ")})"
+      end
+
+      def long_value(key, value)
+        body = klass.annotation_format(key).to_s == "markdown" ? @markdown.call(value.to_s) : multiline(value.to_s)
+        "#heading(level: 2)[#{Typst.str(klass.annotation_title(key))}]\n\n#{body}"
+      end
+
+      def multiline(text)
+        text.lines.map { |line| Typst.str(line.chomp) }.join("#linebreak()")
+      end
+
+      # { verb => { kind => [instances] } }
+      def outgoing = @resource.relations_grouped
+
+      # incoming comes as { kind => { verb => [instances] } }, shown like the outgoing ones
+      def incoming
+        @resource.references_grouped.each_with_object({}) do |(kind, verbs), by_verb|
+          verbs.each { |verb, instances| (by_verb[verb] ||= {})[kind] = instances }
+        end.sort.to_h
+      end
+
+      # The relation (said once for all of its kinds), the kind, and the names of the resources in one or two columns
+      def relation_table(by_verb)
+        cells = by_verb.flat_map do |verb, kinds|
+          kinds.each_with_index.flat_map do |(kind, instances), index|
+            row = []
+            row << "table.cell(rowspan: #{kinds.size})[#text(weight: \"semibold\")[#{Typst.str(self.class.humanize(verb))}]]" if index.zero?
+            row << "[#pad(right: 8pt, text(fill: theme.muted)[#{Typst.str(breakable(kind))}])]"
+            row << "[#{names(instances)}]"
+          end
+        end
+        "#table(columns: (17%, 24%, 1fr), stroke: (x, y) => (bottom: #{RULE}), inset: (x: 0pt, y: 5pt), #{cells.join(", ")})"
+      end
+
+      def names(instances)
+        list = instances.map(&:name).uniq.sort.map { |name| "[#{Typst.str(breakable(name))}]" }
+        columns = list.size >= NAMES_IN_COLUMNS ? "1fr, 1fr" : "1fr"
+        "#grid(columns: (#{columns},), column-gutter: 10pt, row-gutter: 4pt, #{list.join(", ")})"
+      end
+
+      # Names have no spaces: allow a line break after each `:` and between camel-case words (no visible change)
+      def breakable(name)
+        name.gsub(":", ":\u200B").gsub(/([a-z0-9])([A-Z])/, "\\1\u200B\\2")
+      end
+
+      def caption(text)
+        "#text(size: 8.5pt, fill: theme.muted)[#{Typst.str(text)}]"
+      end
+    end
+  end
+end

data/lib/archsight/pdf/sample_document.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "document"
+
+module Archsight
+  module Pdf
+    # A fixed sample document in the look of one pdf Config, to see what the settings do without exporting a real page:
+    # a cover page and a page with the elements a document is made of (headings, text, list, quote, table with
+    # status, code). The content is neutral on purpose; only the Config shapes the result. The "resource" of the document
+    # is the Config (an Archsight::Resources::Config of type pdf).
+    class SampleDocument < Document
+      PARTS = %w[cover page].freeze
+      TITLE = "Sample document"
+      BODY = <<~MD
+        ## Summary
+
+        This page shows how headings, text, lists and tables look with the settings of the Config. It is a fixed sample,
+        not one of your documents, so every change of a colour, a font or the logo is visible at once.
+
+        > A quote stands out from the text around it and is set in the same typeface.
+
+        ### What a document contains
+
+        - Text with **strong** and *emphasised* words, `inline code` and a [link](https://example.com)
+        - Lists, tables, diagrams and code, set in the fonts of the Config
+        - Status badges such as {status:green Active} and {status:yellow Planned}
+
+        ## Components
+
+        | Component | Owner | Status |
+        |:----------|:------|:-------|
+        | Billing API | Payments | {status:green Active} |
+        | Export service | Data | {status:yellow Deprecated} |
+        | Legacy gateway | Platform | {status:red End of life} |
+
+        ### Interface
+
+        ```ruby
+        def total(items)
+          items.sum(&:price)
+        end
+        ```
+      MD
+
+      # @param part [String, nil] `cover` or `page` for just that page (a document of one page, so a viewer needs no
+      #   navigation), else both
+      def initialize(database, config, part: nil, **)
+        @part = part if PARTS.include?(part)
+        super(database, config, **)
+      end
+
+      def filename = "#{["preview", super.delete_suffix(".pdf"), @part].compact.join("-")}.pdf"
+
+      private
+
+      def theme_for(_template) = Theme.new(@resource, resources_dir: @resources_dir)
+      def title_for = TITLE
+      def tag_list = @part == "page" ? [] : %w[pdf:cover]
+      def body(images) = @part == "cover" ? "" : markdown(images).render(BODY)
+      def doc_id = "SAMPLE-001"
+      def version = "1.0"
+      def owner = "Alex Example"
+      def kind = "Sample"
+      def classification = @theme.classification
+    end
+  end
+end

data/lib/archsight/pdf/tables.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "typst"
+require_relative "markdown"
+require_relative "../view_table"
+require_relative "../export/confluence/tables"
+
+module Archsight
+  module Pdf
+    # A ViewTable::Table (the result of a view, of requirements or of an analysis) as a Typst table. Views are live
+    # in Archsight; in the PDF they are the data of the moment of the export.
+    module Tables
+      # A column whose longest text is longer than this shares the width (`fr`), shorter ones take what they need
+      LONG = 30
+      SMALL_FONT_FROM = 4 # columns
+      Confluence = Export::Confluence::Tables
+
+      module_function
+
+      # @param table [Archsight::ViewTable::Table]
+      # @param markdown [#call] Typst markup of a markdown text, for the cells of `as: :markdown`
+      # @param empty [String] shown instead of the table when there are no rows
+      # @return [String] Typst markup
+      def typst(table, markdown:, empty: "No results")
+        parts = []
+        parts << heading(table) unless table.title.to_s.empty?
+        parts << (table.rows.empty? ? Typst.note(empty, fill: "#f2f2f2") : grid(table, markdown))
+        parts << "#emph[#{Typst.str("#{table.cut} more #{table.cut == 1 ? "row" : "rows"} not shown, see Archsight")}]" if table.cut.positive?
+        parts.join("\n\n")
+      end
+
+      def heading(table)
+        count = "(#{table.total} #{table.total == 1 ? "item" : "items"})"
+        "#block(sticky: true)[#strong[#{Typst.str(table.title)}] #text(fill: luma(120))[#{Typst.str(count)}]]"
+      end
+
+      def grid(table, markdown)
+        head = table.columns.map { |c| "[#text(weight: \"semibold\")[#{Typst.str(c)}]]" }
+        cells = table.rows.flat_map { |row| row.map { |cell| "[#{cell(cell, markdown)}]" } }
+        out = "#table(columns: (#{widths(table).join(", ")},), table.header(#{head.join(", ")}), #{cells.join(", ")})"
+        table.columns.size >= SMALL_FONT_FROM ? "#[#set text(size: 8.5pt)\n#{out}]" : out
+      end
+
+      # `auto` for short columns, a share of the rest for long ones, so wide tables wrap instead of running off the page
+      def widths(table)
+        table.columns.each_index.map do |i|
+          longest = [table.columns[i].length, *table.rows.map { |row| row[i] ? text_of(row[i]).length : 0 }].max
+          longest > LONG ? "#{(longest / LONG.to_f).round.clamp(1, 4)}fr" : "auto"
+        end
+      end
+
+      def text_of(cell)
+        cell.resources.empty? ? cell.text.to_s : cell.resources.map(&:name).join(" ")
+      end
+
+      def cell(cell, markdown)
+        return cell.resources.map { |resource| Typst.str(resource.name) }.join("#linebreak()") unless cell.resources.empty?
+
+        case cell.as
+        when :status then badge(cell.text, Confluence::STATUS_COLOURS)
+        when :priority then cell.text.to_s.empty? ? "" : badge(cell.text, Confluence::PRIORITY_COLOURS)
+        when :markdown then markdown.call(cell.text.to_s)
+        else cell.text.to_s.split("\n").map { |line| Typst.str(line) }.join("#linebreak()")
+        end
+      end
+
+      def badge(text, colours)
+        Typst.badge(text, Markdown::STATUS_FILL.fetch(colours.fetch(text, "grey"), "#e8e8e8"))
+      end
+    end
+  end
+end