Use serde-content instead of private serde types (#1062)

Author: devongovett

Cargo.lock

@@ -39,9 +39,10 @@ browserslist = ["browserslist-rs"]
 bundler = ["dashmap", "sourcemap", "rayon"]
 cli = ["atty", "clap", "serde_json", "browserslist", "jemallocator"]
 jsonschema = ["schemars", "serde", "parcel_selectors/jsonschema"]
-nodejs = ["dep:serde"]
+nodejs = ["dep:serde", "dep:serde-content"]
 serde = [
   "dep:serde",
+  "dep:serde-content",
   "bitflags/serde",
   "smallvec/serde",
   "cssparser/serde",
@@ -59,7 +60,8 @@ into_owned = [
 substitute_variables = ["visitor", "into_owned"]
 
 [dependencies]
-serde = { version = "1.0.201", features = ["derive"], optional = true }
+serde = { version = "1.0.228", features = ["derive"], optional = true }
+serde-content = { version = "0.1.2", features = ["serde"], optional = true }
 cssparser = "0.33.0"
 cssparser-color = "0.1.0"
 parcel_selectors = { version = "0.28.2", path = "./selectors" }

Cargo.toml

@@ -14,6 +14,7 @@ bundler = ["dep:crossbeam-channel", "dep:rayon"]
 
 [dependencies]
 serde = { version = "1.0.201", features = ["derive"] }
+serde-content = { version = "0.1.2", features = ["serde"] }
 serde_bytes = "0.11.5"
 cssparser = "0.33.0"
 lightningcss = { version = "1.0.0-alpha.66", path = "../", features = [

napi/Cargo.toml

@@ -755,9 +755,8 @@ impl<'de, V: serde::Deserialize<'de>, const IS_VEC: bool> serde::Deserialize<'de
     D: serde::Deserializer<'de>,
   {
     use serde::Deserializer;
-    let content = serde::__private::de::Content::deserialize(deserializer)?;
-    let de: serde::__private::de::ContentRefDeserializer<D::Error> =
-      serde::__private::de::ContentRefDeserializer::new(&content);
+    let content = serde_content::Value::deserialize(deserializer)?;
+    let de = serde_content::Deserializer::new(content.clone()).coerce_numbers();
 
     // Try to deserialize as a sequence first.
     let mut was_seq = false;
@@ -769,13 +768,15 @@ impl<'de, V: serde::Deserialize<'de>, const IS_VEC: bool> serde::Deserialize<'de
     if was_seq {
       // Allow fallback if we know the value is also a list (e.g. selector).
       if res.is_ok() || !IS_VEC {
-        return res.map(ValueOrVec::Vec);
+        return res.map_err(|e| serde::de::Error::custom(e.to_string())).map(ValueOrVec::Vec);
       }
     }
 
     // If it wasn't a sequence, try a value.
-    let de = serde::__private::de::ContentRefDeserializer::new(&content);
-    return V::deserialize(de).map(ValueOrVec::Value);
+    let de = serde_content::Deserializer::new(content).coerce_numbers();
+    return V::deserialize(de)
+      .map_err(|e| serde::de::Error::custom(e.to_string()))
+      .map(ValueOrVec::Value);
 
     struct SeqVisitor<'a, V> {
       was_seq: &'a mut bool,
@@ -811,25 +812,25 @@ impl<'i, 'de: 'i> serde::Deserialize<'de> for TokensOrRaw<'i> {
   where
     D: serde::Deserializer<'de>,
   {
-    use serde::__private::de::ContentRefDeserializer;
-
     #[derive(serde::Deserialize)]
     struct Raw<'i> {
       #[serde(borrow)]
       raw: CowArcStr<'i>,
     }
 
-    let content = serde::__private::de::Content::deserialize(deserializer)?;
-    let de: ContentRefDeserializer<D::Error> = ContentRefDeserializer::new(&content);
+    let content = serde_content::Value::deserialize(deserializer)?;
+    let de = serde_content::Deserializer::new(content.clone()).coerce_numbers();
 
     if let Ok(res) = Raw::deserialize(de) {
       let res = TokenList::parse_string_with_options(res.raw.as_ref(), ParserOptions::default())
         .map_err(|_| serde::de::Error::custom("Could not parse value"))?;
       return Ok(TokensOrRaw(ValueOrVec::Vec(res.into_owned().0)));
     }
 
-    let de = ContentRefDeserializer::new(&content);
-    Ok(TokensOrRaw(ValueOrVec::deserialize(de)?))
+    let de = serde_content::Deserializer::new(content).coerce_numbers();
+    Ok(TokensOrRaw(
+      ValueOrVec::deserialize(de).map_err(|e| serde::de::Error::custom(e.to_string()))?,
+    ))
   }
 }
 

napi/src/transformer.rs

@@ -989,7 +989,7 @@ macro_rules! define_properties {
         D: serde::Deserializer<'de>,
       {
         enum ContentOrRaw<'de> {
-          Content(serde::__private::de::Content<'de>),
+          Content(serde_content::Value<'de>),
           Raw(CowArcStr<'de>)
         }
 
@@ -1062,26 +1062,26 @@ macro_rules! define_properties {
           ContentOrRaw::Content(content) => content
         };
 
-        let deserializer = serde::__private::de::ContentDeserializer::new(content);
+        let deserializer = serde_content::Deserializer::new(content).coerce_numbers();
         match partial.property_id {
           $(
             $(#[$meta])*
             PropertyId::$property$((vp_name!($vp, prefix)))? => {
-              let value = <$type>::deserialize(deserializer)?;
+              let value = <$type>::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
               Ok(Property::$property(value $(, vp_name!($vp, prefix))?))
             },
           )+
           PropertyId::Custom(name) => {
             if name.as_ref() == "unparsed" {
-              let value = UnparsedProperty::deserialize(deserializer)?;
+              let value = UnparsedProperty::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
               Ok(Property::Unparsed(value))
             } else {
-              let value = CustomProperty::deserialize(deserializer)?;
+              let value = CustomProperty::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
               Ok(Property::Custom(value))
             }
           }
           PropertyId::All => {
-            let value = CSSWideKeyword::deserialize(deserializer)?;
+            let value = CSSWideKeyword::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
             Ok(Property::All(value))
           }
         }

src/properties/mod.rs

@@ -209,7 +209,7 @@ impl<'i, 'de: 'i, R: serde::Deserialize<'de>> serde::Deserialize<'de> for CssRul
 
     struct PartialRule<'de> {
       rule_type: CowArcStr<'de>,
-      content: serde::__private::de::Content<'de>,
+      content: serde_content::Value<'de>,
     }
 
     struct CssRuleVisitor;
@@ -226,7 +226,7 @@ impl<'i, 'de: 'i, R: serde::Deserialize<'de>> serde::Deserialize<'de> for CssRul
         A: serde::de::MapAccess<'de>,
       {
         let mut rule_type: Option<CowArcStr<'de>> = None;
-        let mut value: Option<serde::__private::de::Content> = None;
+        let mut value: Option<serde_content::Value> = None;
         while let Some(key) = map.next_key()? {
           match key {
             Field::Type => {
@@ -245,108 +245,122 @@ impl<'i, 'de: 'i, R: serde::Deserialize<'de>> serde::Deserialize<'de> for CssRul
     }
 
     let partial = deserializer.deserialize_map(CssRuleVisitor)?;
-    let deserializer = serde::__private::de::ContentDeserializer::new(partial.content);
+    let deserializer = serde_content::Deserializer::new(partial.content).coerce_numbers();
 
     match partial.rule_type.as_ref() {
       "media" => {
-        let rule = MediaRule::deserialize(deserializer)?;
+        let rule = MediaRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Media(rule))
       }
       "import" => {
-        let rule = ImportRule::deserialize(deserializer)?;
+        let rule = ImportRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Import(rule))
       }
       "style" => {
-        let rule = StyleRule::deserialize(deserializer)?;
+        let rule = StyleRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Style(rule))
       }
       "keyframes" => {
-        let rule = KeyframesRule::deserialize(deserializer)?;
+        let rule =
+          KeyframesRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Keyframes(rule))
       }
       "font-face" => {
-        let rule = FontFaceRule::deserialize(deserializer)?;
+        let rule = FontFaceRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::FontFace(rule))
       }
       "font-palette-values" => {
-        let rule = FontPaletteValuesRule::deserialize(deserializer)?;
+        let rule =
+          FontPaletteValuesRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::FontPaletteValues(rule))
       }
       "font-feature-values" => {
-        let rule = FontFeatureValuesRule::deserialize(deserializer)?;
+        let rule =
+          FontFeatureValuesRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::FontFeatureValues(rule))
       }
       "page" => {
-        let rule = PageRule::deserialize(deserializer)?;
+        let rule = PageRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Page(rule))
       }
       "supports" => {
-        let rule = SupportsRule::deserialize(deserializer)?;
+        let rule = SupportsRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Supports(rule))
       }
       "counter-style" => {
-        let rule = CounterStyleRule::deserialize(deserializer)?;
+        let rule =
+          CounterStyleRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::CounterStyle(rule))
       }
       "namespace" => {
-        let rule = NamespaceRule::deserialize(deserializer)?;
+        let rule =
+          NamespaceRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Namespace(rule))
       }
       "moz-document" => {
-        let rule = MozDocumentRule::deserialize(deserializer)?;
+        let rule =
+          MozDocumentRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::MozDocument(rule))
       }
       "nesting" => {
-        let rule = NestingRule::deserialize(deserializer)?;
+        let rule = NestingRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Nesting(rule))
       }
       "nested-declarations" => {
-        let rule = NestedDeclarationsRule::deserialize(deserializer)?;
+        let rule = NestedDeclarationsRule::deserialize(deserializer)
+          .map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::NestedDeclarations(rule))
       }
       "viewport" => {
-        let rule = ViewportRule::deserialize(deserializer)?;
+        let rule = ViewportRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Viewport(rule))
       }
       "custom-media" => {
-        let rule = CustomMediaRule::deserialize(deserializer)?;
+        let rule =
+          CustomMediaRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::CustomMedia(rule))
       }
       "layer-statement" => {
-        let rule = LayerStatementRule::deserialize(deserializer)?;
+        let rule =
+          LayerStatementRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::LayerStatement(rule))
       }
       "layer-block" => {
-        let rule = LayerBlockRule::deserialize(deserializer)?;
+        let rule =
+          LayerBlockRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::LayerBlock(rule))
       }
       "property" => {
-        let rule = PropertyRule::deserialize(deserializer)?;
+        let rule = PropertyRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Property(rule))
       }
       "container" => {
-        let rule = ContainerRule::deserialize(deserializer)?;
+        let rule =
+          ContainerRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Container(rule))
       }
       "scope" => {
-        let rule = ScopeRule::deserialize(deserializer)?;
+        let rule = ScopeRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Scope(rule))
       }
       "starting-style" => {
-        let rule = StartingStyleRule::deserialize(deserializer)?;
+        let rule =
+          StartingStyleRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::StartingStyle(rule))
       }
       "view-transition" => {
-        let rule = ViewTransitionRule::deserialize(deserializer)?;
+        let rule =
+          ViewTransitionRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::ViewTransition(rule))
       }
       "ignored" => Ok(CssRule::Ignored),
       "unknown" => {
-        let rule = UnknownAtRule::deserialize(deserializer)?;
+        let rule =
+          UnknownAtRule::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Unknown(rule))
       }
       "custom" => {
-        let rule = R::deserialize(deserializer)?;
+        let rule = R::deserialize(deserializer).map_err(|e| serde::de::Error::custom(e.to_string()))?;
         Ok(CssRule::Custom(rule))
       }
       t => Err(serde::de::Error::unknown_variant(t, &[])),