props: move property serde impls to their own mod

crates/bevy_property/bevy_property_derive/src/lib.rs

@@ -203,7 +203,7 @@ pub fn derive_properties(input: TokenStream) -> TokenStream {
             }
 
             fn serializable(&self) -> #bevy_property_path::Serializable {
-                #bevy_property_path::Serializable::Owned(Box::new(#bevy_property_path::MapSerializer::new(self)))
+                #bevy_property_path::Serializable::Owned(Box::new(#bevy_property_path::property_serde::MapSerializer::new(self)))
             }
         }
     })

crates/bevy_property/src/dynamic_properties.rs

@@ -1,14 +1,5 @@
-use crate::{
-    Properties, PropertiesType, Property, PropertyIter,
-    PropertyTypeRegistry, Serializable,
-};
-use de::SeqAccess;
-use serde::{
-    de::{self, DeserializeSeed, MapAccess, Visitor},
-    ser::{SerializeMap, SerializeSeq},
-    Serialize,
-};
-use std::{any::Any, borrow::Cow, cell::RefCell, collections::HashMap, rc::Rc};
+use crate::{Properties, PropertiesType, Property, PropertyIter, Serializable};
+use std::{any::Any, borrow::Cow, collections::HashMap};
 
 pub struct DynamicProperties {
     pub type_name: String,
@@ -188,372 +179,3 @@ impl Property for DynamicProperties {
         Serializable::Borrowed(self)
     }
 }
-
-impl Serialize for DynamicProperties {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self.properties_type {
-            PropertiesType::Map => MapSerializer::new(self).serialize(serializer),
-            PropertiesType::Seq => SeqSerializer::new(self).serialize(serializer),
-        }
-    }
-}
-
-pub struct MapSerializer<'a> {
-    pub properties: &'a dyn Properties,
-}
-
-impl<'a> MapSerializer<'a> {
-    pub fn new(properties: &'a dyn Properties) -> Self {
-        MapSerializer { properties }
-    }
-}
-
-impl<'a> Serialize for MapSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_map(Some(self.properties.prop_len()))?;
-        state.serialize_entry("type", self.properties.type_name())?;
-        for (index, property) in self.properties.iter_props().enumerate() {
-            let name = self.properties.prop_name(index).unwrap();
-            if property.is_sequence() {
-                state.serialize_entry(name, &SeqSerializer { property })?;
-            } else {
-                state.serialize_entry(name, property.serializable().borrow())?;
-            }
-        }
-        state.end()
-    }
-}
-
-pub struct SeqSerializer<'a> {
-    pub property: &'a dyn Property,
-}
-
-impl<'a> SeqSerializer<'a> {
-    pub fn new(property: &'a dyn Property) -> Self {
-        SeqSerializer { property }
-    }
-}
-
-impl<'a> Serialize for SeqSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_map(Some(2))?;
-        if let Some(properties) = self.property.as_properties() {
-            state.serialize_entry("seq_type", self.property.type_name())?;
-            state.serialize_entry("data", &PropertiesSeqSerializer { properties })?;
-        } else {
-            state.serialize_entry("seq_value_type", self.property.type_name())?;
-            state.serialize_entry("data", self.property.serializable().borrow())?;
-        }
-        state.end()
-    }
-}
-
-pub struct PropertiesSeqSerializer<'a> {
-    pub properties: &'a dyn Properties,
-}
-
-impl<'a> Serialize for PropertiesSeqSerializer<'a> {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        let mut state = serializer.serialize_seq(Some(self.properties.prop_len()))?;
-        for prop in self.properties.iter_props() {
-            state.serialize_element(prop.serializable().borrow())?;
-        }
-        state.end()
-    }
-}
-
-pub struct DynamicPropertiesDeserializer<'a> {
-    pub registry: &'a PropertyTypeRegistry,
-    pub current_type_name: Rc<RefCell<Option<String>>>,
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for DynamicPropertiesDeserializer<'a> {
-    type Value = DynamicProperties;
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_map(DynamicPropertyMapVisiter {
-            registry: self.registry,
-            current_type_name: self.current_type_name,
-        })
-    }
-}
-
-pub struct DynamicPropertyMapVisiter<'a> {
-    registry: &'a PropertyTypeRegistry,
-    current_type_name: Rc<RefCell<Option<String>>>,
-}
-
-impl<'a, 'de> Visitor<'de> for DynamicPropertyMapVisiter<'a> {
-    type Value = DynamicProperties;
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("properties map")
-    }
-
-    fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
-    where
-        V: MapAccess<'de>,
-    {
-        visit_map(map, self.registry, self.current_type_name)
-    }
-}
-pub struct PropertyDeserializer<'a> {
-    pub registry: &'a PropertyTypeRegistry,
-    pub current_type_name: Rc<RefCell<Option<String>>>,
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for PropertyDeserializer<'a> {
-    type Value = Box<dyn Property>;
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_any(AnyPropVisiter {
-            property_type_registry: self.registry,
-            current_type_name: self.current_type_name,
-        })
-    }
-}
-
-pub struct PropSeqDeserializer<'a> {
-    registry: &'a PropertyTypeRegistry,
-    current_type_name: Rc<RefCell<Option<String>>>,
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for PropSeqDeserializer<'a> {
-    type Value = DynamicProperties;
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_seq(PropSeqVisiter {
-            registry: self.registry,
-            current_type_name: self.current_type_name.clone(),
-        })
-    }
-}
-
-pub struct PropSeqVisiter<'a> {
-    registry: &'a PropertyTypeRegistry,
-    current_type_name: Rc<RefCell<Option<String>>>,
-}
-
-impl<'a, 'de> Visitor<'de> for PropSeqVisiter<'a> {
-    type Value = DynamicProperties;
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("property value")
-    }
-
-    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
-    where
-        V: SeqAccess<'de>,
-    {
-        let mut dynamic_properties = DynamicProperties::seq();
-        while let Some(prop) = seq.next_element_seed(PropertyDeserializer {
-            registry: self.registry,
-            current_type_name: self.current_type_name.clone(),
-        })? {
-            dynamic_properties.push(prop, None);
-        }
-        Ok(dynamic_properties)
-    }
-}
-
-pub struct MapValueDeserializer<'a> {
-    registry: &'a PropertyTypeRegistry,
-    current_type_name: Rc<RefCell<Option<String>>>,
-}
-
-impl<'a, 'de> DeserializeSeed<'de> for MapValueDeserializer<'a> {
-    type Value = Box<dyn Property>;
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        if self.current_type_name.borrow().is_some() {
-            let registration = {
-                let current_type_name = self.current_type_name.borrow();
-                let type_name = current_type_name.as_ref().unwrap();
-                self.registry
-                    .get_short(type_name)
-                    .ok_or_else(|| {
-                        de::Error::custom(format!("TypeRegistration is missing for {}", type_name))
-                    })?
-            };
-            let mut erased = erased_serde::Deserializer::erase(deserializer);
-            (registration.deserialize)(&mut erased, self.registry)
-                .map_err(<<D as serde::Deserializer<'de>>::Error as serde::de::Error>::custom)
-        } else {
-            deserializer.deserialize_any(AnyPropVisiter {
-                property_type_registry: self.registry,
-                current_type_name: self.current_type_name,
-            })
-        }
-    }
-}
-
-struct AnyPropVisiter<'a> {
-    property_type_registry: &'a PropertyTypeRegistry,
-    current_type_name: Rc<RefCell<Option<String>>>,
-}
-
-impl<'a, 'de> Visitor<'de> for AnyPropVisiter<'a> {
-    type Value = Box<dyn Property>;
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
-        formatter.write_str("property value")
-    }
-
-    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v))
-    }
-
-    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
-    where
-        E: de::Error,
-    {
-        Ok(Box::new(v.to_string()))
-    }
-
-    fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
-    where
-        V: MapAccess<'de>,
-    {
-        Ok(Box::new(visit_map(map, self.property_type_registry, self.current_type_name)?))
-    }
-}
-
-fn visit_map<'a, 'de, V>(
-    mut map: V,
-    property_type_registry: &'a PropertyTypeRegistry,
-    current_type_name: Rc<RefCell<Option<String>>>,
-) -> Result<DynamicProperties, V::Error>
-where
-    V: MapAccess<'de>,
-{
-    let mut dynamic_properties = DynamicProperties::map();
-    let mut type_name: Option<String> = None;
-    let mut is_seq = false;
-    // TODO: support seq_value_type
-    while let Some(key) = map.next_key::<String>()? {
-        if key == "type" {
-            type_name = Some(map.next_value()?);
-        } else if key == "seq_type" {
-            type_name = Some(map.next_value()?);
-            is_seq = true;
-        } else if is_seq {
-            if key != "data" {
-                return Err(de::Error::custom(
-                    "seq_type must be immediately followed by a data field",
-                ));
-            }
-            dynamic_properties = map.next_value_seed(PropSeqDeserializer {
-                registry: property_type_registry,
-                current_type_name: current_type_name.clone(),
-            })?;
-            break;
-        } else {
-            let prop = map.next_value_seed(MapValueDeserializer {
-                registry: property_type_registry,
-                current_type_name: current_type_name.clone(),
-            })?;
-            dynamic_properties.set_box(&key, prop);
-        }
-    }
-
-    let type_name = type_name.ok_or_else(|| de::Error::missing_field("type"))?;
-    dynamic_properties.type_name = type_name.to_string();
-    Ok(dynamic_properties)
-}

crates/bevy_property/src/impl_property_std.rs

@@ -1,4 +1,4 @@
-use crate::{impl_property, Properties, PropertiesType, Property, PropertyIter, SeqSerializer, Serializable};
+use crate::{impl_property, Properties, PropertiesType, Property, PropertyIter, Serializable, property_serde::SeqSerializer};
 use serde::{Serialize, Deserialize};
 use std::{
     any::Any,

crates/bevy_property/src/lib.rs

@@ -7,6 +7,7 @@ mod impl_property_smallvec;
 mod impl_property_glam;
 mod impl_property_legion;
 pub mod ron;
+pub mod property_serde;
 
 pub use property::*;
 pub use properties::*;

crates/bevy_property/src/property_serde.rs

@@ -0,0 +1,380 @@
+use crate::{DynamicProperties, Properties, PropertiesType, Property, PropertyTypeRegistry};
+use de::SeqAccess;
+use serde::{
+    de::{self, DeserializeSeed, MapAccess, Visitor},
+    ser::{SerializeMap, SerializeSeq},
+    Serialize,
+};
+use std::{cell::RefCell, rc::Rc};
+
+impl Serialize for DynamicProperties {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self.properties_type {
+            PropertiesType::Map => MapSerializer::new(self).serialize(serializer),
+            PropertiesType::Seq => SeqSerializer::new(self).serialize(serializer),
+        }
+    }
+}
+
+pub struct DynamicPropertiesDeserializer<'a> {
+    pub registry: &'a PropertyTypeRegistry,
+    pub current_type_name: Rc<RefCell<Option<String>>>,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for DynamicPropertiesDeserializer<'a> {
+    type Value = DynamicProperties;
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(DynamicPropertyMapVisiter {
+            registry: self.registry,
+            current_type_name: self.current_type_name,
+        })
+    }
+}
+
+pub struct DynamicPropertyMapVisiter<'a> {
+    registry: &'a PropertyTypeRegistry,
+    current_type_name: Rc<RefCell<Option<String>>>,
+}
+
+impl<'a, 'de> Visitor<'de> for DynamicPropertyMapVisiter<'a> {
+    type Value = DynamicProperties;
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("properties map")
+    }
+
+    fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
+    where
+        V: MapAccess<'de>,
+    {
+        visit_map(map, self.registry, self.current_type_name)
+    }
+}
+
+pub struct MapSerializer<'a> {
+    pub properties: &'a dyn Properties,
+}
+
+impl<'a> MapSerializer<'a> {
+    pub fn new(properties: &'a dyn Properties) -> Self {
+        MapSerializer { properties }
+    }
+}
+
+impl<'a> Serialize for MapSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(self.properties.prop_len()))?;
+        state.serialize_entry("type", self.properties.type_name())?;
+        for (index, property) in self.properties.iter_props().enumerate() {
+            let name = self.properties.prop_name(index).unwrap();
+            if property.is_sequence() {
+                state.serialize_entry(name, &SeqSerializer { property })?;
+            } else {
+                state.serialize_entry(name, property.serializable().borrow())?;
+            }
+        }
+        state.end()
+    }
+}
+
+pub struct SeqSerializer<'a> {
+    pub property: &'a dyn Property,
+}
+
+impl<'a> SeqSerializer<'a> {
+    pub fn new(property: &'a dyn Property) -> Self {
+        SeqSerializer { property }
+    }
+}
+
+impl<'a> Serialize for SeqSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_map(Some(2))?;
+        if let Some(properties) = self.property.as_properties() {
+            state.serialize_entry("seq_type", self.property.type_name())?;
+            state.serialize_entry("data", &PropertiesSeqSerializer { properties })?;
+        } else {
+            state.serialize_entry("seq_value_type", self.property.type_name())?;
+            state.serialize_entry("data", self.property.serializable().borrow())?;
+        }
+        state.end()
+    }
+}
+
+pub struct PropertiesSeqSerializer<'a> {
+    pub properties: &'a dyn Properties,
+}
+
+impl<'a> Serialize for PropertiesSeqSerializer<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut state = serializer.serialize_seq(Some(self.properties.prop_len()))?;
+        for prop in self.properties.iter_props() {
+            state.serialize_element(prop.serializable().borrow())?;
+        }
+        state.end()
+    }
+}
+
+pub struct PropertyDeserializer<'a> {
+    pub registry: &'a PropertyTypeRegistry,
+    pub current_type_name: Rc<RefCell<Option<String>>>,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for PropertyDeserializer<'a> {
+    type Value = Box<dyn Property>;
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_any(AnyPropVisiter {
+            property_type_registry: self.registry,
+            current_type_name: self.current_type_name,
+        })
+    }
+}
+
+pub struct PropSeqDeserializer<'a> {
+    registry: &'a PropertyTypeRegistry,
+    current_type_name: Rc<RefCell<Option<String>>>,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for PropSeqDeserializer<'a> {
+    type Value = DynamicProperties;
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_seq(PropSeqVisiter {
+            registry: self.registry,
+            current_type_name: self.current_type_name.clone(),
+        })
+    }
+}
+
+pub struct PropSeqVisiter<'a> {
+    registry: &'a PropertyTypeRegistry,
+    current_type_name: Rc<RefCell<Option<String>>>,
+}
+
+impl<'a, 'de> Visitor<'de> for PropSeqVisiter<'a> {
+    type Value = DynamicProperties;
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("property value")
+    }
+
+    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let mut dynamic_properties = DynamicProperties::seq();
+        while let Some(prop) = seq.next_element_seed(PropertyDeserializer {
+            registry: self.registry,
+            current_type_name: self.current_type_name.clone(),
+        })? {
+            dynamic_properties.push(prop, None);
+        }
+        Ok(dynamic_properties)
+    }
+}
+
+pub struct MapValueDeserializer<'a> {
+    registry: &'a PropertyTypeRegistry,
+    current_type_name: Rc<RefCell<Option<String>>>,
+}
+
+impl<'a, 'de> DeserializeSeed<'de> for MapValueDeserializer<'a> {
+    type Value = Box<dyn Property>;
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        if self.current_type_name.borrow().is_some() {
+            let registration = {
+                let current_type_name = self.current_type_name.borrow();
+                let type_name = current_type_name.as_ref().unwrap();
+                self.registry.get_short(type_name).ok_or_else(|| {
+                    de::Error::custom(format!("TypeRegistration is missing for {}", type_name))
+                })?
+            };
+            let mut erased = erased_serde::Deserializer::erase(deserializer);
+            (registration.deserialize)(&mut erased, self.registry)
+                .map_err(<<D as serde::Deserializer<'de>>::Error as serde::de::Error>::custom)
+        } else {
+            deserializer.deserialize_any(AnyPropVisiter {
+                property_type_registry: self.registry,
+                current_type_name: self.current_type_name,
+            })
+        }
+    }
+}
+
+struct AnyPropVisiter<'a> {
+    property_type_registry: &'a PropertyTypeRegistry,
+    current_type_name: Rc<RefCell<Option<String>>>,
+}
+
+impl<'a, 'de> Visitor<'de> for AnyPropVisiter<'a> {
+    type Value = Box<dyn Property>;
+    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        formatter.write_str("property value")
+    }
+
+    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v))
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: de::Error,
+    {
+        Ok(Box::new(v.to_string()))
+    }
+
+    fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
+    where
+        V: MapAccess<'de>,
+    {
+        Ok(Box::new(visit_map(
+            map,
+            self.property_type_registry,
+            self.current_type_name,
+        )?))
+    }
+}
+
+fn visit_map<'a, 'de, V>(
+    mut map: V,
+    property_type_registry: &'a PropertyTypeRegistry,
+    current_type_name: Rc<RefCell<Option<String>>>,
+) -> Result<DynamicProperties, V::Error>
+where
+    V: MapAccess<'de>,
+{
+    let mut dynamic_properties = DynamicProperties::map();
+    let mut type_name: Option<String> = None;
+    let mut is_seq = false;
+    // TODO: support seq_value_type
+    while let Some(key) = map.next_key::<String>()? {
+        if key == "type" {
+            type_name = Some(map.next_value()?);
+        } else if key == "seq_type" {
+            type_name = Some(map.next_value()?);
+            is_seq = true;
+        } else if is_seq {
+            if key != "data" {
+                return Err(de::Error::custom(
+                    "seq_type must be immediately followed by a data field",
+                ));
+            }
+            dynamic_properties = map.next_value_seed(PropSeqDeserializer {
+                registry: property_type_registry,
+                current_type_name: current_type_name.clone(),
+            })?;
+            break;
+        } else {
+            let prop = map.next_value_seed(MapValueDeserializer {
+                registry: property_type_registry,
+                current_type_name: current_type_name.clone(),
+            })?;
+            dynamic_properties.set_box(&key, prop);
+        }
+    }
+
+    let type_name = type_name.ok_or_else(|| de::Error::missing_field("type"))?;
+    dynamic_properties.type_name = type_name.to_string();
+    Ok(dynamic_properties)
+}

crates/bevy_property/src/ron.rs

@@ -1,9 +1,14 @@
+use crate::{
+    property_serde::DynamicPropertiesDeserializer, DynamicProperties, PropertyTypeRegistry,
+};
 use ron::de::Deserializer;
-use std::{cell::RefCell, rc::Rc};
-use crate::{DynamicPropertiesDeserializer, PropertyTypeRegistry, DynamicProperties};
 use serde::de::DeserializeSeed;
+use std::{cell::RefCell, rc::Rc};
 
-pub fn deserialize_dynamic_properties(ron_string: &str, property_type_registry: &PropertyTypeRegistry) -> Result<DynamicProperties, ron::Error> {
+pub fn deserialize_dynamic_properties(
+    ron_string: &str,
+    property_type_registry: &PropertyTypeRegistry,
+) -> Result<DynamicProperties, ron::Error> {
     let mut deserializer = Deserializer::from_str(&ron_string).unwrap();
     let last_type_name = Rc::new(RefCell::new(None));
     let mut callback = |ident: &Option<&[u8]>| {
@@ -16,4 +21,4 @@ pub fn deserialize_dynamic_properties(ron_string: &str, property_type_registry:
         registry: &property_type_registry,
     };
     dynamic_properties_deserializer.deserialize(&mut deserializer)
-}
+}

crates/bevy_scene/src/serde.rs

@@ -1,6 +1,6 @@
 use crate::{Entity, Scene};
 use anyhow::Result;
-use bevy_property::{DynamicProperties, DynamicPropertiesDeserializer, PropertyTypeRegistry};
+use bevy_property::{DynamicProperties, PropertyTypeRegistry, property_serde::DynamicPropertiesDeserializer};
 use serde::{
     de::{DeserializeSeed, Error, MapAccess, SeqAccess, Visitor},
     Deserialize, Serialize,