dioxus-mirror/packages/core/src.old/nodes/factory.rs

use crate::{innerlude::*, Attribute, Listener, VElement, VNode, VText};
use bumpalo::{boxed::Box as BumpBox, Bump};
use std::{
    cell::{Cell, RefCell},
    fmt::{Arguments, Debug},
};

/// This struct provides an ergonomic API to quickly build VNodes.
///
/// NodeFactory is used to build VNodes in the component's memory space.
/// This struct adds metadata to the final VNode about listeners, attributes, and children
#[derive(Copy, Clone)]
pub struct NodeFactory<'a> {
    pub(crate) scope: &'a ScopeState,
    pub(crate) bump: &'a Bump,
}

impl<'a> NodeFactory<'a> {
    /// Create a new [`NodeFactory`] from a [`Scope`] or [`ScopeState`]
    pub fn new(scope: &'a ScopeState) -> NodeFactory<'a> {
        NodeFactory {
            scope,
            bump: &scope.wip_frame().bump,
        }
    }

    /// Get the custom allocator for this component
    #[inline]
    pub fn bump(&self) -> &'a bumpalo::Bump {
        self.bump
    }

    /// Directly pass in text blocks without the need to use the format_args macro.
    pub fn static_text(&self, text: &'static str) -> VNode<'a> {
        VNode::Text(self.bump.alloc(VText {
            id: Default::default(),
            text,
        }))
    }

    /// Parses a lazy text Arguments and returns a string and a flag indicating if the text is 'static
    ///
    /// Text that's static may be pointer compared, making it cheaper to diff
    pub fn raw_text(&self, args: Arguments) -> (&'a str, bool) {
        match args.as_str() {
            Some(static_str) => (static_str, true),
            None => {
                use bumpalo::core_alloc::fmt::Write;
                let mut str_buf = bumpalo::collections::String::new_in(self.bump);
                str_buf.write_fmt(args).unwrap();
                (str_buf.into_bump_str(), false)
            }
        }
    }

    /// Create some text that's allocated along with the other vnodes
    ///
    pub fn text(&self, args: Arguments) -> VNode<'a> {
        let (text, _is_static) = self.raw_text(args);

        VNode::Text(self.bump.alloc(VText {
            text,
            id: Default::default(),
        }))
    }

    /// Create a new [`VNode::Element`] without the trait bound
    ///
    /// IE pass in "div" instead of `div`
    pub fn raw_element(
        &self,
        tag_name: &'static str,
        namespace: Option<&'static str>,
        listeners: &'a [Listener<'a>],
        attributes: &'a [Attribute<'a>],
        children: &'a [VNode<'a>],
        key: Option<Arguments>,
    ) -> VNode<'a> {
        let key = key.map(|f| self.raw_text(f).0);

        let mut items = self.scope.items.borrow_mut();
        for listener in listeners {
            let long_listener = unsafe { std::mem::transmute(listener) };
            items.listeners.push(long_listener);
        }

        VNode::Element(self.bump.alloc(VElement {
            tag: tag_name,
            key,
            namespace,
            listeners,
            attributes,
            children,
            id: Default::default(),
            parent: Default::default(),
        }))
    }

    /// Create a new [`Attribute`]
    pub fn attr(
        &self,
        name: &'static str,
        val: impl IntoAttributeValue<'a>,
        namespace: Option<&'static str>,
        is_volatile: bool,
    ) -> Attribute<'a> {
        Attribute {
            name,
            namespace,
            volatile: is_volatile,
            value: val.into_value(self.bump),
        }
    }

    /// Create a new [`Attribute`] using non-arguments
    pub fn custom_attr(
        &self,
        name: &'static str,
        value: AttributeValue<'a>,
        namespace: Option<&'static str>,
        is_volatile: bool,
    ) -> Attribute<'a> {
        Attribute {
            name,
            namespace,
            volatile: is_volatile,
            value,
        }
    }

    /// Create a new [`VNode::Component`]
    pub fn component<P>(
        &self,
        component: fn(Scope<'a, P>) -> Element,
        props: P,
        key: Option<Arguments>,
        fn_name: &'static str,
    ) -> VNode<'a>
    where
        P: Properties + 'a,
    {
        let vcomp = self.bump.alloc(VComponent {
            key: key.map(|f| self.raw_text(f).0),
            scope: Default::default(),
            can_memoize: P::IS_STATIC,
            user_fc: component as ComponentPtr,
            fn_name,
            props: RefCell::new(Some(Box::new(VComponentProps {
                props,
                memo: P::memoize, // smuggle the memoization function across borders

                // i'm sorry but I just need to bludgeon the lifetimes into place here
                // this is safe because we're managing all lifetimes to originate from previous calls
                // the intricacies of Rust's lifetime system make it difficult to properly express
                // the transformation from this specific lifetime to the for<'a> lifetime
                render_fn: unsafe { std::mem::transmute(component) },
            }))),
        });

        if !P::IS_STATIC {
            let vcomp = &*vcomp;
            let vcomp = unsafe { std::mem::transmute(vcomp) };
            self.scope.items.borrow_mut().borrowed_props.push(vcomp);
        }

        VNode::Component(vcomp)
    }

    /// Create a new [`Listener`]
    pub fn listener(self, event: &'static str, callback: InternalHandler<'a>) -> Listener<'a> {
        Listener {
            event,
            mounted_node: Cell::new(ElementId(0)),
            callback,
        }
    }

    /// Create a new [`VNode::Fragment`] from a root of the rsx! call
    pub fn fragment_root<'b, 'c>(
        self,
        node_iter: impl IntoIterator<Item = impl IntoVNode<'a> + 'c> + 'b,
    ) -> VNode<'a> {
        let mut nodes = bumpalo::collections::Vec::new_in(self.bump);

        for node in node_iter {
            nodes.push(node.into_vnode(self));
        }

        VNode::Fragment(self.bump.alloc(VFragment {
            children: nodes.into_bump_slice(),
            placeholder: Default::default(),
            key: None,
        }))
    }

    /// Create a new [`VNode::Fragment`] from any iterator
    pub fn fragment_from_iter<'c, I, J>(
        self,
        node_iter: impl IntoVNode<'a, I, J> + 'c,
    ) -> VNode<'a> {
        node_iter.into_vnode(self)
    }

    /// Create a new [`VNode`] from any iterator of children
    pub fn create_children(
        self,
        node_iter: impl IntoIterator<Item = impl IntoVNode<'a>>,
    ) -> Element<'a> {
        let mut nodes = bumpalo::collections::Vec::new_in(self.bump);

        for node in node_iter {
            nodes.push(node.into_vnode(self));
        }

        let children = nodes.into_bump_slice();

        Some(VNode::Fragment(self.bump.alloc(VFragment {
            children,
            key: None,
            placeholder: Default::default(),
        })))
    }

    /// Create a new [`EventHandler`] from an [`FnMut`]
    pub fn event_handler<T>(self, f: impl FnMut(T) + 'a) -> EventHandler<'a, T> {
        let handler: &mut dyn FnMut(T) = self.bump.alloc(f);
        let caller = unsafe { BumpBox::from_raw(handler as *mut dyn FnMut(T)) };
        let callback = RefCell::new(Some(caller));
        EventHandler { callback }
    }

    /// Create a refrence to a template
    pub fn template_ref(
        &self,
        template: Template<'static>,
        nodes: &'a [VNode<'a>],
        attributes: &'a [Attribute<'a>],
        listeners: &'a [Listener<'a>],
        key: Option<Arguments>,
    ) -> VNode<'a> {
        VNode::Template(
            self.bump.alloc(VTemplate {
                key: None,
                node_id: Cell::new(ElementId(0)),
                template,
                dynamic_nodes: self.bump.alloc([]),
                dynamic_attrs: self.bump.alloc([]),
                listeners,
                root_ids:
                    bumpalo::vec![in self.bump; Cell::new(ElementId(0)); template.roots.len()]
                        .into_bump_slice(),
            }),
        )
    }
}

impl Debug for NodeFactory<'_> {
    fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        Ok(())
    }
}

/// Trait implementations for use in the rsx! and html! macros.
///
/// ## Details
///
/// This section provides convenience methods and trait implementations for converting common structs into a format accepted
/// by the macros.
///
/// All dynamic content in the macros must flow in through `fragment_from_iter`. Everything else must be statically layed out.
/// We pipe basically everything through `fragment_from_iter`, so we expect a very specific type:
/// ```rust, ignore
/// impl IntoIterator<Item = impl IntoVNode<'a>>
/// ```
///
/// As such, all node creation must go through the factory, which is only available in the component context.
/// These strict requirements make it possible to manage lifetimes and state.
pub trait IntoVNode<'a, I = (), J = ()> {
    /// Convert this into a [`VNode`], using the [`NodeFactory`] as a source of allocation
    fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a>;
}

// TODO: do we even need this? It almost seems better not to
// // For the case where a rendered VNode is passed into the rsx! macro through curly braces
impl<'a> IntoVNode<'a> for VNode<'a> {
    fn into_vnode(self, _: NodeFactory<'a>) -> VNode<'a> {
        self
    }
}

impl<'a, 'b> IntoVNode<'a> for LazyNodes<'a, '_> {
    fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a> {
        self.call(cx)
    }
}

impl<'b> IntoVNode<'_> for &'b str {
    fn into_vnode(self, cx: NodeFactory) -> VNode {
        cx.text(format_args!("{}", self))
    }
}

impl IntoVNode<'_> for String {
    fn into_vnode(self, cx: NodeFactory) -> VNode {
        cx.text(format_args!("{}", self))
    }
}

impl IntoVNode<'_> for Arguments<'_> {
    fn into_vnode(self, cx: NodeFactory) -> VNode {
        cx.text(self)
    }
}

impl<'a> IntoVNode<'a> for &VNode<'a> {
    fn into_vnode(self, _cx: NodeFactory<'a>) -> VNode<'a> {
        // borrowed nodes are strange
        self.decouple()
    }
}

// Note that we're using the E as a generic but this is never crafted anyways.
pub struct FromNodeIterator;
impl<'a, T, I, E> IntoVNode<'a, FromNodeIterator, E> for T
where
    T: IntoIterator<Item = I>,
    I: IntoVNode<'a, E>,
{
    fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a> {
        let mut nodes = bumpalo::collections::Vec::new_in(cx.bump);

        for node in self {
            nodes.push(node.into_vnode(cx));
        }

        let children = nodes.into_bump_slice();

        if cfg!(debug_assertions) && children.len() > 1 && children.last().unwrap().key().is_none()
        {
            // let bt = backtrace::Backtrace::new();
            let bt = "no backtrace available";

            // todo: make the backtrace prettier or remove it altogether
            log::error!(
                r#"
                Warning: Each child in an array or iterator should have a unique "key" prop.
                Not providing a key will lead to poor performance with lists.
                See docs.rs/dioxus for more information.
                -------------
                {:?}
                "#,
                bt
            );
        }

        VNode::Fragment(cx.bump.alloc(VFragment {
            children,
            placeholder: Default::default(),
            key: None,
        }))
    }
}