Add format equation number and fix parsing issue.

Author: colinc86

README.md

@@ -2,7 +2,7 @@
 
 A SwiftUI view that renders LaTeX equations.
 
-![Swift Version](https://img.shields.io/badge/Swift-5.7-orange?logo=swift) ![iOS Version](https://img.shields.io/badge/iOS-16-informational) ![macOS Version](https://img.shields.io/badge/macOS-13-informational)
+[![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fcolinc86%2FLaTeXSwiftUI%2Fbadge%3Ftype%3Dswift-versions)](https://swiftpackageindex.com/colinc86/LaTeXSwiftUI) [![](https://img.shields.io/endpoint?url=https%3A%2F%2Fswiftpackageindex.com%2Fapi%2Fpackages%2Fcolinc86%2FLaTeXSwiftUI%2Fbadge%3Ftype%3Dplatforms)](https://swiftpackageindex.com/colinc86/LaTeXSwiftUI)
 
 <center><img src="./assets/images/device.png" width="362"></center>
 
@@ -20,7 +20,10 @@ A SwiftUI view that renders LaTeX equations.
       - [Equation Number Mode](#equation-number-mode)
       - [Equation Number Start](#equation-number-start)
       - [Equation Number Offset](#equation-number-offset)
+      - [Format Equation Number](#format-equation-number)
     - [Unencode HTML](#🔗-unencode-html)
+    - [Rendering Style](#🕶️-rendering-style)
+    - [Animated](#🪩-animated)
   - [Caching](#🗄️-caching)
   - [Preloading](#🏃‍♀️-preloading)
 
@@ -44,7 +47,7 @@ It won't
 Add the dependency to your package manifest file.
 
 ```swift
-.package(url: "https://github.com/colinc86/LaTeXSwiftUI", from: "1.1.0")
+.package(url: "https://github.com/colinc86/LaTeXSwiftUI", from: "1.2.0")
 ```
 
 ## ⌨️ Usage
@@ -186,24 +189,26 @@ The default starting number is `1`, but if you need to start at a different valu
 
 To change the left or right offset of the equation number, use the `equationNumberOffset` modifier.
 
-```swift
-// Don't number block equations (default)
-LaTeX("$$a + b = c$$")
-  .equationNumberMode(.none)
+##### Format Equation Number
+
+You can set a closure on the view to do your own custom formatting. The `formatEquationNumber` modifier takes a closure that is passed the equation number and returns a string.
 
-// Add left numbers and a leading offset
-LaTeX("$$d + e = f$$")
-  .equationNumberMode(.left)
+```swift
+LaTeX("$$E = mc^2$$")
+  .equationNumberMode(.right)
   .equationNumberOffset(10)
+  .padding([.bottom])
 
-// Add right numbers, a leading offset, and start at 2
-LaTeX("$$h + i = j$$ $$k + l = m$$")
+LaTeX("$$E = mc^2$$ $$E = mc^2$$")
   .equationNumberMode(.right)
+  .equationNumberOffset(10)
   .equationNumberStart(2)
-  .equationNumberOffset(20)
+  .formatEquationNumber { n in
+    return "~[\(n)]~"
+  }
 ```
 
-> <img src="./assets/images/numbers.png" width="428" height="152">
+> <img src="./assets/images/numbers.png" width="258" height="145">
 
 #### 🔗 Unencode HTML
 
@@ -220,6 +225,31 @@ LaTeX("$x^2&lt;1$")
 
 > <img src="./assets/images/unencoded.png" width="72.5" height="34">
 
+#### 🕶️ Rendering Style
+
+The view has four rendering styles.
+
+| Style      | Asynchronous | Description                                                              |
+|:-----------|:-------------|:-------------------------------------------------------------------------|
+| `empty`    | Yes          | The view remains empty until its finished rendering.                     |
+| `original` | Yes          | The view displays the input text until its finished rendering.           |
+| `progress` | Yes          | The view displays a progress view until its finished rendering.          |
+| `wait`     | No           | *(default)* The view blocks the main queue until its finished rendering. |
+
+The `wait` style is the default style, and loads the view synchronously on the main queue. To get better performance and move SVG rendering off of the main queue, use any of the other three styles.
+
+#### 🪩 Animated
+
+The `animated` modifier applies to the view when using the asynchronous rendering styles `empty`, `original`, or `progress`.
+
+```swift
+LaTeX(input)
+  .renderingStyle(.original)
+  .animated()
+```
+
+> In the above example, the input text will be displayed until the SVGs have been rendered at which point the rendered views will animate in to view.
+
 ### 🗄️ Caching
 
 `LaTeXSwiftUI` caches its SVG responses from MathJax and the images rendered as a result of the view's environment. If you want to control the cache, then you can access the static `dataCache` and `imageCache` properties.

Sources/LaTeXSwiftUI/Extensions/EnvironmentValues+Extensions.swift

@@ -62,6 +62,10 @@ private struct EquationNumberOffsetKey: EnvironmentKey {
   static let defaultValue: CGFloat = 0.0
 }
 
+private struct FormatEquationNumberKey: EnvironmentKey {
+  static let defaultValue: LaTeX.FormatEquationNumber = { "(\($0))" }
+}
+
 private struct RenderingStyleKey: EnvironmentKey {
   static let defaultValue: LaTeX.RenderingStyle = .wait
 }
@@ -126,6 +130,12 @@ extension EnvironmentValues {
     set { self[EquationNumberOffsetKey.self] = newValue }
   }
 
+  /// The closure used to format equation number before displaying them.
+  var formatEquationNumber: LaTeX.FormatEquationNumber {
+    get { self[FormatEquationNumberKey.self] }
+    set { self[FormatEquationNumberKey.self] = newValue }
+  }
+  
   /// The rendering style of this environment.
   var renderingStyle: LaTeX.RenderingStyle {
     get { self[RenderingStyleKey.self] }

Sources/LaTeXSwiftUI/Extensions/Range+Extensions.swift

@@ -0,0 +1,41 @@
+//
+//  Range+Extensions.swift
+//  LaTeXSwiftUI
+//
+//  Copyright (c) 2023 Colin Campbell
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to
+//  deal in the Software without restriction, including without limitation the
+//  rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+//  sell copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+//  FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+//  IN THE SOFTWARE.
+//
+
+import Foundation
+
+extension Range<String.Index> {
+  
+  /// Evaluates whether or not this range is a subrange of the given range.
+  ///
+  /// - Parameter range: The range this range is a subset of.
+  /// - Returns: Whether or not the receiver is a subset.
+  func isSubrange(of range: Self) -> Bool {
+    guard range.lowerBound != lowerBound || range.upperBound != upperBound else {
+      return false
+    }
+    return range.lowerBound <= lowerBound && upperBound <= range.upperBound
+  }
+  
+}

Sources/LaTeXSwiftUI/Extensions/View+Extensions.swift

@@ -28,6 +28,31 @@ import SwiftUI
 
 public extension View {
 
+  /// Preloads a `LaTeX` view's SVG and image data.
+  ///
+  /// This method should be called last in the view's modifier chain (if at
+  /// all).
+  ///
+  /// - Example:
+  ///
+  /// ```
+  /// LaTeX("Hello, $\\LaTeX$!")
+  ///   .font(.title)
+  ///   .processEscapes()
+  ///   .preload()
+  /// ```
+  ///
+  /// - Note: If the receiver isn't a `LaTeX` view, then this method does
+  ///   nothing.
+  ///
+  /// - Returns: A preloaded view.
+  func preload() -> some View {
+    if let latex = self as? LaTeX {
+      latex.preload()
+    }
+    return self
+  }
+  
   /// Sets the image rendering mode for images rendered by MathJax.
   ///
   /// - Parameter mode: The template rendering mode.
@@ -112,6 +137,15 @@ public extension View {
     environment(\.equationNumberOffset, offset)
   }
 
+  /// Sets a block that lets you format the equation number that will be
+  /// displayed for named block equations.
+  ///
+  /// - Parameter perform: The block that will format the equation number.
+  /// - Returns: A view that formats its equation numbers.
+  func formatEquationNumber(_ perform: @escaping LaTeX.FormatEquationNumber) -> some View {
+    environment(\.formatEquationNumber, perform)
+  }
+  
   /// Sets the view rendering style.
   ///
   /// - Parameter style: The rendering style to use.

Sources/LaTeXSwiftUI/LaTeX.swift

@@ -34,6 +34,10 @@ public struct LaTeX: View {
 
   // MARK: Types
 
+  /// A closure that takes an equation number and returns a string to display in
+  /// the view.
+  public typealias FormatEquationNumber = (_ n: Int) -> String
+  
   /// The view's block rendering mode.
   public enum BlockMode {
 
@@ -199,6 +203,18 @@ public struct LaTeX: View {
 
 }
 
+// MARK: Public methods
+
+extension LaTeX {
+  
+  /// Preloads the view's SVG and image data.
+  public func preload() {
+    Task {
+      await render()
+    }
+  }
+}
+
 // MARK: Private methods
 
 extension LaTeX {
@@ -271,6 +287,25 @@ struct LaTeX_Previews: PreviewProvider {
     }
     .fontDesign(.serif)
     .previewLayout(.sizeThatFits)
+    .previewDisplayName("Hello, LaTeX!")
+    
+    VStack {
+      LaTeX("$$E = mc^2$$")
+        .equationNumberMode(.right)
+        .equationNumberOffset(10)
+        .padding([.bottom])
+      
+      LaTeX("\\begin{equation} E = mc^2 \\end{equation} \\begin{equation} E = mc^2 \\end{equation}")
+        .equationNumberMode(.right)
+        .equationNumberOffset(10)
+        .equationNumberStart(2)
+    }
+    .fontDesign(.serif)
+    .previewLayout(.sizeThatFits)
+    .previewDisplayName("Equation Numbers")
+    .formatEquationNumber { n in
+      return "~[\(n)]~"
+    }
   }
 
 }

Sources/LaTeXSwiftUI/Models/LaTeXRenderState.swift

@@ -66,7 +66,9 @@ extension LaTeXRenderState {
   ///   - displayScale: The `displayScale` environment variable.
   ///   - texOptions: The `texOptions` environment variable.
   func render(animated: Bool, unencodeHTML: Bool, parsingMode: LaTeX.ParsingMode, font: Font?, displayScale: CGFloat, texOptions: TeXInputProcessorOptions) async {
-    guard !(await isRendering) else {
+    let isRen = await isRendering
+    let ren = await rendered
+    guard !isRen && !ren else {
       return
     }
     await MainActor.run {

Sources/LaTeXSwiftUI/Models/Parser.swift

@@ -121,15 +121,25 @@ extension Parser {
   /// - Parameter input: The input string.
   /// - Returns: An array of LaTeX components.
   static func parse(_ input: String) -> [Component] {
+    print("parsing input \(input)")
     // Get the first match of each each equation type
-    let matches = allEquations.map({ ($0, input.firstMatch(of: $0.regex)) })
+//    let matches = allEquations.map({ ($0, input.firstMatch(of: $0.regex)) })
+    let matchArrays = allEquations.map { equationComponent in
+      let regexMatches = input.matches(of: equationComponent.regex)
+      return regexMatches.map({ (equationComponent, $0) })
+    }
+    
+    let matches = matchArrays.reduce([], +)
+    
+    for match in matches {
+      let substring = input[match.1.range]
+      print("match: \(substring)")
+    }
 
     // Filter the matches
     let filteredMatches = matches.filter { match in
       // We only want matches with ranges
-      guard let range = match.1?.range else {
-        return false
-      }
+      let range = match.1.range
 
       // Make sure the inner component is non-empty
       let text = Component(text: String(input[range]), type: match.0.equation).text
@@ -154,36 +164,28 @@ extension Parser {
         return false
       }
 
+      // Make sure the range isn't in any other range.
+      // I.e. we only use top-level matches.
+      for subMatch in matches {
+        let subRange = subMatch.1.range
+        
+        if range.isSubrange(of: subRange) {
+          return false
+        }
+      }
+      
       // The component has content and isn't escaped
       return true
     }
 
     // Get the first matched equation
-    guard let smallestMatch = filteredMatches.min(by: { $0.1!.range.lowerBound < $1.1!.range.lowerBound }) else {
+    guard let smallestMatch = filteredMatches.min(by: { $0.1.range.lowerBound < $1.1.range.lowerBound }) else {
       return input.isEmpty ? [] : [Component(text: input, type: .text)]
     }
 
     // If the equation supports recursion, then we'll need to find the last
     // match of its terminating regex component.
-    let equationRange: Range<String.Index>
-    if smallestMatch.0.supportsRecursion {
-      var terminatingMatches = input.matches(of: smallestMatch.0.terminatingRegex).filter { match in
-        // Make sure the terminator isn't escaped
-        if match.range.lowerBound == input.startIndex { return true }
-        let previousIndex = input.index(before: match.range.lowerBound)
-        return input[previousIndex] != "\\"
-      }
-      terminatingMatches.sort(by: { $0.range.lowerBound < $1.range.lowerBound })
-      if let lastMatch = terminatingMatches.last {
-        equationRange = smallestMatch.1!.range.lowerBound ..< lastMatch.range.upperBound
-      }
-      else {
-        equationRange = smallestMatch.1!.range
-      }
-    }
-    else {
-      equationRange = smallestMatch.1!.range
-    }
+    let equationRange: Range<String.Index> = smallestMatch.1.range
 
     // We got our equation range, so lets return the components.
     let stringBeforeEquation = String(input[..<equationRange.lowerBound])