swaits/dioxus
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: some docs, cleaning

Browse Source
This commit is contained in:
Jonathan Kelley committed 2021-09-01 00:57:04 -04:00
1 parent acad9ca622
commit c321532a6c
19 files changed
+269 -195
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/core/.vscode/settings.json
Vendored
+1 -1
View File
@@ -1,3 +1,3 @@
{
"rust-analyzer.inlayHints.enable": true
"rust-analyzer.inlayHints.enable": false
}
packages/core/examples/alternative.rs
+1 -1
View File
@@ -3,7 +3,7 @@ use dioxus_core::prelude::*;
fn main() {}
pub static Example: FC<()> = |cx| {
let list = (0..10).map(|f| LazyNodes::new(move |f| todo!()));
let list = (0..10).map(|_f| LazyNodes::new(move |_f| todo!()));
cx.render(LazyNodes::new(move |cx| {
cx.raw_element(
packages/core/examples/async.rs
+1 -1
View File
@@ -21,7 +21,7 @@ const App: FC<()> = |cx| {
};
const Task: FC<()> = |cx| {
let (task, res) = use_task(cx, || async { true });
let (_task, _res) = use_task(cx, || async { true });
// task.pause();
// task.restart();
// task.stop();
packages/core/examples/vdom_usage.rs
+2 -2
View File
@@ -10,6 +10,6 @@ async fn main() {
dom.rebuild();
let mut deadline = async_std::task::sleep(Duration::from_millis(50));
let fut = dom.run_with_deadline(deadline);
let deadline = async_std::task::sleep(Duration::from_millis(50));
let _fut = dom.run_with_deadline(deadline);
}
packages/core/src/childiter.rs
+4 -3
View File
@@ -60,9 +60,10 @@ impl<'a> Iterator for RealChildIterator<'a> {
// For components, we load their root and push them onto the stack
VNode::Component(sc) => {
let scope =
unsafe { self.scopes.get_scope(sc.associated_scope.get().unwrap()) }
.unwrap();
let scope = self
.scopes
.get_scope(sc.associated_scope.get().unwrap())
.unwrap();
// let scope = self.scopes.get(sc.ass_scope.get().unwrap()).unwrap();
// Simply swap the current node on the stack with the root of the component
packages/core/src/context.rs
+5 -14
View File
@@ -87,6 +87,10 @@ impl<'src, P> Context<'src, P> {
/// })
/// }
/// ```
///
/// ## Notes:
///
/// This method returns a "ScopeChildren" object. This object is copy-able and preserve the correct lifetime.
pub fn children(&self) -> ScopeChildren<'src> {
self.scope.child_nodes()
}
@@ -103,19 +107,6 @@ impl<'src, P> Context<'src, P> {
self.scope.shared.schedule_any_immediate.clone()
}
pub fn schedule_effect(&self) -> Rc<dyn Fn() + 'static> {
todo!()
}
pub fn schedule_layout_effect(&self) {
todo!()
}
/// Get's this component's unique identifier.
pub fn get_scope_id(&self) -> ScopeId {
self.scope.our_arena_idx.clone()
}
/// Take a lazy VNode structure and actually build it with the context of the VDom's efficient VNode allocator.
///
/// This function consumes the context and absorb the lifetime, so these VNodes *must* be returned.
@@ -175,7 +166,7 @@ impl<'src, P> Context<'src, P> {
let getter = &self.scope.shared.get_shared_context;
let ty = TypeId::of::<T>();
let idx = self.scope.our_arena_idx;
getter(idx, ty).map(|f| f.downcast().unwrap())
getter(idx, ty).map(|f| f.downcast().expect("TypeID already validated"))
}
/// Store a value between renders
packages/core/src/diff.rs
+44 -2
View File
@@ -200,7 +200,7 @@ impl<'bump> DiffMachine<'bump> {
fn prepare_move_node(&mut self, node: &'bump VNode<'bump>) {
for el in RealChildIterator::new(node, self.vdom) {
self.mutations.push_root(el.direct_id());
self.mutations.push_root(el.mounted_id());
self.stack.add_child_count(1);
}
}
@@ -223,7 +223,7 @@ impl<'bump> DiffMachine<'bump> {
let mut iter = RealChildIterator::new(old, self.vdom);
let first = iter.next().unwrap();
self.mutations
.replace_with(first.direct_id(), nodes_created as u32);
.replace_with(first.mounted_id(), nodes_created as u32);
self.remove_nodes(iter);
}
@@ -1091,4 +1091,46 @@ impl<'bump> DiffMachine<'bump> {
let long_listener: &'a Listener<'static> = unsafe { std::mem::transmute(listener) };
queue.push(long_listener as *const _)
}
/// Destroy a scope and all of its descendents.
///
/// Calling this will run the destuctors on all hooks in the tree.
/// It will also add the destroyed nodes to the `seen_nodes` cache to prevent them from being renderered.
fn destroy_scopes(&mut self, old_scope: ScopeId) {
let mut nodes_to_delete = vec![old_scope];
let mut scopes_to_explore = vec![old_scope];
// explore the scope tree breadth first
while let Some(scope_id) = scopes_to_explore.pop() {
// If we're planning on deleting this node, then we don't need to both rendering it
self.seen_scopes.insert(scope_id);
let scope = self.vdom.get_scope(scope_id).unwrap();
for child in scope.descendents.borrow().iter() {
// Add this node to be explored
scopes_to_explore.push(child.clone());
// Also add it for deletion
nodes_to_delete.push(child.clone());
}
}
// Delete all scopes that we found as part of this subtree
for node in nodes_to_delete {
log::debug!("Removing scope {:#?}", node);
let _scope = self.vdom.try_remove(node).unwrap();
// do anything we need to do to delete the scope
// I think we need to run the destructors on the hooks
// TODO
}
}
}
fn compare_strs(a: &str, b: &str) -> bool {
// Check by pointer, optimizing for static strs
if !std::ptr::eq(a, b) {
// If the pointers are different then check by value
a == b
} else {
true
}
}
packages/core/src/diffsupport.rs
-72
View File
@@ -1,72 +0,0 @@
/// Destroy a scope and all of its descendents.
///
/// Calling this will run the destuctors on all hooks in the tree.
/// It will also add the destroyed nodes to the `seen_nodes` cache to prevent them from being renderered.
fn destroy_scopes(&mut self, old_scope: ScopeId) {
let mut nodes_to_delete = vec![old_scope];
let mut scopes_to_explore = vec![old_scope];
// explore the scope tree breadth first
while let Some(scope_id) = scopes_to_explore.pop() {
// If we're planning on deleting this node, then we don't need to both rendering it
self.seen_scopes.insert(scope_id);
let scope = self.get_scope(&scope_id).unwrap();
for child in scope.descendents.borrow().iter() {
// Add this node to be explored
scopes_to_explore.push(child.clone());
// Also add it for deletion
nodes_to_delete.push(child.clone());
}
}
// Delete all scopes that we found as part of this subtree
for node in nodes_to_delete {
log::debug!("Removing scope {:#?}", node);
let _scope = self.vdom.try_remove(node).unwrap();
// do anything we need to do to delete the scope
// I think we need to run the destructors on the hooks
// TODO
}
}
pub(crate) fn get_scope_mut(&mut self, id: &ScopeId) -> Option<&'bump mut Scope> {
// ensure we haven't seen this scope before
// if we have, then we're trying to alias it, which is not allowed
debug_assert!(!self.seen_scopes.contains(id));
unsafe { self.vdom.get_scope_mut(*id) }
}
pub(crate) fn get_scope(&mut self, id: &ScopeId) -> Option<&'bump Scope> {
// ensure we haven't seen this scope before
// if we have, then we're trying to alias it, which is not allowed
unsafe { self.vdom.get_scope(*id) }
}
fn compare_strs(a: &str, b: &str) -> bool {
// Check by pointer, optimizing for static strs
if !std::ptr::eq(a, b) {
// If the pointers are different then check by value
a == b
} else {
true
}
}
fn find_first_real_node<'a>(
nodes: impl IntoIterator<Item = &'a VNode<'a>>,
scopes: &'a SharedResources,
) -> Option<&'a VNode<'a>> {
for node in nodes {
let mut iter = RealChildIterator::new(node, scopes);
if let Some(node) = iter.next() {
return Some(node);
}
}
None
}
fn remove_children(&mut self, old: &'bump [VNode<'bump>]) {
self.replace_and_create_many_with_many(old, None)
}
packages/core/src/hooks.rs
+2 -4
View File
@@ -119,13 +119,11 @@ where
let slot = task_dump.clone();
let updater = cx.prepare_update();
let update_id = cx.get_scope_id();
let originator = cx.scope.our_arena_idx.clone();
let originator = cx.scope.our_arena_idx;
let handle = cx.submit_task(Box::pin(task_fut.then(move |output| async move {
*slot.as_ref().borrow_mut() = Some(output);
updater(update_id);
updater(originator);
originator
})));
packages/core/src/lib.rs
-1
View File
@@ -26,7 +26,6 @@ pub mod mutations;
pub mod nodes;
pub mod scheduler;
pub mod scope;
pub mod signals;
pub mod util;
pub mod virtual_dom;
packages/core/src/nodes.rs
+197 -70
View File
@@ -1,12 +1,11 @@
//! Virtual Node Support
//! --------------------
//! 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 insanely quick.
use crate::{
events::SyntheticEvent,
innerlude::{empty_cell, Context, DomTree, ElementId, Properties, Scope, ScopeId, FC},
SuspendedContext,
//! 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.
use crate::innerlude::{
empty_cell, Context, DomTree, ElementId, Properties, Scope, ScopeId, SuspendedContext,
SyntheticEvent, FC,
};
use bumpalo::{boxed::Box as BumpBox, Bump};
use std::{
@@ -16,26 +15,113 @@ use std::{
rc::Rc,
};
/// Tools for the base unit of the virtual dom - the VNode
/// VNodes are intended to be quickly-allocated, lightweight enum values.
/// A composable "VirtualNode" to declare a User Interface in the Dioxus VirtualDOM.
///
/// Components will be generating a lot of these very quickly, so we want to
/// limit the amount of heap allocations / overly large enum sizes.
/// VNodes are designed to be lightweight and used with with a bump alloactor. To create a VNode, you can use either of:
/// - the [`rsx`] macro
/// - the [`html`] macro
/// - the [`NodeFactory`] API
pub enum VNode<'src> {
/// Text VNodes simply bump-allocated (or static) string slices
///
/// # Example
///
/// let node = cx.render(rsx!{ "hello" }).unwrap();
///
/// 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(VText<'src>),
/// Element VNodes are VNodes that may contain attributes, listeners, a key, a tag, and children.
///
/// # Example
///
/// ```rust
/// let node = cx.render(rsx!{
/// div {
/// key: "a",
/// onclick: |e| log::info!("clicked"),
/// hidden: "true",
/// style: { background_color: "red" }
/// "hello"
/// }
/// }).unwrap();
/// if let VNode::Element(velement) = node {
/// assert_eq!(velement.tag_name, "div");
/// assert_eq!(velement.namespace, None);
/// assert_eq!(velement.key, Some("a));
/// }
/// ```
Element(&'src VElement<'src>),
/// Fragment nodes may contain many VNodes without a single root.
///
/// # Example
///
/// ```rust
/// rsx!{
/// a {}
/// link {}
/// style {}
/// "asd"
/// Example {}
/// }
/// ```
Fragment(VFragment<'src>),
/// Component nodes represent a mounted component with props, children, and a key.
///
/// # Example
///
/// ```rust
/// fn Example(cx: Context<()>) -> DomTree {
/// todo!()
/// }
///
/// let node = cx.render(rsx!{
/// Example {}
/// }).unwrap();
///
/// if let VNode::Component(vcomp) = node {
/// assert_eq!(vcomp.user_fc, Example as *const ());
/// }
/// ```
Component(&'src VComponent<'src>),
/// Suspended VNodes represent chunks of the UI tree that are not yet ready to be displayed.
///
/// These nodes currently can only be constructed via the [`use_suspense`] hook.
///
/// # Example
///
/// ```rust
/// rsx!{
/// }
/// ```
Suspended(&'src VSuspended<'src>),
/// Anchors are a type of placeholder VNode used when fragments don't contain any children.
///
/// Anchors cannot be directly constructed via public APIs.
///
/// # Example
///
/// ```rust
/// let node = cx.render(rsx! ( Fragment {} )).unwrap();
/// if let VNode::Fragment(frag) = node {
/// let root = &frag.children[0];
/// assert_eq!(root, VNode::Anchor);
/// }
/// ```
Anchor(VAnchor),
}
impl<'src> VNode<'src> {
/// Get the VNode's "key" used in the keyed diffing algorithm.
pub fn key(&self) -> Option<&'src str> {
match &self {
VNode::Element(el) => el.key,
@@ -46,25 +132,35 @@ impl<'src> VNode<'src> {
VNode::Anchor(_f) => None,
}
}
pub fn direct_id(&self) -> ElementId {
self.try_direct_id().unwrap()
/// 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()
}
pub fn try_direct_id(&self) -> Option<ElementId> {
/// 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> {
match &self {
VNode::Text(el) => el.dom_id.get(),
VNode::Element(el) => el.dom_id.get(),
VNode::Anchor(el) => el.dom_id.get(),
VNode::Suspended(el) => el.dom_id.get(),
VNode::Fragment(_) => None,
VNode::Component(_) => None,
VNode::Suspended(_) => None,
}
}
}
/// A placeholder node only generated when Fragments don't have any children.
pub struct VAnchor {
pub dom_id: Cell<Option<ElementId>>,
}
/// A bump-alloacted string slice and metadata.
pub struct VText<'src> {
pub text: &'src str,
@@ -73,6 +169,7 @@ pub struct VText<'src> {
pub is_static: bool,
}
/// A list of VNodes with no single root.
pub struct VFragment<'src> {
pub key: Option<&'src str>,
@@ -81,6 +178,7 @@ pub struct VFragment<'src> {
pub is_static: bool,
}
/// An element like a "div" with children, listeners, and attributes.
pub struct VElement<'a> {
pub tag_name: &'static str,
@@ -97,6 +195,22 @@ pub struct VElement<'a> {
pub children: &'a [VNode<'a>],
}
/// A trait for any generic Dioxus Element.
///
/// This trait provides the ability to use custom elements in the `rsx!` macro.
///
/// ```rust
/// struct my_element;
///
/// impl DioxusElement for my_element {
/// const TAG_NAME: "my_element";
/// const NAME_SPACE: None;
/// }
///
/// let _ = rsx!{
/// my_element {}
/// };
/// ```
pub trait DioxusElement {
const TAG_NAME: &'static str;
const NAME_SPACE: Option<&'static str>;
@@ -122,18 +236,21 @@ pub struct Attribute<'a> {
pub is_volatile: bool,
// Doesn't exist in the html spec, mostly used to denote "style" tags - could be for any type of group
// Doesn't exist in the html spec.
// Used in Dioxus to denote "style" tags.
pub namespace: Option<&'static str>,
}
/// An event listener.
/// IE onclick, onkeydown, etc
pub struct Listener<'bump> {
/// The type of event to listen for.
pub(crate) event: &'static str,
pub mounted_node: Cell<Option<ElementId>>,
/// The type of event to listen for.
///
/// IE "onclick" - whatever the renderer needs to attach the listener by name.
pub event: &'static str,
pub(crate) callback: RefCell<Option<BumpBox<'bump, dyn FnMut(SyntheticEvent) + 'bump>>>,
}
@@ -144,6 +261,11 @@ pub struct VComponent<'src> {
pub associated_scope: Cell<Option<ScopeId>>,
pub is_static: bool,
// Function pointer to the FC that was used to generate this component
pub user_fc: *const (),
pub(crate) caller: Rc<dyn Fn(&Scope) -> DomTree>,
pub(crate) children: &'src [VNode<'src>],
@@ -152,15 +274,10 @@ pub struct VComponent<'src> {
pub(crate) drop_props: RefCell<Option<BumpBox<'src, dyn FnMut()>>>,
pub is_static: bool,
pub(crate) can_memoize: bool,
// Raw pointer into the bump arena for the props of the component
pub(crate) raw_props: *const (),
// Function pointer to the FC that was used to generate this component
pub(crate) user_fc: *const (),
}
pub struct VSuspended<'a> {
@@ -203,7 +320,7 @@ impl<'a> NodeFactory<'a> {
})
}
/// Used in a place or two to make it easier to build vnodes from dummy text
/// 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(VText {
dom_id: empty_cell(),
@@ -220,9 +337,9 @@ impl<'a> NodeFactory<'a> {
Some(static_str) => (static_str, true),
None => {
use bumpalo::core_alloc::fmt::Write;
let mut s = bumpalo::collections::String::new_in(self.bump());
s.write_fmt(args).unwrap();
(s.into_bump_str(), false)
let mut str_buf = bumpalo::collections::String::new_in(self.bump());
str_buf.write_fmt(args).unwrap();
(str_buf.into_bump_str(), false)
}
}
}
@@ -264,7 +381,7 @@ impl<'a> NodeFactory<'a> {
pub fn raw_element<L, A, V>(
&self,
tag: &'static str,
tag_name: &'static str,
namespace: Option<&'static str>,
listeners: L,
attributes: A,
@@ -288,7 +405,7 @@ impl<'a> NodeFactory<'a> {
let key = key.map(|f| self.raw_text(f).0);
VNode::Element(self.bump().alloc(VElement {
tag_name: tag,
tag_name,
key,
namespace,
listeners,
@@ -315,22 +432,6 @@ impl<'a> NodeFactory<'a> {
}
}
pub fn attr_with_alloc_val(
&self,
name: &'static str,
val: &'a str,
namespace: Option<&'static str>,
is_volatile: bool,
) -> Attribute<'a> {
Attribute {
name,
value: val,
is_static: false,
namespace,
is_volatile,
}
}
pub fn component<P, V>(
&self,
component: FC<P>,
@@ -343,14 +444,9 @@ impl<'a> NodeFactory<'a> {
V: 'a + AsRef<[VNode<'a>]>,
{
let bump = self.bump();
// We don't want the fat part of the fat pointer
// THe "Fat" part is provided on next-render
let children: &'a V = bump.alloc(children);
let children = children.as_ref();
let props = bump.alloc(props);
let raw_props = props as *mut P as *mut ();
let user_fc = component as *const ();
@@ -379,36 +475,46 @@ impl<'a> NodeFactory<'a> {
}
}));
// 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 = raw_props as *mut _ as *mut P;
let b = BumpBox::from_raw(real_other);
std::mem::drop(b);
let drop_props = {
// create a closure to drop the props
let mut has_dropped = false;
has_dropped = true;
let drop_props: &mut dyn FnMut() = bump.alloc_with(|| {
move || unsafe {
if !has_dropped {
let real_other = raw_props as *mut _ as *mut P;
let b = BumpBox::from_raw(real_other);
std::mem::drop(b);
has_dropped = true;
}
}
}
});
let drop_props = unsafe { BumpBox::from_raw(drop_props) };
});
let drop_props = unsafe { BumpBox::from_raw(drop_props) };
RefCell::new(Some(drop_props))
};
let is_static = children.len() == 0 && P::IS_STATIC && key.is_none();
let key = key.map(|f| self.raw_text(f).0);
let caller = NodeFactory::create_component_caller(component, raw_props);
let can_memoize = children.len() == 0 && P::IS_STATIC;
VNode::Component(bump.alloc_with(|| VComponent {
user_fc,
comparator,
raw_props,
children,
caller: NodeFactory::create_component_caller(component, raw_props),
caller,
is_static,
drop_props: RefCell::new(Some(drop_props)),
can_memoize: P::IS_STATIC,
associated_scope: Cell::new(None),
key,
can_memoize,
drop_props,
associated_scope: Cell::new(None),
}))
}
@@ -509,21 +615,41 @@ where
}
}
/// Child nodes of the parent component.
///
/// # Example
///
/// ```rust
/// let children = cx.children();
/// let first_node = &children[0];
/// rsx!{
/// h1 { {first_node} }
/// p { {&children[1..]} }
/// }
/// ```
///
pub struct ScopeChildren<'a>(pub &'a [VNode<'a>]);
impl Copy for ScopeChildren<'_> {}
impl<'a> Clone for ScopeChildren<'a> {
fn clone(&self) -> Self {
ScopeChildren(self.0)
}
}
impl ScopeChildren<'_> {
pub unsafe fn extend_lifetime(self) -> ScopeChildren<'static> {
// dangerous method - used to fix the associated lifetime
pub(crate) unsafe fn extend_lifetime(self) -> ScopeChildren<'static> {
std::mem::transmute(self)
}
pub unsafe fn unextend_lfetime<'a>(self) -> ScopeChildren<'a> {
// dangerous method - used to fix the associated lifetime
pub(crate) unsafe fn shorten_lifetime<'a>(self) -> ScopeChildren<'a> {
std::mem::transmute(self)
}
}
impl<'a> IntoVNodeList<'a> for ScopeChildren<'a> {
fn into_vnode_list(self, _: NodeFactory<'a>) -> &'a [VNode<'a>] {
self.0
@@ -610,6 +736,7 @@ impl IntoVNode<'_> for Option<()> {
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> {
match self {
@@ -647,7 +774,7 @@ impl Debug for VNode<'_> {
.finish()
}
VNode::Text(t) => write!(s, "VText {{ text: {} }}", t.text),
VNode::Anchor(a) => write!(s, "VAnchor"),
VNode::Anchor(_) => write!(s, "VAnchor"),
VNode::Fragment(frag) => write!(s, "VFragment {{ children: {:?} }}", frag.children),
VNode::Suspended { .. } => write!(s, "VSuspended"),
packages/core/src/scheduler.rs
+2
View File
@@ -703,6 +703,8 @@ impl ResourcePool {
id
}
pub fn borrow_bumpframe(&self) {}
pub fn clean_up_garbage(&mut self) {
// let mut scopes_to_kill = Vec::new();
// let mut garbage_list = Vec::new();
packages/core/src/scope.rs
+3 -11
View File
@@ -1,12 +1,9 @@
use crate::innerlude::*;
use bumpalo::boxed::Box as BumpBox;
use futures_channel::mpsc::UnboundedSender;
use fxhash::FxHashSet;
use std::{
any::{Any, TypeId},
borrow::BorrowMut,
cell::{Cell, RefCell},
collections::{HashMap, HashSet},
cell::RefCell,
collections::HashMap,
future::Future,
pin::Pin,
rc::Rc,
@@ -68,15 +65,10 @@ impl Scope {
// Therefore, their lifetimes are connected exclusively to the virtual dom
pub fn new<'creator_node>(
caller: Rc<WrappedCaller>,
arena_idx: ScopeId,
parent: Option<ScopeId>,
height: u32,
child_nodes: ScopeChildren,
shared: EventChannel,
) -> Self {
let child_nodes = unsafe { child_nodes.extend_lifetime() };
@@ -225,7 +217,7 @@ impl Scope {
}
pub fn child_nodes<'a>(&'a self) -> ScopeChildren {
unsafe { self.child_nodes.unextend_lfetime() }
unsafe { self.child_nodes.shorten_lifetime() }
}
pub fn consume_garbage(&self) -> Vec<&VNode> {
packages/core/src/signals.rs
-5
View File
@@ -1,5 +0,0 @@
//! Signas: Avoid the Diff Engine
//! -----------------------------
//!
//!
//! TODO!
packages/core/src/virtual_dom.rs
+1 -2
View File
@@ -14,13 +14,12 @@
//! - The [`ActiveFrame`] object for managing the Scope`s microheap
//! - The [`Context`] object for exposing VirtualDOM API to components
//! - The [`NodeFactory`] object for lazyily exposing the `Context` API to the nodebuilder API
//! - The [`Hook`] object for exposing state management in components.
//!
//! This module includes just the barebones for a complete VirtualDOM API.
//! Additional functionality is defined in the respective files.
use crate::innerlude::*;
use futures_util::{pin_mut, Future, FutureExt};
use futures_util::{Future, FutureExt};
use std::{
any::{Any, TypeId},
pin::Pin,
packages/core/tests/diff_iterative.rs
+1 -1
View File
@@ -31,7 +31,7 @@ async fn test_iterative_create_components() {
}
}
}
{(0..0).map(|f| rsx!{ div { "walalla"}})}
{(0..0).map(|_f| rsx!{ div { "walalla"}})}
p {}
})
}
packages/core/tests/set_state_batch.rs
+3 -3
View File
@@ -16,12 +16,12 @@ about 10ms, which is way more than enough for diffing/creating to happen.
async fn batch() {
let (sender, mut recver) = futures_channel::mpsc::unbounded::<i32>();
let handle = async_std::task::spawn(async move {
let msg = recver.next().await;
let _handle = async_std::task::spawn(async move {
let _msg = recver.next().await;
while let Ok(msg) = recver.try_next() {
println!("{:#?}", msg);
}
let msg = recver.next().await;
let _msg = recver.next().await;
while let Ok(msg) = recver.try_next() {
println!("{:#?}", msg);
}
packages/core/tests/test_logging.rs
+1 -1
View File
@@ -1,6 +1,6 @@
pub fn set_up_logging(enabled: bool) {
use fern::colors::{Color, ColoredLevelConfig};
use log::debug;
if !enabled {
return;
packages/ssr/src/lib.rs
+1 -1
View File
@@ -129,7 +129,7 @@ impl<'a> TextRenderer<'a> {
//
// when the page is loaded, the `querySelectorAll` will be used to collect all the nodes, and then add
// them interpreter's stack
match (self.cfg.pre_render, node.try_direct_id()) {
match (self.cfg.pre_render, node.try_mounted_id()) {
(true, Some(id)) => {
write!(f, " dio_el=\"{}\"", id)?;
//