Props, reconciler fixes, demo fixes

lifecycle/src/rsx/mod.rs

@@ -3,23 +3,22 @@
 //! uses these to build and alter UI; they're typically returned from `render()`
 //! methods.
 
+use std::any::Any;
 use std::fmt::{Debug, Display};
 
+use alchemy_styles::StylesList;
+
 mod virtual_node;
 pub use virtual_node::VirtualNode;
 
 mod virtual_text;
 pub use virtual_text::VirtualText;
 
-mod props;
-pub use props::Props;
-
 use crate::reconciler::key::ComponentKey;
 use crate::traits::Component;
 
 /// An enum representing the types of nodes that the
 /// system can work with. `None`, `VirtualText`, or `VirtualNode`.
-#[derive(Clone)]
 pub enum RSX {
     None,
     VirtualText(VirtualText),
@@ -29,15 +28,19 @@ pub enum RSX {
 impl RSX {
     /// Shorthand method for creating a new `RSX::VirtualNode` instance. Rarely should you call
     /// this yourself; the `rsx! {}` macro handles this for you.
-    pub fn node(
+    pub fn node<P: Any + 'static>(
         tag: &'static str,
+        styles: StylesList,
         create_fn: fn(key: ComponentKey) -> Box<Component>,
-        props: Props
+        props: P,
+        children: Vec<RSX>
     ) -> RSX {
         RSX::VirtualNode(VirtualNode {
             tag: tag,
             create_component_fn: create_fn,
-            props: props
+            styles: styles,
+            props: Box::new(props),
+            children: children
         })
     }
     

lifecycle/src/rsx/props.rs

@@ -31,7 +31,7 @@ impl<'a> From<&'a str> for AttributeType {
 #[derive(Clone, Debug, Default)]
 pub struct Props {
     pub attributes: HashMap<&'static str, AttributeType>,
-    pub children: Vec<RSX>,
+    //pub children: Vec<RSX>,
     pub key: String,
     pub styles: StylesList
 }
@@ -42,17 +42,17 @@ impl Props {
         key: String,
         styles: StylesList,
         attributes: HashMap<&'static str, AttributeType>,
-        children: Vec<RSX>
+        //children: Vec<RSX>
     ) -> Props {
         Props {
             attributes: attributes,
-            children: children,
+            //children: children,
             key: key,
             styles: styles
         }
     }
 
-    /// A helper method used for constructing root-level Properties.
+    /*/// A helper method used for constructing root-level Properties.
     pub(crate) fn root(children: Vec<RSX>) -> Props {
         Props {
             attributes: HashMap::new(),
@@ -65,7 +65,7 @@ impl Props {
     /// Returns a Vec of RSX nodes, which are really just cloned pointers for the most part.
     pub fn children(&self) -> Vec<RSX> {
         self.children.clone()
-    }
+    }*/
 
     /// Returns a Option<&AttributeType> from the `attributes` inner HashMap.
     pub fn get(&self, key: &str) -> Option<&AttributeType> {

lifecycle/src/rsx/virtual_node.rs

@@ -1,30 +1,36 @@
 //! Implements the `RSX::VirtualNode` struct, which is a bit of a recursive
 //! structure.
 
+use std::any::Any;
 use std::fmt::{Display, Debug};
 
+use alchemy_styles::StylesList;
+
 use crate::reconciler::key::ComponentKey;
-use crate::rsx::{RSX, Props};
+use crate::rsx::RSX;
 use crate::traits::Component;
 
 /// A VirtualNode is akin to an `Element` in React terms. Here, we provide a way
 /// for lazy `Component` instantiation, properties, children and so on.
-#[derive(Clone)]
 pub struct VirtualNode {
     /// Used in debugging/printing/etc.
     pub tag: &'static str,
 
+    /// Used for determining which CSS styles should be applied to this node.
+    /// This property is accessed often enough that it's separated out here.
+    pub styles: StylesList,
+
     /// `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: fn(key: ComponentKey) -> Box<Component>,
 
-    /// `Props`, which are to be passed to this `Component` at various lifecycle methods. Once 
-    /// the reconciler takes ownership of this VirtualNode, these props are moved to a different 
-    /// location - thus, you shouldn't rely on them for anything unless you specifically keep 
-    /// ownership of a VirtualNode.
-    ///
-    /// This aspect of functionality may be pulled in a later release if it causes too many issues.
-    pub props: Props
+    /// When some RSX is returned, we scoop up the props inside a special block, and then shove
+    /// them in here as an `Any` object. When you `derive(Props)` on a `Component` struct, it 
+    /// creates a setter that specifically handles downcasting and persisting props for you.
+    pub props: Box<Any>,
+
+    /// Child components for this node.
+    pub children: Vec<RSX>
 }
 
 impl Display for VirtualNode {
@@ -32,7 +38,7 @@ impl Display for VirtualNode {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> {
         write!(f, "<{}>", self.tag)?;
 
-        for child in &self.props.children {
+        for child in &self.children {
             write!(f, "{:?}", child)?;
         }