Merge branch 'dev'

Author: tomasf

Package.resolved

@@ -8,7 +8,7 @@ let package = Package(
         .library(name: "Cadova", targets: ["Cadova"]),
     ],
     dependencies: [
-        .package(url: "https://github.com/tomasf/manifold-swift.git", .upToNextMinor(from: "0.2.3")),
+        .package(url: "https://github.com/tomasf/manifold-swift.git", .upToNextMinor(from: "0.4.0")),
         .package(url: "https://github.com/tomasf/ThreeMF.git", .upToNextMinor(from: "0.2.0")),
         .package(url: "https://github.com/tomasf/Apus.git", .upToNextMinor(from: "0.1.1")),
     ],

Package.swift

@@ -77,3 +77,14 @@ public extension Polygon {
         Self([.zero, [x, 0], [0, y]])
     }
 }
+
+public extension ParametricCurve where V == Vector2D {
+    /// Converts the curve into a filled 2D polygon.
+    ///
+    /// The curve is sampled and used to create a ``Polygon``, which represents the filled interior of the curve.
+    ///
+    /// - Returns: A polygon representing the filled shape of the curve.
+    func filled() -> Polygon {
+        Polygon(self)
+    }
+}

Sources/Cadova/Abstract Layer/2D/Polygon/Polygon.swift

@@ -75,14 +75,3 @@ extension ReferenceState {
         otherState.usedAnchors.intersection(definedAnchors.keys).count > 0 || otherState.usedTags.intersection(definedTags.keys).count > 0
     }
 }
-
-extension ReferenceState {
-    func printWarningsAtTopLevel() {
-        if !undefinedAnchors.isEmpty {
-            logger.warning("Undefined anchors: \(undefinedAnchors)")
-        }
-        if !undefinedTags.isEmpty {
-            logger.warning("Undefined tags: \(undefinedTags)")
-        }
-    }
-}

Sources/Cadova/Abstract Layer/Geometry/References/ReferenceState.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)
+        }
+    }
 }

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

@@ -24,9 +24,11 @@ extension Geometry {
     ///
     @GeometryBuilder<D>
     public func repeated(along axis: D.Axis, in range: Range<Double>, count: Int) -> D.Geometry {
-        let step = (range.upperBound - range.lowerBound) / Double(count)
-        for value in stride(from: range.lowerBound, to: range.upperBound, by: step) {
-            translated(D.Vector(axis, value: value))
+        if count > 0 {
+            let step = (range.upperBound - range.lowerBound) / Double(count)
+            for value in stride(from: range.lowerBound, to: range.upperBound, by: step) {
+                translated(D.Vector(axis, value: value))
+            }
         }
     }
 
@@ -40,9 +42,13 @@ extension Geometry {
     ///
     @GeometryBuilder<D>
     public func repeated(along axis: D.Axis, in range: ClosedRange<Double>, count: Int) -> D.Geometry {
-        let step = (range.upperBound - range.lowerBound) / Double(count - 1)
-        for value in stride(from: range.lowerBound, through: range.upperBound, by: step) {
-            translated(D.Vector(axis, value: value))
+        if count > 1 {
+            let step = (range.upperBound - range.lowerBound) / Double(count - 1)
+            for value in stride(from: range.lowerBound, through: range.upperBound, by: step) {
+                translated(D.Vector(axis, value: value))
+            }
+        } else if count == 1 {
+            translated(D.Vector(axis, value: range.lowerBound))
         }
     }
 
@@ -102,15 +108,19 @@ extension Geometry {
 
             if cyclically {
                 let count = Int(floor(rangeLength / (boundsLength + minimumSpacing)))
-                let step = rangeLength / Double(count)
-                self.repeated(along: axis, step: step, count: count)
-                    .translated(D.Vector(axis, value: range.lowerBound))
+                if count > 0 {
+                    let step = rangeLength / Double(count)
+                    self.repeated(along: axis, step: step, count: count)
+                        .translated(D.Vector(axis, value: range.lowerBound))
+                }
             } else {
                 let availableLength = rangeLength - boundsLength
                 let count = Int(floor(availableLength / (boundsLength + minimumSpacing)))
-                let step = availableLength / Double(count)
-                self.repeated(along: axis, step: step, count: count + 1)
-                    .translated(D.Vector(axis, value: range.lowerBound))
+                if count > 0 {
+                    let step = availableLength / Double(count)
+                    self.repeated(along: axis, step: step, count: count + 1)
+                        .translated(D.Vector(axis, value: range.lowerBound))
+                }
             }
         }
     }

Sources/Cadova/Abstract Layer/Operations/Duplication/RepeatAlong.swift

@@ -39,11 +39,13 @@ extension Geometry2D {
 
     @GeometryBuilder2D
     public func repeated(in range: ClosedRange<Angle>, count: Int) -> any Geometry2D {
-        if count > 0 {
+        if count > 1 {
             let step = (range.upperBound - range.lowerBound) / Double(count - 1)
             for value in stride(from: range.lowerBound, through: range.upperBound, by: step) {
                 rotated(value)
             }
+        } else if count == 1 {
+            rotated(range.lowerBound)
         }
     }
 }
@@ -89,11 +91,13 @@ extension Geometry3D {
 
     @GeometryBuilder3D
     public func repeated(around axis: Axis3D, in range: ClosedRange<Angle>, count: Int) -> any Geometry3D {
-        if count > 0 {
+        if count > 1 {
             let step = (range.upperBound - range.lowerBound) / Double(count - 1)
             for value in stride(from: range.lowerBound, through: range.upperBound, by: step) {
                 rotated(angle: value, axis: axis)
             }
+        } else if count == 1 {
+            rotated(angle: range.lowerBound, axis: axis)
         }
     }
 }

Sources/Cadova/Abstract Layer/Operations/Duplication/RepeatAround.swift

@@ -7,7 +7,7 @@ public extension Geometry2D {
     /// the external outline.
     ///
     /// - Returns: A new geometry representing the shape with its holes filled.
-    func filled() -> any Geometry2D {
+    func fillingHoles() -> any Geometry2D {
         CachedConcreteTransformer(body: self, name: "Cadova.Fill") {
             .boolean(.union, with: $0.polygons().map {
                 D2.Concrete(polygons: [$0], fillRule: .nonZero)