[DNR] All the caching

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

@@ -0,0 +1,32 @@
+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 `CacheStorage.Key.Value` associated value.
+///
+/// ## Example
+///
+/// Usually a key is implemented with an uninhabited type, such an empty enum.
+///
+///     enum WidgetCountsKey: CacheStorage.Key {
+///         static let emptyValue: [WidgetID: Int] = [:]
+///     }
+///
+/// You can write a small extension on `CacheStorage` to make it easier to use your key.
+///
+///     extension CacheStorage {
+///         var widgetCounts: [WidgetID: Int] {
+///             get { self[WidgetCountsKey.self] }
+///             set { self[WidgetCountsKey.self] = newValue }
+///         }
+///     }
+///
+extension CacheStorage {
+
+    public protocol Key {
+        associatedtype Value
+        static var emptyValue: Self.Value { get }
+    }
+
+}

BlueprintUI/Sources/Environment/Cache/CacheStorage.swift

@@ -0,0 +1,89 @@
+import Foundation
+#if canImport(UIKit)
+import UIKit
+#endif
+
+/// Environment-associated storage used to cache types used across layout passes (eg, size calculations).
+/// The storage itself is type-agnostic, requiring only that its keys and values conform to the `CacheKey` protocol
+/// Caches are responsible for managing their own lifetimes and eviction strategies.
+@_spi(CacheStorage) public final class CacheStorage: Sendable, CustomDebugStringConvertible {
+
+    // Optional name to distinguish between instances for debugging purposes.
+    public var name: String? = nil
+    fileprivate var storage: [ObjectIdentifier: Any] = [:]
+
+    init() {
+        #if canImport(UIKit)
+        NotificationCenter.default.addObserver(
+            forName: UIApplication.didReceiveMemoryWarningNotification,
+            object: nil,
+            queue: .main
+        ) { [weak self] _ in
+            self?.storage.removeAll()
+        }
+        #endif
+    }
+
+    public subscript<KeyType>(key: KeyType.Type) -> KeyType.Value where KeyType: CacheStorage.Key {
+        get {
+            storage[ObjectIdentifier(key), default: KeyType.emptyValue] as! KeyType.Value
+        }
+        set {
+            storage[ObjectIdentifier(key)] = newValue
+        }
+    }
+
+    public var debugDescription: String {
+        let debugName = if let name {
+            "CacheStorage (\(name))"
+        } else {
+            "CacheStorage"
+        }
+        return "\(debugName): \(storage.count) entries"
+    }
+
+}
+
+extension Environment {
+
+    struct CacheStorageEnvironmentKey: InternalEnvironmentKey {
+        static var defaultValue = CacheStorage()
+    }
+
+
+    @_spi(CacheStorage) public var cacheStorage: CacheStorage {
+        get { self[CacheStorageEnvironmentKey.self] }
+        set { self[CacheStorageEnvironmentKey.self] = newValue }
+    }
+
+}
+
+/// A UUID that changes based on value changes of the containing type.
+/// Two fingerprinted objects may be quickly compared for equality by comparing their fingerprints.
+/// This is roughly analagous to a hash, although with inverted properties: Two objects with the same fingerprint can be trivially considered equal, but two otherwise equal objects may have different fingerprint.
+/// - Note: This type is deliberately NOT equatable – this is to prevent accidental inclusion of it when its containing type is equatable.
+struct ComparableFingerprint: ContextuallyEquivalent, CustomStringConvertible {
+
+    typealias Value = UUID
+
+    var value: Value
+
+    init() {
+        value = Value()
+    }
+
+    mutating func modified() {
+        value = Value()
+    }
+
+    /// - Note: This is a duplicate message but: this type is deliberately NOT equatable – this is to prevent accidental inclusion of it when its containing type is equatable. Use this instead.
+    func isEquivalent(to other: ComparableFingerprint?, in context: EquivalencyContext) -> Bool {
+        value == other?.value
+    }
+
+    var description: String {
+        value.uuidString
+    }
+
+}
+