Improve perf of AttributedLabel link focus changes and suppress console messages (#565)

This PR mainly fixes two separate things:
1. Performance issues with the focus changes in `AttributedLabel` - Due
to the `frame` property being requested each time the focus is changed,
the code was doing an expensive recalculation of the bounding shape.
This change introduces caching for the bounding shape and only ensures
that the cache is invalidated when the label is updated or when
`layoutSubviews` is called on the label view.
[This](7876c9e)
commit (not being pushed to main) contains the test code that I used for
measuring the performance of this code. In the "before" version, the
frame rate had dropped to ~25 FPS. In the "after" version, the frame
rate is ~110 FPS.
2. Despite using the
[API](https://developer.apple.com/documentation/uikit/uifocusitemcontainer/focusitems(in:))
in the prescribed manner, there would be repeated console output of the
form `_TtCV25BlueprintUICommonControls15AttributedLabel9LabelView
implements focusItemsInRect: - caching for linear focus movement is
limited as long as this view is on screen.` I am able to replicate this
on both iPadOS and tvOS (the platform that Apple had
[originally](https://devstreaming-cdn.apple.com/videos/wwdc/2018/208piymryv9im6/208/208_whats_new_in_tvos_12.pdf)
demonstrated this API on). This change implements the
`_supportsInvalidatingFocusCache()` function similar to how Apple does
it in a number of their system classes such as `UITableView` and
`UICollectionView`, amongst others.


![image](https://github.com/user-attachments/assets/5d226b9f-694b-48e6-924f-19045023d379)

Author: meherkasam-square

BlueprintUICommonControls/Sources/AttributedLabel.swift

@@ -211,6 +211,9 @@ extension AttributedLabel {
             }
         }
 
+        // Store bounding shapes in this cache to avoid costly recalculations
+        private var boundingShapeCache: [Link: Link.BoundingShape] = [:]
+
         override var accessibilityCustomRotors: [UIAccessibilityCustomRotor]? {
             set { assertionFailure("accessibilityCustomRotors is not settable.") }
             get { !linkElements.isEmpty ? [linkElements.accessibilityRotor(systemType: .link)] : [] }
@@ -222,6 +225,46 @@ extension AttributedLabel {
 
         var urlHandler: URLHandler?
 
+        override init(frame: CGRect) {
+            super.init(frame: frame)
+
+            if #available(iOS 17.0, *) {
+                registerForTraitChanges([UITraitPreferredContentSizeCategory.self]) { (
+                    view: LabelView,
+                    previousTraitCollection: UITraitCollection
+                ) in
+                    view.invalidateLinkBoundingShapeCaches()
+                }
+            } else {
+                NotificationCenter
+                    .default
+                    .addObserver(
+                        self,
+                        selector: #selector(sizeCategoryChanged(notification:)),
+                        name: UIContentSizeCategory.didChangeNotification,
+                        object: nil
+                    )
+            }
+        }
+
+        deinit {
+            if #available(iOS 17.0, *) {
+                // Do nothing
+            } else {
+                NotificationCenter
+                    .default
+                    .removeObserver(self)
+            }
+        }
+
+        @objc private func sizeCategoryChanged(notification: Notification) {
+            invalidateLinkBoundingShapeCaches()
+        }
+
+        required init?(coder: NSCoder) {
+            fatalError("init(coder:) has not been implemented")
+        }
+
         func update(model: AttributedLabel, text: NSAttributedString, environment: Environment, isMeasuring: Bool) {
             let previousAttributedText = isMeasuring ? nil : attributedText
 
@@ -251,6 +294,8 @@ extension AttributedLabel {
             layoutDirection = environment.layoutDirection
 
             if !isMeasuring {
+                invalidateLinkBoundingShapeCaches()
+
                 if previousAttributedText != attributedText {
                     links = attributedLinks(in: model.attributedText) + detectedDataLinks(in: model.attributedText)
                     accessibilityLabel = accessibilityLabel(
@@ -644,8 +689,38 @@ extension AttributedLabel {
             trackingLinks = nil
             applyLinkColors()
         }
+
+        override func layoutSubviews() {
+            super.layoutSubviews()
+
+            invalidateLinkBoundingShapeCaches()
+        }
+
+        func boundingShape(for link: Link) -> Link.BoundingShape {
+            if let cachedShape = boundingShapeCache[link] {
+                return cachedShape
+            }
+
+            let calculatedShape = link.calculateBoundingShape()
+            boundingShapeCache[link] = calculatedShape
+            return calculatedShape
+        }
+
+        private func invalidateLinkBoundingShapeCaches() {
+            boundingShapeCache.removeAll()
+        }
     }
+}
 
+extension AttributedLabel.LabelView {
+    // Without this, we were seeing console messages like the following:
+    // "LabelView implements focusItemsInRect: - caching for linear focus movement is limited as long as this view is on screen."
+    // It's unclear as to why they are appearing despite using the API in the intended manner.
+    // To suppress the messages, we implemented this function much like Apple did with `UITableView`,
+    // `UICollectionView`, etc.
+    @objc private class func _supportsInvalidatingFocusCache() -> Bool {
+        true
+    }
 }
 
 extension AttributedLabel {
@@ -674,6 +749,10 @@ extension AttributedLabel {
         }
 
         var boundingShape: BoundingShape {
+            container?.boundingShape(for: self) ?? calculateBoundingShape()
+        }
+
+        fileprivate func calculateBoundingShape() -> BoundingShape {
             guard let container = container,
                   let textStorage = container.makeTextStorage(),
                   let layoutManager = textStorage.layoutManagers.first,
@@ -776,7 +855,7 @@ extension AttributedLabel {
         override var accessibilityPath: UIBezierPath? {
             set { assertionFailure("cannot set accessibilityPath") }
             get {
-                if let path = link.boundingShape.path, let container = link.container {
+                if let path = link.boundingShape.path?.copy() as? UIBezierPath, let container = link.container {
                     return UIAccessibility.convertToScreenCoordinates(path, in: container)
                 }
 

SampleApp/Sources/XcodePreviewDemo.swift

@@ -1,5 +1,6 @@
 import BlueprintUI
 import BlueprintUICommonControls
+import Foundation
 
 
 struct TestElement: ProxyElement {