dioxus/packages/core/src/nodes.rs

879 lines
26 KiB
Rust
Raw Normal View History

2021-02-03 07:26:04 +00:00
//! Virtual Node Support
//!
2021-09-01 04:57:04 +00:00
//! VNodes represent lazily-constructed VDom trees that support diffing and event handlers. These VNodes should be *very*
//! cheap and *very* fast to construct - building a full tree should be quick.
2021-11-01 06:41:23 +00:00
use crate::{
2021-11-09 07:16:25 +00:00
innerlude::{Context, Element, Properties, Scope, ScopeId},
2021-11-01 06:41:23 +00:00
lazynodes::LazyNodes,
2021-03-11 00:42:10 +00:00
};
2021-07-29 22:04:09 +00:00
use bumpalo::{boxed::Box as BumpBox, Bump};
2021-06-03 14:42:28 +00:00
use std::{
any::Any,
cell::{Cell, RefCell},
2021-06-23 05:44:48 +00:00
fmt::{Arguments, Debug, Formatter},
2021-11-12 03:07:38 +00:00
sync::Arc,
2021-06-03 14:42:28 +00:00
};
2021-02-21 02:59:16 +00:00
2021-09-01 04:57:04 +00:00
/// A composable "VirtualNode" to declare a User Interface in the Dioxus VirtualDOM.
2021-02-03 07:26:04 +00:00
///
2021-10-24 17:30:36 +00:00
/// VNodes are designed to be lightweight and used with with a bump allocator. To create a VNode, you can use either of:
///
2021-09-01 04:57:04 +00:00
/// - the [`rsx`] macro
/// - the [`NodeFactory`] API
2021-08-20 14:34:41 +00:00
pub enum VNode<'src> {
2021-09-01 04:57:04 +00:00
/// Text VNodes simply bump-allocated (or static) string slices
///
/// # Example
///
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
/// let mut vdom = VirtualDom::new();
/// let node = vdom.render_vnode(rsx!( "hello" ));
2021-09-01 04:57:04 +00:00
///
/// if let VNode::Text(vtext) = node {
/// assert_eq!(vtext.text, "hello");
/// assert_eq!(vtext.dom_id.get(), None);
/// assert_eq!(vtext.is_static, true);
/// }
/// ```
Text(&'src VText<'src>),
2021-09-01 04:57:04 +00:00
/// Element VNodes are VNodes that may contain attributes, listeners, a key, a tag, and children.
///
/// # Example
///
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
/// let mut vdom = VirtualDom::new();
///
/// let node = vdom.render_vnode(rsx!{
2021-09-01 04:57:04 +00:00
/// div {
/// key: "a",
/// onclick: |e| log::info!("clicked"),
/// hidden: "true",
/// style: { background_color: "red" }
/// "hello"
/// }
/// });
///
2021-09-01 04:57:04 +00:00
/// if let VNode::Element(velement) = node {
/// assert_eq!(velement.tag_name, "div");
/// assert_eq!(velement.namespace, None);
/// assert_eq!(velement.key, Some("a));
/// }
/// ```
2021-07-12 22:19:27 +00:00
Element(&'src VElement<'src>),
2021-09-01 04:57:04 +00:00
/// Fragment nodes may contain many VNodes without a single root.
///
/// # Example
///
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
2021-09-01 04:57:04 +00:00
/// rsx!{
/// a {}
/// link {}
/// style {}
/// "asd"
/// Example {}
/// }
/// ```
2021-07-12 22:19:27 +00:00
Fragment(VFragment<'src>),
2021-09-01 04:57:04 +00:00
/// Component nodes represent a mounted component with props, children, and a key.
///
/// # Example
///
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
/// fn Example(cx: Context, props: &()) -> Element {
2021-09-01 04:57:04 +00:00
/// todo!()
/// }
///
/// let mut vdom = VirtualDom::new();
///
/// let node = vdom.render_vnode(rsx!( Example {} ));
2021-09-01 04:57:04 +00:00
///
/// if let VNode::Component(vcomp) = node {
/// assert_eq!(vcomp.user_fc, Example as *const ());
/// }
/// ```
Component(&'src VComponent<'src>),
2021-11-23 20:53:57 +00:00
/// Placeholders are a type of placeholder VNode used when fragments don't contain any children.
2021-09-01 04:57:04 +00:00
///
2021-11-23 20:53:57 +00:00
/// Placeholders cannot be directly constructed via public APIs.
2021-09-01 04:57:04 +00:00
///
/// # Example
///
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
/// let mut vdom = VirtualDom::new();
///
/// let node = vdom.render_vnode(rsx!( Fragment {} ));
///
2021-09-01 04:57:04 +00:00
/// if let VNode::Fragment(frag) = node {
/// let root = &frag.children[0];
/// assert_eq!(root, VNode::Anchor);
/// }
/// ```
2021-11-23 20:53:57 +00:00
Placeholder(&'src VPlaceholder),
2021-11-07 03:11:17 +00:00
/// A VNode that is actually a pointer to some nodes rather than the nodes directly. Useful when rendering portals
/// or eliding lifetimes on VNodes through runtime checks.
///
/// Linked VNodes can only be made through the [`Context::render`] method
///
/// Typically, linked nodes are found *not* in a VNode. When NodeLinks are in a VNode, the NodeLink was passed into
/// an `rsx!` call.
2021-11-07 03:11:17 +00:00
///
/// # Example
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
/// let mut vdom = VirtualDom::new();
2021-11-07 03:11:17 +00:00
///
/// let node: NodeLink = vdom.render_vnode(rsx!( "hello" ));
/// ```
2021-11-28 21:25:42 +00:00
Portal(VPortal),
2021-07-29 22:04:09 +00:00
}
2021-08-20 14:34:41 +00:00
impl<'src> VNode<'src> {
2021-09-01 04:57:04 +00:00
/// Get the VNode's "key" used in the keyed diffing algorithm.
2021-08-20 14:34:41 +00:00
pub fn key(&self) -> Option<&'src str> {
match &self {
2021-08-21 17:24:47 +00:00
VNode::Element(el) => el.key,
VNode::Component(c) => c.key,
VNode::Fragment(f) => f.key,
VNode::Text(_t) => None,
2021-11-23 20:53:57 +00:00
VNode::Placeholder(_f) => None,
2021-11-28 21:25:42 +00:00
VNode::Portal(_c) => None,
2021-08-20 14:34:41 +00:00
}
}
2021-09-01 04:57:04 +00:00
/// Get the ElementID of the mounted VNode.
///
/// Panics if the mounted ID is None or if the VNode is not represented by a single Element.
pub fn mounted_id(&self) -> ElementId {
self.try_mounted_id().unwrap()
2021-08-20 14:34:41 +00:00
}
2021-09-01 04:57:04 +00:00
/// Try to get the ElementID of the mounted VNode.
///
/// Returns None if the VNode is not mounted, or if the VNode cannot be presented by a mounted ID (Fragment/Component)
pub fn try_mounted_id(&self) -> Option<ElementId> {
2021-08-20 14:34:41 +00:00
match &self {
VNode::Text(el) => el.dom_id.get(),
VNode::Element(el) => el.dom_id.get(),
2021-11-23 20:53:57 +00:00
VNode::Placeholder(el) => el.dom_id.get(),
2021-11-28 21:25:42 +00:00
VNode::Portal(_) => None,
2021-08-20 14:34:41 +00:00
VNode::Fragment(_) => None,
VNode::Component(_) => None,
}
}
pub(crate) fn children(&self) -> &[VNode<'src>] {
2021-11-05 20:28:08 +00:00
match &self {
2021-11-07 14:58:19 +00:00
VNode::Fragment(f) => f.children,
2021-11-05 20:28:08 +00:00
_ => &[],
}
}
// Create an "owned" version of the vnode.
pub fn decouple(&self) -> VNode<'src> {
match self {
VNode::Text(t) => VNode::Text(*t),
VNode::Element(e) => VNode::Element(*e),
VNode::Component(c) => VNode::Component(*c),
2021-11-23 20:53:57 +00:00
VNode::Placeholder(a) => VNode::Placeholder(*a),
VNode::Fragment(f) => VNode::Fragment(VFragment {
children: f.children,
key: f.key,
}),
2021-11-28 21:25:42 +00:00
VNode::Portal(c) => VNode::Portal(VPortal {
2021-11-10 22:09:52 +00:00
scope_id: c.scope_id.clone(),
link_idx: c.link_idx.clone(),
2021-11-12 02:34:20 +00:00
node: c.node,
2021-11-07 03:11:17 +00:00
}),
}
}
2021-08-20 14:34:41 +00:00
}
impl Debug for VNode<'_> {
fn fmt(&self, s: &mut Formatter<'_>) -> std::result::Result<(), std::fmt::Error> {
match &self {
VNode::Element(el) => s
2021-11-08 03:36:57 +00:00
.debug_struct("VNode::VElement")
.field("name", &el.tag_name)
.field("key", &el.key)
.finish(),
2021-11-08 03:36:57 +00:00
VNode::Text(t) => write!(s, "VNode::VText {{ text: {} }}", t.text),
2021-11-23 20:53:57 +00:00
VNode::Placeholder(_) => write!(s, "VNode::VAnchor"),
2021-11-08 03:36:57 +00:00
VNode::Fragment(frag) => {
write!(s, "VNode::VFragment {{ children: {:?} }}", frag.children)
}
VNode::Component(comp) => write!(s, "VNode::VComponent {{ fc: {:?}}}", comp.user_fc),
2021-11-28 21:25:42 +00:00
VNode::Portal(c) => write!(s, "VNode::VCached {{ scope_id: {:?} }}", c.scope_id.get()),
}
}
}
2021-11-09 07:16:25 +00:00
/// An Element's unique identifier.
///
/// `ElementId` is a `usize` that is unique across the entire VirtualDOM - but not unique across time. If a component is
/// unmounted, then the `ElementId` will be reused for a new component.
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
pub struct ElementId(pub usize);
impl std::fmt::Display for ElementId {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.0)
}
}
impl ElementId {
pub fn as_u64(self) -> u64 {
self.0 as u64
}
}
fn empty_cell() -> Cell<Option<ElementId>> {
Cell::new(None)
}
2021-09-01 04:57:04 +00:00
/// A placeholder node only generated when Fragments don't have any children.
2021-11-23 20:53:57 +00:00
pub struct VPlaceholder {
2021-07-29 22:04:09 +00:00
pub dom_id: Cell<Option<ElementId>>,
}
2021-10-24 17:30:36 +00:00
/// A bump-allocated string slice and metadata.
pub struct VText<'src> {
pub text: &'src str,
2021-07-29 22:04:09 +00:00
pub dom_id: Cell<Option<ElementId>>,
pub is_static: bool,
}
2021-09-01 04:57:04 +00:00
/// A list of VNodes with no single root.
2021-07-12 22:19:27 +00:00
pub struct VFragment<'src> {
2021-08-20 14:34:41 +00:00
pub key: Option<&'src str>,
2021-08-27 13:53:26 +00:00
pub children: &'src [VNode<'src>],
2021-07-12 22:19:27 +00:00
}
2021-06-26 01:15:33 +00:00
2021-09-01 04:57:04 +00:00
/// An element like a "div" with children, listeners, and attributes.
2021-08-27 13:53:26 +00:00
pub struct VElement<'a> {
pub tag_name: &'static str,
pub namespace: Option<&'static str>,
pub key: Option<&'a str>,
pub dom_id: Cell<Option<ElementId>>,
2021-09-20 16:32:21 +00:00
pub parent_id: Cell<Option<ElementId>>,
2021-08-27 13:53:26 +00:00
pub listeners: &'a [Listener<'a>],
pub attributes: &'a [Attribute<'a>],
pub children: &'a [VNode<'a>],
}
2021-09-24 04:05:56 +00:00
impl Debug for VElement<'_> {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("VElement")
.field("tag_name", &self.tag_name)
.field("namespace", &self.namespace)
.field("key", &self.key)
.field("dom_id", &self.dom_id)
.field("parent_id", &self.parent_id)
.field("listeners", &self.listeners.len())
.field("attributes", &self.attributes)
.field("children", &self.children)
.finish()
}
}
2021-09-01 04:57:04 +00:00
/// A trait for any generic Dioxus Element.
///
/// This trait provides the ability to use custom elements in the `rsx!` macro.
///
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
2021-09-01 04:57:04 +00:00
/// struct my_element;
///
/// impl DioxusElement for my_element {
/// const TAG_NAME: "my_element";
/// const NAME_SPACE: None;
/// }
///
/// let _ = rsx!{
/// my_element {}
/// };
/// ```
2021-07-12 22:19:27 +00:00
pub trait DioxusElement {
const TAG_NAME: &'static str;
const NAME_SPACE: Option<&'static str>;
2021-07-13 04:56:39 +00:00
#[inline]
2021-07-12 22:19:27 +00:00
fn tag_name(&self) -> &'static str {
Self::TAG_NAME
}
2021-07-13 04:56:39 +00:00
#[inline]
fn namespace(&self) -> Option<&'static str> {
Self::NAME_SPACE
}
2021-07-12 22:19:27 +00:00
}
2021-03-11 00:42:10 +00:00
/// An attribute on a DOM node, such as `id="my-thing"` or
/// `href="https://example.com"`.
#[derive(Clone, Debug)]
2021-03-11 00:42:10 +00:00
pub struct Attribute<'a> {
pub name: &'static str,
2021-03-11 00:42:10 +00:00
pub value: &'a str,
pub is_static: bool,
2021-07-12 22:19:27 +00:00
pub is_volatile: bool,
2021-09-01 04:57:04 +00:00
// Doesn't exist in the html spec.
// Used in Dioxus to denote "style" tags.
pub namespace: Option<&'static str>,
2021-03-11 00:42:10 +00:00
}
2021-02-03 07:26:04 +00:00
2021-03-11 00:42:10 +00:00
/// An event listener.
2021-07-12 22:19:27 +00:00
/// IE onclick, onkeydown, etc
2021-03-11 00:42:10 +00:00
pub struct Listener<'bump> {
2021-09-13 16:42:38 +00:00
/// The ID of the node that this listener is mounted to
/// Used to generate the event listener's ID on the DOM
pub mounted_node: Cell<Option<ElementId>>,
2021-09-01 04:57:04 +00:00
/// The type of event to listen for.
///
2021-09-10 00:58:48 +00:00
/// IE "click" - whatever the renderer needs to attach the listener by name.
2021-09-01 04:57:04 +00:00
pub event: &'static str,
2021-09-13 16:42:38 +00:00
/// The actual callback that the user specified
2021-12-10 02:19:31 +00:00
pub(crate) callback: EventHandler<'bump>,
}
2021-12-13 05:06:17 +00:00
/// The callback based into element event listeners.
2021-12-10 02:19:31 +00:00
pub struct EventHandler<'bump> {
pub callback: &'bump RefCell<Option<ListenerCallback<'bump>>>,
}
impl EventHandler<'_> {
pub fn call(&self, event: Arc<dyn Any + Send + Sync>) {
if let Some(callback) = self.callback.borrow_mut().as_mut() {
callback(event);
}
}
pub fn release(&self) {
self.callback.replace(None);
}
}
2021-12-13 05:06:17 +00:00
2021-12-10 02:19:31 +00:00
type ListenerCallback<'bump> = BumpBox<'bump, dyn FnMut(Arc<dyn Any + Send + Sync>) + 'bump>;
impl Copy for EventHandler<'_> {}
impl Clone for EventHandler<'_> {
fn clone(&self) -> Self {
Self {
callback: self.callback,
}
}
2021-03-11 00:42:10 +00:00
}
2021-02-03 07:26:04 +00:00
2021-11-28 21:25:42 +00:00
/// A cached node is a "pointer" to a "rendered" node in a particular scope
///
/// It does not provide direct access to the node, so it doesn't carry any lifetime information with it
///
/// It is used during the diffing/rendering process as a runtime key into an existing set of nodes. The "render" key
/// is essentially a unique key to guarantee safe usage of the Node.
///
/// Linked VNodes can only be made through the [`Context::render`] method
///
/// Typically, NodeLinks are found *not* in a VNode. When NodeLinks are in a VNode, the NodeLink was passed into
/// an `rsx!` call.
///
/// todo: remove the raw pointer and use runtime checks instead
#[derive(Debug)]
pub struct VPortal {
pub(crate) link_idx: Cell<usize>,
pub(crate) scope_id: Cell<Option<ScopeId>>,
pub(crate) node: *const VNode<'static>,
}
impl PartialEq for VPortal {
fn eq(&self, other: &Self) -> bool {
self.node == other.node
}
}
2021-07-12 22:19:27 +00:00
/// Virtual Components for custom user-defined components
/// Only supports the functional syntax
pub struct VComponent<'src> {
2021-08-20 14:34:41 +00:00
pub key: Option<&'src str>,
pub associated_scope: Cell<Option<ScopeId>>,
2021-09-01 04:57:04 +00:00
// Function pointer to the FC that was used to generate this component
pub user_fc: *const (),
2021-08-27 13:53:26 +00:00
pub(crate) can_memoize: bool,
2021-08-08 19:15:16 +00:00
2021-11-12 02:34:20 +00:00
pub(crate) _hard_allocation: Cell<Option<*const ()>>,
2021-08-27 13:53:26 +00:00
// Raw pointer into the bump arena for the props of the component
pub(crate) bump_props: *const (),
2021-11-05 20:28:08 +00:00
// during the "teardown" process we'll take the caller out so it can be dropped properly
2021-11-09 07:11:44 +00:00
pub(crate) caller: &'src dyn Fn(&'src Scope) -> Element,
pub(crate) comparator: Option<&'src dyn Fn(&VComponent) -> bool>,
2021-11-28 21:25:42 +00:00
// todo: re-add this
2021-11-09 07:11:44 +00:00
pub(crate) drop_props: RefCell<Option<BumpBox<'src, dyn FnMut()>>>,
2021-11-05 20:28:08 +00:00
}
2021-07-12 22:19:27 +00:00
/// 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> {
2021-07-29 22:04:09 +00:00
pub(crate) bump: &'a Bump,
2021-03-11 00:42:10 +00:00
}
2021-07-12 22:19:27 +00:00
impl<'a> NodeFactory<'a> {
2021-07-29 22:04:09 +00:00
pub fn new(bump: &'a Bump) -> NodeFactory<'a> {
NodeFactory { bump }
}
2021-03-11 00:42:10 +00:00
#[inline]
2021-07-12 22:19:27 +00:00
pub fn bump(&self) -> &'a bumpalo::Bump {
2021-11-12 02:34:20 +00:00
self.bump
2021-07-29 22:04:09 +00:00
}
2021-09-01 04:57:04 +00:00
/// 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 {
2021-08-20 14:34:41 +00:00
dom_id: empty_cell(),
text,
is_static: true,
}))
2021-02-03 07:26:04 +00:00
}
/// 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
2021-07-12 22:19:27 +00:00
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;
2021-11-10 22:09:52 +00:00
let mut str_buf = bumpalo::collections::String::new_in(self.bump);
2021-09-01 04:57:04 +00:00
str_buf.write_fmt(args).unwrap();
(str_buf.into_bump_str(), false)
2021-07-12 22:19:27 +00:00
}
}
2021-03-11 00:42:10 +00:00
}
2021-07-02 05:30:52 +00:00
2021-07-12 22:19:27 +00:00
/// Create some text that's allocated along with the other vnodes
///
2021-07-12 22:19:27 +00:00
pub fn text(&self, args: Arguments) -> VNode<'a> {
let (text, is_static) = self.raw_text(args);
2021-08-20 14:34:41 +00:00
VNode::Text(self.bump.alloc(VText {
2021-08-20 14:34:41 +00:00
text,
is_static,
dom_id: empty_cell(),
}))
2021-07-02 05:30:52 +00:00
}
2021-03-11 00:42:10 +00:00
pub fn element<L, A, V>(
2021-07-12 22:19:27 +00:00
&self,
el: impl DioxusElement,
listeners: L,
attributes: A,
children: V,
2021-07-30 14:35:47 +00:00
key: Option<Arguments>,
) -> VNode<'a>
where
L: 'a + AsRef<[Listener<'a>]>,
A: 'a + AsRef<[Attribute<'a>]>,
V: 'a + AsRef<[VNode<'a>]>,
{
self.raw_element(
el.tag_name(),
el.namespace(),
listeners,
attributes,
children,
key,
)
2021-07-12 22:19:27 +00:00
}
pub fn raw_element<L, A, V>(
2021-07-13 04:56:39 +00:00
&self,
2021-09-01 04:57:04 +00:00
tag_name: &'static str,
namespace: Option<&'static str>,
listeners: L,
attributes: A,
children: V,
2021-07-30 14:35:47 +00:00
key: Option<Arguments>,
) -> VNode<'a>
where
L: 'a + AsRef<[Listener<'a>]>,
A: 'a + AsRef<[Attribute<'a>]>,
V: 'a + AsRef<[VNode<'a>]>,
{
2021-11-10 22:09:52 +00:00
let listeners: &'a L = self.bump.alloc(listeners);
let listeners = listeners.as_ref();
2021-11-10 22:09:52 +00:00
let attributes: &'a A = self.bump.alloc(attributes);
let attributes = attributes.as_ref();
2021-11-10 22:09:52 +00:00
let children: &'a V = self.bump.alloc(children);
let children = children.as_ref();
2021-07-30 14:35:47 +00:00
let key = key.map(|f| self.raw_text(f).0);
2021-11-10 22:09:52 +00:00
VNode::Element(self.bump.alloc(VElement {
2021-09-01 04:57:04 +00:00
tag_name,
2021-07-13 04:56:39 +00:00
key,
2021-08-20 14:34:41 +00:00
namespace,
listeners,
attributes,
children,
dom_id: empty_cell(),
2021-09-20 16:32:21 +00:00
parent_id: empty_cell(),
2021-08-20 14:34:41 +00:00
}))
2021-07-13 04:56:39 +00:00
}
2021-07-12 22:19:27 +00:00
pub fn attr(
&self,
name: &'static str,
val: Arguments,
namespace: Option<&'static str>,
is_volatile: bool,
) -> Attribute<'a> {
let (value, is_static) = self.raw_text(val);
Attribute {
name,
value,
is_static,
namespace,
is_volatile,
}
}
2021-02-12 05:29:46 +00:00
2021-11-07 03:11:17 +00:00
pub fn component<P>(
2021-07-12 22:19:27 +00:00
&self,
2021-12-13 05:06:17 +00:00
component: fn(Context<'a, P>) -> Element,
2021-06-02 15:07:30 +00:00
props: P,
2021-07-30 14:35:47 +00:00
key: Option<Arguments>,
2021-07-12 22:19:27 +00:00
) -> VNode<'a>
where
P: Properties + 'a,
{
2021-11-10 22:09:52 +00:00
let bump = self.bump;
2021-11-08 03:45:41 +00:00
let props = bump.alloc(props);
let bump_props = props as *mut P as *mut ();
let user_fc = component as *const ();
2021-11-05 20:28:08 +00:00
2021-11-08 03:45:41 +00:00
let comparator: &mut dyn Fn(&VComponent) -> bool = bump.alloc_with(|| {
move |other: &VComponent| {
if user_fc == other.user_fc {
// Safety
// - We guarantee that FC<P> is the same by function pointer
// - Because FC<P> is the same, then P must be the same (even with generics)
// - Non-static P are autoderived to memoize as false
// - This comparator is only called on a corresponding set of bumpframes
2021-11-12 02:34:20 +00:00
//
2021-11-08 03:45:41 +00:00
// It's only okay to memoize if there are no children and the props can be memoized
// Implementing memoize is unsafe and done automatically with the props trait
2021-11-12 02:34:20 +00:00
unsafe {
let real_other: &P = &*(other.bump_props as *const _ as *const P);
props.memoize(real_other)
}
2021-11-08 03:45:41 +00:00
} else {
false
}
}
});
2021-11-05 20:28:08 +00:00
2021-11-08 03:45:41 +00:00
let drop_props = {
// create a closure to drop the props
let mut has_dropped = false;
let drop_props: &mut dyn FnMut() = bump.alloc_with(|| {
move || unsafe {
if !has_dropped {
let real_other = bump_props as *mut _ as *mut P;
let b = BumpBox::from_raw(real_other);
std::mem::drop(b);
2021-07-12 22:19:27 +00:00
2021-11-08 03:45:41 +00:00
has_dropped = true;
} else {
panic!("Drop props called twice - this is an internal failure of Dioxus");
}
}
});
let drop_props = unsafe { BumpBox::from_raw(drop_props) };
RefCell::new(Some(drop_props))
};
2021-07-27 15:28:05 +00:00
2021-07-30 14:35:47 +00:00
let key = key.map(|f| self.raw_text(f).0);
2021-11-09 07:11:44 +00:00
let caller: &'a mut dyn Fn(&'a Scope) -> Element =
2021-11-08 03:45:41 +00:00
bump.alloc(move |scope: &Scope| -> Element {
let props: &'_ P = unsafe { &*(bump_props as *const P) };
2021-12-13 05:06:17 +00:00
component(Context { scope, props })
2021-11-08 03:45:41 +00:00
});
let can_memoize = P::IS_STATIC;
VNode::Component(bump.alloc(VComponent {
user_fc,
2021-11-09 07:11:44 +00:00
comparator: Some(comparator),
2021-11-08 03:45:41 +00:00
bump_props,
caller,
key,
can_memoize,
drop_props,
associated_scope: Cell::new(None),
2021-11-12 02:34:20 +00:00
_hard_allocation: Cell::new(None),
2021-11-08 03:45:41 +00:00
}))
2021-07-12 22:19:27 +00:00
}
2021-12-10 02:19:31 +00:00
pub fn listener(self, event: &'static str, callback: EventHandler<'a>) -> Listener<'a> {
2021-11-07 03:11:17 +00:00
Listener {
event,
2021-11-28 21:25:42 +00:00
mounted_node: Cell::new(None),
2021-12-10 02:19:31 +00:00
callback,
2021-11-07 03:11:17 +00:00
}
}
2021-11-16 18:09:41 +00:00
pub fn fragment_root<'b, 'c>(
self,
node_iter: impl IntoIterator<Item = impl IntoVNode<'a> + 'c> + 'b,
) -> VNode<'a> {
2021-11-28 21:25:42 +00:00
let mut nodes = bumpalo::collections::Vec::new_in(self.bump);
2021-11-16 18:09:41 +00:00
for node in node_iter {
nodes.push(node.into_vnode(self));
}
if nodes.is_empty() {
2021-11-28 21:25:42 +00:00
nodes.push(VNode::Placeholder(self.bump.alloc(VPlaceholder {
2021-11-16 18:09:41 +00:00
dom_id: empty_cell(),
})));
}
VNode::Fragment(VFragment {
children: nodes.into_bump_slice(),
key: None,
})
}
2021-11-16 06:25:38 +00:00
pub fn fragment_from_iter<'b, 'c>(
self,
2021-11-16 06:25:38 +00:00
node_iter: impl IntoIterator<Item = impl IntoVNode<'a> + 'c> + 'b,
) -> VNode<'a> {
2021-11-28 21:25:42 +00:00
let mut nodes = bumpalo::collections::Vec::new_in(self.bump);
for node in node_iter {
nodes.push(node.into_vnode(self));
}
if nodes.is_empty() {
2021-11-28 21:25:42 +00:00
nodes.push(VNode::Placeholder(self.bump.alloc(VPlaceholder {
dom_id: empty_cell(),
})));
}
let children = nodes.into_bump_slice();
2021-11-16 06:25:38 +00:00
if cfg!(debug_assertions) && children.len() > 1 && children.last().unwrap().key().is_none()
{
2021-11-28 21:25:42 +00:00
// todo: make the backtrace prettier or remove it altogether
2021-11-16 06:25:38 +00:00
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.
-------------
2021-11-16 18:09:41 +00:00
{:?}
2021-11-16 06:25:38 +00:00
"#,
2021-11-28 21:25:42 +00:00
backtrace::Backtrace::new()
2021-11-16 06:25:38 +00:00
);
}
2021-08-22 21:08:25 +00:00
2021-08-20 14:34:41 +00:00
VNode::Fragment(VFragment {
children,
2021-07-12 22:19:27 +00:00
key: None,
2021-08-20 14:34:41 +00:00
})
2021-02-03 07:26:04 +00:00
}
2021-11-10 22:09:52 +00:00
// this isn't quite feasible yet
// I think we need some form of interior mutability or state on nodefactory that stores which subtree was created
pub fn create_children(
self,
node_iter: impl IntoIterator<Item = impl IntoVNode<'a>>,
) -> Element {
let bump = self.bump;
let mut nodes = bumpalo::collections::Vec::new_in(bump);
for node in node_iter {
nodes.push(node.into_vnode(self));
}
if nodes.is_empty() {
2021-11-23 20:53:57 +00:00
nodes.push(VNode::Placeholder(bump.alloc(VPlaceholder {
2021-11-10 22:09:52 +00:00
dom_id: empty_cell(),
})));
}
let children = nodes.into_bump_slice();
// TODO
// We need a dedicated path in the rsx! macro that will trigger the "you need keys" warning
let frag = VNode::Fragment(VFragment {
children,
key: None,
});
let ptr = self.bump.alloc(frag) as *const _;
2021-11-28 21:25:42 +00:00
Some(VPortal {
2021-11-10 22:09:52 +00:00
link_idx: Default::default(),
scope_id: Default::default(),
node: unsafe { std::mem::transmute(ptr) },
})
}
2021-02-03 07:26:04 +00:00
}
2021-06-03 14:42:28 +00:00
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:
2021-11-12 02:34:20 +00:00
/// ```rust, ignore
/// impl IntoIterator<Item = impl IntoVNode<'a>>
/// ```
///
2021-10-24 17:30:36 +00:00
/// 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> {
fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a>;
2021-07-26 16:14:48 +00:00
}
// For the case where a rendered VNode is passed into the rsx! macro through curly braces
2021-07-12 22:19:27 +00:00
impl<'a> IntoIterator for VNode<'a> {
type Item = VNode<'a>;
type IntoIter = std::iter::Once<Self::Item>;
fn into_iter(self) -> Self::IntoIter {
std::iter::once(self)
}
}
// 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
}
}
2021-07-12 22:19:27 +00:00
// Conveniently, we also support "null" (nothing) passed in
impl IntoVNode<'_> for () {
fn into_vnode(self, cx: NodeFactory) -> VNode {
cx.fragment_from_iter(None as Option<VNode>)
}
}
// Conveniently, we also support "None"
impl IntoVNode<'_> for Option<()> {
fn into_vnode(self, cx: NodeFactory) -> VNode {
cx.fragment_from_iter(None as Option<VNode>)
}
}
impl<'a> IntoVNode<'a> for Option<VNode<'a>> {
fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a> {
self.unwrap_or_else(|| cx.fragment_from_iter(None as Option<VNode>))
}
}
2021-11-01 06:41:23 +00:00
impl<'a> IntoVNode<'a> for Option<LazyNodes<'a, '_>> {
fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a> {
2021-07-20 23:03:49 +00:00
match self {
2021-11-01 06:41:23 +00:00
Some(lazy) => lazy.call(cx),
None => VNode::Fragment(VFragment {
children: &[],
key: None,
}),
2021-07-20 23:03:49 +00:00
}
}
}
2021-07-12 22:19:27 +00:00
2021-11-16 06:25:38 +00:00
impl<'a, 'b> IntoVNode<'a> for LazyNodes<'a, 'b> {
fn into_vnode(self, cx: NodeFactory<'a>) -> VNode<'a> {
2021-11-01 06:41:23 +00:00
self.call(cx)
}
}
impl IntoVNode<'_> for &'static str {
2021-09-21 22:13:09 +00:00
fn into_vnode(self, cx: NodeFactory) -> VNode {
cx.static_text(self)
2021-07-21 21:05:48 +00:00
}
}
impl IntoVNode<'_> for Arguments<'_> {
2021-09-21 22:13:09 +00:00
fn into_vnode(self, cx: NodeFactory) -> VNode {
2021-07-21 21:05:48 +00:00
cx.text(self)
}
}
2021-11-01 07:49:32 +00:00
2021-11-10 22:09:52 +00:00
// called cx.render from a helper function
2021-11-28 21:25:42 +00:00
impl IntoVNode<'_> for Option<VPortal> {
2021-11-10 22:09:52 +00:00
fn into_vnode(self, _cx: NodeFactory) -> VNode {
match self {
2021-11-28 21:25:42 +00:00
Some(node) => VNode::Portal(node),
2021-11-10 22:09:52 +00:00
None => {
todo!()
}
}
}
}
2021-11-10 22:09:52 +00:00
// essentially passing elements through props
// just build a new element in place
2021-11-28 21:25:42 +00:00
impl IntoVNode<'_> for &Option<VPortal> {
2021-11-10 22:09:52 +00:00
fn into_vnode(self, _cx: NodeFactory) -> VNode {
match self {
2021-11-28 21:25:42 +00:00
Some(node) => VNode::Portal(VPortal {
2021-11-10 22:09:52 +00:00
link_idx: node.link_idx.clone(),
scope_id: node.scope_id.clone(),
node: node.node,
}),
None => {
//
todo!()
}
}
2021-11-03 19:13:50 +00:00
}
}
2021-11-28 21:25:42 +00:00
impl IntoVNode<'_> for VPortal {
2021-11-10 22:09:52 +00:00
fn into_vnode(self, _cx: NodeFactory) -> VNode {
2021-11-28 21:25:42 +00:00
VNode::Portal(self)
2021-11-01 07:49:32 +00:00
}
}
2021-11-28 21:25:42 +00:00
impl IntoVNode<'_> for &VPortal {
2021-11-10 22:09:52 +00:00
fn into_vnode(self, _cx: NodeFactory) -> VNode {
2021-11-28 21:25:42 +00:00
VNode::Portal(VPortal {
2021-11-10 22:09:52 +00:00
link_idx: self.link_idx.clone(),
scope_id: self.scope_id.clone(),
node: self.node,
})
2021-11-01 07:49:32 +00:00
}
}