Check for cached values.

Author: colinc86

Sources/LaTeXSwiftUI/Extensions/Font+Extensions.swift

@@ -33,6 +33,8 @@ import Cocoa
 #endif
 
 internal extension Font {
+  
+  /// The font's text style.
   func textStyle() -> _Font.TextStyle? {
     switch self {
     case .largeTitle, .largeTitle.bold(), .largeTitle.italic(), .largeTitle.monospaced(): return .largeTitle
@@ -48,6 +50,12 @@ internal extension Font {
     default: return nil
     }
   }
+  
+  /// The font's x-height.
+  var xHeight: CGFloat {
+    _Font.preferredFont(from: self).xHeight
+  }
+  
 }
 
 internal extension _Font {

Sources/LaTeXSwiftUI/LaTeX.swift

@@ -104,18 +104,18 @@ public struct LaTeX: View {
 
   /// The package's shared data cache.
   public static var dataCache: NSCache<NSString, NSData> {
-    Renderer.shared.dataCache
+    Renderer.shared.cache.dataCache
   }
 
 #if os(macOS)
   /// The package's shared image cache.
   public static var imageCache: NSCache<NSString, NSImage> {
-    Renderer.shared.imageCache
+    Renderer.shared.cache.imageCache
   }
 #else
   /// The package's shared image cache.
   public static var imageCache: NSCache<NSString, UIImage> {
-    Renderer.shared.imageCache
+    Renderer.shared.cache.imageCache
   }
 #endif
 
@@ -159,22 +159,6 @@ public struct LaTeX: View {
   /// The view's render state.
   @StateObject private var renderState: LaTeXRenderState
 
-  /// Renders the blocks synchronously.
-  ///
-  /// This will block whatever thread you call it on.
-  private var syncBlocks: [ComponentBlock] {
-    Renderer.shared.render(
-      blocks: Parser.parse(unencodeHTML ? latex.htmlUnescape() : latex, mode: parsingMode),
-      font: font ?? .body,
-      displayScale: displayScale,
-      texOptions: texOptions)
-  }
-  
-  /// The TeX options to use when submitting requests to the renderer.
-  private var texOptions: TeXInputProcessorOptions {
-    TeXInputProcessorOptions(processEscapes: processEscapes, errorMode: errorMode)
-  }
-  
   // MARK: Initializers
 
   /// Initializes a view with a LaTeX input string.
@@ -190,21 +174,22 @@ public struct LaTeX: View {
   public var body: some View {
     VStack(spacing: 0) {
       if renderState.rendered {
+        // If our blocks have been rendered, display them
         bodyWithBlocks(renderState.blocks)
       }
+      else if isCached() {
+        // If our blocks are cached, display them
+        bodyWithBlocks(renderSync())
+      }
       else {
+        // The view is not rendered nor cached
         switch renderingStyle {
-        case .empty:
-          Text("")
-            .task(render)
-        case .original:
-          Text(latex)
-            .task(render)
-        case .progress:
-          ProgressView()
-            .task(render)
+        case .empty, .original, .progress:
+          // Render the components asynchronously
+          loadingView().task(renderAsync)
         case .wait:
-          bodyWithBlocks(syncBlocks)
+          // Render the components synchronously
+          bodyWithBlocks(renderSync())
         }
       }
     }
@@ -220,7 +205,7 @@ extension LaTeX {
   /// Preloads the view's SVG and image data.
   public func preload() {
     Task {
-      await render()
+      await renderAsync()
     }
   }
 }
@@ -229,14 +214,45 @@ extension LaTeX {
 
 extension LaTeX {
 
+  /// Checks the renderer's caches for the current view.
+  ///
+  /// If this method returns `true`, then there is no need to do an async
+  /// render.
+  ///
+  /// - Returns: A boolean indicating whether the components to the view are
+  ///   cached.
+  private func isCached() -> Bool {
+    renderState.isCached(
+      unencodeHTML: unencodeHTML,
+      parsingMode: parsingMode,
+      processEscapes: processEscapes,
+      errorMode: errorMode,
+      font: font ?? .body,
+      displayScale: displayScale)
+  }
+  
   /// Renders the view's components.
-  @Sendable private func render() async {
+  @Sendable private func renderAsync() async {
     await renderState.render(
       unencodeHTML: unencodeHTML,
       parsingMode: parsingMode,
-      font: font,
-      displayScale: displayScale,
-      texOptions: texOptions)
+      processEscapes: processEscapes,
+      errorMode: errorMode,
+      font: font ?? .body,
+      displayScale: displayScale)
+  }
+  
+  /// Renders the view's components synchronously.
+  ///
+  /// - Returns: The rendered components.
+  private func renderSync() -> [ComponentBlock] {
+    renderState.renderSync(
+      unencodeHTML: unencodeHTML,
+      parsingMode: parsingMode,
+      processEscapes: processEscapes,
+      errorMode: errorMode,
+      font: font ?? .body,
+      displayScale: displayScale)
   }
 
   /// Creates the view's body based on its block mode.
@@ -254,6 +270,22 @@ extension LaTeX {
     }
   }
 
+  @MainActor @ViewBuilder private func loadingView() -> some View {
+    switch renderingStyle {
+    case .empty:
+      Text("")
+        .task(renderAsync)
+    case .original:
+      Text(latex)
+        .task(renderAsync)
+    case .progress:
+      ProgressView()
+        .task(renderAsync)
+    default:
+      EmptyView()
+    }
+  }
+  
 }
 
 @available(iOS 16.1, *)

Sources/LaTeXSwiftUI/Models/Cache.swift

@@ -0,0 +1,139 @@
+//
+//  Cache.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 CryptoKit
+import Foundation
+import MathJaxSwift
+
+fileprivate protocol CacheKey: Codable {
+  
+  /// The key type used to identify the cache key in storage.
+  static var keyType: String { get }
+  
+  /// A key to use if encoding fails.
+  var fallbackKey: String { get }
+  
+}
+
+extension CacheKey {
+  
+  /// The key to use in the cache.
+  func key() -> String {
+    do {
+      let data = try JSONEncoder().encode(self)
+      let hashedData = SHA256.hash(data: data)
+      return hashedData.compactMap { String(format: "%02x", $0) }.joined() + "-" + Self.keyType
+    }
+    catch {
+      return fallbackKey + "-" + Self.keyType
+    }
+  }
+  
+}
+
+internal class Cache {
+  
+  // MARK: Types
+  
+  /// An SVG cache key.
+  struct SVGCacheKey: CacheKey {
+    static let keyType: String = "svg"
+    let componentText: String
+    let conversionOptions: ConversionOptions
+    let texOptions: TeXInputProcessorOptions
+    internal var fallbackKey: String { componentText }
+  }
+  
+  /// An image cache key.
+  struct ImageCacheKey: CacheKey {
+    static let keyType: String = "image"
+    let svg: SVG
+    let xHeight: CGFloat
+    internal var fallbackKey: String { String(data: svg.data, encoding: .utf8) ?? "" }
+  }
+  
+  // MARK: Static properties
+  
+  /// The renderer's data cache.
+  internal let dataCache: NSCache<NSString, NSData> = NSCache()
+  
+  /// Semaphore for thread-safe access to `dataCache`.
+  internal let dataCacheSemaphore = DispatchSemaphore(value: 1)
+  
+  /// The renderer's image cache.
+  internal let imageCache: NSCache<NSString, _Image> = NSCache()
+  
+  /// Semaphore for thread-safe access to `imageCache`.
+  internal let imageCacheSemaphore = DispatchSemaphore(value: 1)
+  
+}
+
+// MARK: Public methods
+
+extension Cache {
+  
+  /// Safely access the cache value for the given key.
+  ///
+  /// - Parameter key: The key of the value to get.
+  /// - Returns: A value.
+  func dataCacheValue(for key: SVGCacheKey) -> Data? {
+    dataCacheSemaphore.wait()
+    defer { dataCacheSemaphore.signal() }
+    return dataCache.object(forKey: key.key() as NSString) as Data?
+  }
+  
+  /// Safely sets the cache value.
+  ///
+  /// - Parameters:
+  ///   - value: The value to set.
+  ///   - key: The value's key.
+  func setDataCacheValue(_ value: Data, for key: SVGCacheKey) {
+    dataCacheSemaphore.wait()
+    dataCache.setObject(value as NSData, forKey: key.key() as NSString)
+    dataCacheSemaphore.signal()
+  }
+  
+  /// Safely access the cache value for the given key.
+  ///
+  /// - Parameter key: The key of the value to get.
+  /// - Returns: A value.
+  func imageCacheValue(for key: ImageCacheKey) -> _Image? {
+    imageCacheSemaphore.wait()
+    defer { imageCacheSemaphore.signal() }
+    return imageCache.object(forKey: key.key() as NSString)
+  }
+  
+  /// Safely sets the cache value.
+  ///
+  /// - Parameters:
+  ///   - value: The value to set.
+  ///   - key: The value's key.
+  func setImageCacheValue(_ value: _Image, for key: ImageCacheKey) {
+    imageCacheSemaphore.wait()
+    imageCache.setObject(value, forKey: key.key() as NSString)
+    imageCacheSemaphore.signal()
+  }
+  
+}