wip: remove scopechildren in favor of elements directly

packages/core/src/component.rs

@@ -5,40 +5,67 @@
 //! 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, LazyNodes, ScopeChildren};
+use crate::innerlude::{Context, Element, LazyNodes, NodeLink};
 
-pub struct FragmentProps<'a> {
-    children: ScopeChildren<'a>,
+pub struct FragmentProps(Element);
+pub struct FragmentBuilder<const BUILT: bool>(Element);
+impl FragmentBuilder<false> {
+    pub fn children(self, children: Option<NodeLink>) -> FragmentBuilder<true> {
+        FragmentBuilder(children)
+    }
 }
-
-pub struct FragmentBuilder<'a, const BUILT: bool> {
-    children: Option<ScopeChildren<'a>>,
-}
-impl<'a> FragmentBuilder<'a, false> {
-    pub fn children(self, children: ScopeChildren<'a>) -> FragmentBuilder<'a, true> {
-        FragmentBuilder {
-            children: Some(children),
-        }
+impl<const A: bool> FragmentBuilder<A> {
+    pub fn build(self) -> FragmentProps {
+        FragmentProps(self.0)
     }
 }
 
-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 = FragmentBuilder<'a, false>;
-
+/// Access the children elements passed into the component
+///
+/// This enables patterns where a component is passed children from its parent.
+///
+/// ## Details
+///
+/// Unlike React, Dioxus allows *only* lists of children to be passed from parent to child - not arbitrary functions
+/// or classes. If you want to generate nodes instead of accepting them as a list, consider declaring a closure
+/// on the props that takes Context.
+///
+/// If a parent passes children into a component, the child will always re-render when the parent re-renders. In other
+/// words, a component cannot be automatically memoized if it borrows nodes from its parent, even if the component's
+/// props are valid for the static lifetime.
+///
+/// ## Example
+///
+/// ```rust
+/// fn App(cx: Context, props: &()) -> Element {
+///     cx.render(rsx!{
+///         CustomCard {
+///             h1 {}
+///             p {}
+///         }
+///     })
+/// }
+///
+/// #[derive(PartialEq, Props)]
+/// struct CardProps {
+///     children: Element
+/// }
+///
+/// fn CustomCard(cx: Context, props: &CardProps) -> Element {
+///     cx.render(rsx!{
+///         div {
+///             h1 {"Title card"}
+///             {props.children}
+///         }
+///     })
+/// }
+/// ```
+impl Properties for FragmentProps {
+    type Builder = FragmentBuilder<false>;
     const IS_STATIC: bool = false;
-
     fn builder() -> Self::Builder {
-        FragmentBuilder { children: None }
+        FragmentBuilder(None)
     }
-
     unsafe fn memoize(&self, _other: &Self) -> bool {
         false
     }
@@ -46,9 +73,14 @@ impl<'a> Properties for FragmentProps<'a> {
 
 /// Create inline fragments using Component syntax.
 ///
+/// ## Details
+///
 /// Fragments capture a series of children without rendering extra nodes.
 ///
-/// # Example
+/// Creating fragments explicitly with the Fragment component is particularly useful when rendering lists or tables and
+/// a key is needed to identify each item.
+///
+/// ## Example
 ///
 /// ```rust
 /// rsx!{
@@ -56,20 +88,17 @@ impl<'a> Properties for FragmentProps<'a> {
 /// }
 /// ```
 ///
-/// # Details
+/// ## Usage
 ///
 /// Fragments are incredibly useful when necessary, but *do* add cost in the diffing phase.
-/// Try to avoid nesting fragments if you can. There is no protection against infinitely nested fragments.
+/// Try to avoid highly nested fragments if you can. Unlike React, there is no protection against infinitely nested fragments.
 ///
 /// This function defines a dedicated `Fragment` component that can be used to create inline fragments in the RSX macro.
 ///
 /// 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>(cx: Context<'a>, props: &'a FragmentProps<'a>) -> Element {
-    cx.render(Some(LazyNodes::new(|f| {
-        f.fragment_from_iter(&props.children)
-    })))
+pub fn Fragment(cx: Context, props: &FragmentProps) -> Element {
+    cx.render(Some(LazyNodes::new(|f| f.fragment_from_iter(&props.0))))
 }
 
 /// Every "Props" used for a component must implement the `Properties` trait. This trait gives some hints to Dioxus
@@ -131,7 +160,6 @@ impl Properties for () {
 // that the macros use to anonymously complete prop construction.
 pub struct EmptyBuilder;
 impl EmptyBuilder {
-    #[inline]
     pub fn build(self) {}
 }