Don't cache subelements

BlueprintUI/Sources/Element/LayoutStorage.swift

@@ -126,21 +126,19 @@ extension LayoutStorage: LegacyContentStorage {
 extension LayoutStorage: CaffeinatedContentStorage {
 
     private func subelements(from node: LayoutTreeNode, environment: Environment) -> LayoutSubelements {
-        node.layoutSubelements {
-            var identifierFactory = ElementIdentifier.Factory(elementCount: children.count)
-            return children.map { child in
-                let identifier = identifierFactory.nextIdentifier(
-                    for: type(of: child.element),
-                    key: child.key
-                )
-                return LayoutSubelement(
-                    identifier: identifier,
-                    content: child.content,
-                    environment: environment,
-                    node: node.subnode(key: identifier),
-                    traits: child.traits
-                )
-            }
+        var identifierFactory = ElementIdentifier.Factory(elementCount: children.count)
+        return children.map { child in
+            let identifier = identifierFactory.nextIdentifier(
+                for: type(of: child.element),
+                key: child.key
+            )
+            return LayoutSubelement(
+                identifier: identifier,
+                content: child.content,
+                environment: environment,
+                node: node.subnode(key: identifier),
+                traits: child.traits
+            )
         }
     }
 

BlueprintUI/Sources/Internal/LayoutTreeNode.swift

@@ -27,7 +27,6 @@ final class LayoutTreeNode {
 
     // These commonly used properties have dedicated storage. If we need to hang more generalized
     // things off this type we may want to store them in a heterogeneous dictionary.
-    private var _layoutSubelements: [LayoutSubelement]?
     private var _associatedCache: Any?
 
     init(path: String, signpostRef: AnyObject, options: LayoutOptions) {
@@ -48,15 +47,6 @@ final class LayoutTreeNode {
         return subnode
     }
 
-    func layoutSubelements(create: () -> [LayoutSubelement]) -> [LayoutSubelement] {
-        if let layoutSubelements = _layoutSubelements {
-            return layoutSubelements
-        }
-        let layoutSubelements = create()
-        _layoutSubelements = layoutSubelements
-        return layoutSubelements
-    }
-
     func associatedCache<AssociatedCache>(create: () -> AssociatedCache) -> AssociatedCache {
         assert(
             _associatedCache is AssociatedCache?,

BlueprintUI/Tests/GeometryReaderTests.swift

@@ -87,6 +87,60 @@ final class GeometryReaderTests: XCTestCase {
 
         wait(for: [layoutExpectation], timeout: 5)
     }
+
+    func test_dynamicSubelements() {
+        let threshold: CGFloat = 100
+        let size = CGSize(width: 120, height: 120)
+
+        let element: Element = Row { outerRow in
+            outerRow.horizontalUnderflow = .growUniformly
+            outerRow.horizontalOverflow = .condenseUniformly
+            outerRow.verticalAlignment = .fill
+
+            outerRow.addFlexible(
+                child: GeometryReader { geometry in
+
+                    Row { innerRow in
+                        innerRow.horizontalUnderflow = .growUniformly
+                        innerRow.horizontalOverflow = .condenseUniformly
+                        innerRow.verticalAlignment = .fill
+
+                        if let width = geometry.constraint.width.constrainedValue, width < threshold {
+                            // If constrained < 100, 2 children
+                            innerRow.addFixed(child: Spacer(1))
+                            innerRow.addFixed(child: Spacer(1))
+                        } else {
+                            // else 1 child
+                            innerRow.addFixed(child: Spacer(threshold))
+                        }
+                    }
+                }
+            )
+
+            outerRow.addFlexible(child: Spacer(threshold / 2))
+        }
+
+        // during layout:
+        // 1. Outer row measures GR with full width
+        // 2. GR body evaluates as a row with 1 child
+        // 3. Outer row measures again with reduced width
+        // 4. GR body evaluates as a row with 2 children
+        // 5. Subelement count has changed, as well as content of child 1
+
+        let frames = element
+            .layout(frame: CGRect(origin: .zero, size: size))
+            .queryLayout(for: Spacer.self)
+            .map { $0.layoutAttributes.frame }
+
+        XCTAssertEqual(
+            frames,
+            [
+                CGRect(origin: CGPoint(x: 0, y: 0), size: CGSize(width: 1, height: 120)),
+                CGRect(origin: CGPoint(x: 1, y: 0), size: CGSize(width: 1, height: 120)),
+                CGRect(origin: CGPoint(x: 85, y: 0), size: CGSize(width: 35, height: 120)),
+            ]
+        )
+    }
 }
 
 extension SizeConstraint.Axis {

BlueprintUI/Tests/LayoutResultNode+Testing.swift

@@ -14,4 +14,18 @@ extension LayoutResultNode {
         }
         return nil
     }
+
+    func queryLayout(for elementType: Element.Type) -> [LayoutResultNode] {
+        var results: [LayoutResultNode] = []
+
+        if type(of: element) == elementType {
+            results.append(self)
+        }
+
+        for child in children {
+            results.append(contentsOf: child.node.queryLayout(for: elementType))
+        }
+
+        return results
+    }
 }