Implement new mutations with native core (#630)

* work on seperating tree struture from realdom * intial update to new mutations * handle height * update to taffy 0.2 * add as_varient functions to OwnedAttributeValue * make get node parent mut optionally return a parent * work on upward pass * add more code for parrellel passes * make resolve passes public * more work on parallel passes * fix deadlock and add more tests * move height into the tree instead of the realdom * make passes exicute in parallel instead of executing invidual passes in parellel * fix some warnings * add up dependant test * clean up examples * work on intigrating state with passes * update to new mutations * work on implementing macro * make the macro compile * more progress on macro * mark cloned nodes as dirty * update persistant_iterator utility * fix mask generation * update tui with new mutations * more progress updating tui * some basic tui examples working * don't push template nodes onto the stack * update hover example * update benchmark * update more examples * fix root node layout * ignore out of bounds renders * update color picker example * update all events example * update remaining examples * update tests * tests passing * move persistant iterator test * update examples * fix gaps in layout * fix formatting * fix memory leak
2022-12-06 15:38:04 -08:00
1 parent b9aad5e8f4
commit 67a6fa9eb8
@@ -0,0 +1,119 @@
+use crate::{state::State, tree::NodeId};
+use dioxus_core::ElementId;
+use rustc_hash::{FxHashMap, FxHashSet};
+
+/// The node is stored client side and stores only basic data about the node.
+#[derive(Debug, Clone)]
+pub struct Node<S: State> {
+    /// The transformed state of the node.
+    pub state: S,
+    /// The raw data for the node
+    pub node_data: NodeData,
+}
+
+#[derive(Debug, Clone)]
+pub struct NodeData {
+    /// The id of the node
+    pub node_id: NodeId,
+    /// The id of the node in the vdom.
+    pub element_id: Option<ElementId>,
+    /// Additional inforation specific to the node type
+    pub node_type: NodeType,
+}
+
+/// A type of node with data specific to the node type. The types are a subset of the [VNode] types.
+#[derive(Debug, Clone)]
+pub enum NodeType {
+    Text {
+        text: String,
+    },
+    Element {
+        tag: String,
+        namespace: Option<String>,
+        attributes: FxHashMap<OwnedAttributeDiscription, OwnedAttributeValue>,
+        listeners: FxHashSet<String>,
+    },
+    Placeholder,
+}
+
+impl<S: State> Node<S> {
+    pub(crate) fn new(node_type: NodeType) -> Self {
+        Node {
+            state: S::default(),
+            node_data: NodeData {
+                element_id: None,
+                node_type,
+                node_id: NodeId(0),
+            },
+        }
+    }
+
+    /// get the mounted id of the node
+    pub fn mounted_id(&self) -> Option<ElementId> {
+        self.node_data.element_id
+    }
+}
+
+#[derive(Debug, Clone, Hash, PartialEq, Eq)]
+pub struct OwnedAttributeDiscription {
+    pub name: String,
+    pub namespace: Option<String>,
+    pub volatile: bool,
+}
+
+/// An attribute on a DOM node, such as `id="my-thing"` or
+/// `href="https://example.com"`.
+#[derive(Clone, Copy, Debug)]
+pub struct OwnedAttributeView<'a> {
+    /// The discription of the attribute.
+    pub attribute: &'a OwnedAttributeDiscription,
+
+    /// The value of the attribute.
+    pub value: &'a OwnedAttributeValue,
+}
+
+#[derive(Clone, Debug)]
+pub enum OwnedAttributeValue {
+    Text(String),
+    Float(f32),
+    Int(i32),
+    Bool(bool),
+    None,
+}
+
+impl OwnedAttributeValue {
+    pub fn as_text(&self) -> Option<&str> {
+        match self {
+            OwnedAttributeValue::Text(text) => Some(text),
+            _ => None,
+        }
+    }
+
+    pub fn as_float(&self) -> Option<f32> {
+        match self {
+            OwnedAttributeValue::Float(float) => Some(*float),
+            _ => None,
+        }
+    }
+
+    pub fn as_int(&self) -> Option<i32> {
+        match self {
+            OwnedAttributeValue::Int(int) => Some(*int),
+            _ => None,
+        }
+    }
+
+    pub fn as_bool(&self) -> Option<bool> {
+        match self {
+            OwnedAttributeValue::Bool(bool) => Some(*bool),
+            _ => None,
+        }
+    }
+
+    pub fn as_none(&self) -> Option<()> {
+        match self {
+            OwnedAttributeValue::None => Some(()),
+            _ => None,
+        }
+    }
+}