Guess I should put this under version control LOL

lifecycle/src/rsx/virtual_node.rs

@@ -0,0 +1,59 @@
+//! Implements the `RSX::VirtualNode` struct, which is a bit of a recursive
+//! structure.
+
+use std::sync::Arc;
+use std::fmt::{Display, Debug};
+
+use alchemy_styles::node::Node;
+
+use crate::traits::Component;
+use crate::rsx::{RSX, Props};
+
+/// A VirtualNode is akin to an `Element` in React terms. Here, we provide a way
+/// for lazy `Component` instantiation, along with storage for things like layout nodes,
+/// properties, children and so on.
+#[derive(Clone)]
+pub struct VirtualNode {
+    /// Used in debugging/printing/etc.
+    pub tag: &'static str,
+
+    /// `Component` instances are created on-demand, if the reconciler deems it be so. This
+    /// is a closure that should return an instance of the correct type.
+    pub create_component_fn: Arc<Fn() -> Box<Component> + Send + Sync + 'static>,
+
+    /// A cached component instance, which is transferred between trees. Since `Component` 
+    /// instances are lazily created, this is an `Option`, and defaults to `None`.
+    pub instance: Option<Arc<Component>>,
+
+    /// A cached `Node` for computing `Layout` with `Stretch`. Some components may not have
+    /// a need for layout (e.g, if they don't have a backing node), and thus this is optional.
+    ///
+    /// The reconciler will handle bridging tree structures as necessary.
+    pub layout_node: Option<Node>,
+
+    /// `Props`, which are to be passed to this `Component` at various lifecycle methods.
+    pub props: Props,
+
+    /// Computed children get stored here.
+    pub children: Vec<RSX>
+}
+
+impl Display for VirtualNode {
+    /// Special formatting for displaying nodes.
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
+        write!(f, "<{}>", self.tag)?;
+
+        for child in &self.children {
+            write!(f, "{:?}", child)?;
+        }
+
+        write!(f, "</{}>", self.tag)
+    }
+}
+
+impl Debug for VirtualNode {
+    /// Special formatting for debugging nodes.
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "VirtualNode({})", self.tag)
+    }
+}