wip: move examples around

packages/core/src/component.rs

@@ -5,7 +5,10 @@
 //! if the type supports PartialEq. The Properties trait is used by the rsx! and html! macros to generate the type-safe builder
 //! that ensures compile-time required and optional fields on cx.
 
-use crate::innerlude::{Context, Element, VNode};
+use crate::{
+    innerlude::{Context, Element, VAnchor, VFragment, VNode},
+    LazyNodes, ScopeChildren,
+};
 /// A component is a wrapper around a Context and some Props that share a lifetime
 ///
 ///
@@ -41,23 +44,39 @@ use crate::innerlude::{Context, Element, VNode};
 pub type Scope<'a, T> = (Context<'a>, &'a T);
 
 pub struct FragmentProps<'a> {
-    childen: &'a VNode<'a>,
+    children: ScopeChildren<'a>,
 }
-pub struct FragmentPropsBuilder<'a> {
-    childen: Option<&'a VNode<'a>>,
+
+pub struct FragmentBuilder<'a, const BUILT: bool> {
+    children: Option<ScopeChildren<'a>>,
+}
+impl<'a> FragmentBuilder<'a, false> {
+    pub fn children(mut self, children: ScopeChildren<'a>) -> FragmentBuilder<'a, true> {
+        FragmentBuilder {
+            children: Some(children),
+        }
+    }
+}
+
+impl<'a, const A: bool> FragmentBuilder<'a, A> {
+    pub fn build(self) -> FragmentProps<'a> {
+        FragmentProps {
+            children: self.children.unwrap_or_default(),
+        }
+    }
 }
 
 impl<'a> Properties for FragmentProps<'a> {
-    type Builder = FragmentPropsBuilder<'a>;
+    type Builder = FragmentBuilder<'a, false>;
 
     const IS_STATIC: bool = false;
 
     fn builder() -> Self::Builder {
-        todo!()
+        FragmentBuilder { children: None }
     }
 
     unsafe fn memoize(&self, other: &Self) -> bool {
-        todo!()
+        false
     }
 }
 
@@ -83,8 +102,10 @@ impl<'a> Properties for FragmentProps<'a> {
 /// You want to use this free-function when your fragment needs a key and simply returning multiple nodes from rsx! won't cut it.
 ///
 #[allow(non_upper_case_globals, non_snake_case)]
-pub fn Fragment<'a>((_, props): Scope<'a, FragmentProps<'a>>) -> Element<'a> {
-    Some(props.childen.decouple())
+pub fn Fragment<'a>((cx, props): Scope<'a, FragmentProps<'a>>) -> Element<'a> {
+    cx.render(Some(LazyNodes::new(|f| {
+        f.fragment_from_iter(&props.children)
+    })))
 }
 
 /// Every "Props" used for a component must implement the `Properties` trait. This trait gives some hints to Dioxus