trait based event system

packages/html/src/events/form.rs

@@ -4,28 +4,176 @@ use dioxus_core::Event;
 
 pub type FormEvent = Event<FormData>;
 
-/* DOMEvent:  Send + SyncTarget relatedTarget */
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[derive(Clone)]
 pub struct FormData {
-    pub value: String,
+    inner: Box<dyn HasFormData>,
+}
 
-    pub values: HashMap<String, Vec<String>>,
+impl<E: HasFormData> From<E> for FormData {
+    fn from(e: E) -> Self {
+        Self { inner: Box::new(e) }
+    }
+}
 
-    #[cfg_attr(
-        feature = "serialize",
-        serde(
-            default,
-            skip_serializing,
-            deserialize_with = "deserialize_file_engine"
-        )
-    )]
-    pub files: Option<std::sync::Arc<dyn FileEngine>>,
+impl PartialEq for FormData {
+    fn eq(&self, other: &Self) -> bool {
+        self.value() == other.value() && self.values() == other.values()
+    }
+}
+
+impl Debug for FormData {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FormEvent")
+            .field("value", &self.value())
+            .field("values", &self.values())
+            .finish()
+    }
+}
+
+impl FormData {
+    /// Create a new form event
+    pub fn new(event: impl HasFormData + 'static) -> Self {
+        Self {
+            inner: Box::new(event),
+        }
+    }
+
+    /// Get the value of the form event
+    pub fn value(&self) -> String {
+        self.inner.value()
+    }
+
+    /// Get the values of the form event
+    pub fn values(&self) -> HashMap<String, Vec<String>> {
+        self.inner.values()
+    }
+
+    /// Get the files of the form event
+    pub fn files(&self) -> Option<std::sync::Arc<dyn FileEngine>> {
+        self.inner.files()
+    }
+
+    /// Downcast this event to a concrete event type
+    pub fn downcast<T: 'static>(&self) -> Option<&T> {
+        self.inner.as_any().downcast_ref::<T>()
+    }
+}
+
+/// An object that has all the data for a form event
+pub trait HasFormData: std::any::Any {
+    fn value(&self) -> String {
+        Default::default()
+    }
+
+    fn values(&self) -> HashMap<String, Vec<String>> {
+        Default::default()
+    }
+
+    fn files(&self) -> Option<std::sync::Arc<dyn FileEngine>> {
+        None
+    }
+
+    /// return self as Any
+    fn as_any(&self) -> &dyn std::any::Any;
 }
 
 #[cfg(feature = "serialize")]
+/// A serialized form data object
 #[derive(serde::Serialize, serde::Deserialize)]
-struct SerializedFileEngine {
+pub struct SerializedFormData {
+    value: String,
+    values: HashMap<String, Vec<String>>,
+    files: Option<std::sync::Arc<SerializedFileEngine>>,
+}
+
+#[cfg(feature = "serialize")]
+impl SerializedFormData {
+    /// Create a new serialized form data object
+    pub fn new(
+        value: String,
+        values: HashMap<String, Vec<String>>,
+        files: Option<std::sync::Arc<SerializedFileEngine>>,
+    ) -> Self {
+        Self {
+            value,
+            values,
+            files,
+        }
+    }
+
+    /// Create a new serialized form data object from a traditional form data object
+    pub async fn async_from(data: &FormData) -> Self {
+        Self {
+            value: data.value(),
+            values: data.values(),
+            files: match data.files() {
+                Some(files) => {
+                    let mut resolved_files = HashMap::new();
+
+                    for file in files.files() {
+                        let bytes = files.read_file(&file).await;
+                        resolved_files.insert(file, bytes.unwrap_or_default());
+                    }
+
+                    Some(std::sync::Arc::new(SerializedFileEngine {
+                        files: resolved_files,
+                    }))
+                }
+                None => None,
+            },
+        }
+    }
+
+    fn from_lossy(data: &FormData) -> Self {
+        Self {
+            value: data.value(),
+            values: data.values(),
+            files: None,
+        }
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl HasFormData for SerializedFormData {
+    fn value(&self) -> String {
+        self.value.clone()
+    }
+
+    fn values(&self) -> HashMap<String, Vec<String>> {
+        self.values.clone()
+    }
+
+    fn files(&self) -> Option<std::sync::Arc<dyn FileEngine>> {
+        self.files
+            .as_ref()
+            .map(|files| std::sync::Arc::clone(files) as std::sync::Arc<dyn FileEngine>)
+    }
+
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl serde::Serialize for FormData {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        SerializedFormData::from_lossy(self).serialize(serializer)
+    }
+}
+
+#[cfg(feature = "serialize")]
+impl<'de> serde::Deserialize<'de> for FormData {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let data = SerializedFormData::deserialize(deserializer)?;
+        Ok(Self {
+            inner: Box::new(data),
+        })
+    }
+}
+
+#[cfg(feature = "serialize")]
+/// A file engine that serializes files to bytes
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct SerializedFileEngine {
     files: HashMap<String, Vec<u8>>,
 }
 
@@ -53,38 +201,6 @@ impl FileEngine for SerializedFileEngine {
     }
 }
 
-#[cfg(feature = "serialize")]
-fn deserialize_file_engine<'de, D>(
-    deserializer: D,
-) -> Result<Option<std::sync::Arc<dyn FileEngine>>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    use serde::Deserialize;
-
-    let Ok(file_engine) = SerializedFileEngine::deserialize(deserializer) else {
-        return Ok(None);
-    };
-
-    let file_engine = std::sync::Arc::new(file_engine);
-    Ok(Some(file_engine))
-}
-
-impl PartialEq for FormData {
-    fn eq(&self, other: &Self) -> bool {
-        self.value == other.value && self.values == other.values
-    }
-}
-
-impl Debug for FormData {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("FormEvent")
-            .field("value", &self.value)
-            .field("values", &self.values)
-            .finish()
-    }
-}
-
 #[async_trait::async_trait(?Send)]
 pub trait FileEngine {
     // get a list of file names