gitbay/Views/Shared/MathRendering.swift

  1import OrgSwift
  2import OrgSwiftUI
  3import SwiftMath
  4import SwiftUI
  5import UIKit
  6
  7/// One typeset expression: an alpha mask, tinted by the text around it, and
  8/// how far its baseline sits above the bottom edge.
  9struct RenderedMath {
 10    let image: CGImage
 11    let scale: CGFloat
 12    let descent: CGFloat
 13}
 14
 15/// Typesets TeX with SwiftMath. Input is bounded as the server's converter
 16/// bounds it (internal/texmath), so a pathological body cannot run the
 17/// parser deep or long; anything refused shows as its source.
 18enum MathRenderer {
 19    static let maxInput = 8 << 10
 20    static let maxDepth = 64
 21    /// SwiftMath recurses once per command that takes an argument, so the
 22    /// count bounds nesting that braces do not show.
 23    static let maxCommands = 200
 24    /// The longest side of an image, in points.
 25    static let maxSide: CGFloat = 4096
 26
 27    private final class Entry {
 28        let value: RenderedMath?
 29        init(_ value: RenderedMath?) { self.value = value }
 30    }
 31
 32    private static let cache: NSCache<NSString, Entry> = {
 33        let cache = NSCache<NSString, Entry>()
 34        cache.countLimit = 500
 35        cache.totalCostLimit = 64 << 20
 36        return cache
 37    }()
 38
 39    static func render(_ tex: String, display: Bool, pointSize: CGFloat) -> RenderedMath? {
 40        let key = "\(display) \(pointSize) \(tex)" as NSString
 41        if let entry = cache.object(forKey: key) { return entry.value }
 42        let value = typeset(tex, display: display, pointSize: pointSize)
 43        cache.setObject(Entry(value), forKey: key, cost: value.map { $0.image.bytesPerRow * $0.image.height } ?? 0)
 44        return value
 45    }
 46
 47    private static func typeset(_ tex: String, display: Bool, pointSize: CGFloat) -> RenderedMath? {
 48        guard !tex.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty,
 49              tex.utf8.count <= maxInput, admits(tex) else { return nil }
 50        let latex = swiftMath(tex)
 51        let mode: MTMathUILabelMode = display ? .display : .text
 52        // Measured before it is drawn, so an expression too large to show never
 53        // allocates its bitmap.
 54        let label = MTMathUILabel()
 55        label.labelMode = mode
 56        label.fontSize = pointSize
 57        label.latex = latex
 58        let size = label.intrinsicContentSize
 59        guard label.error == nil, size.width <= maxSide, size.height <= maxSide else { return nil }
 60        var math = MathImage(latex: latex, fontSize: pointSize, textColor: .black,
 61                             labelMode: mode, textAlignment: .left)
 62        let (error, image, layout) = math.asImage()
 63        guard error == nil, let image, let cgImage = image.cgImage, let layout,
 64              image.size.width > 0, image.size.height > 0 else { return nil }
 65        return RenderedMath(image: cgImage, scale: image.scale, descent: layout.descent)
 66    }
 67
 68    /// Whether `tex` nests groups, `\left…\right` and environments no
 69    /// deeper than `maxDepth`, has at most `maxCommands` commands, and has no
 70    /// unescaped `$`, `#` or `%`, which the server's converter refuses, and no
 71    /// character outside printable ASCII, which SwiftMath leaves out without
 72    /// an error.
 73    static func admits(_ tex: String) -> Bool {
 74        guard tex.unicodeScalars.allSatisfy({ (0x20...0x7E).contains($0.value) || $0 == "\n" || $0 == "\t" })
 75        else { return false }
 76        var depth = 0
 77        var commands = 0
 78        var chars = tex[...]
 79        while let c = chars.popFirst() {
 80            switch c {
 81            case "\\":
 82                let name = chars.prefix(while: \.isLetter)
 83                if name.isEmpty {
 84                    chars = chars.dropFirst()
 85                    continue
 86                }
 87                chars = chars.dropFirst(name.count)
 88                commands += 1
 89                if commands > maxCommands { return false }
 90                if name == "left" || name == "begin" { depth += 1 }
 91                if name == "right" || name == "end" { depth -= 1 }
 92            case "{": depth += 1
 93            case "}": depth -= 1
 94            case "$", "#", "%": return false
 95            default: continue
 96            }
 97            if depth > maxDepth { return false }
 98        }
 99        return true
100    }
101
102    private static let commands: [Substring: String] = [
103        "dfrac": "frac", "tfrac": "frac", "cfrac": "frac",
104        "dbinom": "binom", "tbinom": "binom",
105        "operatorname": "mathrm", "boldsymbol": "mathbf", "bm": "mathbf", "mathscr": "mathcal",
106        "textrm": "text", "textnormal": "text", "mbox": "text", "middle": "",
107    ]
108
109    private static let environments: [Substring: String] = [
110        "align": "aligned", "align*": "aligned", "gathered": "gather", "gather*": "gather",
111        "smallmatrix": "matrix", "equation": "", "equation*": "", "displaymath": "",
112    ]
113
114    /// The web's spellings in SwiftMath's: the `\frac` and `\binom` variants,
115    /// font and operator names, primes, `~`, and the environments it names
116    /// differently. An environment that only displays its body is dropped.
117    static func swiftMath(_ tex: String) -> String {
118        var out = ""
119        var chars = tex[...]
120        while let c = chars.popFirst() {
121            switch c {
122            case "\\":
123                let name = chars.prefix(while: \.isLetter)
124                guard !name.isEmpty else {
125                    out.append(c)
126                    if let next = chars.popFirst() { out.append(next) }
127                    continue
128                }
129                chars = chars.dropFirst(name.count)
130                if name == "operatorname", chars.first == "*" { chars = chars.dropFirst() }
131                // An operator name is upright with a thin space after it.
132                if name == "operatorname", chars.first == "{", let close = chars.firstIndex(of: "}") {
133                    out += "\\mathrm" + chars[...close] + "\\,"
134                    chars = chars[chars.index(after: close)...]
135                    continue
136                }
137                if name == "begin" || name == "end", chars.first == "{",
138                   let close = chars.firstIndex(of: "}") {
139                    let env = chars[chars.index(after: chars.startIndex)..<close]
140                    if let renamed = environments[env] {
141                        chars = chars[chars.index(after: close)...]
142                        if !renamed.isEmpty { out += "\\\(name){\(renamed)}" }
143                        continue
144                    }
145                }
146                let renamed = commands[name] ?? String(name)
147                if !renamed.isEmpty { out += "\\" + renamed }
148            case "'":
149                var primes = 1
150                while chars.first == "'" { primes += 1; chars = chars.dropFirst() }
151                out += "^{" + String(repeating: "\\prime", count: primes) + "}"
152            case "~":
153                out += "\\;"
154            default:
155                out.append(c)
156            }
157        }
158        return out
159    }
160
161    /// The expression as text: the image, set on the baseline and tinted
162    /// like the text around it, or the source where it is refused.
163    static func text(_ math: MathExpression, pointSize: CGFloat) -> Text {
164        drawn(math.tex, display: math.display, pointSize: pointSize) ?? Text(verbatim: math.source)
165    }
166
167    static func drawn(_ tex: String, display: Bool, pointSize: CGFloat) -> Text? {
168        guard let rendered = render(tex, display: display, pointSize: pointSize) else { return nil }
169        return Text(Image(rendered.image, scale: rendered.scale, label: Text(verbatim: tex))
170            .renderingMode(.template))
171            .baselineOffset(-rendered.descent)
172    }
173
174    /// `OrgView`'s math hook: each expression the allowance admits, drawn at the size of
175    /// the text it sits in.
176    static func org(dynamicTypeSize: DynamicTypeSize, allowance: MathAllowance) -> OrgMathRenderer {
177        { math, style in
178            guard allowance.admits(math) else { return nil }
179            return drawn(math.tex, display: math.display, pointSize: UIFont.pointSize(style, dynamicTypeSize))
180        }
181    }
182}
183
184/// The web's per-document budget for org, which is drawn view by view: the first
185/// expressions asked for are admitted, and keep their place on later passes.
186final class MathAllowance {
187    private let start: MathBudget
188    private var budget: MathBudget
189    private var admitted: Set<OrgMath> = []
190    private var text: String?
191
192    init(budget: MathBudget = .document) {
193        start = budget
194        self.budget = budget
195    }
196
197    /// Starts over when the document changes.
198    func reset(for text: String) {
199        guard text != self.text else { return }
200        self.text = text
201        budget = start
202        admitted = []
203    }
204
205    func admits(_ math: OrgMath) -> Bool {
206        if admitted.contains(math) { return true }
207        guard budget.take(math.tex) else { return false }
208        admitted.insert(math)
209        return true
210    }
211}
212
213/// A display block: centred, scrolling sideways when wider than the screen,
214/// or the source as code where it is refused.
215struct MathBlockView: View {
216    let math: MathExpression
217    let pointSize: CGFloat
218
219    var body: some View {
220        if let rendered = MathRenderer.render(math.tex, display: true, pointSize: pointSize) {
221            let image = Image(rendered.image, scale: rendered.scale, label: Text(verbatim: math.tex))
222                .renderingMode(.template)
223                .padding(.vertical, 4)
224            ViewThatFits(in: .horizontal) {
225                image.frame(maxWidth: .infinity)
226                ScrollView(.horizontal, showsIndicators: false) { image }
227            }
228        } else {
229            ScrollView(.horizontal) {
230                Text(math.source)
231                    .font(.gbMono(.caption))
232                    .padding(10)
233            }
234            .background(Color.gbCodeBackground, in: RoundedRectangle(cornerRadius: 2))
235        }
236    }
237}
238
239extension UIFont {
240    /// The point size of `style` at a Dynamic Type size, for typesetting
241    /// math beside text set in that style.
242    static func pointSize(_ style: UIFont.TextStyle, _ size: DynamicTypeSize) -> CGFloat {
243        preferredFont(forTextStyle: style,
244                      compatibleWith: UITraitCollection(preferredContentSizeCategory: UIContentSizeCategory(size)))
245            .pointSize
246    }
247
248    static func pointSize(_ style: Font.TextStyle, _ size: DynamicTypeSize) -> CGFloat {
249        pointSize(UIFont.TextStyle(style), size)
250    }
251}
252
253extension UIFont.TextStyle {
254    init(_ style: Font.TextStyle) {
255        switch style {
256        case .largeTitle: self = .largeTitle
257        case .title: self = .title1
258        case .title2: self = .title2
259        case .title3: self = .title3
260        case .headline: self = .headline
261        case .subheadline: self = .subheadline
262        case .callout: self = .callout
263        case .footnote: self = .footnote
264        case .caption: self = .caption1
265        case .caption2: self = .caption2
266        default: self = .body
267        }
268    }
269}