feat: Allow dasharrays to be expressions

Author: Maximkaaa

galileo-maplibre/src/layer/vector_tile.rs

@@ -64,7 +64,7 @@ pub fn try_create(
 /// entire tile. WE don't support this currently, and always put background at the back.
 fn get_background(layers: &[&MaplibreStyleLayer]) -> ColorExpr {
     const DEFAULT_TILE_BACKGROUND: ColorExpr =
-        ColorExpr::new(Expr::Literal(ExprValue::Color(Color::TRANSPARENT)));
+        ColorExpr::new(Expr::Value(ExprValue::Color(Color::TRANSPARENT)));
 
     let layer = match layers {
         [] => return DEFAULT_TILE_BACKGROUND,
@@ -113,21 +113,21 @@ fn get_color_value(color: &MlStyleValue<MlColor>, opacity: &MlStyleValue<f64>) -
     })
 }
 
-fn get_galileo_value<T: Copy + Default + std::fmt::Debug>(value: &MlStyleValue<T>) -> Option<Expr>
+fn get_galileo_value<T: Clone + Default + std::fmt::Debug>(value: &MlStyleValue<T>) -> Option<Expr>
 where
     for<'de> FunctionStop<T>: Deserialize<'de>,
-    ExprValue<String>: From<T>,
+    ExprValue<'static>: From<T>,
 {
     match value {
-        MlStyleValue::Literal(v) => Some(Expr::Literal(ExprValue::from(*v))),
+        MlStyleValue::Literal(v) => Some(Expr::Value(ExprValue::from(v.clone()))),
         MlStyleValue::Expression(expr) => expr.to_galileo_expr(),
         MlStyleValue::Function(function) => {
             let control_points = function
                 .stops
                 .iter()
                 .map(|stop| ControlPoint {
                     input: stop.input.into(),
-                    output: ExprValue::<String>::from(stop.output).into(),
+                    output: ExprValue::from(stop.output.clone()).into(),
                 })
                 .collect();
 
@@ -298,7 +298,11 @@ fn line_rule(line: &LineLayer, tile_schema: &TileSchema) -> Option<StyleRule> {
         .minzoom
         .and_then(|lod| tile_schema.lod_resolution(lod.round() as u32));
     let filter = line.filter.as_ref().and_then(|v| v.to_galileo_expr());
-    let dasharray = line.paint.line_dasharray.clone();
+    let dasharray = line
+        .paint
+        .line_dasharray
+        .as_ref()
+        .and_then(|v| get_galileo_value(v).map(|v| v.into()));
 
     Some(StyleRule {
         layer_name: Some(source_layer),

galileo-maplibre/src/style/color.rs

@@ -24,7 +24,7 @@ impl From<MlColor> for Color {
     }
 }
 
-impl<T> From<MlColor> for ExprValue<T> {
+impl From<MlColor> for ExprValue<'_> {
     fn from(value: MlColor) -> Self {
         Self::Color(value.0)
     }

galileo-maplibre/src/style/expression.rs

@@ -806,14 +806,14 @@ impl MlExpr {
             })
         }
 
-        fn literal(v: &Value) -> Option<ExprValue<String>> {
+        fn literal(v: &Value) -> Option<ExprValue<'static>> {
             match v {
                 Value::Bool(v) => Some(ExprValue::Boolean(*v)),
                 Value::Number(v) => Some(ExprValue::Number(v.as_f64()?)),
                 Value::String(v) => Some(
                     parse_css_color(v)
                         .map(ExprValue::from)
-                        .unwrap_or_else(|| ExprValue::String(v.clone())),
+                        .unwrap_or_else(|| ExprValue::String(v.clone().into())),
                 ),
                 Value::Null => Some(ExprValue::Null),
                 _ => None,

galileo-maplibre/src/style/layer/line.rs

@@ -48,7 +48,7 @@ pub struct LinePaint {
 
     /// Dash pattern for the line. Supports expressions.
     #[serde(rename = "line-dasharray", skip_serializing_if = "Option::is_none")]
-    pub line_dasharray: Option<Vec<f32>>,
+    pub line_dasharray: Option<MlStyleValue<Vec<f64>>>,
 
     /// Gap width for a casing effect. Supports expressions.
     #[serde(rename = "line-gap-width", skip_serializing_if = "Option::is_none")]

galileo/src/expr/interpolation.rs

@@ -17,7 +17,7 @@ pub trait Interpolation {
     fn control_points(&self) -> &[ControlPoint];
     fn interpolate_num(&self, t: f64, x1: f64, out1: f64, x2: f64, out2: f64) -> f64;
 
-    fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<&'a str> {
+    fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<'static> {
         let Some(input) = self.input().eval(f, v).as_number() else {
             return ExprValue::Null;
         };
@@ -36,8 +36,8 @@ pub trait Interpolation {
 
         match (lower, upper) {
             (None, None) => ExprValue::Null,
-            (Some(lower), None) => lower.1.eval(f, v),
-            (None, Some(upper)) => upper.1.eval(f, v),
+            (Some(lower), None) => lower.1.eval(f, v).owned(),
+            (None, Some(upper)) => upper.1.eval(f, v).owned(),
             (Some(lower), Some(upper)) => self.interpolate(
                 *input,
                 **lower.0,
@@ -66,21 +66,25 @@ pub trait Interpolation {
         Some(evaluated)
     }
 
-    fn interpolate<T>(
+    fn interpolate(
         &self,
         t: f64,
         x1: f64,
-        out1: ExprValue<T>,
+        out1: ExprValue<'_>,
         x2: f64,
-        out2: ExprValue<T>,
-    ) -> ExprValue<T> {
+        out2: ExprValue<'_>,
+    ) -> ExprValue<'static> {
         match (out1, out2) {
             (ExprValue::Number(out1), ExprValue::Number(out2)) => {
                 self.interpolate_num(t, x1, out1, x2, out2).into()
             }
             (ExprValue::Color(out1), ExprValue::Color(out2)) => {
                 self.interpolate_color(t, x1, out1, x2, out2).into()
             }
+            (ExprValue::NumArray(out1), ExprValue::NumArray(out2)) => self
+                .interpolate_num_array(t, x1, &out1, x2, &out2)
+                .map(|v| v.into())
+                .unwrap_or(ExprValue::Null),
             _ => ExprValue::Null,
         }
     }
@@ -93,6 +97,26 @@ pub trait Interpolation {
 
         Color::rgba(r, g, b, a)
     }
+
+    fn interpolate_num_array(
+        &self,
+        t: f64,
+        x1: f64,
+        out1: &[f64],
+        x2: f64,
+        out2: &[f64],
+    ) -> Option<Vec<f64>> {
+        if out1.is_empty() || out1.len() != out2.len() {
+            return None;
+        }
+
+        let mut result = vec![0.0; out1.len()];
+        for i in 0..out1.len() {
+            result[i] = self.interpolate_num(t, x1, out1[i], x2, out2[i]);
+        }
+
+        Some(result)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]

galileo/src/expr/match_expr.rs

@@ -11,12 +11,12 @@ pub struct MatchExpr {
 
 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct MatchCase {
-    pub in_values: Vec<ExprValue<String>>,
+    pub in_values: Vec<ExprValue<'static>>,
     pub out: Expr,
 }
 
 impl MatchExpr {
-    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<&'a str> {
+    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<'a> {
         let input = self.input.eval(f, v);
         let fallback = self.fallback.eval(f, v);
         if input.is_null() {

galileo/src/expr/mod.rs

@@ -1,5 +1,6 @@
 #![allow(missing_docs)] //TODO: temporary allow
 
+use std::borrow::Cow;
 use std::marker::PhantomData;
 
 use itertools::Itertools;
@@ -50,7 +51,7 @@ pub enum Expr {
     WithOpacity(WithOpacityExpr),
 
     #[serde(untagged)]
-    Literal(ExprValue<String>),
+    Value(ExprValue<'static>),
 }
 
 #[derive(Debug, Clone, PartialEq, Serialize)]
@@ -63,7 +64,7 @@ pub type BoolExpr = TypedExpr<bool>;
 
 impl<T> Default for TypedExpr<T> {
     fn default() -> Self {
-        Self(Expr::Literal(ExprValue::Null), PhantomData)
+        Self(Expr::Value(ExprValue::Null), PhantomData)
     }
 }
 
@@ -91,6 +92,15 @@ impl TypedExpr<bool> {
     }
 }
 
+impl TypedExpr<Vec<f64>> {
+    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> Option<Cow<'a, [f64]>> {
+        match self.0.eval(f, v) {
+            ExprValue::NumArray(arr) => Some(arr),
+            _ => None,
+        }
+    }
+}
+
 impl<Out> From<Expr> for TypedExpr<Out> {
     fn from(value: Expr) -> Self {
         Self::new(value)
@@ -99,37 +109,43 @@ impl<Out> From<Expr> for TypedExpr<Out> {
 
 impl From<Color> for TypedExpr<Color> {
     fn from(value: Color) -> Self {
-        Expr::Literal(value.into()).into()
+        Expr::Value(value.into()).into()
     }
 }
 
 impl From<f64> for TypedExpr<f64> {
     fn from(value: f64) -> Self {
-        Expr::Literal(value.into()).into()
+        Expr::Value(value.into()).into()
     }
 }
 
 impl From<Color> for Expr {
     fn from(value: Color) -> Self {
-        Expr::Literal(value.into())
+        Expr::Value(value.into())
     }
 }
 
 impl From<f64> for Expr {
     fn from(value: f64) -> Self {
-        Expr::Literal(value.into())
+        Expr::Value(value.into())
     }
 }
 
 impl From<String> for Expr {
     fn from(value: String) -> Self {
-        Expr::Literal(value.into())
+        Expr::Value(value.into())
     }
 }
 
 impl From<bool> for Expr {
     fn from(value: bool) -> Self {
-        Expr::Literal(value.into())
+        Expr::Value(value.into())
+    }
+}
+
+impl From<Vec<f64>> for Expr {
+    fn from(value: Vec<f64>) -> Self {
+        Expr::Value(value.into())
     }
 }
 
@@ -161,13 +177,13 @@ impl<'de, Out> Deserialize<'de> for TypedExpr<Out> {
 }
 
 pub trait ExprFeature {
-    fn property(&self, property_name: &str) -> ExprValue<&str>;
+    fn property(&self, property_name: &str) -> ExprValue<'_>;
     fn geom_type(&self) -> ExprGeometryType;
 }
 
 pub struct EmptyExprFeature;
 impl ExprFeature for EmptyExprFeature {
-    fn property(&self, _property_name: &str) -> ExprValue<&str> {
+    fn property(&self, _property_name: &str) -> ExprValue<'_> {
         ExprValue::Null
     }
 
@@ -183,9 +199,9 @@ pub struct ExprView {
 }
 
 impl Expr {
-    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<&'a str> {
+    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<'a> {
         match self {
-            Expr::Literal(x) => x.borrowed(),
+            Expr::Value(x) => x.borrowed(),
             Expr::All(exprs) => exprs.iter().all(|expr| expr.eval(f, v).to_bool()).into(),
             Expr::Any(exprs) => exprs.iter().any(|expr| expr.eval(f, v).to_bool()).into(),
             Expr::Not(expr) => (!expr.eval(f, v).to_bool()).into(),
@@ -218,9 +234,9 @@ impl Expr {
     }
 }
 
-impl From<ExprValue<String>> for Expr {
-    fn from(value: ExprValue<String>) -> Self {
-        Self::Literal(value)
+impl From<ExprValue<'static>> for Expr {
+    fn from(value: ExprValue<'static>) -> Self {
+        Self::Value(value)
     }
 }
 
@@ -231,7 +247,7 @@ pub struct WithOpacityExpr {
 }
 
 impl WithOpacityExpr {
-    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<&'a str> {
+    pub fn eval<'a>(&'a self, f: &'a impl ExprFeature, v: ExprView) -> ExprValue<'a> {
         let Some(color) = self.color.eval(f, v).as_color() else {
             return ExprValue::Null;
         };
@@ -258,7 +274,7 @@ mod tests {
             expr.0,
             Expr::Eq(
                 Box::new(Expr::Get("kind".to_string())),
-                Box::new(Expr::Literal(ExprValue::String("road".to_string()))),
+                Box::new(Expr::Value("road".to_string().into())),
             )
         );
     }
@@ -267,7 +283,7 @@ mod tests {
     fn deserialize_expr_from_num() {
         let json = "42";
         let expr: NumExpr = serde_json::from_str(json).unwrap();
-        assert_eq!(expr.0, Expr::Literal(ExprValue::Number(42.0)));
+        assert_eq!(expr.0, Expr::Value(ExprValue::Number(42.0)));
     }
 
     #[test]