Conversions between Euclid and Kurbo types (#463)

Inspired after #450

We could use those in servo and blitz.
Theoretically they could also live in euclid, but given higher number of
breaking releases in kurbo, kurbo seems better place for this.

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>

Author: sagudev

Cargo.lock

@@ -21,14 +21,16 @@ workspace = true
 
 [features]
 default = ["std"]
-std = []
-libm = ["dep:libm"]
+std = ["euclid?/std"]
+libm = ["dep:libm", "euclid?/libm"]
 mint = ["dep:mint"]
 serde = ["smallvec/serde", "dep:serde"]
 schemars = ["schemars/smallvec", "dep:schemars"]
+euclid = ["dep:euclid"]
 
 [dependencies]
 smallvec = "1.15.0"
+euclid = { version = "0.22", optional = true, default-features = false }
 
 [dependencies.arrayvec]
 version = "0.7.6"

kurbo/Cargo.toml

@@ -0,0 +1,79 @@
+// Copyright 2025 the Kurbo Authors
+// SPDX-License-Identifier: Apache-2.0 OR MIT
+
+use euclid::UnknownUnit;
+
+impl From<euclid::Vector2D<f64, UnknownUnit>> for crate::Vec2 {
+    fn from(value: euclid::Vector2D<f64, UnknownUnit>) -> Self {
+        Self::new(value.x, value.y)
+    }
+}
+
+impl From<crate::Vec2> for euclid::Vector2D<f64, UnknownUnit> {
+    fn from(value: crate::Vec2) -> Self {
+        Self::new(value.x, value.y)
+    }
+}
+
+impl From<euclid::Point2D<f64, UnknownUnit>> for crate::Point {
+    fn from(value: euclid::Point2D<f64, UnknownUnit>) -> Self {
+        Self::new(value.x, value.y)
+    }
+}
+
+impl From<crate::Point> for euclid::Point2D<f64, UnknownUnit> {
+    fn from(value: crate::Point) -> Self {
+        Self::new(value.x, value.y)
+    }
+}
+
+impl From<euclid::Size2D<f64, UnknownUnit>> for crate::Size {
+    fn from(value: euclid::Size2D<f64, UnknownUnit>) -> Self {
+        Self::new(value.width, value.height)
+    }
+}
+
+impl From<crate::Size> for euclid::Size2D<f64, UnknownUnit> {
+    fn from(value: crate::Size) -> Self {
+        Self::new(value.width, value.height)
+    }
+}
+
+impl From<euclid::Rect<f64, UnknownUnit>> for crate::Rect {
+    fn from(value: euclid::Rect<f64, UnknownUnit>) -> Self {
+        Self::from_origin_size(value.origin, value.size)
+    }
+}
+
+impl From<crate::Rect> for euclid::Rect<f64, UnknownUnit> {
+    fn from(value: crate::Rect) -> Self {
+        Self::new(value.origin().into(), value.size().into())
+    }
+}
+
+impl From<euclid::Box2D<f64, UnknownUnit>> for crate::Rect {
+    fn from(value: euclid::Box2D<f64, UnknownUnit>) -> Self {
+        Self::from_points(value.min, value.max)
+    }
+}
+
+impl From<crate::Rect> for euclid::Box2D<f64, UnknownUnit> {
+    fn from(value: crate::Rect) -> Self {
+        Self::new(
+            euclid::Point2D::new(value.min_x(), value.min_y()),
+            euclid::Point2D::new(value.max_x(), value.max_y()),
+        )
+    }
+}
+
+impl From<euclid::Transform2D<f64, UnknownUnit, UnknownUnit>> for crate::Affine {
+    fn from(t: euclid::Transform2D<f64, UnknownUnit, UnknownUnit>) -> Self {
+        Self::new(t.to_array())
+    }
+}
+
+impl From<crate::Affine> for euclid::Transform2D<f64, UnknownUnit, UnknownUnit> {
+    fn from(a: crate::Affine) -> Self {
+        Self::from_array(a.as_coeffs())
+    }
+}

kurbo/src/interop_euclid.rs

@@ -142,6 +142,9 @@ mod translate_scale;
 mod triangle;
 mod vec2;
 
+#[cfg(feature = "euclid")]
+mod interop_euclid;
+
 pub use crate::affine::Affine;
 pub use crate::arc::{Arc, ArcAppendIter};
 pub use crate::bezpath::{