Utilize cache infra

BlueprintUI/Sources/BlueprintView/BlueprintView.swift

@@ -40,6 +40,8 @@ public final class BlueprintView: UIView {
 
     private var sizesThatFit: [SizeConstraint: CGSize] = [:]
 
+    private var cacheStorage = Environment.CacheStorageEnvironmentKey.defaultValue
+
     /// A base environment used when laying out and rendering the element tree.
     ///
     /// Some keys will be overridden with the traits from the view itself. Eg, `windowSize`, `safeAreaInsets`, etc.
@@ -52,6 +54,13 @@ public final class BlueprintView: UIView {
         didSet {
             // Shortcut: If both environments were empty, nothing changed.
             if oldValue.isEmpty && environment.isEmpty { return }
+            // Shortcut: If there are no changes to the environment, then, well, nothing changed.
+            if let layoutMode, layoutMode.options.skipUnneededSetNeedsViewHierarchyUpdates && oldValue.isEquivalent(
+                to: environment,
+                in: .all
+            ) {
+                return
+            }
 
             setNeedsViewHierarchyUpdate()
         }
@@ -86,6 +95,13 @@ public final class BlueprintView: UIView {
             if oldValue == nil && element == nil {
                 return
             }
+            if let layoutMode, layoutMode.options.skipUnneededSetNeedsViewHierarchyUpdates, let contextuallyEquivalent = element as? ContextuallyEquivalent, contextuallyEquivalent.isEquivalent(
+                to: oldValue as? ContextuallyEquivalent,
+                in: .all
+            ) {
+                return
+            }
+            cacheStorage = Environment.CacheStorageEnvironmentKey.defaultValue
 
             Logger.logElementAssigned(view: self)
 
@@ -148,6 +164,7 @@ public final class BlueprintView: UIView {
 
         self.element = element
         self.environment = environment
+        self.environment.cacheStorage = cacheStorage
 
         rootController = NativeViewController(
             node: NativeViewNode(
@@ -542,9 +559,13 @@ public final class BlueprintView: UIView {
             environment.layoutMode = layoutMode
         }
 
+        environment.cacheStorage = cacheStorage
+
         return environment
     }
 
+
+
     private func handleAppeared() {
         rootController.traverse { node in
             node.onAppear?()

BlueprintUI/Sources/Element/ElementContent.swift

@@ -249,6 +249,17 @@ extension ElementContent {
         storage = MeasurableStorage(measurer: measureFunction)
     }
 
+    /// Initializes a new `ElementContent` with no children that delegates to the provided measure function.
+    ///
+    /// - parameter validationKey: If present, measureFunction will attempt to cache sizing based on the path of the node. validationKey will be evaluated to ensure that the result is valid.
+    /// - parameter measureFunction: How to measure the `ElementContent` in the given `SizeConstraint` and `Environment`.
+    public init(
+        validationKey: some ContextuallyEquivalent,
+        measureFunction: @escaping (SizeConstraint, Environment) -> CGSize
+    ) {
+        storage = MeasurableStorage(validationKey: validationKey, measurer: measureFunction)
+    }
+
     /// Initializes a new `ElementContent` with no children that uses the provided intrinsic size for measuring.
     public init(intrinsicSize: CGSize) {
         self = ElementContent(measureFunction: { _ in intrinsicSize })

BlueprintUI/Sources/Element/MeasurableStorage.swift

@@ -7,7 +7,18 @@ struct MeasurableStorage: ContentStorage {
 
     let childCount = 0
 
+    let validationKey: AnyContextuallyEquivalent?
     let measurer: (SizeConstraint, Environment) -> CGSize
+
+    init(validationKey: some ContextuallyEquivalent, measurer: @escaping (SizeConstraint, Environment) -> CGSize) {
+        self.validationKey = AnyContextuallyEquivalent(validationKey)
+        self.measurer = measurer
+    }
+
+    init(measurer: @escaping (SizeConstraint, Environment) -> CGSize) {
+        validationKey = nil
+        self.measurer = measurer
+    }
 }
 
 extension MeasurableStorage: CaffeinatedContentStorage {
@@ -17,7 +28,19 @@ extension MeasurableStorage: CaffeinatedContentStorage {
         environment: Environment,
         node: LayoutTreeNode
     ) -> CGSize {
-        measurer(proposal, environment)
+        guard environment.layoutMode.options.measureableStorageCache, let validationKey else {
+            return measurer(proposal, environment)
+        }
+
+        let key = MeasurableSizeKey(path: node.path, max: proposal.maximum)
+        return environment.cacheStorage.measurableStorageCache.retrieveOrCreate(
+            key: key,
+            environment: environment,
+            validationValue: validationKey,
+            context: .elementSizing,
+        ) { environment in
+            measurer(proposal, environment)
+        }
     }
 
     func performCaffeinatedLayout(
@@ -28,3 +51,40 @@ extension MeasurableStorage: CaffeinatedContentStorage {
         []
     }
 }
+
+extension MeasurableStorage {
+
+    fileprivate struct MeasurableSizeKey: Hashable {
+
+        let path: String
+        let max: CGSize
+
+        func hash(into hasher: inout Hasher) {
+            path.hash(into: &hasher)
+            max.hash(into: &hasher)
+        }
+
+    }
+
+}
+
+extension CacheStorage {
+
+    private struct MeasurableStorageCacheKey: CacheStorage.Key {
+        static var emptyValue = EnvironmentAndValueValidatingCache<
+            MeasurableStorage.MeasurableSizeKey,
+            CGSize,
+            AnyContextuallyEquivalent
+        >()
+    }
+
+    fileprivate var measurableStorageCache: EnvironmentAndValueValidatingCache<
+        MeasurableStorage.MeasurableSizeKey,
+        CGSize,
+        AnyContextuallyEquivalent
+    > {
+        get { self[MeasurableStorageCacheKey.self] }
+        set { self[MeasurableStorageCacheKey.self] = newValue }
+    }
+
+}

BlueprintUI/Sources/Environment/Cache/CacheKey.swift

@@ -3,13 +3,13 @@ import Foundation
 /// Types conforming to this protocol can be used as keys in `CacheStorage`.
 ///
 /// Using a type as the key allows us to strongly type each value, with the
-/// key's `CacheKey.Value` associated value.
+/// key's `CacheStorage.Key.Value` associated value.
 ///
 /// ## Example
 ///
 /// Usually a key is implemented with an uninhabited type, such an empty enum.
 ///
-///     enum WidgetCountsKey: CacheKey {
+///     enum WidgetCountsKey: CacheStorage.Key {
 ///         static let emptyValue: [WidgetID: Int] = [:]
 ///     }
 ///
@@ -21,7 +21,12 @@ import Foundation
 ///             set { self[WidgetCountsKey.self] = newValue }
 ///         }
 ///     }
-public protocol CacheKey {
-    associatedtype Value
-    static var emptyValue: Self.Value { get }
+///
+extension CacheStorage {
+
+    public protocol Key {
+        associatedtype Value
+        static var emptyValue: Self.Value { get }
+    }
+
 }

BlueprintUI/Sources/Environment/Cache/CacheStorage.swift

@@ -24,7 +24,7 @@ import UIKit
         #endif
     }
 
-    public subscript<KeyType>(key: KeyType.Type) -> KeyType.Value where KeyType: CacheKey {
+    public subscript<KeyType>(key: KeyType.Type) -> KeyType.Value where KeyType: CacheStorage.Key {
         get {
             storage[ObjectIdentifier(key), default: KeyType.emptyValue] as! KeyType.Value
         }

BlueprintUI/Sources/Environment/Environment.swift

@@ -244,8 +244,8 @@ extension CacheStorage {
     }
 
     /// A cache of previously compared environments and their results.
-    private struct EnvironmentComparisonCacheKey: CacheKey {
-        static var emptyValue = EnvironmentFingerprintCache()
+    private struct EnvironmentComparisonCacheKey: CacheStorage.Key {
+        static let emptyValue = EnvironmentFingerprintCache()
     }
 
     fileprivate var environmentComparisonCache: EnvironmentFingerprintCache {

BlueprintUI/Sources/Layout/LayoutMode.swift

@@ -11,7 +11,7 @@ import Foundation
 /// Changing the default will cause all instances of ``BlueprintView`` to be invalidated, and re-
 /// render their contents.
 ///
-public struct LayoutMode: Equatable {
+public struct LayoutMode: Hashable {
     public static var `default`: Self = .caffeinated {
         didSet {
             guard oldValue != .default else { return }
@@ -41,15 +41,29 @@ public struct LayoutMode: Equatable {
 
 extension LayoutMode: CustomStringConvertible {
     public var description: String {
-        switch (options.hintRangeBoundaries, options.searchUnconstrainedKeys) {
-        case (true, true):
-            return "Caffeinated (hint+search)"
-        case (true, false):
-            return "Caffeinated (hint)"
-        case (false, true):
-            return "Caffeinated (search)"
-        case (false, false):
+        var optionsDescription: [String] = []
+        if options.hintRangeBoundaries {
+            optionsDescription.append("hint")
+        }
+        if options.searchUnconstrainedKeys {
+            optionsDescription.append("search")
+        }
+        if options.measureableStorageCache {
+            optionsDescription.append("measureableStorageCache")
+        }
+        if options.stringNormalizationCache {
+            optionsDescription.append("stringNormalizationCache")
+        }
+        if options.skipUnneededSetNeedsViewHierarchyUpdates {
+            optionsDescription.append("needsViewHierarchyUpdates")
+        }
+        if options.labelAttributedStringCache {
+            optionsDescription.append("labelAttributedStringCache")
+        }
+        if optionsDescription.isEmpty {
             return "Caffeinated"
+        } else {
+            return "Caffeinated \(optionsDescription.joined(separator: "+"))"
         }
     }
 }

BlueprintUI/Sources/Layout/LayoutOptions.swift

@@ -4,12 +4,16 @@ import Foundation
 ///
 /// Generally these are only useful for experimenting with the performance profile of different
 /// element compositions, and you should stick with ``default``.
-public struct LayoutOptions: Equatable {
+public struct LayoutOptions: Hashable {
 
     /// The default configuration.
     public static let `default` = LayoutOptions(
         hintRangeBoundaries: true,
-        searchUnconstrainedKeys: true
+        searchUnconstrainedKeys: true,
+        measureableStorageCache: false,
+        stringNormalizationCache: false,
+        skipUnneededSetNeedsViewHierarchyUpdates: false,
+        labelAttributedStringCache: false
     )
 
     /// Enables aggressive cache hinting along the boundaries of the range between constraints and
@@ -22,8 +26,32 @@ public struct LayoutOptions: Equatable {
     /// Layout contract for correct behavior.
     public var searchUnconstrainedKeys: Bool
 
-    public init(hintRangeBoundaries: Bool, searchUnconstrainedKeys: Bool) {
+    /// Allows caching the results of `MeasurableStorage` `sizeThatFits`.
+    public var measureableStorageCache: Bool
+
+    /// Caches results of AttributedLabel normalization process.
+    public var stringNormalizationCache: Bool
+
+    /// Allows skipping calls to setNeedsViewHierarchyUpdates when updating Environment, if the environment is
+    /// equilvalent to the prior value.
+    public var skipUnneededSetNeedsViewHierarchyUpdates: Bool
+
+    /// Caches MarketLabel attributed string generation
+    public var labelAttributedStringCache: Bool
+
+    public init(
+        hintRangeBoundaries: Bool,
+        searchUnconstrainedKeys: Bool,
+        measureableStorageCache: Bool,
+        stringNormalizationCache: Bool,
+        skipUnneededSetNeedsViewHierarchyUpdates: Bool,
+        labelAttributedStringCache: Bool
+    ) {
         self.hintRangeBoundaries = hintRangeBoundaries
         self.searchUnconstrainedKeys = searchUnconstrainedKeys
+        self.measureableStorageCache = measureableStorageCache
+        self.stringNormalizationCache = stringNormalizationCache
+        self.skipUnneededSetNeedsViewHierarchyUpdates = skipUnneededSetNeedsViewHierarchyUpdates
+        self.labelAttributedStringCache = labelAttributedStringCache
     }
 }

BlueprintUI/Tests/EnvironmentEntangledCacheTests.swift

@@ -0,0 +1,7 @@
+//
+//  EnvironmentEntangledCacheTests.swift
+//  Development
+//
+//  Created by Max Goedjen on 7/23/25.
+//
+