Tell the math hook the text style around each expression !12

merged merged by cmc on 2026-10-16 02:12 UTC · krz/org-swift:math-text-style into main

4 files changed, +41 −10

Layout: unified · split

README.md +5 −4

 LaTeX fragments (`$…$`, `$$…$$`, `\(…\)`, `\[…\]`, `\begin{…}…\end{…}`) and
 `\begin{…}` blocks parse to `.math` objects and `.latexBlock` elements, found by
 go-org's rules with org's border rule for `$…$`. The HTML and `AttributedString`
-renderers show their source. `OrgView` draws them through `math`, which returns a
+renderers show their source. `OrgView` draws them through `math`, which is given the
-`Text` (an image from a typesetter, say) or nil to keep the source:
+text style of the run the expression sits in and returns a `Text` (an image from a
+typesetter, say) or nil to keep the source:
 ```swift
-OrgView(orgSource, options: options, math: { math in
+OrgView(orgSource, options: options, math: { math, style in
-    typeset(math.tex, display: math.display).map { Text($0) }
+    typeset(math.tex, display: math.display, style: style).map { Text($0) }
 })
 ```

Sources/OrgSwiftUI/OrgInlineStyler.swift +4

                 break
             }
+            if string[range][OrgMathAttribute.self] != nil {
+                string[range][OrgMathStyleAttribute.self] = textStyle
+            }
             // Always set the font, never only on modified runs: a run with no emphasis
             // would otherwise inherit the surrounding view's font and a heading, table cell
             // or footnote would render at body size.

Sources/OrgSwiftUI/OrgMathText.swift +12 −4

 import SwiftUI
 /// Draws one TeX expression for ``OrgView``: a `Text` holding it, typically an image set on
-/// the baseline, or nil to show the source as written.
+/// the baseline, or nil to show the source as written. The style is that of the text the
-public typealias OrgMathRenderer = @MainActor (OrgMath) -> Text?
+/// expression sits in, so math in a heading can be set at the heading's size.
+public typealias OrgMathRenderer = @MainActor (OrgMath, Font.TextStyle) -> Text?
+/// The text style a math run is set in, recorded by ``OrgInlineStyler`` for the renderer.
+enum OrgMathStyleAttribute: AttributedStringKey {
+    typealias Value = Font.TextStyle
+    static let name = "OrgSwiftUI.mathStyle"
+}
 private struct OrgMathKey: EnvironmentKey {
     static let defaultValue: OrgMathRenderer? = nil
     var result = Text(verbatim: "")
     for (expression, range) in string.runs[OrgMathAttribute.self] {
         let piece = AttributedString(string[range])
-        guard let expression, let drawn = math(expression) else {
+        let style = piece.runs.first?[OrgMathStyleAttribute.self] ?? .body
+        guard let expression, let drawn = math(expression, style) else {
             result = Text("\(result)\(Text(piece))")
             continue
         }
     @Environment(\.orgMath) private var renderer
     var body: some View {
-        if let drawn = renderer?(math) {
+        if let drawn = renderer?(math, .body) {
             ViewThatFits(in: .horizontal) {
                 drawn.frame(maxWidth: .infinity)
                 ScrollView(.horizontal, showsIndicators: false) { drawn }

Tests/OrgSwiftUITests/OrgMathLayoutTests.swift +20 −2

             Issue.record("expected a paragraph"); return
         }
         var drawn = 0
-        _ = orgText(text) { _ in
+        _ = orgText(text) { _, _ in
             drawn += 1
             return Text(verbatim: "·")
         }
         #expect(drawn == 1)
     }
+    @Test func theHookIsToldTheStyleOfTheTextAroundIt() {
+        let blocks = layout("* Heading $x$\n\nbody $y$").blocks
+        var styles: [String: Font.TextStyle] = [:]
+        for block in blocks {
+            let text: AttributedString
+            switch block {
+            case .heading(let heading, _): text = heading
+            case .paragraph(let paragraph): text = paragraph
+            default: continue
+            }
+            _ = orgText(text) { math, style in
+                styles[math.tex] = style
+                return Text(verbatim: "·")
+            }
+        }
+        #expect(styles == ["x": .title, "y": .body])
+    }
     @Test func orgTextDrawsEachExpression() {
         guard case .paragraph(let text) = layout("$x$$x$ and $y$").blocks.first else {
             Issue.record("expected a paragraph"); return
         }
         var drawn: [String] = []
-        _ = orgText(text) { math in
+        _ = orgText(text) { math, _ in
             drawn.append(math.tex)
             return Text(verbatim: "·")
         }