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

more cleanup

Browse Source
This commit is contained in:
Jonathan Kelley committed 2021-08-31 12:28:44 -04:00
1 parent 9f99f46cfd
commit 5cbdc571e3
10 files changed
+148 -192
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

packages/core/src/bumpframe.rs
+2 -2
View File
@@ -2,7 +2,7 @@ use crate::innerlude::*;
use bumpalo::Bump;
use std::cell::Cell;
pub struct ActiveFrame {
pub(crate) struct ActiveFrame {
// We use a "generation" for users of contents in the bump frames to ensure their data isn't broken
pub generation: Cell<usize>,
@@ -10,7 +10,7 @@ pub struct ActiveFrame {
pub frames: [BumpFrame; 2],
}
pub struct BumpFrame {
pub(crate) struct BumpFrame {
pub bump: Bump,
pub(crate) head_node: VNode<'static>,
packages/core/src/childiter.rs
+1 -14
View File
@@ -4,7 +4,7 @@ use crate::innerlude::*;
///
/// This iterator is useful when it's important to load the next real root onto the top of the stack for operations like
/// "InsertBefore".
pub struct RealChildIterator<'a> {
pub(crate) struct RealChildIterator<'a> {
scopes: &'a ResourcePool,
// Heuristcally we should never bleed into 4 completely nested fragments/components
@@ -20,19 +20,6 @@ impl<'a> RealChildIterator<'a> {
stack: smallvec::smallvec![(0, starter)],
}
}
pub fn new_from_slice(nodes: &'a [VNode<'a>], scopes: &'a ResourcePool) -> Self {
let mut stack = smallvec::smallvec![];
for node in nodes {
stack.push((0, node));
}
Self { scopes, stack }
}
// keep the memory around
pub fn reset_with(&mut self, node: &'a VNode<'a>) {
self.stack.clear();
self.stack.push((0, node));
}
}
impl<'a> Iterator for RealChildIterator<'a> {
packages/core/src/context.rs
-1
View File
@@ -112,7 +112,6 @@ impl<'src, P> Context<'src, P> {
}
/// Get's this component's unique identifier.
///
pub fn get_scope_id(&self) -> ScopeId {
self.scope.our_arena_idx.clone()
}
packages/core/src/events.rs
+7 -9
View File
@@ -6,13 +6,15 @@
use crate::innerlude::{ElementId, ScopeId};
#[derive(Debug)]
pub struct EventTrigger {
pub struct UiEvent {
/// The originator of the event trigger
pub scope: ScopeId,
/// The optional real node associated with the trigger
pub mounted_dom_id: Option<ElementId>,
pub listener_type: &'static str,
/// The type of event
pub event: SyntheticEvent,
}
@@ -26,7 +28,6 @@ pub enum SyntheticEvent {
FocusEvent(on::FocusEvent),
FormEvent(on::FormEvent),
SelectionEvent(on::SelectionEvent),
UIEvent(on::UIEvent),
WheelEvent(on::WheelEvent),
MediaEvent(on::MediaEvent),
AnimationEvent(on::AnimationEvent),
@@ -46,7 +47,6 @@ impl std::fmt::Debug for SyntheticEvent {
SyntheticEvent::FormEvent(_) => "FormEvent",
SyntheticEvent::SelectionEvent(_) => "SelectionEvent",
SyntheticEvent::TouchEvent(_) => "TouchEvent",
SyntheticEvent::UIEvent(_) => "UIEvent",
SyntheticEvent::WheelEvent(_) => "WheelEvent",
SyntheticEvent::MediaEvent(_) => "MediaEvent",
SyntheticEvent::AnimationEvent(_) => "AnimationEvent",
@@ -284,6 +284,9 @@ pub mod on {
/// onmouseout
onmouseout
///
onscroll
/// onmouseover
///
/// Triggered when the users's mouse hovers over an element.
@@ -331,14 +334,9 @@ pub mod on {
ontouchstart
];
UIEventInner(UIEvent): [
///
scroll
];
WheelEventInner(WheelEvent): [
///
wheel
onwheel
];
MediaEventInner(MediaEvent): [
packages/core/src/hooks.rs
+1 -1
View File
@@ -13,7 +13,7 @@ use crate::innerlude::*;
use futures_util::FutureExt;
use std::{
any::{Any, TypeId},
cell::{Cell, RefCell},
cell::RefCell,
future::Future,
rc::Rc,
};
packages/core/src/lib.rs
+49 -53
View File
@@ -1,65 +1,16 @@
#![allow(non_snake_case)]
#![doc = include_str!("../README.md")]
pub use crate::innerlude::{
format_args_f, html, rsx, Context, DiffInstruction, DioxusElement, DomEdit, DomTree, ElementId,
EventPriority, EventTrigger, LazyNodes, MountType, Mutations, NodeFactory, Properties, ScopeId,
SuspendedContext, SyntheticEvent, VNode, VirtualDom, FC,
};
pub mod prelude {
pub use crate::component::{fc_to_builder, Fragment, Properties};
pub use crate::context::Context;
pub use crate::hooks::*;
pub use crate::innerlude::{DioxusElement, DomTree, LazyNodes, Mutations, NodeFactory, FC};
pub use crate::nodes::VNode;
pub use crate::VirtualDom;
pub use dioxus_core_macro::{format_args_f, html, rsx, Props};
}
pub(crate) mod innerlude {
pub use crate::bumpframe::*;
pub use crate::childiter::*;
pub use crate::component::*;
pub use crate::context::*;
pub use crate::diff::*;
pub use crate::diff_stack::*;
pub use crate::events::*;
pub use crate::heuristics::*;
pub use crate::hooklist::*;
pub use crate::hooks::*;
pub use crate::mutations::*;
pub use crate::nodes::*;
pub use crate::scheduler::*;
pub use crate::scope::*;
pub use crate::util::*;
pub use crate::virtual_dom::*;
pub use crate::yield_now::*;
pub type DomTree<'a> = Option<VNode<'a>>;
pub type FC<P> = fn(Context<P>) -> DomTree;
pub use dioxus_core_macro::{format_args_f, html, rsx};
}
pub mod exports {
//! Important dependencies that are used by the rest of the library
// the foundation of this library
pub use bumpalo;
}
/*
Navigating this crate:
- virtual_dom: the primary entrypoint for the crate
- scheduler: the core interior logic called by virtual_dom
- nodes: the definition of VNodes, listeners, etc.
-
- diff: the stackmachine-based diffing algorithm
- hooks: foundational hooks that require crate-private APIs
- mutations: DomEdits/NodeRefs and internal API to create them
Some utilities
*/
pub mod bumpframe;
pub mod childiter;
@@ -78,4 +29,49 @@ pub mod scope;
pub mod signals;
pub mod util;
pub mod virtual_dom;
pub mod yield_now;
pub(crate) mod innerlude {
pub(crate) use crate::bumpframe::*;
pub(crate) use crate::childiter::*;
pub use crate::component::*;
pub use crate::context::*;
pub(crate) use crate::diff::*;
pub use crate::diff_stack::*;
pub use crate::events::*;
pub use crate::heuristics::*;
pub use crate::hooklist::*;
pub use crate::hooks::*;
pub use crate::mutations::*;
pub use crate::nodes::*;
pub use crate::scheduler::*;
pub use crate::scope::*;
pub use crate::util::*;
pub use crate::virtual_dom::*;
pub type DomTree<'a> = Option<VNode<'a>>;
pub type FC<P> = fn(Context<P>) -> DomTree;
pub use dioxus_core_macro::{format_args_f, html, rsx};
}
pub use crate::innerlude::{
format_args_f, html, rsx, Context, DiffInstruction, DioxusElement, DomEdit, DomTree, ElementId,
EventPriority, LazyNodes, MountType, Mutations, NodeFactory, Properties, ScopeId,
SuspendedContext, SyntheticEvent, UiEvent, VNode, VirtualDom, FC,
};
pub mod prelude {
pub use crate::component::{fc_to_builder, Fragment, Properties};
pub use crate::context::Context;
pub use crate::hooks::*;
pub use crate::innerlude::{DioxusElement, DomTree, LazyNodes, Mutations, NodeFactory, FC};
pub use crate::nodes::VNode;
pub use crate::VirtualDom;
pub use dioxus_core_macro::{format_args_f, html, rsx, Props};
}
pub mod exports {
//! Important dependencies that are used by the rest of the library
// the foundation of this library
pub use bumpalo;
}
packages/core/src/scheduler.rs
+34 -49
View File
@@ -97,7 +97,7 @@ pub struct EventChannel {
pub enum SchedulerMsg {
Immediate(ScopeId),
UiEvent(EventTrigger),
UiEvent(UiEvent),
SubmitTask(FiberTask, u64),
ToggleTask(u64),
PauseTask(u64),
@@ -140,11 +140,11 @@ pub(crate) struct Scheduler {
// scheduler stuff
pub current_priority: EventPriority,
pub ui_events: VecDeque<EventTrigger>,
pub ui_events: VecDeque<UiEvent>,
pub pending_immediates: VecDeque<ScopeId>,
pub pending_tasks: VecDeque<EventTrigger>,
pub pending_tasks: VecDeque<UiEvent>,
pub garbage_scopes: HashSet<ScopeId>,
@@ -248,39 +248,37 @@ impl Scheduler {
// Converts UI events into dirty scopes with various priorities
pub fn consume_pending_events(&mut self) {
// while let Some(trigger) = self.ui_events.pop_back() {
// match &trigger.event {
// SyntheticEvent::ClipboardEvent(_)
// | SyntheticEvent::CompositionEvent(_)
// | SyntheticEvent::KeyboardEvent(_)
// | SyntheticEvent::FocusEvent(_)
// | SyntheticEvent::FormEvent(_)
// | SyntheticEvent::SelectionEvent(_)
// | SyntheticEvent::TouchEvent(_)
// | SyntheticEvent::UIEvent(_)
// | SyntheticEvent::WheelEvent(_)
// | SyntheticEvent::MediaEvent(_)
// | SyntheticEvent::AnimationEvent(_)
// | SyntheticEvent::TransitionEvent(_)
// | SyntheticEvent::ToggleEvent(_)
// | SyntheticEvent::MouseEvent(_)
// | SyntheticEvent::PointerEvent(_) => {
// if let Some(scope) = self.get_scope_mut(trigger.scope) {
// if let Some(element) = trigger.mounted_dom_id {
// scope.call_listener(trigger.event, element)?;
while let Some(trigger) = self.ui_events.pop_back() {
if let Some(scope) = self.pool.get_scope_mut(trigger.scope) {
if let Some(element) = trigger.mounted_dom_id {
let priority = match &trigger.event {
SyntheticEvent::ClipboardEvent(_) => {}
SyntheticEvent::CompositionEvent(_) => {}
SyntheticEvent::KeyboardEvent(_) => {}
SyntheticEvent::FocusEvent(_) => {}
SyntheticEvent::FormEvent(_) => {}
SyntheticEvent::SelectionEvent(_) => {}
SyntheticEvent::TouchEvent(_) => {}
SyntheticEvent::WheelEvent(_) => {}
SyntheticEvent::MediaEvent(_) => {}
SyntheticEvent::AnimationEvent(_) => {}
SyntheticEvent::TransitionEvent(_) => {}
SyntheticEvent::ToggleEvent(_) => {}
SyntheticEvent::MouseEvent(_) => {}
SyntheticEvent::PointerEvent(_) => {}
};
// // let receiver = self.immediate_receiver.clone();
// // let mut receiver = receiver.borrow_mut();
scope.call_listener(trigger.event, element);
// let receiver = self.immediate_receiver.clone();
// let mut receiver = receiver.borrow_mut();
// // // Drain the immediates into the dirty scopes, setting the appropiate priorities
// // while let Ok(Some(dirty_scope)) = receiver.try_next() {
// // self.add_dirty_scope(dirty_scope, trigger.priority)
// // }
// }
// }
// }
// }
// }
// // Drain the immediates into the dirty scopes, setting the appropiate priorities
// while let Ok(Some(dirty_scope)) = receiver.try_next() {
// self.add_dirty_scope(dirty_scope, trigger.priority)
// }
}
}
}
}
// nothing to do, no events on channels, no work
@@ -293,26 +291,13 @@ impl Scheduler {
}
pub fn has_work(&self) -> bool {
todo!()
// self.high_priorty.has_work()
// || self.medium_priority.has_work()
// || self.low_priority.has_work()
self.lanes.iter().find(|f| f.has_work()).is_some()
}
pub fn has_pending_garbage(&self) -> bool {
!self.garbage_scopes.is_empty()
}
fn get_current_fiber<'a>(&'a mut self) -> &mut DiffMachine<'a> {
todo!()
// let fib = match self.current_priority {
// EventPriority::High => &mut self.high_priorty,
// EventPriority::Medium => &mut self.medium_priority,
// EventPriority::Low => &mut self.low_priority,
// };
// unsafe { std::mem::transmute(fib) }
}
fn shift_priorities(&mut self) {
self.current_priority = match (
self.lanes[0].has_work(),
@@ -634,7 +619,7 @@ pub enum EventPriority {
}
#[derive(Clone)]
pub struct ResourcePool {
pub(crate) struct ResourcePool {
/*
This *has* to be an UnsafeCell.
packages/core/src/scope.rs
+1 -7
View File
@@ -195,11 +195,7 @@ impl Scope {
// A safe wrapper around calling listeners
//
//
pub(crate) fn call_listener(
&mut self,
event: SyntheticEvent,
element: ElementId,
) -> Option<()> {
pub(crate) fn call_listener(&mut self, event: SyntheticEvent, element: ElementId) {
let listners = self.listeners.borrow_mut();
let raw_listener = listners.iter().find(|lis| {
@@ -222,8 +218,6 @@ impl Scope {
} else {
log::warn!("An event was triggered but there was no listener to handle it");
}
Some(())
}
pub fn root(&self) -> &VNode {
packages/core/src/util.rs
+53
View File
@@ -11,3 +11,56 @@ pub fn empty_cell() -> Cell<Option<ElementId>> {
pub fn type_name_of<T>(_: T) -> &'static str {
std::any::type_name::<T>()
}
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
// use crate::task::{Context, Poll};
/// Cooperatively gives up a timeslice to the task scheduler.
///
/// Calling this function will move the currently executing future to the back
/// of the execution queue, making room for other futures to execute. This is
/// especially useful after running CPU-intensive operations inside a future.
///
/// See also [`task::spawn_blocking`].
///
/// [`task::spawn_blocking`]: fn.spawn_blocking.html
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// # async_std::task::block_on(async {
/// #
/// use async_std::task;
///
/// task::yield_now().await;
/// #
/// # })
/// ```
#[inline]
pub async fn yield_now() {
YieldNow(false).await
}
struct YieldNow(bool);
impl Future for YieldNow {
type Output = ();
// The futures executor is implemented as a FIFO queue, so all this future
// does is re-schedule the future back to the end of the queue, giving room
// for other futures to progress.
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
if !self.0 {
self.0 = true;
cx.waker().wake_by_ref();
Poll::Pending
} else {
Poll::Ready(())
}
}
}
packages/core/src/yield_now.rs
-56
View File
@@ -1,56 +0,0 @@
//! Utility Code taken from async_std to immediately yield the current task to the executor.
//!
//!
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
// use crate::task::{Context, Poll};
/// Cooperatively gives up a timeslice to the task scheduler.
///
/// Calling this function will move the currently executing future to the back
/// of the execution queue, making room for other futures to execute. This is
/// especially useful after running CPU-intensive operations inside a future.
///
/// See also [`task::spawn_blocking`].
///
/// [`task::spawn_blocking`]: fn.spawn_blocking.html
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// # async_std::task::block_on(async {
/// #
/// use async_std::task;
///
/// task::yield_now().await;
/// #
/// # })
/// ```
#[inline]
pub async fn yield_now() {
YieldNow(false).await
}
struct YieldNow(bool);
impl Future for YieldNow {
type Output = ();
// The futures executor is implemented as a FIFO queue, so all this future
// does is re-schedule the future back to the end of the queue, giving room
// for other futures to progress.
fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
if !self.0 {
self.0 = true;
cx.waker().wake_by_ref();
Poll::Pending
} else {
Poll::Ready(())
}
}
}