Add whileAligned operation and tests

Author: tomasf

Sources/Cadova/Abstract Layer/Operations/Aligned.swift

@@ -24,4 +24,33 @@ public extension Geometry {
             child.translated(bounds.translation(for: .init(merging: alignment)))
         }
     }
+
+    /// Temporarily aligns this geometry while performing operations, then restores its original position.
+    ///
+    /// This helper aligns the geometry according to the provided alignment options, evaluates `operations` in that
+    /// aligned coordinate space, and then applies the inverse translation to return the result to its original space.
+    ///
+    /// - Parameters:
+    ///   - alignment: A list of alignment criteria specifying how the geometry should be aligned before evaluating
+    ///     `operations`.
+    ///   - operations: A builder that produces geometry to be evaluated in the aligned space.
+    /// - Returns: The resulting geometry mapped back into the original coordinate space.
+    ///
+    /// Example:
+    /// ```
+    /// Rectangle(x: 20, y: 10)
+    ///     .whileAligned(at: .center) {
+    ///         $0.rotated(45°)
+    ///     }
+    /// ```
+    ///
+    func whileAligned(
+        at alignment: D.Alignment...,
+        @GeometryBuilder<D> do operations: @Sendable @escaping (D.Geometry) -> D.Geometry
+    ) -> D.Geometry {
+        measuringBounds { child, bounds in
+            let translation = bounds.translation(for: .init(merging: alignment))
+            return operations(child.translated(translation)).translated(-translation)
+        }
+    }
 }

Tests/Tests/Alignment.swift

@@ -261,6 +261,42 @@ struct AlignmentTests {
         #expect(bounds?.maximum.y ≈ 0)
     }
 
+    // MARK: - whileAligned
+
+    @Test func `2D whileAligned matches rotated around center`() async throws {
+        let geometry = Rectangle(x: 10, y: 6)
+            .translated(x: 20, y: 10)
+        let viaWhileAligned = geometry
+            .whileAligned(at: .center) { $0.rotated(90°) }
+        let viaPivot = geometry.rotated(90°, around: .center)
+
+        let whileBounds = try await viaWhileAligned.bounds
+        let pivotBounds = try await viaPivot.bounds
+
+        #expect(whileBounds?.minimum.x ≈ pivotBounds?.minimum.x)
+        #expect(whileBounds?.maximum.x ≈ pivotBounds?.maximum.x)
+        #expect(whileBounds?.minimum.y ≈ pivotBounds?.minimum.y)
+        #expect(whileBounds?.maximum.y ≈ pivotBounds?.maximum.y)
+    }
+
+    @Test func `3D whileAligned matches rotated around center`() async throws {
+        let geometry = Box(x: 10, y: 6, z: 4)
+            .translated(x: 20, y: 10, z: 5)
+        let viaWhileAligned = geometry
+            .whileAligned(at: .center) { $0.rotated(y: 90°) }
+        let viaPivot = geometry.rotated(y: 90°, around: .center)
+
+        let whileBounds = try await viaWhileAligned.bounds
+        let pivotBounds = try await viaPivot.bounds
+
+        #expect(whileBounds?.minimum.x ≈ pivotBounds?.minimum.x)
+        #expect(whileBounds?.maximum.x ≈ pivotBounds?.maximum.x)
+        #expect(whileBounds?.minimum.y ≈ pivotBounds?.minimum.y)
+        #expect(whileBounds?.maximum.y ≈ pivotBounds?.maximum.y)
+        #expect(whileBounds?.minimum.z ≈ pivotBounds?.minimum.z)
+        #expect(whileBounds?.maximum.z ≈ pivotBounds?.maximum.z)
+    }
+
     // MARK: - Edge Cases
 
     @Test func `align none leaves geometry unchanged`() async throws {