(s) {
Err(err) => err.to_compile_error().into(),
Ok(stream) => stream.to_token_stream().into(),
}
}
-/// Derive macro used to mark an enum as Routable.
-///
-/// This macro can only be used on enums. Every varient of the macro needs to be marked
-/// with the `at` attribute to specify the URL of the route. It generates an implementation of
-/// `yew_router::Routable` trait and `const`s for the routes passed which are used with `Route`
-/// component.
-///
-/// # Example
-///
-/// ```
-/// # use yew_router::Routable;
-/// #[derive(Debug, Clone, Copy, PartialEq, Routable)]
-/// enum Routes {
-/// #[at("/")]
-/// Home,
-/// #[at("/secure")]
-/// Secure,
-/// #[at("/profile/{id}")]
-/// Profile(u32),
-/// #[at("/404")]
-/// NotFound,
-/// }
-/// ```
-#[proc_macro_derive(Routable, attributes(at, not_found))]
-pub fn routable_derive(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
- use router::{routable_derive_impl, Routable};
- let input = parse_macro_input!(input as Routable);
- routable_derive_impl(input).into()
-}
-
/// Derive props for a component within the component definition.
///
/// This macro provides a simple transformation from `Scope<{}>` to `Scope`,
diff --git a/packages/core-macro/src/router.rs b/packages/core-macro/src/router.rs
deleted file mode 100644
index 3edad75e3..000000000
--- a/packages/core-macro/src/router.rs
+++ /dev/null
@@ -1,214 +0,0 @@
-#![allow(dead_code)]
-
-use proc_macro2::TokenStream;
-use quote::quote;
-use syn::parse::{Parse, ParseStream};
-use syn::punctuated::Punctuated;
-use syn::spanned::Spanned;
-use syn::{Data, DeriveInput, Fields, Ident, LitStr, Variant};
-
-const AT_ATTR_IDENT: &str = "at";
-const NOT_FOUND_ATTR_IDENT: &str = "not_found";
-
-pub struct Routable {
- ident: Ident,
- ats: Vec,
- variants: Punctuated,
- not_found_route: Option,
-}
-
-impl Parse for Routable {
- fn parse(input: ParseStream) -> syn::Result {
- let DeriveInput { ident, data, .. } = input.parse()?;
-
- let data = match data {
- Data::Enum(data) => data,
- Data::Struct(s) => {
- return Err(syn::Error::new(
- s.struct_token.span(),
- "expected enum, found struct",
- ))
- }
- Data::Union(u) => {
- return Err(syn::Error::new(
- u.union_token.span(),
- "expected enum, found union",
- ))
- }
- };
-
- let (not_found_route, ats) = parse_variants_attributes(&data.variants)?;
-
- Ok(Self {
- ident,
- variants: data.variants,
- ats,
- not_found_route,
- })
- }
-}
-
-fn parse_variants_attributes(
- variants: &Punctuated,
-) -> syn::Result<(Option, Vec)> {
- let mut not_founds = vec![];
- let mut ats: Vec = vec![];
-
- let mut not_found_attrs = vec![];
-
- for variant in variants.iter() {
- if let Fields::Unnamed(ref field) = variant.fields {
- return Err(syn::Error::new(
- field.span(),
- "only named fields are supported",
- ));
- }
-
- let attrs = &variant.attrs;
- let at_attrs = attrs
- .iter()
- .filter(|attr| attr.path.is_ident(AT_ATTR_IDENT))
- .collect::>();
-
- let attr = match at_attrs.len() {
- 1 => *at_attrs.first().unwrap(),
- 0 => {
- return Err(syn::Error::new(
- variant.span(),
- format!(
- "{} attribute must be present on every variant",
- AT_ATTR_IDENT
- ),
- ))
- }
- _ => {
- return Err(syn::Error::new_spanned(
- quote! { #(#at_attrs)* },
- format!("only one {} attribute must be present", AT_ATTR_IDENT),
- ))
- }
- };
-
- let lit = attr.parse_args::()?;
- ats.push(lit);
-
- for attr in attrs.iter() {
- if attr.path.is_ident(NOT_FOUND_ATTR_IDENT) {
- not_found_attrs.push(attr);
- not_founds.push(variant.ident.clone())
- }
- }
- }
-
- if not_founds.len() > 1 {
- return Err(syn::Error::new_spanned(
- quote! { #(#not_found_attrs)* },
- format!("there can only be one {}", NOT_FOUND_ATTR_IDENT),
- ));
- }
-
- Ok((not_founds.into_iter().next(), ats))
-}
-
-impl Routable {
- // fn build_from_path(&self) -> TokenStream {
- // let from_path_matches = self.variants.iter().enumerate().map(|(i, variant)| {
- // let ident = &variant.ident;
- // let right = match &variant.fields {
- // Fields::Unit => quote! { Self::#ident },
- // Fields::Named(field) => {
- // let fields = field.named.iter().map(|it| {
- // //named fields have idents
- // it.ident.as_ref().unwrap()
- // });
- // quote! { Self::#ident { #(#fields: params.get(stringify!(#fields))?.parse().ok()?,)* } }
- // }
- // Fields::Unnamed(_) => unreachable!(), // already checked
- // };
-
- // let left = self.ats.get(i).unwrap();
- // quote! {
- // #left => ::std::option::Option::Some(#right)
- // }
- // });
-
- // quote! {
- // fn from_path(path: &str, params: &::std::collections::HashMap<&str, &str>) -> ::std::option::Option {
- // match path {
- // #(#from_path_matches),*,
- // _ => ::std::option::Option::None,
- // }
- // }
- // }
- // }
-
- // fn build_to_path(&self) -> TokenStream {
- // let to_path_matches = self.variants.iter().enumerate().map(|(i, variant)| {
- // let ident = &variant.ident;
- // let mut right = self.ats.get(i).unwrap().value();
-
- // match &variant.fields {
- // Fields::Unit => quote! { Self::#ident => ::std::string::ToString::to_string(#right) },
- // Fields::Named(field) => {
- // let fields = field
- // .named
- // .iter()
- // .map(|it| it.ident.as_ref().unwrap())
- // .collect::>();
-
- // for field in fields.iter() {
- // // :param -> {param}
- // // so we can pass it to `format!("...", param)`
- // right = right.replace(&format!(":{}", field), &format!("{{{}}}", field))
- // }
-
- // quote! {
- // Self::#ident { #(#fields),* } => ::std::format!(#right, #(#fields = #fields),*)
- // }
- // }
- // Fields::Unnamed(_) => unreachable!(), // already checked
- // }
- // });
-
- // quote! {
- // fn to_path(&self) -> ::std::string::String {
- // match self {
- // #(#to_path_matches),*,
- // }
- // }
- // }
- // }
-}
-
-pub fn routable_derive_impl(input: Routable) -> TokenStream {
- let Routable {
- // ats,
- // not_found_route,
- // ident,
- ..
- } = &input;
-
- // let from_path = input.build_from_path();
- // let to_path = input.build_to_path();
-
- quote! {
- // #[automatically_derived]
- // impl ::dioxus::router::Routable for #ident {
-
- // fn recognize(pathname: &str) -> ::std::option::Option {
- // todo!()
- // // ::std::thread_local! {
- // // static ROUTER: ::dioxus::router::__macro::Router = ::dioxus::router::__macro::build_router::<#ident>();
- // // }
- // // let route = ROUTER.with(|router| ::dioxus::router::__macro::recognize_with_router(router, pathname));
- // // {
- // // let route = ::std::clone::Clone::clone(&route);
- // // #cache_thread_local_ident.with(move |val| {
- // // *val.borrow_mut() = route;
- // // });
- // // }
- // // route
- // }
- // }
- }
-}
diff --git a/packages/core-macro/src/rsxtemplate.rs b/packages/core-macro/src/rsxtemplate.rs
deleted file mode 100644
index 9222d7117..000000000
--- a/packages/core-macro/src/rsxtemplate.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use crate::{rsx::RsxBody, util::is_valid_svg_tag};
-
-use {
- proc_macro::TokenStream,
- proc_macro2::{Span, TokenStream as TokenStream2},
- quote::{quote, ToTokens, TokenStreamExt},
- syn::{
- ext::IdentExt,
- parse::{Parse, ParseStream},
- token, Error, Expr, ExprClosure, Ident, LitBool, LitStr, Path, Result, Token,
- },
-};
-
-// ==============================================
-// Parse any stream coming from the html! macro
-// ==============================================
-pub struct RsxTemplate {
- inner: RsxBody,
-}
-
-impl Parse for RsxTemplate {
- fn parse(s: ParseStream) -> Result {
- if s.peek(LitStr) {
- use std::str::FromStr;
-
- let lit = s.parse::()?;
- let g = lit.span();
- let mut value = lit.value();
- if value.ends_with('\n') {
- value.pop();
- if value.ends_with('\r') {
- value.pop();
- }
- }
- let lit = LitStr::new(&value, lit.span());
-
- // panic!("{:#?}", lit);
- match lit.parse::() {
- Ok(r) => Ok(Self { inner: r }),
- Err(e) => Err(e),
- }
- } else {
- panic!("Not a str lit")
- }
- // let t = s.parse::()?;
-
- // let new_stream = TokenStream::from(t.to_s)
-
- // let cx: Ident = s.parse()?;
- // s.parse::()?;
- // if elements are in an array, return a bumpalo::collections::Vec rather than a Node.
- // let kind = if s.peek(token::Bracket) {
- // let nodes_toks;
- // syn::bracketed!(nodes_toks in s);
- // let mut nodes: Vec> = vec![nodes_toks.parse()?];
- // while nodes_toks.peek(Token![,]) {
- // nodes_toks.parse::()?;
- // nodes.push(nodes_toks.parse()?);
- // }
- // NodeOrList::List(NodeList(nodes))
- // } else {
- // NodeOrList::Node(s.parse()?)
- // };
- // Ok(HtmlRender { kind })
- }
-}
-
-impl ToTokens for RsxTemplate {
- fn to_tokens(&self, out_tokens: &mut TokenStream2) {
- self.inner.to_tokens(out_tokens);
- // let new_toks = ToToksCtx::new(&self.kind).to_token_stream();
-
- // // create a lazy tree that accepts a bump allocator
- // let final_tokens = quote! {
- // dioxus::prelude::LazyNodes::new(move |cx| {
- // let bump = &cx.bump();
-
- // #new_toks
- // })
- // };
-
- // final_tokens.to_tokens(out_tokens);
- }
-}
diff --git a/packages/core/CHANGELOG.md b/packages/core/CHANGELOG.md
index a0aa9f28d..563106db3 100644
--- a/packages/core/CHANGELOG.md
+++ b/packages/core/CHANGELOG.md
@@ -5,6 +5,58 @@ All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## Unreleased
+
+### Documentation
+
+ - add comments for the Handler
+
+### New Features
+
+ - add "spawn" method
+ - allow providing context to the root component
+
+### Bug Fixes
+
+ - provide_root_context on root scopes
+ - proprogation of root context
+ - allow eventhandler to derive default
+
+### Commit Statistics
+
+
+
+ - 18 commits contributed to the release over the course of 13 calendar days.
+ - 8 commits where understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' where seen in commit messages
+
+### Commit Details
+
+
+
+view details
+
+ * **Uncategorized**
+ - Merge pull request #169 from DioxusLabs/jk/router-userouter ([`3509602`](https://github.comgit//DioxusLabs/dioxus/commit/3509602c0bcd327a33bc8c95896775e24751da1a))
+ - Merge branch 'master' of github.com:DioxusLabs/dioxus ([`8899701`](https://github.comgit//DioxusLabs/dioxus/commit/88997019c5c74658bfd76344d6bb6f3565943b41))
+ - add miri stress test ([`e9792e9`](https://github.comgit//DioxusLabs/dioxus/commit/e9792e9b95521fcf0b0b4e240d7cf0397cd79b8f))
+ - add "spawn" method ([`bad4b77`](https://github.comgit//DioxusLabs/dioxus/commit/bad4b773b7bbab6a38d4f48d88d8c5a8787927ac))
+ - drop hooks before resetting bump arena ([`2e4f765`](https://github.comgit//DioxusLabs/dioxus/commit/2e4f7659327b69b74e20af59b6d5e65c699b6adb))
+ - provide_root_context on root scopes ([`d9a07dd`](https://github.comgit//DioxusLabs/dioxus/commit/d9a07ddddb45ba00e35645ac0e0ad1a4d2dd996d))
+ - Fix various typos and grammar nits ([`9e4ec43`](https://github.comgit//DioxusLabs/dioxus/commit/9e4ec43b1e78d355c56a38e4c092170b2b01b20d))
+ - Merge pull request #121 from DioxusLabs/jk/unify ([`b287a4c`](https://github.comgit//DioxusLabs/dioxus/commit/b287a4cab3eec9e6961a3f010846291f4f105747))
+ - Merge pull request #108 from DioxusLabs/jk/fstring-component-fields ([`f4132d1`](https://github.comgit//DioxusLabs/dioxus/commit/f4132d1874f7495049fac23ba0a022ac137ad74f))
+ - proprogation of root context ([`c8d528b`](https://github.comgit//DioxusLabs/dioxus/commit/c8d528b3b18e320ca0cee1542ae5fc659c1cca81))
+ - allow providing context to the root component ([`d2bd175`](https://github.comgit//DioxusLabs/dioxus/commit/d2bd1751436ef4bec554bb361ba87aea1357036a))
+ - Enable clippy ([`b6903bf`](https://github.comgit//DioxusLabs/dioxus/commit/b6903bf558bc7a3d0fe6794a137c44fca0957d11))
+ - Merge pull request #107 from autarch/autarch/half-assed-router ([`8d3ac3f`](https://github.comgit//DioxusLabs/dioxus/commit/8d3ac3ff148aef9d10a393eda453a11c1e882f58))
+ - Merge pull request #138 from mrxiaozhuox/master ([`8c7473d`](https://github.comgit//DioxusLabs/dioxus/commit/8c7473d1943dd133f388ec36116c9d8295861b97))
+ - Merge pull request #133 from mrxiaozhuox/master ([`887f69d`](https://github.comgit//DioxusLabs/dioxus/commit/887f69d5b47bdcde4fe0eab094c0cd0de23e4f3f))
+ - Don't expect all components to have a scope in ScopeArena.ensure_drop_safety ([`9b282d8`](https://github.comgit//DioxusLabs/dioxus/commit/9b282d877ba0fe2463687cde7ea899b7f8510425))
+ - add comments for the Handler ([`036a0ff`](https://github.comgit//DioxusLabs/dioxus/commit/036a0ff49a7dade0e04c9c07071a1ff49133ee24))
+ - allow eventhandler to derive default ([`e47ead5`](https://github.comgit//DioxusLabs/dioxus/commit/e47ead5347ce778935f8f2127fcb14f520eda0ce))
+view details
* **Uncategorized**
- - Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 ([`40d1f85`](https://github.comgit//DioxusLabs/dioxus/commit/40d1f85d0c3e2c9fd23c08840cca9f459d4e4307))
+ - Release dioxus-core v0.1.7 ([`16d73b2`](https://github.comgit//DioxusLabs/dioxus/commit/16d73b240fc446c6f6996c19ccf52bbcda2eca79))
- add title to doc comment ([`d11f322`](https://github.comgit//DioxusLabs/dioxus/commit/d11f322f554e7dbf43b988c9cfda56498cc49872))
+ - Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 ([`40d1f85`](https://github.comgit//DioxusLabs/dioxus/commit/40d1f85d0c3e2c9fd23c08840cca9f459d4e4307))
- better document the `EventHandler` type ([`be9f1a5`](https://github.comgit//DioxusLabs/dioxus/commit/be9f1a52ad2b04f101397ae34482ea7394df653b))
- component pass thru events ([`c439b0a`](https://github.comgit//DioxusLabs/dioxus/commit/c439b0ac7e09f70a04262b7c29938d8c52197b76))
- Merge pull request #74 from mrxiaozhuox/master ([`47056fd`](https://github.comgit//DioxusLabs/dioxus/commit/47056fda4577bcbdaa2a6f63d82eec876e5a5aee))
diff --git a/packages/core/Cargo.toml b/packages/core/Cargo.toml
index f54c6d5d9..4126eb47f 100644
--- a/packages/core/Cargo.toml
+++ b/packages/core/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "dioxus-core"
-version = "0.1.7"
+version = "0.1.9"
authors = ["Jonathan Kelley"]
edition = "2018"
description = "Core functionality for Dioxus - a concurrent renderer-agnostic Virtual DOM for interactive user experiences"
@@ -32,7 +32,7 @@ smallvec = "1.6"
slab = "0.4"
-futures-channel = "0.3"
+futures-channel = "0.3.21"
# used for noderefs
once_cell = "1.8"
diff --git a/packages/core/examples/borrowed.rs b/packages/core/examples/borrowed.rs
deleted file mode 100644
index b7a9f513c..000000000
--- a/packages/core/examples/borrowed.rs
+++ /dev/null
@@ -1,33 +0,0 @@
-use dioxus::prelude::*;
-use dioxus_core as dioxus;
-use dioxus_core_macro::*;
-use dioxus_html as dioxus_elements;
-
-fn main() {}
-
-fn app(cx: Scope) -> Element {
- cx.render(rsx!(div {
- app2(
- p: "asd"
- )
- }))
-}
-
-#[derive(Props)]
-struct Borrowed<'a> {
- p: &'a str,
-}
-
-fn app2<'a>(cx: Scope<'a, Borrowed<'a>>) -> Element {
- let g = eat2(&cx);
- rsx!(cx, "")
-}
-
-fn eat2(s: &ScopeState) {}
-
-fn eat(f: &str) {}
-
-fn bleat() {
- let blah = String::from("asd");
- eat(&blah);
-}
diff --git a/packages/core/examples/component_children.rs b/packages/core/examples/component_children.rs
deleted file mode 100644
index ac76740b8..000000000
--- a/packages/core/examples/component_children.rs
+++ /dev/null
@@ -1,40 +0,0 @@
-#![allow(non_snake_case)]
-
-use dioxus::prelude::*;
-use dioxus_core as dioxus;
-use dioxus_core_macro::*;
-use dioxus_html as dioxus_elements;
-
-fn main() {
- let mut dom = VirtualDom::new(parent);
- let edits = dom.rebuild();
- dbg!(edits);
-}
-
-fn parent(cx: Scope) -> Element {
- let value = cx.use_hook(|_| String::new());
-
- cx.render(rsx! {
- div {
- child(
- name: value,
- h1 {"hi"}
- )
- }
- })
-}
-
-#[derive(Props)]
-struct ChildProps<'a> {
- name: &'a str,
- children: Element<'a>,
-}
-
-fn child<'a>(cx: Scope<'a, ChildProps<'a>>) -> Element {
- cx.render(rsx! {
- div {
- "it's nested {cx.props.name}",
- &cx.props.children
- }
- })
-}
diff --git a/packages/core/examples/simple_hello.rs b/packages/core/examples/simple_hello.rs
deleted file mode 100644
index 94a897e7c..000000000
--- a/packages/core/examples/simple_hello.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use dioxus::prelude::*;
-use dioxus_core as dioxus;
-use dioxus_core_macro::*;
-use dioxus_html as dioxus_elements;
-
-// very tiny hello world
-fn main() {
- dioxus::VirtualDom::new(|cx| rsx!(cx, "hello world"));
-}
diff --git a/packages/core/examples/works.rs b/packages/core/examples/works.rs
deleted file mode 100644
index 0de94b5c3..000000000
--- a/packages/core/examples/works.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-#![allow(non_snake_case)]
-
-use dioxus::prelude::*;
-use dioxus_core as dioxus;
-use dioxus_core_macro::*;
-use dioxus_html as dioxus_elements;
-
-fn main() {
- let _ = VirtualDom::new(parent);
-}
-
-fn parent(cx: Scope) -> Element {
- let value = cx.use_hook(|_| String::new());
-
- cx.render(rsx! {
- div {
- child( name: value )
- }
- })
-}
-
-#[derive(Props)]
-struct ChildProps<'a> {
- name: &'a str,
-}
-
-fn child<'a>(cx: Scope<'a, ChildProps<'a>>) -> Element {
- cx.render(rsx! {
- div {
- h1 { "it's nested" }
- grandchild( name: cx.props.name )
- }
- })
-}
-
-#[derive(Props)]
-struct Grandchild<'a> {
- name: &'a str,
-}
-
-fn grandchild<'a>(cx: Scope<'a, Grandchild>) -> Element<'a> {
- cx.render(rsx! {
- div { "Hello {cx.props.name}!" }
- great_grandchild( name: cx.props.name )
- })
-}
-
-fn great_grandchild<'a>(cx: Scope<'a, Grandchild>) -> Element<'a> {
- cx.render(rsx! {
- div {
- h1 { "it's nested" }
- }
- })
-}
diff --git a/packages/core/src/diff.rs b/packages/core/src/diff.rs
index 499d9543e..d7189a710 100644
--- a/packages/core/src/diff.rs
+++ b/packages/core/src/diff.rs
@@ -1,33 +1,36 @@
-//! This module contains the stateful DiffState and all methods to diff VNodes, their properties, and their children.
+#![warn(clippy::pedantic)]
+#![allow(clippy::cast_possible_truncation)]
+
+//! This module contains the stateful [`DiffState`] and all methods to diff [`VNodes`], their properties, and their children.
//!
//! The [`DiffState`] calculates the diffs between the old and new frames, updates the new nodes, and generates a set
-//! of mutations for the RealDom to apply.
+//! of mutations for the [`RealDom`] to apply.
//!
//! ## Notice:
//!
//! The inspiration and code for this module was originally taken from Dodrio (@fitzgen) and then modified to support
-//! Components, Fragments, Suspense, SubTree memoization, incremental diffing, cancellation, NodeRefs, pausing, priority
+//! Components, Fragments, Suspense, [`SubTree`] memoization, incremental diffing, cancellation, [`NodeRefs`], pausing, priority
//! scheduling, and additional batching operations.
//!
//! ## Implementation Details:
//!
//! ### IDs for elements
//! --------------------
-//! All nodes are addressed by their IDs. The RealDom provides an imperative interface for making changes to these nodes.
+//! All nodes are addressed by their IDs. The [`RealDom`] provides an imperative interface for making changes to these nodes.
//! We don't necessarily require that DOM changes happen instantly during the diffing process, so the implementor may choose
//! to batch nodes if it is more performant for their application. The element IDs are indices into the internal element
//! array. The expectation is that implementors will use the ID as an index into a Vec of real nodes, allowing for passive
-//! garbage collection as the VirtualDOM replaces old nodes.
+//! garbage collection as the [`VirtualDOM`] replaces old nodes.
//!
//! When new vnodes are created through `cx.render`, they won't know which real node they correspond to. During diffing,
-//! we always make sure to copy over the ID. If we don't do this properly, the ElementId will be populated incorrectly
+//! we always make sure to copy over the ID. If we don't do this properly, the [`ElementId`] will be populated incorrectly
//! and brick the user's page.
//!
//! ### Fragment Support
//! --------------------
//! Fragments (nodes without a parent) are supported through a combination of "replace with" and anchor vnodes. Fragments
//! can be particularly challenging when they are empty, so the anchor node lets us "reserve" a spot for the empty
-//! fragment to be replaced with when it is no longer empty. This is guaranteed by logic in the NodeFactory - it is
+//! fragment to be replaced with when it is no longer empty. This is guaranteed by logic in the [`NodeFactory`] - it is
//! impossible to craft a fragment with 0 elements - they must always have at least a single placeholder element. Adding
//! "dummy" nodes _is_ inefficient, but it makes our diffing algorithm faster and the implementation is completely up to
//! the platform.
@@ -41,13 +44,13 @@
//! into a promise-like value. React will then work on the next "ready" fiber, checking back on the previous fiber once
//! it has finished its new work. In Dioxus, we use a similar approach, but try to completely render the tree before
//! switching sub-fibers. Instead, each future is submitted into a futures-queue and the node is manually loaded later on.
-//! Due to the frequent calls to "yield_now" we can get the pure "fetch-as-you-render" behavior of React Fiber.
+//! Due to the frequent calls to [`yield_now`] we can get the pure "fetch-as-you-render" behavior of React Fiber.
//!
//! We're able to use this approach because we use placeholder nodes - futures that aren't ready still get submitted to
//! DOM, but as a placeholder.
//!
//! Right now, the "suspense" queue is intertwined with hooks. In the future, we should allow any future to drive attributes
-//! and contents, without the need for the "use_suspense" hook. In the interim, this is the quickest way to get Suspense working.
+//! and contents, without the need for the [`use_suspense`] hook. In the interim, this is the quickest way to get Suspense working.
//!
//! ## Subtree Memoization
//! -----------------------
@@ -88,254 +91,78 @@
//! More info on how to improve this diffing algorithm:
//! -
-use crate::innerlude::*;
+use crate::innerlude::{
+ AnyProps, ElementId, Mutations, ScopeArena, ScopeId, VComponent, VElement, VFragment, VNode,
+ VPlaceholder, VText,
+};
use fxhash::{FxHashMap, FxHashSet};
use smallvec::{smallvec, SmallVec};
-use DomEdit::*;
-/// Our DiffState is an iterative tree differ.
-///
-/// It uses techniques of a stack machine to allow pausing and restarting of the diff algorithm. This
-/// was originally implemented using recursive techniques, but Rust lacks the ability to call async functions recursively,
-/// meaning we could not "pause" the original diffing algorithm.
-///
-/// Instead, we use a traditional stack machine approach to diff and create new nodes. The diff algorithm periodically
-/// calls "yield_now" which allows the machine to pause and return control to the caller. The caller can then wait for
-/// the next period of idle time, preventing our diff algorithm from blocking the main thread.
-///
-/// Funnily enough, this stack machine's entire job is to create instructions for another stack machine to execute. It's
-/// stack machines all the way down!
pub(crate) struct DiffState<'bump> {
pub(crate) scopes: &'bump ScopeArena,
pub(crate) mutations: Mutations<'bump>,
- pub(crate) stack: DiffStack<'bump>,
pub(crate) force_diff: bool,
+ pub(crate) element_stack: SmallVec<[ElementId; 10]>,
+ pub(crate) scope_stack: SmallVec<[ScopeId; 5]>,
}
-impl<'bump> DiffState<'bump> {
- pub(crate) fn new(scopes: &'bump ScopeArena) -> Self {
+impl<'b> DiffState<'b> {
+ pub fn new(scopes: &'b ScopeArena) -> Self {
Self {
scopes,
mutations: Mutations::new(),
- stack: DiffStack::new(),
force_diff: false,
- }
- }
-}
-
-/// The stack instructions we use to diff and create new nodes.
-#[derive(Debug)]
-pub(crate) enum DiffInstruction<'a> {
- Diff {
- old: &'a VNode<'a>,
- new: &'a VNode<'a>,
- },
-
- Create {
- node: &'a VNode<'a>,
- },
-
- /// pushes the node elements onto the stack for use in mount
- PrepareMove {
- node: &'a VNode<'a>,
- },
-
- Mount {
- and: MountType<'a>,
- },
-
- PopScope,
- PopElement,
-}
-
-#[derive(Debug, Clone, Copy)]
-pub(crate) enum MountType<'a> {
- Absorb,
- Append,
- Replace { old: &'a VNode<'a> },
- InsertAfter { other_node: &'a VNode<'a> },
- InsertBefore { other_node: &'a VNode<'a> },
-}
-
-pub(crate) struct DiffStack<'bump> {
- pub(crate) instructions: Vec>,
- pub(crate) nodes_created_stack: SmallVec<[usize; 10]>,
- pub(crate) scope_stack: SmallVec<[ScopeId; 5]>,
- pub(crate) element_stack: SmallVec<[ElementId; 10]>,
-}
-
-impl<'bump> DiffStack<'bump> {
- fn new() -> Self {
- Self {
- instructions: Vec::with_capacity(1000),
- nodes_created_stack: smallvec![],
- scope_stack: smallvec![],
element_stack: smallvec![],
+ scope_stack: smallvec![],
}
}
- fn pop(&mut self) -> Option> {
- self.instructions.pop()
- }
+ pub fn diff_scope(&mut self, scopeid: ScopeId) {
+ let (old, new) = (self.scopes.wip_head(scopeid), self.scopes.fin_head(scopeid));
+ let scope = self.scopes.get_scope(scopeid).unwrap();
- fn pop_off_scope(&mut self) {
+ self.scope_stack.push(scopeid);
+ self.element_stack.push(scope.container);
+ {
+ self.diff_node(old, new);
+ }
+ self.element_stack.pop();
self.scope_stack.pop();
+
+ self.mutations.mark_dirty_scope(scopeid);
}
- pub(crate) fn push(&mut self, instruction: DiffInstruction<'bump>) {
- self.instructions.push(instruction)
- }
+ pub fn diff_node(&mut self, old_node: &'b VNode<'b>, new_node: &'b VNode<'b>) {
+ use VNode::{Component, Element, Fragment, Placeholder, Text};
+ match (old_node, new_node) {
+ (Text(old), Text(new)) => {
+ self.diff_text_nodes(old, new, old_node, new_node);
+ }
- fn create_children(&mut self, children: &'bump [VNode<'bump>], and: MountType<'bump>) {
- self.nodes_created_stack.push(0);
- self.instructions.push(DiffInstruction::Mount { and });
+ (Placeholder(old), Placeholder(new)) => {
+ self.diff_placeholder_nodes(old, new, old_node, new_node);
+ }
- for child in children.iter().rev() {
- self.instructions
- .push(DiffInstruction::Create { node: child });
+ (Element(old), Element(new)) => {
+ self.diff_element_nodes(old, new, old_node, new_node);
+ }
+
+ (Component(old), Component(new)) => {
+ self.diff_component_nodes(old_node, new_node, *old, *new);
+ }
+
+ (Fragment(old), Fragment(new)) => {
+ self.diff_fragment_nodes(old, new);
+ }
+
+ (
+ Component(_) | Fragment(_) | Text(_) | Element(_) | Placeholder(_),
+ Component(_) | Fragment(_) | Text(_) | Element(_) | Placeholder(_),
+ ) => self.replace_node(old_node, new_node),
}
}
- // todo: subtrees
- // fn push_subtree(&mut self) {
- // self.nodes_created_stack.push(0);
- // self.instructions.push(DiffInstruction::Mount {
- // and: MountType::Append,
- // });
- // }
-
- fn push_nodes_created(&mut self, count: usize) {
- self.nodes_created_stack.push(count);
- }
-
- pub(crate) fn create_node(&mut self, node: &'bump VNode<'bump>, and: MountType<'bump>) {
- self.nodes_created_stack.push(0);
- self.instructions.push(DiffInstruction::Mount { and });
- self.instructions.push(DiffInstruction::Create { node });
- }
-
- fn add_child_count(&mut self, count: usize) {
- *self.nodes_created_stack.last_mut().unwrap() += count;
- }
-
- fn pop_nodes_created(&mut self) -> usize {
- self.nodes_created_stack.pop().unwrap()
- }
-
- fn current_scope(&self) -> Option {
- self.scope_stack.last().copied()
- }
-
- fn create_component(&mut self, idx: ScopeId, node: &'bump VNode<'bump>) {
- // Push the new scope onto the stack
- self.scope_stack.push(idx);
-
- self.instructions.push(DiffInstruction::PopScope);
-
- // Run the creation algorithm with this scope on the stack
- // ?? I think we treat components as fragments??
- self.instructions.push(DiffInstruction::Create { node });
- }
-}
-
-impl<'bump> DiffState<'bump> {
- /// Progress the diffing for this "fiber"
- ///
- /// This method implements a depth-first iterative tree traversal.
- ///
- /// We do depth-first to maintain high cache locality (nodes were originally generated recursively).
- ///
- /// Returns a `bool` indicating that the work completed properly.
- pub fn work(&mut self, mut deadline_expired: impl FnMut() -> bool) -> bool {
- while let Some(instruction) = self.stack.pop() {
- match instruction {
- DiffInstruction::Diff { old, new } => self.diff_node(old, new),
- DiffInstruction::Create { node } => self.create_node(node),
- DiffInstruction::Mount { and } => self.mount(and),
- DiffInstruction::PrepareMove { node } => {
- let num_on_stack = self.push_all_nodes(node);
- self.stack.add_child_count(num_on_stack);
- }
- DiffInstruction::PopScope => self.stack.pop_off_scope(),
- DiffInstruction::PopElement => {
- self.stack.element_stack.pop();
- }
- };
-
- if deadline_expired() {
- log::trace!("Deadline expired before we could finish!");
- return false;
- }
- }
-
- true
- }
-
- // recursively push all the nodes of a tree onto the stack and return how many are there
- fn push_all_nodes(&mut self, node: &'bump VNode<'bump>) -> usize {
- match node {
- VNode::Text(_) | VNode::Placeholder(_) => {
- self.mutations.push_root(node.mounted_id());
- 1
- }
-
- VNode::Fragment(_) | VNode::Component(_) => {
- //
- let mut added = 0;
- for child in node.children() {
- added += self.push_all_nodes(child);
- }
- added
- }
-
- VNode::Element(el) => {
- let mut num_on_stack = 0;
- for child in el.children.iter() {
- num_on_stack += self.push_all_nodes(child);
- }
- self.mutations.push_root(el.id.get().unwrap());
-
- num_on_stack + 1
- }
- }
- }
-
- fn mount(&mut self, and: MountType<'bump>) {
- let nodes_created = self.stack.pop_nodes_created();
- match and {
- // add the nodes from this virtual list to the parent
- // used by fragments and components
- MountType::Absorb => {
- self.stack.add_child_count(nodes_created);
- }
-
- MountType::Replace { old } => {
- self.replace_node(old, nodes_created);
- }
-
- MountType::Append => {
- self.mutations.edits.push(AppendChildren {
- many: nodes_created as u32,
- });
- }
-
- MountType::InsertAfter { other_node } => {
- let root = self.find_last_element(other_node).unwrap();
- self.mutations.insert_after(root, nodes_created as u32);
- }
-
- MountType::InsertBefore { other_node } => {
- let root = self.find_first_element_id(other_node).unwrap();
- self.mutations.insert_before(root, nodes_created as u32);
- }
- }
- }
-
- // =================================
- // Tools for creating new nodes
- // =================================
-
- fn create_node(&mut self, node: &'bump VNode<'bump>) {
+ pub fn create_node(&mut self, node: &'b VNode<'b>) -> usize {
match node {
VNode::Text(vtext) => self.create_text_node(vtext, node),
VNode::Placeholder(anchor) => self.create_anchor_node(anchor, node),
@@ -345,24 +172,21 @@ impl<'bump> DiffState<'bump> {
}
}
- fn create_text_node(&mut self, vtext: &'bump VText<'bump>, node: &'bump VNode<'bump>) {
+ fn create_text_node(&mut self, text: &'b VText<'b>, node: &'b VNode<'b>) -> usize {
let real_id = self.scopes.reserve_node(node);
-
- self.mutations.create_text_node(vtext.text, real_id);
- vtext.id.set(Some(real_id));
- self.stack.add_child_count(1);
+ text.id.set(Some(real_id));
+ self.mutations.create_text_node(text.text, real_id);
+ 1
}
- fn create_anchor_node(&mut self, anchor: &'bump VPlaceholder, node: &'bump VNode<'bump>) {
+ fn create_anchor_node(&mut self, anchor: &'b VPlaceholder, node: &'b VNode<'b>) -> usize {
let real_id = self.scopes.reserve_node(node);
-
- self.mutations.create_placeholder(real_id);
anchor.id.set(Some(real_id));
-
- self.stack.add_child_count(1);
+ self.mutations.create_placeholder(real_id);
+ 1
}
- fn create_element_node(&mut self, element: &'bump VElement<'bump>, node: &'bump VNode<'bump>) {
+ fn create_element_node(&mut self, element: &'b VElement<'b>, node: &'b VNode<'b>) -> usize {
let VElement {
tag: tag_name,
listeners,
@@ -372,56 +196,44 @@ impl<'bump> DiffState<'bump> {
id: dom_id,
parent: parent_id,
..
- } = element;
+ } = &element;
- // set the parent ID for event bubbling
- self.stack.instructions.push(DiffInstruction::PopElement);
+ parent_id.set(self.element_stack.last().copied());
- let parent = self.stack.element_stack.last().unwrap();
- parent_id.set(Some(*parent));
-
- // set the id of the element
let real_id = self.scopes.reserve_node(node);
- self.stack.element_stack.push(real_id);
+
dom_id.set(Some(real_id));
- self.mutations.create_element(tag_name, *namespace, real_id);
+ self.element_stack.push(real_id);
+ {
+ self.mutations.create_element(tag_name, *namespace, real_id);
- self.stack.add_child_count(1);
+ let cur_scope_id = self.current_scope();
- if let Some(cur_scope_id) = self.stack.current_scope() {
- for listener in *listeners {
+ for listener in listeners.iter() {
listener.mounted_node.set(Some(real_id));
self.mutations.new_event_listener(listener, cur_scope_id);
}
- } else {
- log::warn!("create element called with no scope on the stack - this is an error for a live dom");
- }
- for attr in *attributes {
- self.mutations.set_attribute(attr, real_id.as_u64());
- }
+ for attr in attributes.iter() {
+ self.mutations.set_attribute(attr, real_id.as_u64());
+ }
- // todo: the settext optimization
- //
- // if children.len() == 1 {
- // if let VNode::Text(vtext) = children[0] {
- // self.mutations.set_text(vtext.text, real_id.as_u64());
- // return;
- // }
- // }
-
- if !children.is_empty() {
- self.stack.create_children(children, MountType::Append);
+ if !children.is_empty() {
+ self.create_and_append_children(children);
+ }
}
+ self.element_stack.pop();
+
+ 1
}
- fn create_fragment_node(&mut self, frag: &'bump VFragment<'bump>) {
- self.stack.create_children(frag.children, MountType::Absorb);
+ fn create_fragment_node(&mut self, frag: &'b VFragment<'b>) -> usize {
+ self.create_children(frag.children)
}
- fn create_component_node(&mut self, vcomponent: &'bump VComponent<'bump>) {
- let parent_idx = self.stack.current_scope().unwrap();
+ fn create_component_node(&mut self, vcomponent: &'b VComponent<'b>) -> usize {
+ let parent_idx = self.current_scope();
// the component might already exist - if it does, we need to reuse it
// this makes figure out when to drop the component more complicated
@@ -430,116 +242,121 @@ impl<'bump> DiffState<'bump> {
idx
} else {
// Insert a new scope into our component list
- let props: Box = vcomponent.props.borrow_mut().take().unwrap();
+ let props: Box = vcomponent.props.borrow_mut().take().unwrap();
let props: Box = unsafe { std::mem::transmute(props) };
- let new_idx = self.scopes.new_with_key(
+ self.scopes.new_with_key(
vcomponent.user_fc,
props,
Some(parent_idx),
- self.stack.element_stack.last().copied().unwrap(),
+ self.element_stack.last().copied().unwrap(),
0,
- );
-
- new_idx
+ )
};
// Actually initialize the caller's slot with the right address
vcomponent.scope.set(Some(new_idx));
- match vcomponent.can_memoize {
- true => {
- // todo: implement promotion logic. save us from boxing props that we don't need
- }
- false => {
- // track this component internally so we know the right drop order
- }
- }
+ log::trace!(
+ "created component \"{}\", id: {:?} parent {:?} orig: {:?}",
+ vcomponent.fn_name,
+ new_idx,
+ parent_idx,
+ vcomponent.originator
+ );
- // Run the scope for one iteration to initialize it
- self.scopes.run_scope(new_idx);
+ // if vcomponent.can_memoize {
+ // // todo: implement promotion logic. save us from boxing props that we don't need
+ // } else {
+ // // track this component internally so we know the right drop order
+ // }
- // Take the node that was just generated from running the component
- let nextnode = self.scopes.fin_head(new_idx);
- self.stack.create_component(new_idx, nextnode);
+ self.enter_scope(new_idx);
- // Finally, insert this scope as a seen node.
- self.mutations.dirty_scopes.insert(new_idx);
+ let created = {
+ // Run the scope for one iteration to initialize it
+ self.scopes.run_scope(new_idx);
+ self.mutations.mark_dirty_scope(new_idx);
+
+ // Take the node that was just generated from running the component
+ let nextnode = self.scopes.fin_head(new_idx);
+ self.create_node(nextnode)
+ };
+
+ self.leave_scope();
+
+ created
}
- // =================================
- // Tools for diffing nodes
- // =================================
-
- pub fn diff_node(&mut self, old_node: &'bump VNode<'bump>, new_node: &'bump VNode<'bump>) {
- use VNode::*;
- match (old_node, new_node) {
- // Check the most common cases first
- // these are *actual* elements, not wrappers around lists
- (Text(old), Text(new)) => {
- if let Some(root) = old.id.get() {
- if old.text != new.text {
- self.mutations.set_text(new.text, root.as_u64());
- }
- self.scopes.update_node(new_node, root);
-
- new.id.set(Some(root));
- }
- }
-
- (Placeholder(old), Placeholder(new)) => {
- if let Some(root) = old.id.get() {
- self.scopes.update_node(new_node, root);
- new.id.set(Some(root))
- }
- }
-
- (Element(old), Element(new)) => self.diff_element_nodes(old, new, old_node, new_node),
-
- // These two sets are pointers to nodes but are not actually nodes themselves
- (Component(old), Component(new)) => {
- self.diff_component_nodes(old_node, new_node, *old, *new)
- }
-
- (Fragment(old), Fragment(new)) => self.diff_fragment_nodes(old, new),
-
- // The normal pathway still works, but generates slightly weird instructions
- // This pathway ensures uses the ReplaceAll, not the InsertAfter and remove
- (Placeholder(_), Fragment(new)) => {
- self.stack
- .create_children(new.children, MountType::Replace { old: old_node });
- }
-
- // Anything else is just a basic replace and create
- (
- Component(_) | Fragment(_) | Text(_) | Element(_) | Placeholder(_),
- Component(_) | Fragment(_) | Text(_) | Element(_) | Placeholder(_),
- ) => self
- .stack
- .create_node(new_node, MountType::Replace { old: old_node }),
+ pub(crate) fn diff_text_nodes(
+ &mut self,
+ old: &'b VText<'b>,
+ new: &'b VText<'b>,
+ _old_node: &'b VNode<'b>,
+ new_node: &'b VNode<'b>,
+ ) {
+ if std::ptr::eq(old, new) {
+ return;
}
+
+ // if the node is comming back not assigned, that means it was borrowed but removed
+ let root = match old.id.get() {
+ Some(id) => id,
+ None => self.scopes.reserve_node(new_node),
+ };
+
+ if old.text != new.text {
+ self.mutations.set_text(new.text, root.as_u64());
+ }
+
+ self.scopes.update_node(new_node, root);
+
+ new.id.set(Some(root));
+ }
+
+ pub(crate) fn diff_placeholder_nodes(
+ &mut self,
+ old: &'b VPlaceholder,
+ new: &'b VPlaceholder,
+ _old_node: &'b VNode<'b>,
+ new_node: &'b VNode<'b>,
+ ) {
+ if std::ptr::eq(old, new) {
+ return;
+ }
+
+ // if the node is comming back not assigned, that means it was borrowed but removed
+ let root = match old.id.get() {
+ Some(id) => id,
+ None => self.scopes.reserve_node(new_node),
+ };
+
+ self.scopes.update_node(new_node, root);
+ new.id.set(Some(root));
}
fn diff_element_nodes(
&mut self,
- old: &'bump VElement<'bump>,
- new: &'bump VElement<'bump>,
- old_node: &'bump VNode<'bump>,
- new_node: &'bump VNode<'bump>,
+ old: &'b VElement<'b>,
+ new: &'b VElement<'b>,
+ old_node: &'b VNode<'b>,
+ new_node: &'b VNode<'b>,
) {
- let root = old.id.get().unwrap();
+ if std::ptr::eq(old, new) {
+ return;
+ }
+
+ // if the node is comming back not assigned, that means it was borrowed but removed
+ let root = match old.id.get() {
+ Some(id) => id,
+ None => self.scopes.reserve_node(new_node),
+ };
// If the element type is completely different, the element needs to be re-rendered completely
// This is an optimization React makes due to how users structure their code
//
// This case is rather rare (typically only in non-keyed lists)
if new.tag != old.tag || new.namespace != old.namespace {
- // maybe make this an instruction?
- // issue is that we need the "vnode" but this method only has the velement
- self.stack.push_nodes_created(0);
- self.stack.push(DiffInstruction::Mount {
- and: MountType::Replace { old: old_node },
- });
- self.create_element_node(new, new_node);
+ self.replace_node(old_node, new_node);
return;
}
@@ -570,7 +387,7 @@ impl<'bump> DiffState<'bump> {
self.mutations.remove_attribute(attribute, root.as_u64());
}
for attribute in new.attributes {
- self.mutations.set_attribute(attribute, root.as_u64())
+ self.mutations.set_attribute(attribute, root.as_u64());
}
}
@@ -582,181 +399,123 @@ impl<'bump> DiffState<'bump> {
// We also need to make sure that all listeners are properly attached to the parent scope (fix_listener)
//
// TODO: take a more efficient path than this
- if let Some(cur_scope_id) = self.stack.current_scope() {
- if old.listeners.len() == new.listeners.len() {
- for (old_l, new_l) in old.listeners.iter().zip(new.listeners.iter()) {
- if old_l.event != new_l.event {
- self.mutations
- .remove_event_listener(old_l.event, root.as_u64());
- self.mutations.new_event_listener(new_l, cur_scope_id);
- }
- new_l.mounted_node.set(old_l.mounted_node.get());
- }
- } else {
- for listener in old.listeners {
+ let cur_scope_id = self.current_scope();
+
+ if old.listeners.len() == new.listeners.len() {
+ for (old_l, new_l) in old.listeners.iter().zip(new.listeners.iter()) {
+ if old_l.event != new_l.event {
self.mutations
- .remove_event_listener(listener.event, root.as_u64());
- }
- for listener in new.listeners {
- listener.mounted_node.set(Some(root));
- self.mutations.new_event_listener(listener, cur_scope_id);
+ .remove_event_listener(old_l.event, root.as_u64());
+ self.mutations.new_event_listener(new_l, cur_scope_id);
}
+ new_l.mounted_node.set(old_l.mounted_node.get());
+ }
+ } else {
+ for listener in old.listeners {
+ self.mutations
+ .remove_event_listener(listener.event, root.as_u64());
+ }
+ for listener in new.listeners {
+ listener.mounted_node.set(Some(root));
+ self.mutations.new_event_listener(listener, cur_scope_id);
}
}
- if old.children.is_empty() && !new.children.is_empty() {
- self.mutations.edits.push(PushRoot {
- root: root.as_u64(),
- });
- self.stack.element_stack.push(root);
- self.stack.instructions.push(DiffInstruction::PopElement);
- self.stack.create_children(new.children, MountType::Append);
- } else {
- self.stack.element_stack.push(root);
- self.stack.instructions.push(DiffInstruction::PopElement);
- self.diff_children(old.children, new.children);
- }
-
- // todo: this is for the "settext" optimization
- // it works, but i'm not sure if it's the direction we want to take right away
- // I haven't benchmarked the performance imporvemenet yet. Perhaps
- // we can make it a config?
-
- // match (old.children.len(), new.children.len()) {
- // (0, 0) => {}
- // (1, 1) => {
- // let old1 = &old.children[0];
- // let new1 = &new.children[0];
-
- // match (old1, new1) {
- // (VNode::Text(old_text), VNode::Text(new_text)) => {
- // if old_text.text != new_text.text {
- // self.mutations.set_text(new_text.text, root.as_u64());
- // }
- // }
- // (VNode::Text(_old_text), _) => {
- // self.stack.element_stack.push(root);
- // self.stack.instructions.push(DiffInstruction::PopElement);
- // self.stack.create_node(new1, MountType::Append);
- // }
- // (_, VNode::Text(new_text)) => {
- // self.remove_nodes([old1], false);
- // self.mutations.set_text(new_text.text, root.as_u64());
- // }
- // _ => {
- // self.stack.element_stack.push(root);
- // self.stack.instructions.push(DiffInstruction::PopElement);
- // self.diff_children(old.children, new.children);
- // }
- // }
- // }
- // (0, 1) => {
- // if let VNode::Text(text) = &new.children[0] {
- // self.mutations.set_text(text.text, root.as_u64());
- // } else {
- // self.stack.element_stack.push(root);
- // self.stack.instructions.push(DiffInstruction::PopElement);
- // }
- // }
- // (0, _) => {
- // self.mutations.edits.push(PushRoot {
- // root: root.as_u64(),
- // });
- // self.stack.element_stack.push(root);
- // self.stack.instructions.push(DiffInstruction::PopElement);
- // self.stack.create_children(new.children, MountType::Append);
- // }
- // (_, 0) => {
- // self.remove_nodes(old.children, false);
- // self.mutations.set_text("", root.as_u64());
- // }
- // (_, _) => {
- // self.stack.element_stack.push(root);
- // self.stack.instructions.push(DiffInstruction::PopElement);
- // self.diff_children(old.children, new.children);
- // }
- // }
+ match (old.children.len(), new.children.len()) {
+ (0, 0) => {}
+ (0, _) => {
+ let created = self.create_children(new.children);
+ self.mutations.append_children(created as u32);
+ }
+ (_, _) => self.diff_children(old.children, new.children),
+ };
}
fn diff_component_nodes(
&mut self,
- old_node: &'bump VNode<'bump>,
- new_node: &'bump VNode<'bump>,
- old: &'bump VComponent<'bump>,
- new: &'bump VComponent<'bump>,
+ old_node: &'b VNode<'b>,
+ new_node: &'b VNode<'b>,
+ old: &'b VComponent<'b>,
+ new: &'b VComponent<'b>,
) {
- let scope_addr = old.scope.get().unwrap();
- log::trace!("diff_component_nodes: {:?}", scope_addr);
+ let scope_addr = old
+ .scope
+ .get()
+ .expect("existing component nodes should have a scope");
if std::ptr::eq(old, new) {
- log::trace!("skipping component diff - component is the sames");
return;
}
// Make sure we're dealing with the same component (by function pointer)
if old.user_fc == new.user_fc {
- self.stack.scope_stack.push(scope_addr);
+ self.enter_scope(scope_addr);
+ {
+ // Make sure the new component vnode is referencing the right scope id
+ new.scope.set(Some(scope_addr));
- // Make sure the new component vnode is referencing the right scope id
- new.scope.set(Some(scope_addr));
+ // make sure the component's caller function is up to date
+ let scope = self
+ .scopes
+ .get_scope(scope_addr)
+ .unwrap_or_else(|| panic!("could not find {:?}", scope_addr));
- // make sure the component's caller function is up to date
- let scope = self
- .scopes
- .get_scope(scope_addr)
- .unwrap_or_else(|| panic!("could not find {:?}", scope_addr));
-
- // take the new props out regardless
- // when memoizing, push to the existing scope if memoization happens
- let new_props = new.props.borrow_mut().take().unwrap();
-
- let should_run = {
- if old.can_memoize {
- let props_are_the_same = unsafe {
- scope
- .props
- .borrow()
- .as_ref()
- .unwrap()
- .memoize(new_props.as_ref())
- };
- !props_are_the_same || self.force_diff
- } else {
- true
- }
- };
-
- if should_run {
- let _old_props = scope
+ // take the new props out regardless
+ // when memoizing, push to the existing scope if memoization happens
+ let new_props = new
.props
- .replace(unsafe { std::mem::transmute(Some(new_props)) });
+ .borrow_mut()
+ .take()
+ .expect("new component props should exist");
- // this should auto drop the previous props
- self.scopes.run_scope(scope_addr);
- self.mutations.dirty_scopes.insert(scope_addr);
+ let should_diff = {
+ if old.can_memoize {
+ // safety: we trust the implementation of "memoize"
+ let props_are_the_same = unsafe {
+ let new_ref = new_props.as_ref();
+ scope.props.borrow().as_ref().unwrap().memoize(new_ref)
+ };
+ !props_are_the_same || self.force_diff
+ } else {
+ true
+ }
+ };
- self.diff_node(
- self.scopes.wip_head(scope_addr),
- self.scopes.fin_head(scope_addr),
- );
- } else {
- log::trace!("memoized");
- // memoization has taken place
- drop(new_props);
- };
+ if should_diff {
+ let _old_props = scope
+ .props
+ .replace(unsafe { std::mem::transmute(Some(new_props)) });
- self.stack.scope_stack.pop();
+ // this should auto drop the previous props
+ self.scopes.run_scope(scope_addr);
+ self.mutations.mark_dirty_scope(scope_addr);
+
+ self.diff_node(
+ self.scopes.wip_head(scope_addr),
+ self.scopes.fin_head(scope_addr),
+ );
+ } else {
+ // memoization has taken place
+ drop(new_props);
+ };
+ }
+ self.leave_scope();
} else {
- self.stack
- .create_node(new_node, MountType::Replace { old: old_node });
+ self.replace_node(old_node, new_node);
}
}
- fn diff_fragment_nodes(&mut self, old: &'bump VFragment<'bump>, new: &'bump VFragment<'bump>) {
+ fn diff_fragment_nodes(&mut self, old: &'b VFragment<'b>, new: &'b VFragment<'b>) {
+ if std::ptr::eq(old, new) {
+ return;
+ }
+
// This is the case where options or direct vnodes might be used.
// In this case, it's faster to just skip ahead to their diff
if old.children.len() == 1 && new.children.len() == 1 {
- self.diff_node(&old.children[0], &new.children[0]);
+ if !std::ptr::eq(old, new) {
+ self.diff_node(&old.children[0], &new.children[0]);
+ }
return;
}
@@ -766,10 +525,6 @@ impl<'bump> DiffState<'bump> {
self.diff_children(old.children, new.children);
}
- // =============================================
- // Utilities for creating new diff instructions
- // =============================================
-
// Diff the given set of old and new children.
//
// The parent must be on top of the change list stack when this function is
@@ -785,11 +540,15 @@ impl<'bump> DiffState<'bump> {
//
// Fragment nodes cannot generate empty children lists, so we can assume that when a list is empty, it belongs only
// to an element, and appending makes sense.
- fn diff_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
+ fn diff_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
+ if std::ptr::eq(old, new) {
+ return;
+ }
+
// Remember, fragments can never be empty (they always have a single child)
match (old, new) {
([], []) => {}
- ([], _) => self.stack.create_children(new, MountType::Append),
+ ([], _) => self.create_and_append_children(new),
(_, []) => self.remove_nodes(old, true),
_ => {
let new_is_keyed = new[0].key().is_some();
@@ -821,29 +580,21 @@ impl<'bump> DiffState<'bump> {
// [... parent]
//
// the change list stack is in the same state when this function returns.
- fn diff_non_keyed_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
+ fn diff_non_keyed_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
+ use std::cmp::Ordering;
+
// Handled these cases in `diff_children` before calling this function.
debug_assert!(!new.is_empty());
debug_assert!(!old.is_empty());
- for (new, old) in new.iter().zip(old.iter()).rev() {
- self.stack.push(DiffInstruction::Diff { new, old });
- }
-
- use std::cmp::Ordering;
match old.len().cmp(&new.len()) {
Ordering::Greater => self.remove_nodes(&old[new.len()..], true),
- Ordering::Less => {
- self.stack.create_children(
- &new[old.len()..],
- MountType::InsertAfter {
- other_node: old.last().unwrap(),
- },
- );
- }
- Ordering::Equal => {
- // nothing - they're the same size
- }
+ Ordering::Less => self.create_and_insert_after(&new[old.len()..], old.last().unwrap()),
+ Ordering::Equal => {}
+ }
+
+ for (new, old) in new.iter().zip(old.iter()) {
+ self.diff_node(old, new);
}
}
@@ -863,10 +614,10 @@ impl<'bump> DiffState<'bump> {
// https://github.com/infernojs/inferno/blob/36fd96/packages/inferno/src/DOM/patching.ts#L530-L739
//
// The stack is empty upon entry.
- fn diff_keyed_children(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
+ fn diff_keyed_children(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
if cfg!(debug_assertions) {
let mut keys = fxhash::FxHashSet::default();
- let mut assert_unique_keys = |children: &'bump [VNode<'bump>]| {
+ let mut assert_unique_keys = |children: &'b [VNode<'b>]| {
keys.clear();
for child in children {
let key = child.key();
@@ -907,6 +658,7 @@ impl<'bump> DiffState<'bump> {
!((old_middle.len() == new_middle.len()) && old_middle.is_empty()),
"keyed children must have the same number of children"
);
+
if new_middle.is_empty() {
// remove the old elements
self.remove_nodes(old_middle, true);
@@ -916,30 +668,15 @@ impl<'bump> DiffState<'bump> {
if left_offset == 0 {
// insert at the beginning of the old list
let foothold = &old[old.len() - right_offset];
- self.stack.create_children(
- new_middle,
- MountType::InsertBefore {
- other_node: foothold,
- },
- );
+ self.create_and_insert_before(new_middle, foothold);
} else if right_offset == 0 {
// insert at the end the old list
let foothold = old.last().unwrap();
- self.stack.create_children(
- new_middle,
- MountType::InsertAfter {
- other_node: foothold,
- },
- );
+ self.create_and_insert_after(new_middle, foothold);
} else {
// inserting in the middle
let foothold = &old[left_offset - 1];
- self.stack.create_children(
- new_middle,
- MountType::InsertAfter {
- other_node: foothold,
- },
- );
+ self.create_and_insert_after(new_middle, foothold);
}
} else {
self.diff_keyed_middle(old_middle, new_middle);
@@ -953,9 +690,8 @@ impl<'bump> DiffState<'bump> {
/// If there is no offset, then this function returns None and the diffing is complete.
fn diff_keyed_ends(
&mut self,
-
- old: &'bump [VNode<'bump>],
- new: &'bump [VNode<'bump>],
+ old: &'b [VNode<'b>],
+ new: &'b [VNode<'b>],
) -> Option<(usize, usize)> {
let mut left_offset = 0;
@@ -964,19 +700,14 @@ impl<'bump> DiffState<'bump> {
if old.key() != new.key() {
break;
}
- self.stack.push(DiffInstruction::Diff { old, new });
+ self.diff_node(old, new);
left_offset += 1;
}
// If that was all of the old children, then create and append the remaining
// new children and we're finished.
if left_offset == old.len() {
- self.stack.create_children(
- &new[left_offset..],
- MountType::InsertAfter {
- other_node: old.last().unwrap(),
- },
- );
+ self.create_and_insert_after(&new[left_offset..], old.last().unwrap());
return None;
}
@@ -1014,7 +745,8 @@ impl<'bump> DiffState<'bump> {
// This function will load the appropriate nodes onto the stack and do diffing in place.
//
// Upon exit from this function, it will be restored to that same self.
- fn diff_keyed_middle(&mut self, old: &'bump [VNode<'bump>], new: &'bump [VNode<'bump>]) {
+ #[allow(clippy::too_many_lines)]
+ fn diff_keyed_middle(&mut self, old: &'b [VNode<'b>], new: &'b [VNode<'b>]) {
/*
1. Map the old keys into a numerical ordering based on indices.
2. Create a map of old key to its index
@@ -1039,8 +771,8 @@ impl<'bump> DiffState<'bump> {
// 0. Debug sanity checks
// Should have already diffed the shared-key prefixes and suffixes.
- debug_assert_ne!(new.first().map(|n| n.key()), old.first().map(|o| o.key()));
- debug_assert_ne!(new.last().map(|n| n.key()), old.last().map(|o| o.key()));
+ debug_assert_ne!(new.first().map(VNode::key), old.first().map(VNode::key));
+ debug_assert_ne!(new.last().map(VNode::key), old.last().map(VNode::key));
// 1. Map the old keys into a numerical ordering based on indices.
// 2. Create a map of old key to its index
@@ -1072,10 +804,12 @@ impl<'bump> DiffState<'bump> {
if shared_keys.is_empty() {
if let Some(first_old) = old.get(0) {
self.remove_nodes(&old[1..], true);
- self.stack
- .create_children(new, MountType::Replace { old: first_old })
+ let nodes_created = self.create_children(new);
+ self.replace_inner(first_old, nodes_created);
} else {
- self.stack.create_children(new, MountType::Append {});
+ // I think this is wrong - why are we appending?
+ // only valid of the if there are no trailing elements
+ self.create_and_append_children(new);
}
return;
}
@@ -1103,33 +837,31 @@ impl<'bump> DiffState<'bump> {
lis_sequence.pop();
}
- let apply = |new_idx, new_node: &'bump VNode<'bump>, stack: &mut DiffStack<'bump>| {
- let old_index = new_index_to_old_index[new_idx];
- if old_index == u32::MAX as usize {
- stack.create_node(new_node, MountType::Absorb);
- } else {
- // this function should never take LIS indices
- stack.push(DiffInstruction::PrepareMove { node: new_node });
- stack.push(DiffInstruction::Diff {
- new: new_node,
- old: &old[old_index],
- });
- }
- };
+ for idx in &lis_sequence {
+ self.diff_node(&old[new_index_to_old_index[*idx]], &new[*idx]);
+ }
- // add mount instruction for the last items not covered by the lis
- let first_lis = *lis_sequence.first().unwrap();
- if first_lis > 0 {
- self.stack.push_nodes_created(0);
- self.stack.push(DiffInstruction::Mount {
- and: MountType::InsertBefore {
- other_node: &new[first_lis],
- },
- });
+ let mut nodes_created = 0;
- for (idx, new_node) in new[..first_lis].iter().enumerate().rev() {
- apply(idx, new_node, &mut self.stack);
+ // add mount instruction for the first items not covered by the lis
+ let last = *lis_sequence.last().unwrap();
+ if last < (new.len() - 1) {
+ for (idx, new_node) in new[(last + 1)..].iter().enumerate() {
+ let new_idx = idx + last + 1;
+ let old_index = new_index_to_old_index[new_idx];
+ if old_index == u32::MAX as usize {
+ nodes_created += self.create_node(new_node);
+ } else {
+ self.diff_node(&old[old_index], new_node);
+ nodes_created += self.push_all_nodes(new_node);
+ }
}
+
+ self.mutations.insert_after(
+ self.find_last_element(&new[last]).unwrap(),
+ nodes_created as u32,
+ );
+ nodes_created = 0;
}
// for each spacing, generate a mount instruction
@@ -1137,85 +869,53 @@ impl<'bump> DiffState<'bump> {
let mut last = *lis_iter.next().unwrap();
for next in lis_iter {
if last - next > 1 {
- self.stack.push_nodes_created(0);
- self.stack.push(DiffInstruction::Mount {
- and: MountType::InsertBefore {
- other_node: &new[last],
- },
- });
- for (idx, new_node) in new[(next + 1)..last].iter().enumerate().rev() {
- apply(idx + next + 1, new_node, &mut self.stack);
+ for (idx, new_node) in new[(next + 1)..last].iter().enumerate() {
+ let new_idx = idx + next + 1;
+ let old_index = new_index_to_old_index[new_idx];
+ if old_index == u32::MAX as usize {
+ nodes_created += self.create_node(new_node);
+ } else {
+ self.diff_node(&old[old_index], new_node);
+ nodes_created += self.push_all_nodes(new_node);
+ }
}
+
+ self.mutations.insert_before(
+ self.find_first_element(&new[last]).unwrap(),
+ nodes_created as u32,
+ );
+
+ nodes_created = 0;
}
last = *next;
}
- // add mount instruction for the first items not covered by the lis
- let last = *lis_sequence.last().unwrap();
- if last < (new.len() - 1) {
- self.stack.push_nodes_created(0);
- self.stack.push(DiffInstruction::Mount {
- and: MountType::InsertAfter {
- other_node: &new[last],
- },
- });
- for (idx, new_node) in new[(last + 1)..].iter().enumerate().rev() {
- apply(idx + last + 1, new_node, &mut self.stack);
+ // add mount instruction for the last items not covered by the lis
+ let first_lis = *lis_sequence.first().unwrap();
+ if first_lis > 0 {
+ for (idx, new_node) in new[..first_lis].iter().enumerate() {
+ let old_index = new_index_to_old_index[idx];
+ if old_index == u32::MAX as usize {
+ nodes_created += self.create_node(new_node);
+ } else {
+ self.diff_node(&old[old_index], new_node);
+ nodes_created += self.push_all_nodes(new_node);
+ }
}
- }
- for idx in lis_sequence.iter().rev() {
- self.stack.push(DiffInstruction::Diff {
- new: &new[*idx],
- old: &old[new_index_to_old_index[*idx]],
- });
+ self.mutations.insert_before(
+ self.find_first_element(&new[first_lis]).unwrap(),
+ nodes_created as u32,
+ );
}
}
- // =====================
- // Utilities
- // =====================
-
- fn find_last_element(&mut self, vnode: &'bump VNode<'bump>) -> Option {
- let mut search_node = Some(vnode);
-
- loop {
- match &search_node.take().unwrap() {
- VNode::Text(t) => break t.id.get(),
- VNode::Element(t) => break t.id.get(),
- VNode::Placeholder(t) => break t.id.get(),
- VNode::Fragment(frag) => {
- search_node = frag.children.last();
- }
- VNode::Component(el) => {
- let scope_id = el.scope.get().unwrap();
- search_node = Some(self.scopes.root_node(scope_id));
- }
- }
- }
+ fn replace_node(&mut self, old: &'b VNode<'b>, new: &'b VNode<'b>) {
+ let nodes_created = self.create_node(new);
+ self.replace_inner(old, nodes_created);
}
- fn find_first_element_id(&mut self, vnode: &'bump VNode<'bump>) -> Option {
- let mut search_node = Some(vnode);
-
- loop {
- match &search_node.take().unwrap() {
- // the ones that have a direct id
- VNode::Fragment(frag) => {
- search_node = Some(&frag.children[0]);
- }
- VNode::Component(el) => {
- let scope_id = el.scope.get().unwrap();
- search_node = Some(self.scopes.root_node(scope_id));
- }
- VNode::Text(t) => break t.id.get(),
- VNode::Element(t) => break t.id.get(),
- VNode::Placeholder(t) => break t.id.get(),
- }
- }
- }
-
- fn replace_node(&mut self, old: &'bump VNode<'bump>, nodes_created: usize) {
+ fn replace_inner(&mut self, old: &'b VNode<'b>, nodes_created: usize) {
match old {
VNode::Element(el) => {
let id = old
@@ -1224,6 +924,7 @@ impl<'bump> DiffState<'bump> {
self.mutations.replace_with(id, nodes_created as u32);
self.remove_nodes(el.children, false);
+ self.scopes.collect_garbage(id);
}
VNode::Text(_) | VNode::Placeholder(_) => {
@@ -1232,41 +933,51 @@ impl<'bump> DiffState<'bump> {
.unwrap_or_else(|| panic!("broke on {:?}", old));
self.mutations.replace_with(id, nodes_created as u32);
+ self.scopes.collect_garbage(id);
}
VNode::Fragment(f) => {
- self.replace_node(&f.children[0], nodes_created);
+ self.replace_inner(&f.children[0], nodes_created);
self.remove_nodes(f.children.iter().skip(1), true);
}
VNode::Component(c) => {
- let node = self.scopes.fin_head(c.scope.get().unwrap());
- self.replace_node(node, nodes_created);
-
+ log::trace!("Replacing component {:?}", old);
let scope_id = c.scope.get().unwrap();
+ let node = self.scopes.fin_head(scope_id);
- // we can only remove components if they are actively being diffed
- if self.stack.scope_stack.contains(&c.originator) {
+ self.enter_scope(scope_id);
+ {
+ self.replace_inner(node, nodes_created);
+
+ log::trace!("Replacing component x2 {:?}", old);
+
+ let scope = self.scopes.get_scope(scope_id).unwrap();
+ c.scope.set(None);
+ let props = scope.props.take().unwrap();
+ c.props.borrow_mut().replace(props);
self.scopes.try_remove(scope_id).unwrap();
+
+ // // we can only remove components if they are actively being diffed
+ // if self.scope_stack.contains(&c.originator) {
+ // log::trace!("Removing component {:?}", old);
+
+ // self.scopes.try_remove(scope_id).unwrap();
+ // }
}
+ self.leave_scope();
}
}
}
- /// schedules nodes for garbage collection and pushes "remove" to the mutation stack
- /// remove can happen whenever
- pub(crate) fn remove_nodes(
- &mut self,
- nodes: impl IntoIterator- >,
- gen_muts: bool,
- ) {
- // or cache the vec on the diff machine
+ pub fn remove_nodes(&mut self, nodes: impl IntoIterator
- >, gen_muts: bool) {
for node in nodes {
match node {
VNode::Text(t) => {
// this check exists because our null node will be removed but does not have an ID
if let Some(id) = t.id.get() {
self.scopes.collect_garbage(id);
+ t.id.set(None);
if gen_muts {
self.mutations.remove(id.as_u64());
@@ -1276,6 +987,7 @@ impl<'bump> DiffState<'bump> {
VNode::Placeholder(a) => {
let id = a.id.get().unwrap();
self.scopes.collect_garbage(id);
+ a.id.set(None);
if gen_muts {
self.mutations.remove(id.as_u64());
@@ -1288,6 +1000,9 @@ impl<'bump> DiffState<'bump> {
self.mutations.remove(id.as_u64());
}
+ self.scopes.collect_garbage(id);
+ e.id.set(None);
+
self.remove_nodes(e.children, false);
}
@@ -1296,16 +1011,124 @@ impl<'bump> DiffState<'bump> {
}
VNode::Component(c) => {
- let scope_id = c.scope.get().unwrap();
- let root = self.scopes.root_node(scope_id);
- self.remove_nodes(Some(root), gen_muts);
+ self.enter_scope(c.scope.get().unwrap());
+ {
+ let scope_id = c.scope.get().unwrap();
+ let root = self.scopes.root_node(scope_id);
+ self.remove_nodes([root], gen_muts);
- // we can only remove this node if the originator is actively
- if self.stack.scope_stack.contains(&c.originator) {
+ let scope = self.scopes.get_scope(scope_id).unwrap();
+ c.scope.set(None);
+
+ let props = scope.props.take().unwrap();
+ c.props.borrow_mut().replace(props);
self.scopes.try_remove(scope_id).unwrap();
}
+ self.leave_scope();
}
}
}
}
+
+ fn create_children(&mut self, nodes: &'b [VNode<'b>]) -> usize {
+ let mut created = 0;
+ for node in nodes {
+ created += self.create_node(node);
+ }
+ created
+ }
+
+ fn create_and_append_children(&mut self, nodes: &'b [VNode<'b>]) {
+ let created = self.create_children(nodes);
+ self.mutations.append_children(created as u32);
+ }
+
+ fn create_and_insert_after(&mut self, nodes: &'b [VNode<'b>], after: &'b VNode<'b>) {
+ let created = self.create_children(nodes);
+ let last = self.find_last_element(after).unwrap();
+ self.mutations.insert_after(last, created as u32);
+ }
+
+ fn create_and_insert_before(&mut self, nodes: &'b [VNode<'b>], before: &'b VNode<'b>) {
+ let created = self.create_children(nodes);
+ let first = self.find_first_element(before).unwrap();
+ self.mutations.insert_before(first, created as u32);
+ }
+
+ fn current_scope(&self) -> ScopeId {
+ self.scope_stack.last().copied().expect("no current scope")
+ }
+
+ fn enter_scope(&mut self, scope: ScopeId) {
+ self.scope_stack.push(scope);
+ }
+
+ fn leave_scope(&mut self) {
+ self.scope_stack.pop();
+ }
+
+ fn find_last_element(&self, vnode: &'b VNode<'b>) -> Option {
+ let mut search_node = Some(vnode);
+ loop {
+ match &search_node.take().unwrap() {
+ VNode::Text(t) => break t.id.get(),
+ VNode::Element(t) => break t.id.get(),
+ VNode::Placeholder(t) => break t.id.get(),
+ VNode::Fragment(frag) => search_node = frag.children.last(),
+ VNode::Component(el) => {
+ let scope_id = el.scope.get().unwrap();
+ search_node = Some(self.scopes.root_node(scope_id));
+ }
+ }
+ }
+ }
+
+ fn find_first_element(&self, vnode: &'b VNode<'b>) -> Option {
+ let mut search_node = Some(vnode);
+ loop {
+ match &search_node.take().expect("search node to have an ID") {
+ VNode::Text(t) => break t.id.get(),
+ VNode::Element(t) => break t.id.get(),
+ VNode::Placeholder(t) => break t.id.get(),
+ VNode::Fragment(frag) => search_node = Some(&frag.children[0]),
+ VNode::Component(el) => {
+ let scope = el.scope.get().expect("element to have a scope assigned");
+ search_node = Some(self.scopes.root_node(scope));
+ }
+ }
+ }
+ }
+
+ // recursively push all the nodes of a tree onto the stack and return how many are there
+ fn push_all_nodes(&mut self, node: &'b VNode<'b>) -> usize {
+ match node {
+ VNode::Text(_) | VNode::Placeholder(_) => {
+ self.mutations.push_root(node.mounted_id());
+ 1
+ }
+
+ VNode::Fragment(frag) => {
+ let mut added = 0;
+ for child in frag.children {
+ added += self.push_all_nodes(child);
+ }
+ added
+ }
+
+ VNode::Component(c) => {
+ let scope_id = c.scope.get().unwrap();
+ let root = self.scopes.root_node(scope_id);
+ self.push_all_nodes(root)
+ }
+
+ VNode::Element(el) => {
+ let mut num_on_stack = 0;
+ for child in el.children.iter() {
+ num_on_stack += self.push_all_nodes(child);
+ }
+ self.mutations.push_root(el.id.get().unwrap());
+ num_on_stack + 1
+ }
+ }
+ }
}
diff --git a/packages/core/src/lib.rs b/packages/core/src/lib.rs
index dba4effbb..e81ddca87 100644
--- a/packages/core/src/lib.rs
+++ b/packages/core/src/lib.rs
@@ -12,7 +12,6 @@ pub(crate) mod util;
pub(crate) mod virtual_dom;
pub(crate) mod innerlude {
- pub(crate) use crate::diff::*;
pub use crate::events::*;
pub use crate::lazynodes::*;
pub use crate::mutations::*;
diff --git a/packages/core/src/mutations.rs b/packages/core/src/mutations.rs
index fa96edd1b..bd94d0b71 100644
--- a/packages/core/src/mutations.rs
+++ b/packages/core/src/mutations.rs
@@ -143,6 +143,10 @@ impl<'a> Mutations<'a> {
self.edits.push(InsertBefore { n, root });
}
+ pub(crate) fn append_children(&mut self, n: u32) {
+ self.edits.push(AppendChildren { many: n });
+ }
+
// Remove Nodes from the dom
pub(crate) fn remove(&mut self, id: u64) {
self.edits.push(Remove { root: id });
@@ -217,6 +221,10 @@ impl<'a> Mutations<'a> {
let name = attribute.name;
self.edits.push(RemoveAttribute { name, root });
}
+
+ pub(crate) fn mark_dirty_scope(&mut self, scope: ScopeId) {
+ self.dirty_scopes.insert(scope);
+ }
}
// refs are only assigned once
diff --git a/packages/core/src/nodes.rs b/packages/core/src/nodes.rs
index e30a07001..7a36f58ce 100644
--- a/packages/core/src/nodes.rs
+++ b/packages/core/src/nodes.rs
@@ -4,7 +4,7 @@
//! cheap and *very* fast to construct - building a full tree should be quick.
use crate::{
- innerlude::{Element, Properties, Scope, ScopeId, ScopeState},
+ innerlude::{ComponentPtr, Element, Properties, Scope, ScopeId, ScopeState},
lazynodes::LazyNodes,
AnyEvent, Component,
};
@@ -147,13 +147,6 @@ impl<'src> VNode<'src> {
}
}
- pub(crate) fn children(&self) -> &[VNode<'src>] {
- match &self {
- VNode::Fragment(f) => f.children,
- _ => &[],
- }
- }
-
// Create an "owned" version of the vnode.
pub fn decouple(&self) -> VNode<'src> {
match *self {
@@ -175,13 +168,21 @@ impl Debug for VNode<'_> {
.field("key", &el.key)
.field("attrs", &el.attributes)
.field("children", &el.children)
+ .field("id", &el.id)
.finish(),
VNode::Text(t) => write!(s, "VNode::VText {{ text: {} }}", t.text),
- VNode::Placeholder(_) => write!(s, "VNode::VPlaceholder"),
+ VNode::Placeholder(t) => write!(s, "VNode::VPlaceholder {{ id: {:?} }}", t.id),
VNode::Fragment(frag) => {
write!(s, "VNode::VFragment {{ children: {:?} }}", frag.children)
}
- VNode::Component(comp) => write!(s, "VNode::VComponent {{ fc: {:?}}}", comp.user_fc),
+ VNode::Component(comp) => s
+ .debug_struct("VNode::VComponent")
+ .field("name", &comp.fn_name)
+ .field("fnptr", &comp.user_fc)
+ .field("key", &comp.key)
+ .field("scope", &comp.scope)
+ .field("originator", &comp.originator)
+ .finish(),
}
}
}
@@ -351,11 +352,18 @@ type ExternalListenerCallback<'bump, T> = BumpBox<'bump, dyn FnMut(T) + 'bump>;
/// }
///
/// ```
-#[derive(Default)]
pub struct EventHandler<'bump, T = ()> {
pub callback: RefCell>>,
}
+impl<'a, T> Default for EventHandler<'a, T> {
+ fn default() -> Self {
+ Self {
+ callback: RefCell::new(None),
+ }
+ }
+}
+
impl EventHandler<'_, T> {
/// Call this event handler with the appropriate event type
pub fn call(&self, event: T) {
@@ -377,7 +385,8 @@ pub struct VComponent<'src> {
pub originator: ScopeId,
pub scope: Cell>,
pub can_memoize: bool,
- pub user_fc: *const (),
+ pub user_fc: ComponentPtr,
+ pub fn_name: &'static str,
pub props: RefCell>>,
}
@@ -542,6 +551,7 @@ impl<'a> NodeFactory<'a> {
component: fn(Scope<'a, P>) -> Element,
props: P,
key: Option,
+ fn_name: &'static str,
) -> VNode<'a>
where
P: Properties + 'a,
@@ -550,8 +560,9 @@ impl<'a> NodeFactory<'a> {
key: key.map(|f| self.raw_text(f).0),
scope: Default::default(),
can_memoize: P::IS_STATIC,
- user_fc: component as *const (),
+ user_fc: component as ComponentPtr,
originator: self.scope.scope_id(),
+ fn_name,
props: RefCell::new(Some(Box::new(VComponentProps {
// local_props: RefCell::new(Some(props)),
// heap_props: RefCell::new(None),
diff --git a/packages/core/src/scopes.rs b/packages/core/src/scopes.rs
index 77c648d18..00c3024bf 100644
--- a/packages/core/src/scopes.rs
+++ b/packages/core/src/scopes.rs
@@ -13,7 +13,9 @@ use std::{
rc::Rc,
};
-pub(crate) type FcSlot = *const ();
+/// for traceability, we use the raw fn pointer to identify the function
+/// we also get the component name, but that's not necessarily unique in the app
+pub(crate) type ComponentPtr = *mut std::os::raw::c_void;
pub(crate) struct Heuristic {
hook_arena_size: usize,
@@ -28,7 +30,7 @@ pub(crate) struct ScopeArena {
pub scope_gen: Cell,
pub bump: Bump,
pub scopes: RefCell>,
- pub heuristics: RefCell>,
+ pub heuristics: RefCell>,
pub free_scopes: RefCell>,
pub nodes: RefCell>>,
pub tasks: Rc,
@@ -82,7 +84,7 @@ impl ScopeArena {
pub(crate) fn new_with_key(
&self,
- fc_ptr: *const (),
+ fc_ptr: ComponentPtr,
vcomp: Box,
parent_scope: Option,
container: ElementId,
@@ -94,7 +96,7 @@ impl ScopeArena {
// Get the height of the scope
let height = parent_scope
- .map(|id| self.get_scope(id).map(|scope| scope.height))
+ .map(|id| self.get_scope(id).map(|scope| scope.height + 1))
.flatten()
.unwrap_or_default();
@@ -110,31 +112,62 @@ impl ScopeArena {
if let Some(old_scope) = self.free_scopes.borrow_mut().pop() {
// reuse the old scope
let scope = unsafe { &mut *old_scope };
- scope.props.get_mut().replace(vcomp);
+
+ scope.container = container;
+ scope.our_arena_idx = new_scope_id;
scope.parent_scope = parent_scope;
scope.height = height;
+ scope.fnptr = fc_ptr;
+ scope.props.get_mut().replace(vcomp);
scope.subtree.set(subtree);
- scope.our_arena_idx = new_scope_id;
- scope.container = container;
+ scope.frames[0].reset();
+ scope.frames[1].reset();
+ scope.shared_contexts.get_mut().clear();
+ scope.items.get_mut().listeners.clear();
+ scope.items.get_mut().borrowed_props.clear();
+ scope.hook_idx.set(0);
+ scope.hook_vals.get_mut().clear();
+
let any_item = self.scopes.borrow_mut().insert(new_scope_id, scope);
debug_assert!(any_item.is_none());
} else {
// else create a new scope
+ let (node_capacity, hook_capacity) = self
+ .heuristics
+ .borrow()
+ .get(&fc_ptr)
+ .map(|h| (h.node_arena_size, h.hook_arena_size))
+ .unwrap_or_default();
+
self.scopes.borrow_mut().insert(
new_scope_id,
- self.bump.alloc(ScopeState::new(
- height,
+ self.bump.alloc(ScopeState {
container,
- new_scope_id,
+ our_arena_idx: new_scope_id,
parent_scope,
- vcomp,
- self.tasks.clone(),
- self.heuristics
- .borrow()
- .get(&fc_ptr)
- .map(|h| (h.node_arena_size, h.hook_arena_size))
- .unwrap_or_default(),
- )),
+ height,
+ fnptr: fc_ptr,
+ props: RefCell::new(Some(vcomp)),
+ frames: [BumpFrame::new(node_capacity), BumpFrame::new(node_capacity)],
+
+ // todo: subtrees
+ subtree: Cell::new(0),
+ is_subtree_root: Cell::new(false),
+
+ generation: 0.into(),
+
+ tasks: self.tasks.clone(),
+ shared_contexts: Default::default(),
+
+ items: RefCell::new(SelfReferentialItems {
+ listeners: Default::default(),
+ borrowed_props: Default::default(),
+ }),
+
+ hook_arena: Bump::new(),
+ hook_vals: RefCell::new(Vec::with_capacity(hook_capacity)),
+ hook_idx: Default::default(),
+ }),
);
}
@@ -189,8 +222,6 @@ impl ScopeArena {
/// This also makes sure that drop order is consistent and predictable. All resources that rely on being dropped will
/// be dropped.
pub(crate) fn ensure_drop_safety(&self, scope_id: ScopeId) {
- log::trace!("Ensuring drop safety for scope {:?}", scope_id);
-
if let Some(scope) = self.get_scope(scope_id) {
let mut items = scope.items.borrow_mut();
@@ -201,7 +232,6 @@ impl ScopeArena {
if let Some(scope_id) = comp.scope.get() {
self.ensure_drop_safety(scope_id);
}
-
drop(comp.props.take());
});
@@ -217,18 +247,18 @@ impl ScopeArena {
// Cycle to the next frame and then reset it
// This breaks any latent references, invalidating every pointer referencing into it.
// Remove all the outdated listeners
- log::trace!("Running scope {:?}", id);
self.ensure_drop_safety(id);
// todo: we *know* that this is aliased by the contents of the scope itself
let scope = unsafe { &mut *self.get_scope_raw(id).expect("could not find scope") };
+ log::trace!("running scope {:?} symbol: {:?}", id, scope.fnptr);
+
// Safety:
// - We dropped the listeners, so no more &mut T can be used while these are held
// - All children nodes that rely on &mut T are replaced with a new reference
scope.hook_idx.set(0);
- // book keeping to ensure safety around the borrowed data
{
// Safety:
// - We've dropped all references to the wip bump frame with "ensure_drop_safety"
@@ -241,8 +271,6 @@ impl ScopeArena {
debug_assert!(items.borrowed_props.is_empty());
}
- // safety: this is definitely not dropped
-
/*
If the component returns None, then we fill in a placeholder node. This will wipe what was there.
An alternate approach is to leave the Real Dom the same, but that can lead to safety issues and a lot more checks.
@@ -284,14 +312,13 @@ impl ScopeArena {
while let Some(id) = cur_el.take() {
if let Some(el) = nodes.get(id.0) {
- log::trace!("Found valid receiver element");
-
let real_el = unsafe { &**el };
+ log::debug!("looking for listener on {:?}", real_el);
+
if let VNode::Element(real_el) = real_el {
for listener in real_el.listeners.borrow().iter() {
if listener.event == event.name {
- log::trace!("Found valid receiver event");
-
+ log::debug!("calling listener {:?}", listener.event);
if state.canceled.get() {
// stop bubbling if canceled
break;
@@ -421,6 +448,7 @@ pub struct ScopeState {
pub(crate) container: ElementId,
pub(crate) our_arena_idx: ScopeId,
pub(crate) height: u32,
+ pub(crate) fnptr: ComponentPtr,
// todo: subtrees
pub(crate) is_subtree_root: Cell,
@@ -449,43 +477,6 @@ pub struct SelfReferentialItems<'a> {
// Public methods exposed to libraries and components
impl ScopeState {
- fn new(
- height: u32,
- container: ElementId,
- our_arena_idx: ScopeId,
- parent_scope: Option<*mut ScopeState>,
- vcomp: Box,
- tasks: Rc,
- (node_capacity, hook_capacity): (usize, usize),
- ) -> Self {
- ScopeState {
- container,
- our_arena_idx,
- parent_scope,
- height,
- props: RefCell::new(Some(vcomp)),
- frames: [BumpFrame::new(node_capacity), BumpFrame::new(node_capacity)],
-
- // todo: subtrees
- subtree: Cell::new(0),
- is_subtree_root: Cell::new(false),
-
- generation: 0.into(),
-
- tasks,
- shared_contexts: Default::default(),
-
- items: RefCell::new(SelfReferentialItems {
- listeners: Default::default(),
- borrowed_props: Default::default(),
- }),
-
- hook_arena: Bump::new(),
- hook_vals: RefCell::new(Vec::with_capacity(hook_capacity)),
- hook_idx: Default::default(),
- }
- }
-
/// Get the subtree ID that this scope belongs to.
///
/// Each component has its own subtree ID - the root subtree has an ID of 0. This ID is used by the renderer to route
diff --git a/packages/core/src/virtual_dom.rs b/packages/core/src/virtual_dom.rs
index 4e426caad..a7092104c 100644
--- a/packages/core/src/virtual_dom.rs
+++ b/packages/core/src/virtual_dom.rs
@@ -2,6 +2,7 @@
//!
//! This module provides the primary mechanics to create a hook-based, concurrent VDOM for Rust.
+use crate::diff::DiffState;
use crate::innerlude::*;
use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
use futures_util::{future::poll_fn, StreamExt};
@@ -212,7 +213,7 @@ impl VirtualDom {
let scopes = ScopeArena::new(channel.0.clone());
scopes.new_with_key(
- root as *const _,
+ root as ComponentPtr,
Box::new(VComponentProps {
props: root_props,
memo: |_a, _b| unreachable!("memo on root will neve be run"),
@@ -448,6 +449,7 @@ impl VirtualDom {
/// apply_mutations(mutations);
/// }
/// ```
+ #[allow(unused)]
pub fn work_with_deadline(&mut self, mut deadline: impl FnMut() -> bool) -> Vec {
let mut committed_mutations = vec![];
@@ -467,36 +469,41 @@ impl VirtualDom {
h1.cmp(&h2).reverse()
});
+ log::debug!("dirty_scopes: {:?}", self.dirty_scopes);
+
if let Some(scopeid) = self.dirty_scopes.pop() {
if !ran_scopes.contains(&scopeid) {
ran_scopes.insert(scopeid);
self.scopes.run_scope(scopeid);
- let (old, new) = (self.scopes.wip_head(scopeid), self.scopes.fin_head(scopeid));
- diff_state.stack.push(DiffInstruction::Diff { new, old });
- diff_state.stack.scope_stack.push(scopeid);
+ diff_state.diff_scope(scopeid);
- let scope = scopes.get_scope(scopeid).unwrap();
- diff_state.stack.element_stack.push(scope.container);
+ let DiffState { mutations, .. } = diff_state;
+
+ log::debug!("succesffuly resolved scopes {:?}", mutations.dirty_scopes);
+ for scope in &mutations.dirty_scopes {
+ self.dirty_scopes.remove(scope);
+ }
+
+ committed_mutations.push(mutations);
+
+ // todo: pause the diff machine
+ // if diff_state.work(&mut deadline) {
+ // let DiffState { mutations, .. } = diff_state;
+ // for scope in &mutations.dirty_scopes {
+ // self.dirty_scopes.remove(scope);
+ // }
+ // committed_mutations.push(mutations);
+ // } else {
+ // // leave the work in an incomplete state
+ // //
+ // // todo: we should store the edits and re-apply them later
+ // // for now, we just dump the work completely (threadsafe)
+ // return committed_mutations;
+ // }
}
}
-
- if diff_state.work(&mut deadline) {
- let DiffState { mutations, .. } = diff_state;
-
- for scope in &mutations.dirty_scopes {
- self.dirty_scopes.remove(scope);
- }
-
- committed_mutations.push(mutations);
- } else {
- // leave the work in an incomplete state
- //
- // todo: we should store the edits and re-apply them later
- // for now, we just dump the work completely (threadsafe)
- return committed_mutations;
- }
}
committed_mutations
@@ -524,13 +531,15 @@ impl VirtualDom {
let mut diff_state = DiffState::new(&self.scopes);
self.scopes.run_scope(scope_id);
- diff_state
- .stack
- .create_node(self.scopes.fin_head(scope_id), MountType::Append);
- diff_state.stack.element_stack.push(ElementId(0));
- diff_state.stack.scope_stack.push(scope_id);
- diff_state.work(|| false);
+ diff_state.element_stack.push(ElementId(0));
+ diff_state.scope_stack.push(scope_id);
+
+ let node = self.scopes.fin_head(scope_id);
+ let created = diff_state.create_node(node);
+
+ diff_state.mutations.append_children(created as u32);
+
self.dirty_scopes.clear();
assert!(self.dirty_scopes.is_empty());
@@ -577,12 +586,11 @@ impl VirtualDom {
);
diff_machine.force_diff = true;
- diff_machine.stack.push(DiffInstruction::Diff { old, new });
- diff_machine.stack.scope_stack.push(scope_id);
-
+ diff_machine.scope_stack.push(scope_id);
let scope = diff_machine.scopes.get_scope(scope_id).unwrap();
- diff_machine.stack.element_stack.push(scope.container);
- diff_machine.work(|| false);
+ diff_machine.element_stack.push(scope.container);
+
+ diff_machine.diff_node(old, new);
diff_machine.mutations
}
@@ -621,10 +629,10 @@ impl VirtualDom {
/// ```
pub fn diff_vnodes<'a>(&'a self, old: &'a VNode<'a>, new: &'a VNode<'a>) -> Mutations<'a> {
let mut machine = DiffState::new(&self.scopes);
- machine.stack.push(DiffInstruction::Diff { new, old });
- machine.stack.element_stack.push(ElementId(0));
- machine.stack.scope_stack.push(ScopeId(0));
- machine.work(|| false);
+ machine.element_stack.push(ElementId(0));
+ machine.scope_stack.push(ScopeId(0));
+ machine.diff_node(old, new);
+
machine.mutations
}
@@ -643,11 +651,11 @@ impl VirtualDom {
/// ```
pub fn create_vnodes<'a>(&'a self, nodes: LazyNodes<'a, '_>) -> Mutations<'a> {
let mut machine = DiffState::new(&self.scopes);
- machine.stack.element_stack.push(ElementId(0));
- machine
- .stack
- .create_node(self.render_vnodes(nodes), MountType::Append);
- machine.work(|| false);
+ machine.scope_stack.push(ScopeId(0));
+ machine.element_stack.push(ElementId(0));
+ let node = self.render_vnodes(nodes);
+ let created = machine.create_node(node);
+ machine.mutations.append_children(created as u32);
machine.mutations
}
@@ -672,16 +680,15 @@ impl VirtualDom {
let (old, new) = (self.render_vnodes(left), self.render_vnodes(right));
let mut create = DiffState::new(&self.scopes);
- create.stack.scope_stack.push(ScopeId(0));
- create.stack.element_stack.push(ElementId(0));
- create.stack.create_node(old, MountType::Append);
- create.work(|| false);
+ create.scope_stack.push(ScopeId(0));
+ create.element_stack.push(ElementId(0));
+ let created = create.create_node(old);
+ create.mutations.append_children(created as u32);
let mut edit = DiffState::new(&self.scopes);
- edit.stack.scope_stack.push(ScopeId(0));
- edit.stack.element_stack.push(ElementId(0));
- edit.stack.push(DiffInstruction::Diff { old, new });
- edit.work(|| false);
+ edit.scope_stack.push(ScopeId(0));
+ edit.element_stack.push(ElementId(0));
+ edit.diff_node(old, new);
(create.mutations, edit.mutations)
}
diff --git a/packages/core/tests/.rustfmt.toml b/packages/core/tests/.rustfmt.toml
new file mode 100644
index 000000000..70a9483a8
--- /dev/null
+++ b/packages/core/tests/.rustfmt.toml
@@ -0,0 +1 @@
+struct_lit_width = 80
diff --git a/packages/core/tests/create_dom.rs b/packages/core/tests/create_dom.rs
index 044be289c..0cdc37c6d 100644
--- a/packages/core/tests/create_dom.rs
+++ b/packages/core/tests/create_dom.rs
@@ -36,18 +36,9 @@ fn test_original_diff() {
assert_eq!(
mutations.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateElement {
- root: 2,
- tag: "div"
- },
- CreateTextNode {
- root: 3,
- text: "Hello, world!"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateElement { root: 2, tag: "div" },
+ CreateTextNode { root: 3, text: "Hello, world!" },
AppendChildren { many: 1 },
AppendChildren { many: 1 },
AppendChildren { many: 1 },
@@ -81,34 +72,13 @@ fn create() {
assert_eq!(
mutations.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateElement {
- root: 2,
- tag: "div"
- },
- CreateTextNode {
- root: 3,
- text: "Hello, world!"
- },
- CreateElement {
- root: 4,
- tag: "div"
- },
- CreateElement {
- root: 5,
- tag: "div"
- },
- CreateTextNode {
- root: 6,
- text: "hello"
- },
- CreateTextNode {
- root: 7,
- text: "world"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateElement { root: 2, tag: "div" },
+ CreateTextNode { root: 3, text: "Hello, world!" },
+ CreateElement { root: 4, tag: "div" },
+ CreateElement { root: 5, tag: "div" },
+ CreateTextNode { root: 6, text: "hello" },
+ CreateTextNode { root: 7, text: "world" },
AppendChildren { many: 2 },
AppendChildren { many: 1 },
AppendChildren { many: 2 },
@@ -135,32 +105,14 @@ fn create_list() {
assert_eq!(
mutations.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateTextNode {
- root: 2,
- text: "hello"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateTextNode { root: 2, text: "hello" },
AppendChildren { many: 1 },
- CreateElement {
- root: 3,
- tag: "div"
- },
- CreateTextNode {
- root: 4,
- text: "hello"
- },
+ CreateElement { root: 3, tag: "div" },
+ CreateTextNode { root: 4, text: "hello" },
AppendChildren { many: 1 },
- CreateElement {
- root: 5,
- tag: "div"
- },
- CreateTextNode {
- root: 6,
- text: "hello"
- },
+ CreateElement { root: 5, tag: "div" },
+ CreateTextNode { root: 6, text: "hello" },
AppendChildren { many: 1 },
AppendChildren { many: 3 },
]
@@ -185,22 +137,10 @@ fn create_simple() {
assert_eq!(
mutations.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateElement {
- root: 2,
- tag: "div"
- },
- CreateElement {
- root: 3,
- tag: "div"
- },
- CreateElement {
- root: 4,
- tag: "div"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateElement { root: 2, tag: "div" },
+ CreateElement { root: 3, tag: "div" },
+ CreateElement { root: 4, tag: "div" },
AppendChildren { many: 4 },
]
);
@@ -235,36 +175,18 @@ fn create_components() {
mutations.edits,
[
CreateElement { root: 1, tag: "h1" },
- CreateElement {
- root: 2,
- tag: "div"
- },
- CreateTextNode {
- root: 3,
- text: "abc1"
- },
+ CreateElement { root: 2, tag: "div" },
+ CreateTextNode { root: 3, text: "abc1" },
AppendChildren { many: 1 },
CreateElement { root: 4, tag: "p" },
CreateElement { root: 5, tag: "h1" },
- CreateElement {
- root: 6,
- tag: "div"
- },
- CreateTextNode {
- root: 7,
- text: "abc2"
- },
+ CreateElement { root: 6, tag: "div" },
+ CreateTextNode { root: 7, text: "abc2" },
AppendChildren { many: 1 },
CreateElement { root: 8, tag: "p" },
CreateElement { root: 9, tag: "h1" },
- CreateElement {
- root: 10,
- tag: "div"
- },
- CreateTextNode {
- root: 11,
- text: "abc3"
- },
+ CreateElement { root: 10, tag: "div" },
+ CreateTextNode { root: 11, text: "abc3" },
AppendChildren { many: 1 },
CreateElement { root: 12, tag: "p" },
AppendChildren { many: 9 },
@@ -285,14 +207,8 @@ fn anchors() {
assert_eq!(
mutations.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateTextNode {
- root: 2,
- text: "hello"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateTextNode { root: 2, text: "hello" },
AppendChildren { many: 1 },
CreatePlaceholder { root: 3 },
AppendChildren { many: 2 },
diff --git a/packages/core/tests/diffing.rs b/packages/core/tests/diffing.rs
index 5b98ea80e..6bc9b5596 100644
--- a/packages/core/tests/diffing.rs
+++ b/packages/core/tests/diffing.rs
@@ -1,4 +1,5 @@
#![allow(unused, non_upper_case_globals)]
+
//! Diffing Tests
//!
//! These tests only verify that the diffing algorithm works properly for single components.
@@ -31,26 +32,14 @@ fn html_and_rsx_generate_the_same_output() {
assert_eq!(
create.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateTextNode {
- root: 2,
- text: "Hello world"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateTextNode { root: 2, text: "Hello world" },
AppendChildren { many: 1 },
AppendChildren { many: 1 },
]
);
- assert_eq!(
- change.edits,
- [SetText {
- text: "Goodbye world",
- root: 2
- },]
- );
+ assert_eq!(change.edits, [SetText { text: "Goodbye world", root: 2 },]);
}
/// Should result in 3 elements on the stack
@@ -67,32 +56,14 @@ fn fragments_create_properly() {
assert_eq!(
create.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateTextNode {
- root: 2,
- text: "Hello a"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateTextNode { root: 2, text: "Hello a" },
AppendChildren { many: 1 },
- CreateElement {
- root: 3,
- tag: "div"
- },
- CreateTextNode {
- root: 4,
- text: "Hello b"
- },
+ CreateElement { root: 3, tag: "div" },
+ CreateTextNode { root: 4, text: "Hello b" },
AppendChildren { many: 1 },
- CreateElement {
- root: 5,
- tag: "div"
- },
- CreateTextNode {
- root: 6,
- text: "Hello c"
- },
+ CreateElement { root: 5, tag: "div" },
+ CreateTextNode { root: 6, text: "Hello c" },
AppendChildren { many: 1 },
AppendChildren { many: 3 },
]
@@ -116,10 +87,7 @@ fn empty_fragments_create_anchors() {
assert_eq!(
change.edits,
[
- CreateElement {
- root: 2,
- tag: "div"
- },
+ CreateElement { root: 2, tag: "div" },
ReplaceWith { m: 1, root: 1 }
]
);
@@ -138,29 +106,15 @@ fn empty_fragments_create_many_anchors() {
create.edits,
[CreatePlaceholder { root: 1 }, AppendChildren { many: 1 }]
);
+
assert_eq!(
change.edits,
[
- CreateElement {
- root: 2,
- tag: "div"
- },
- CreateElement {
- root: 3,
- tag: "div"
- },
- CreateElement {
- root: 4,
- tag: "div"
- },
- CreateElement {
- root: 5,
- tag: "div"
- },
- CreateElement {
- root: 6,
- tag: "div"
- },
+ CreateElement { root: 2, tag: "div" },
+ CreateElement { root: 3, tag: "div" },
+ CreateElement { root: 4, tag: "div" },
+ CreateElement { root: 5, tag: "div" },
+ CreateElement { root: 6, tag: "div" },
ReplaceWith { m: 5, root: 1 }
]
);
@@ -188,32 +142,14 @@ fn empty_fragments_create_anchors_with_many_children() {
assert_eq!(
change.edits,
[
- CreateElement {
- tag: "div",
- root: 2,
- },
- CreateTextNode {
- text: "hello: 0",
- root: 3
- },
+ CreateElement { tag: "div", root: 2 },
+ CreateTextNode { text: "hello: 0", root: 3 },
AppendChildren { many: 1 },
- CreateElement {
- tag: "div",
- root: 4,
- },
- CreateTextNode {
- text: "hello: 1",
- root: 5
- },
+ CreateElement { tag: "div", root: 4 },
+ CreateTextNode { text: "hello: 1", root: 5 },
AppendChildren { many: 1 },
- CreateElement {
- tag: "div",
- root: 6,
- },
- CreateTextNode {
- text: "hello: 2",
- root: 7
- },
+ CreateElement { tag: "div", root: 6 },
+ CreateTextNode { text: "hello: 2", root: 7 },
AppendChildren { many: 1 },
ReplaceWith { root: 1, m: 3 }
]
@@ -236,23 +172,11 @@ fn many_items_become_fragment() {
assert_eq!(
create.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateTextNode {
- text: "hello",
- root: 2
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateTextNode { text: "hello", root: 2 },
AppendChildren { many: 1 },
- CreateElement {
- root: 3,
- tag: "div"
- },
- CreateTextNode {
- text: "hello",
- root: 4
- },
+ CreateElement { root: 3, tag: "div" },
+ CreateTextNode { text: "hello", root: 4 },
AppendChildren { many: 1 },
AppendChildren { many: 2 },
]
@@ -315,7 +239,7 @@ fn two_fragments_with_differrent_elements_are_differet() {
// replace the divs with new h1s
CreateElement { tag: "h1", root: 7 },
ReplaceWith { root: 1, m: 1 },
- CreateElement { tag: "h1", root: 8 },
+ CreateElement { tag: "h1", root: 1 }, // notice how 1 gets re-used
ReplaceWith { root: 2, m: 1 },
]
);
@@ -339,39 +263,27 @@ fn two_fragments_with_differrent_elements_are_differet_shorter() {
assert_eq!(
create.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateElement {
- root: 2,
- tag: "div"
- },
- CreateElement {
- root: 3,
- tag: "div"
- },
- CreateElement {
- root: 4,
- tag: "div"
- },
- CreateElement {
- root: 5,
- tag: "div"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateElement { root: 2, tag: "div" },
+ CreateElement { root: 3, tag: "div" },
+ CreateElement { root: 4, tag: "div" },
+ CreateElement { root: 5, tag: "div" },
CreateElement { root: 6, tag: "p" },
AppendChildren { many: 6 },
]
);
+
+ // note: key reuse is always the last node that got used
+ // slab maintains a linked list, essentially
assert_eq!(
change.edits,
[
Remove { root: 3 },
Remove { root: 4 },
Remove { root: 5 },
- CreateElement { root: 7, tag: "h1" },
- ReplaceWith { root: 1, m: 1 },
- CreateElement { root: 8, tag: "h1" },
+ CreateElement { root: 5, tag: "h1" }, // 3 gets reused
+ ReplaceWith { root: 1, m: 1 }, // 1 gets deleted
+ CreateElement { root: 1, tag: "h1" }, // 1 gets reused
ReplaceWith { root: 2, m: 1 },
]
);
@@ -395,14 +307,8 @@ fn two_fragments_with_same_elements_are_differet() {
assert_eq!(
create.edits,
[
- CreateElement {
- root: 1,
- tag: "div"
- },
- CreateElement {
- root: 2,
- tag: "div"
- },
+ CreateElement { root: 1, tag: "div" },
+ CreateElement { root: 2, tag: "div" },
CreateElement { root: 3, tag: "p" },
AppendChildren { many: 3 },
]
@@ -410,18 +316,9 @@ fn two_fragments_with_same_elements_are_differet() {
assert_eq!(
change.edits,
[
- CreateElement {
- root: 4,
- tag: "div"
- },
- CreateElement {
- root: 5,
- tag: "div"
- },
- CreateElement {
- root: 6,
- tag: "div"
- },
+ CreateElement { root: 4, tag: "div" },
+ CreateElement { root: 5, tag: "div" },
+ CreateElement { root: 6, tag: "div" },
InsertAfter { root: 2, n: 3 },
]
);
@@ -628,14 +525,8 @@ fn keyed_diffing_additions() {
assert_eq!(
change.edits,
[
- CreateElement {
- root: 6,
- tag: "div"
- },
- CreateElement {
- root: 7,
- tag: "div"
- },
+ CreateElement { root: 6, tag: "div" },
+ CreateElement { root: 7, tag: "div" },
InsertAfter { n: 2, root: 5 }
]
);
@@ -663,14 +554,8 @@ fn keyed_diffing_additions_and_moves_on_ends() {
change.edits,
[
// create 11, 12
- CreateElement {
- tag: "div",
- root: 5
- },
- CreateElement {
- tag: "div",
- root: 6
- },
+ CreateElement { tag: "div", root: 5 },
+ CreateElement { tag: "div", root: 6 },
InsertAfter { root: 3, n: 2 },
// move 7 to the front
PushRoot { root: 4 },
@@ -684,13 +569,13 @@ fn keyed_diffing_additions_and_moves_in_middle() {
let dom = new_dom();
let left = rsx!({
- [/**/ 4, 5, 6, 7 /**/].iter().map(|f| {
+ [/**/ 1, 2, 3, 4 /**/].iter().map(|f| {
rsx! { div { key: "{f}" }}
})
});
let right = rsx!({
- [/**/ 7, 4, 13, 17, 5, 11, 12, 6 /**/].iter().map(|f| {
+ [/**/ 4, 1, 7, 8, 2, 5, 6, 3 /**/].iter().map(|f| {
rsx! { div { key: "{f}" }}
})
});
@@ -701,26 +586,14 @@ fn keyed_diffing_additions_and_moves_in_middle() {
assert_eq!(
change.edits,
[
- // create 13, 17
- CreateElement {
- tag: "div",
- root: 5
- },
- CreateElement {
- tag: "div",
- root: 6
- },
- InsertBefore { root: 2, n: 2 },
- // create 11, 12
- CreateElement {
- tag: "div",
- root: 7
- },
- CreateElement {
- tag: "div",
- root: 8
- },
+ // create 5, 6
+ CreateElement { tag: "div", root: 5 },
+ CreateElement { tag: "div", root: 6 },
InsertBefore { root: 3, n: 2 },
+ // create 7, 8
+ CreateElement { tag: "div", root: 7 },
+ CreateElement { tag: "div", root: 8 },
+ InsertBefore { root: 2, n: 2 },
// move 7
PushRoot { root: 4 },
InsertBefore { root: 1, n: 1 }
@@ -756,16 +629,10 @@ fn controlled_keyed_diffing_out_of_order() {
// remove 7
// create 9 and insert before 6
- CreateElement {
- root: 5,
- tag: "div"
- },
+ CreateElement { root: 5, tag: "div" },
InsertBefore { n: 1, root: 3 },
// create 0 and insert before 5
- CreateElement {
- root: 6,
- tag: "div"
- },
+ CreateElement { root: 6, tag: "div" },
InsertBefore { n: 1, root: 2 },
]
);
@@ -792,10 +659,7 @@ fn controlled_keyed_diffing_out_of_order_max_test() {
assert_eq!(
changes.edits,
[
- CreateElement {
- root: 6,
- tag: "div"
- },
+ CreateElement { root: 6, tag: "div" },
InsertBefore { n: 1, root: 3 },
PushRoot { root: 4 },
InsertBefore { n: 1, root: 1 },
diff --git a/packages/core/tests/earlyabort.rs b/packages/core/tests/earlyabort.rs
index 7dc2ae4d4..3999a7402 100644
--- a/packages/core/tests/earlyabort.rs
+++ b/packages/core/tests/earlyabort.rs
@@ -42,14 +42,8 @@ fn test_early_abort() {
assert_eq!(
edits.edits,
[
- CreateElement {
- tag: "div",
- root: 1,
- },
- CreateTextNode {
- text: "Hello, world!",
- root: 2,
- },
+ CreateElement { tag: "div", root: 1 },
+ CreateTextNode { text: "Hello, world!", root: 2 },
AppendChildren { many: 1 },
AppendChildren { many: 1 },
]
@@ -65,14 +59,8 @@ fn test_early_abort() {
assert_eq!(
edits.edits,
[
- CreateElement {
- tag: "div",
- root: 2,
- },
- CreateTextNode {
- text: "Hello, world!",
- root: 4,
- },
+ CreateElement { tag: "div", root: 1 }, // keys get reused
+ CreateTextNode { text: "Hello, world!", root: 2 }, // keys get reused
AppendChildren { many: 1 },
ReplaceWith { root: 3, m: 1 },
]
diff --git a/packages/core/tests/lifecycle.rs b/packages/core/tests/lifecycle.rs
index 6c0df4e1e..35058d418 100644
--- a/packages/core/tests/lifecycle.rs
+++ b/packages/core/tests/lifecycle.rs
@@ -1,4 +1,5 @@
#![allow(unused, non_upper_case_globals)]
+#![allow(non_snake_case)]
//! Tests for the lifecycle of components.
use dioxus::prelude::*;
@@ -27,12 +28,7 @@ fn manual_diffing() {
};
let value = Arc::new(Mutex::new("Hello"));
- let mut dom = VirtualDom::new_with_props(
- App,
- AppProps {
- value: value.clone(),
- },
- );
+ let mut dom = VirtualDom::new_with_props(App, AppProps { value: value.clone() });
let _ = dom.rebuild();
@@ -45,7 +41,7 @@ fn manual_diffing() {
#[test]
fn events_generate() {
- static App: Component = |cx| {
+ fn app(cx: Scope) -> Element {
let count = cx.use_hook(|_| 0);
let inner = match *count {
@@ -66,7 +62,7 @@ fn events_generate() {
cx.render(inner)
};
- let mut dom = VirtualDom::new(App);
+ let mut dom = VirtualDom::new(app);
let mut channel = dom.get_scheduler_channel();
assert!(dom.has_work());
@@ -74,28 +70,12 @@ fn events_generate() {
assert_eq!(
edits.edits,
[
- CreateElement {
- tag: "div",
- root: 1,
- },
- NewEventListener {
- event_name: "click",
- scope: ScopeId(0),
- root: 1,
- },
- CreateElement {
- tag: "div",
- root: 2,
- },
- CreateTextNode {
- text: "nested",
- root: 3,
- },
+ CreateElement { tag: "div", root: 1 },
+ NewEventListener { event_name: "click", scope: ScopeId(0), root: 1 },
+ CreateElement { tag: "div", root: 2 },
+ CreateTextNode { text: "nested", root: 3 },
AppendChildren { many: 1 },
- CreateTextNode {
- text: "Click me!",
- root: 4,
- },
+ CreateTextNode { text: "Click me!", root: 4 },
AppendChildren { many: 2 },
AppendChildren { many: 1 },
]
@@ -104,7 +84,7 @@ fn events_generate() {
#[test]
fn components_generate() {
- static App: Component = |cx| {
+ fn app(cx: Scope) -> Element {
let render_phase = cx.use_hook(|_| 0);
*render_phase += 1;
@@ -121,106 +101,84 @@ fn components_generate() {
})
};
- static Child: Component = |cx| {
+ fn Child(cx: Scope) -> Element {
+ log::debug!("Running child");
cx.render(rsx! {
h1 {}
})
- };
+ }
- let mut dom = VirtualDom::new(App);
+ let mut dom = VirtualDom::new(app);
let edits = dom.rebuild();
assert_eq!(
edits.edits,
[
- CreateTextNode {
- text: "Text0",
- root: 1,
- },
+ CreateTextNode { text: "Text0", root: 1 },
AppendChildren { many: 1 },
]
);
- let edits = dom.hard_diff(ScopeId(0));
assert_eq!(
- edits.edits,
+ dom.hard_diff(ScopeId(0)).edits,
[
- CreateElement {
- tag: "div",
- root: 2,
- },
+ CreateElement { tag: "div", root: 2 },
ReplaceWith { root: 1, m: 1 },
]
);
- let edits = dom.hard_diff(ScopeId(0));
assert_eq!(
- edits.edits,
+ dom.hard_diff(ScopeId(0)).edits,
[
- CreateTextNode {
- text: "Text2",
- root: 3,
- },
+ CreateTextNode { text: "Text2", root: 1 },
ReplaceWith { root: 2, m: 1 },
]
);
- let edits = dom.hard_diff(ScopeId(0));
+ // child {}
assert_eq!(
- edits.edits,
+ dom.hard_diff(ScopeId(0)).edits,
[
- CreateElement { tag: "h1", root: 4 },
- ReplaceWith { root: 3, m: 1 },
+ CreateElement { tag: "h1", root: 2 },
+ ReplaceWith { root: 1, m: 1 },
]
);
- let edits = dom.hard_diff(ScopeId(0));
+ // placeholder
assert_eq!(
- edits.edits,
- [CreatePlaceholder { root: 5 }, ReplaceWith { root: 4, m: 1 },]
+ dom.hard_diff(ScopeId(0)).edits,
+ [CreatePlaceholder { root: 1 }, ReplaceWith { root: 2, m: 1 },]
);
- let edits = dom.hard_diff(ScopeId(0));
assert_eq!(
- edits.edits,
+ dom.hard_diff(ScopeId(0)).edits,
[
- CreateTextNode {
- text: "text 3",
- root: 6,
- },
- ReplaceWith { root: 5, m: 1 },
+ CreateTextNode { text: "text 3", root: 2 },
+ ReplaceWith { root: 1, m: 1 },
]
);
- let edits = dom.hard_diff(ScopeId(0));
assert_eq!(
- edits.edits,
+ dom.hard_diff(ScopeId(0)).edits,
[
- CreateTextNode {
- text: "text 0",
- root: 7,
- },
- CreateTextNode {
- text: "text 1",
- root: 8,
- },
- ReplaceWith { root: 6, m: 2 },
+ CreateTextNode { text: "text 0", root: 1 },
+ CreateTextNode { text: "text 1", root: 3 },
+ ReplaceWith { root: 2, m: 2 },
]
);
- let edits = dom.hard_diff(ScopeId(0));
assert_eq!(
- edits.edits,
+ dom.hard_diff(ScopeId(0)).edits,
[
- CreateElement { tag: "h1", root: 9 },
- ReplaceWith { root: 7, m: 1 },
- Remove { root: 8 },
+ CreateElement { tag: "h1", root: 2 },
+ ReplaceWith { root: 1, m: 1 },
+ Remove { root: 3 },
]
);
}
#[test]
fn component_swap() {
- static App: Component = |cx| {
+ fn app(cx: Scope) -> Element {
let render_phase = cx.use_hook(|_| 0);
*render_phase += 1;
@@ -296,7 +254,7 @@ fn component_swap() {
})
};
- let mut dom = VirtualDom::new(App);
+ let mut dom = VirtualDom::new(app);
let edits = dom.rebuild();
dbg!(&edits);
diff --git a/packages/core/tests/miri_stress.rs b/packages/core/tests/miri_stress.rs
index bb4963b71..fe98c83ae 100644
--- a/packages/core/tests/miri_stress.rs
+++ b/packages/core/tests/miri_stress.rs
@@ -1,3 +1,4 @@
+#![allow(non_snake_case)]
/*
Stress Miri as much as possible.
@@ -152,12 +153,7 @@ fn free_works_on_root_props() {
}
}
- let mut dom = new_dom(
- app,
- Custom {
- val: String::from("asd"),
- },
- );
+ let mut dom = new_dom(app, Custom { val: String::from("asd") });
dom.rebuild();
}
@@ -313,3 +309,112 @@ fn leak_thru_children() {
dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
dom.work_with_deadline(|| false);
}
+
+#[test]
+fn test_pass_thru() {
+ #[inline_props]
+ fn NavContainer<'a>(cx: Scope, children: Element<'a>) -> Element {
+ cx.render(rsx! {
+ header {
+ nav { children }
+ }
+ })
+ }
+
+ fn NavMenu(cx: Scope) -> Element {
+ rsx!(cx,
+ NavBrand {}
+ div {
+ NavStart {}
+ NavEnd {}
+ }
+ )
+ }
+
+ fn NavBrand(cx: Scope) -> Element {
+ rsx!(cx, div {})
+ }
+
+ fn NavStart(cx: Scope) -> Element {
+ rsx!(cx, div {})
+ }
+
+ fn NavEnd(cx: Scope) -> Element {
+ rsx!(cx, div {})
+ }
+
+ #[inline_props]
+ fn MainContainer<'a>(
+ cx: Scope,
+ nav: Element<'a>,
+ body: Element<'a>,
+ footer: Element<'a>,
+ ) -> Element {
+ cx.render(rsx! {
+ div {
+ class: "columns is-mobile",
+ div {
+ class: "column is-full",
+ nav,
+ body,
+ footer,
+ }
+ }
+ })
+ }
+
+ fn app(cx: Scope) -> Element {
+ let nav = cx.render(rsx! {
+ NavContainer {
+ NavMenu {}
+ }
+ });
+ let body = cx.render(rsx! {
+ div {}
+ });
+ let footer = cx.render(rsx! {
+ div {}
+ });
+
+ cx.render(rsx! {
+ MainContainer {
+ nav: nav,
+ body: body,
+ footer: footer,
+ }
+ })
+ }
+
+ let mut dom = new_dom(app, ());
+ let _ = dom.rebuild();
+
+ for _ in 0..40 {
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(1)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(1)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(1)));
+ dom.work_with_deadline(|| false);
+
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(2)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(2)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(2)));
+ dom.work_with_deadline(|| false);
+
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(3)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(3)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(3)));
+ dom.work_with_deadline(|| false);
+ }
+}
diff --git a/packages/core/tests/passthru.rs b/packages/core/tests/passthru.rs
new file mode 100644
index 000000000..948de8b67
--- /dev/null
+++ b/packages/core/tests/passthru.rs
@@ -0,0 +1,107 @@
+#![allow(unused, non_upper_case_globals)]
+#![allow(non_snake_case)]
+
+//! Diffing Tests
+//!
+//! These tests only verify that the diffing algorithm works properly for single components.
+//!
+//! It does not validated that component lifecycles work properly. This is done in another test file.
+
+use dioxus::{prelude::*, DomEdit, ScopeId};
+use dioxus_core as dioxus;
+use dioxus_core_macro::*;
+use dioxus_html as dioxus_elements;
+
+mod test_logging;
+
+fn new_dom() -> VirtualDom {
+ const IS_LOGGING_ENABLED: bool = false;
+ test_logging::set_up_logging(IS_LOGGING_ENABLED);
+ VirtualDom::new(|cx| rsx!(cx, "hi"))
+}
+
+use DomEdit::*;
+
+/// Should push the text node onto the stack and modify it
+#[test]
+fn nested_passthru_creates() {
+ fn app(cx: Scope) -> Element {
+ cx.render(rsx! {
+ Child {
+ Child {
+ Child {
+ div {
+ "hi"
+ }
+ }
+ }
+ }
+ })
+ };
+
+ #[inline_props]
+ fn Child<'a>(cx: Scope, children: Element<'a>) -> Element {
+ cx.render(rsx! { children })
+ };
+
+ let mut dom = VirtualDom::new(app);
+ let mut channel = dom.get_scheduler_channel();
+ assert!(dom.has_work());
+
+ let edits = dom.rebuild();
+ assert_eq!(
+ edits.edits,
+ [
+ CreateElement { tag: "div", root: 1 },
+ CreateTextNode { text: "hi", root: 2 },
+ AppendChildren { many: 1 },
+ AppendChildren { many: 1 },
+ ]
+ )
+}
+
+/// Should push the text node onto the stack and modify it
+#[test]
+fn nested_passthru_creates_add() {
+ fn app(cx: Scope) -> Element {
+ cx.render(rsx! {
+ Child {
+ "1"
+ Child {
+ "2"
+ Child {
+ "3"
+ div {
+ "hi"
+ }
+ }
+ }
+ }
+ })
+ };
+
+ #[inline_props]
+ fn Child<'a>(cx: Scope, children: Element<'a>) -> Element {
+ cx.render(rsx! {
+ children
+ })
+ };
+
+ let mut dom = VirtualDom::new(app);
+ let mut channel = dom.get_scheduler_channel();
+ assert!(dom.has_work());
+
+ let edits = dom.rebuild();
+ assert_eq!(
+ edits.edits,
+ [
+ CreateTextNode { text: "1", root: 1 },
+ CreateTextNode { text: "2", root: 2 },
+ CreateTextNode { text: "3", root: 3 },
+ CreateElement { tag: "div", root: 4 },
+ CreateTextNode { text: "hi", root: 5 },
+ AppendChildren { many: 1 },
+ AppendChildren { many: 4 },
+ ]
+ )
+}
diff --git a/packages/core/tests/sharedstate.rs b/packages/core/tests/sharedstate.rs
index 3f04aa154..18d569914 100644
--- a/packages/core/tests/sharedstate.rs
+++ b/packages/core/tests/sharedstate.rs
@@ -1,6 +1,6 @@
-#![allow(unused, non_upper_case_globals)]
+#![allow(unused, non_upper_case_globals, non_snake_case)]
-use dioxus::{prelude::*, DomEdit, Mutations};
+use dioxus::{prelude::*, DomEdit, Mutations, SchedulerMsg, ScopeId};
use dioxus_core as dioxus;
use dioxus_core_macro::*;
use dioxus_html as dioxus_elements;
@@ -29,11 +29,102 @@ fn shared_state_test() {
assert_eq!(
edits,
[
- CreateTextNode {
- root: 1,
- text: "Hello, world!"
- },
+ CreateTextNode { root: 1, text: "Hello, world!" },
AppendChildren { many: 1 },
]
);
}
+
+#[test]
+fn swap_test() {
+ struct MySharedState(&'static str);
+
+ fn app(cx: Scope) -> Element {
+ let val = cx.use_hook(|_| 0);
+ *val += 1;
+
+ cx.provide_context(MySharedState("world!"));
+
+ let child = match *val % 2 {
+ 0 => rsx!(
+ Child1 {
+ Child1 { }
+ Child2 { }
+ }
+ ),
+ _ => rsx!(
+ Child2 {
+ Child2 { }
+ Child2 { }
+ }
+ ),
+ };
+
+ cx.render(rsx!(
+ Router {
+ div { child }
+ }
+ ))
+ }
+
+ #[inline_props]
+ fn Router<'a>(cx: Scope, children: Element<'a>) -> Element<'a> {
+ cx.render(rsx!(div { children }))
+ }
+
+ #[inline_props]
+ fn Child1<'a>(cx: Scope, children: Element<'a>) -> Element {
+ let shared = cx.consume_context::().unwrap();
+ println!("Child1: {}", shared.0);
+ cx.render(rsx! {
+ div {
+ "{shared.0}",
+ children
+ }
+ })
+ }
+
+ #[inline_props]
+ fn Child2<'a>(cx: Scope, children: Element<'a>) -> Element {
+ let shared = cx.consume_context::().unwrap();
+ println!("Child2: {}", shared.0);
+ cx.render(rsx! {
+ h1 {
+ "{shared.0}",
+ children
+ }
+ })
+ }
+
+ let mut dom = VirtualDom::new(app);
+ let Mutations { edits, .. } = dom.rebuild();
+
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+ dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ dom.work_with_deadline(|| false);
+
+ // dom.handle_message(SchedulerMsg::Immediate(ScopeId(1)));
+ // dom.work_with_deadline(|| false);
+
+ // dom.handle_message(SchedulerMsg::Immediate(ScopeId(2)));
+ // dom.work_with_deadline(|| false);
+
+ // dom.handle_message(SchedulerMsg::Immediate(ScopeId(3)));
+ // dom.work_with_deadline(|| false);
+
+ // dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ // dom.work_with_deadline(|| false);
+ // dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ // dom.work_with_deadline(|| false);
+ // dom.handle_message(SchedulerMsg::Immediate(ScopeId(0)));
+ // dom.work_with_deadline(|| false);
+}
diff --git a/packages/core/tests/vdom_rebuild.rs b/packages/core/tests/vdom_rebuild.rs
index 5d1dbcdf8..83b4ff35f 100644
--- a/packages/core/tests/vdom_rebuild.rs
+++ b/packages/core/tests/vdom_rebuild.rs
@@ -68,15 +68,9 @@ fn conditional_rendering() {
mutations.edits,
[
CreateElement { root: 1, tag: "h1" },
- CreateTextNode {
- root: 2,
- text: "hello"
- },
+ CreateTextNode { root: 2, text: "hello" },
AppendChildren { many: 1 },
- CreateElement {
- root: 3,
- tag: "span"
- },
+ CreateElement { root: 3, tag: "span" },
CreateTextNode { root: 4, text: "a" },
AppendChildren { many: 1 },
CreatePlaceholder { root: 5 },
diff --git a/packages/desktop/CHANGELOG.md b/packages/desktop/CHANGELOG.md
index 245d05623..65657ab37 100644
--- a/packages/desktop/CHANGELOG.md
+++ b/packages/desktop/CHANGELOG.md
@@ -5,6 +5,76 @@ All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## Unreleased
+
+### Documentation
+
+ - fix web doc example and use &mut for builders everywhere
+
+### New Features
+
+ - default asset server
+ - remove dioxus id on non-event elements
+ - also hide placeholder node
+ - wire up both desktop and web
+ - bool attr white list
+ - setup a typescript build
+
+### Bug Fixes
+
+ - custom protocol receiver type
+ - clippy
+ - wry pathing
+ - cursor jumping and use set instead of lsit
+ - format code
+ - check `href` null
+ - add exclusion list
+ - check `href` null
+ - prevent `submit` default
+
+### Commit Statistics
+
+
+
+ - 26 commits contributed to the release over the course of 11 calendar days.
+ - 17 commits where understood as [conventional](https://www.conventionalcommits.org).
+ - 0 issues like '(#ID)' where seen in commit messages
+
+### Commit Details
+
+
+
+
view details
+
+ * **Uncategorized**
+ - custom protocol receiver type ([`22308eb`](https://github.comgit//DioxusLabs/dioxus/commit/22308eb26a9ea48b14f5f5abb833aa90a4e3fc40))
+ - default asset server ([`430cde7`](https://github.comgit//DioxusLabs/dioxus/commit/430cde7068d308f2783e33d278fd0c0efa659c1b))
+ - fix web doc example and use &mut for builders everywhere ([`a239d2b`](https://github.comgit//DioxusLabs/dioxus/commit/a239d2ba6ac7f1f3d09de16c022ce8ca52cf0f63))
+ - Merge pull request #111 from DioxusLabs/jk/props-attrs ([`0369fe7`](https://github.comgit//DioxusLabs/dioxus/commit/0369fe72fb247409da300a54ef11ba9155d0efb3))
+ - clippy ([`6bc45b1`](https://github.comgit//DioxusLabs/dioxus/commit/6bc45b1c5064a4e2b04d452c52a8167ad179691e))
+ - Merge pull request #113 from DioxusLabs/jk/desktop-cursor-jump ([`20a2940`](https://github.comgit//DioxusLabs/dioxus/commit/20a29409b22510b001fdbee349724adb7b44d401))
+ - wry pathing ([`bad3616`](https://github.comgit//DioxusLabs/dioxus/commit/bad36162af764291f5a031b6233d151f61d745a4))
+ - remove dioxus id on non-event elements ([`95e93ed`](https://github.comgit//DioxusLabs/dioxus/commit/95e93ed0bcf6c69990f4cf3c6448b2bf5da96c36))
+ - also hide placeholder node ([`eb13884`](https://github.comgit//DioxusLabs/dioxus/commit/eb138848ec7a8978f0ed7c717374684d2315dc03))
+ - drag and drop support ([`9ae981a`](https://github.comgit//DioxusLabs/dioxus/commit/9ae981a1af4b5474ce16e27e070794d59128c12a))
+ - feat(events:focus): add missing `onfocusin` event ([`007d06d`](https://github.comgit//DioxusLabs/dioxus/commit/007d06d602f1adfaa51c87ec89b2afe90d8cdef9))
+ - cursor jumping and use set instead of lsit ([`be614e6`](https://github.comgit//DioxusLabs/dioxus/commit/be614e6535e6e13e6ff93e9c6a171c1c002e6b01))
+ - Merge pull request #108 from DioxusLabs/jk/fstring-component-fields ([`f4132d1`](https://github.comgit//DioxusLabs/dioxus/commit/f4132d1874f7495049fac23ba0a022ac137ad74f))
+ - feat(example:todomvc): add editing support ([`9849f68`](https://github.comgit//DioxusLabs/dioxus/commit/9849f68f257200fac511c048bfb1a076243b86d3))
+ - Merge pull request #101 from alexkirsz/ci ([`29bf424`](https://github.comgit//DioxusLabs/dioxus/commit/29bf424b0976b95ff645bb128d0e758cf0186614))
+ - Merge pull request #139 from DioxusLabs/jk/provide-context-any ([`70f2ef4`](https://github.comgit//DioxusLabs/dioxus/commit/70f2ef43db5b6737bd9bcbfc1aa21c834ce4b395))
+ - Merge branch 'master' into jk/unify ([`824defa`](https://github.comgit//DioxusLabs/dioxus/commit/824defa2dbcc16d66588b3976699d89b65a8a068))
+ - wire up both desktop and web ([`05331dd`](https://github.comgit//DioxusLabs/dioxus/commit/05331ddd8033f6997d4916179b62f4d62f832988))
+ - format code ([`9256161`](https://github.comgit//DioxusLabs/dioxus/commit/92561612c727e73356d7d36e16af39aacf02a56d))
+ - Enable clippy ([`b6903bf`](https://github.comgit//DioxusLabs/dioxus/commit/b6903bf558bc7a3d0fe6794a137c44fca0957d11))
+ - bool attr white list ([`8f4aa84`](https://github.comgit//DioxusLabs/dioxus/commit/8f4aa84f1a4f2443b34d81ee42490564e168de53))
+ - setup a typescript build ([`5bf6c96`](https://github.comgit//DioxusLabs/dioxus/commit/5bf6c96f9fed04de949403202bafcbeadb5d2030))
+ - check `href` null ([`2073b40`](https://github.comgit//DioxusLabs/dioxus/commit/2073b400df55f0c6d8bed7371b2313be6c064e6e))
+ - add exclusion list ([`2123228`](https://github.comgit//DioxusLabs/dioxus/commit/21232285d9d84168d9003969ddd254fc22951e4b))
+ - check `href` null ([`327f901`](https://github.comgit//DioxusLabs/dioxus/commit/327f9015481809d8e5b9e69f26202e8d66dd198e))
+ - prevent `submit` default ([`8089023`](https://github.comgit//DioxusLabs/dioxus/commit/8089023a6c3a54957af9c9c05c9dee6088b059ef))
+view details
* **Uncategorized**
- - Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 ([`a36dab7`](https://github.comgit//DioxusLabs/dioxus/commit/a36dab7f45920acd8535a69b4aa3695f3bb92111))
- - Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 ([`40d1f85`](https://github.comgit//DioxusLabs/dioxus/commit/40d1f85d0c3e2c9fd23c08840cca9f459d4e4307))
- - add exclusion list ([`2123228`](https://github.comgit//DioxusLabs/dioxus/commit/21232285d9d84168d9003969ddd254fc22951e4b))
+ - Release dioxus-desktop v0.1.5 ([`cd0dcac`](https://github.comgit//DioxusLabs/dioxus/commit/cd0dcacaf2862f26d29acb21d98f75d41b940e3f))
- handle bool attrs properly ([`8d685f4`](https://github.comgit//DioxusLabs/dioxus/commit/8d685f40b7e0ef6521c60310d8687291e9b9c48a))
+ - link open in browser ([`46fd6ac`](https://github.comgit//DioxusLabs/dioxus/commit/46fd6ac3450ca5ebf9aecb2d59a5a92b2a68bdd0))
+ - Release dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 ([`a36dab7`](https://github.comgit//DioxusLabs/dioxus/commit/a36dab7f45920acd8535a69b4aa3695f3bb92111))
+ - error pattern ([`62b637f`](https://github.comgit//DioxusLabs/dioxus/commit/62b637f8b0eaf616c49461fa23b9251a79abc147))
+ - move `rpc` to handler ([`f006f50`](https://github.comgit//DioxusLabs/dioxus/commit/f006f50317f4b75fac353bc988db057a281ba7f8))
+ - `open_browser` bool attribute ([`9e04ce5`](https://github.comgit//DioxusLabs/dioxus/commit/9e04ce5342850d2e0a01dde169807d6f6eb16566))
+ - Release dioxus-core v0.1.7, dioxus-core-macro v0.1.6, dioxus-html v0.1.4, dioxus-desktop v0.1.5, dioxus-hooks v0.1.6, dioxus-mobile v0.0.3, dioxus-router v0.1.0, dioxus-ssr v0.1.2, dioxus-web v0.0.4, dioxus v0.1.7 ([`40d1f85`](https://github.comgit//DioxusLabs/dioxus/commit/40d1f85d0c3e2c9fd23c08840cca9f459d4e4307))
+ - format code ([`5233ee9`](https://github.comgit//DioxusLabs/dioxus/commit/5233ee97d9314f7f0e0bdf05c56d2a9e4201a596))
+ - link open in browser ([`c737c42`](https://github.comgit//DioxusLabs/dioxus/commit/c737c424b05ad8453e8770a14a0d210fb0c7c2fe))
- Merge pull request #89 from DioxusLabs/jk/simplify-example-run ([`8b6aa8b`](https://github.comgit//DioxusLabs/dioxus/commit/8b6aa8b880b6cb5c95e0c0743aad4e4e74388e05))
+ - link open in browser ([`a0f6015`](https://github.comgit//DioxusLabs/dioxus/commit/a0f60152bc7e5866f114ed469809ce8be70d17d4))
- Merge pull request #74 from mrxiaozhuox/master ([`47056fd`](https://github.comgit//DioxusLabs/dioxus/commit/47056fda4577bcbdaa2a6f63d82eec876e5a5aee))
- Merge pull request #80 from DioxusLabs/jk/router2dotoh ([`cdc2d8e`](https://github.comgit//DioxusLabs/dioxus/commit/cdc2d8ec6d123245c2ea5f6d10af02b6a6833994))
- clear warnigns ([`175a6a1`](https://github.comgit//DioxusLabs/dioxus/commit/175a6a199c6738d8d0c7646ba0ec3fc4406c6535))
diff --git a/packages/desktop/Cargo.toml b/packages/desktop/Cargo.toml
index eb9425c1f..6fd277ba4 100644
--- a/packages/desktop/Cargo.toml
+++ b/packages/desktop/Cargo.toml
@@ -1,6 +1,6 @@
[package]
name = "dioxus-desktop"
-version = "0.1.5"
+version = "0.1.6"
authors = ["Jonathan Kelley"]
edition = "2018"
description = "Dioxus VirtualDOM renderer for a remote webview instance"
@@ -12,29 +12,38 @@ keywords = ["dom", "ui", "gui", "react", "wasm"]
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
[dependencies]
-dioxus-core = { path = "../core", version ="^0.1.7", features = ["serialize"] }
-argh = "0.1.4"
-serde = "1.0.120"
-serde_json = "1.0.61"
-thiserror = "1.0.23"
-log = "0.4.13"
-html-escape = "0.2.9"
-wry = "0.12.2"
-futures-channel = "0.3"
-tokio = { version = "1.12.0", features = [
+dioxus-core = { path = "../core", version = "^0.1.9", features = ["serialize"] }
+serde = "1.0.136"
+serde_json = "1.0.79"
+thiserror = "1.0.30"
+log = "0.4.14"
+wry = { version = "0.13.1" }
+futures-channel = "0.3.21"
+tokio = { version = "1.16.1", features = [
"sync",
"rt-multi-thread",
"rt",
"time",
], optional = true, default-features = false }
-dioxus-core-macro = { path = "../core-macro", version ="^0.1.6"}
-dioxus-html = { path = "../html", features = ["serialize"], version ="^0.1.4"}
+dioxus-html = { path = "../html", features = ["serialize"], version = "^0.1.6" }
webbrowser = "0.5.5"
+mime_guess = "2.0.3"
+dioxus-interpreter-js = { path = "../interpreter", version = "^0.0.0" }
+
[features]
default = ["tokio_runtime"]
tokio_runtime = ["tokio"]
+devtool = ["wry/devtool"]
+fullscreen = ["wry/fullscreen"]
+transparent = ["wry/transparent"]
+
+tray = ["wry/tray"]
+ayatana = ["wry/ayatana"]
+
[dev-dependencies]
+dioxus-core-macro = { path = "../core-macro", version = "^0.1.7" }
dioxus-hooks = { path = "../hooks" }
+# image = "0.24.0" # enable this when generating a new desktop image
diff --git a/packages/desktop/examples/async.rs b/packages/desktop/examples/async.rs
deleted file mode 100644
index 056e7b591..000000000
--- a/packages/desktop/examples/async.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use dioxus::prelude::*;
-use dioxus_core as dioxus;
-use dioxus_core_macro::*;
-use dioxus_hooks::*;
-use dioxus_html as dioxus_elements;
-use std::time::Duration;
-
-fn main() {
- dioxus_desktop::launch(app);
-}
-
-fn app(cx: Scope) -> Element {
- let count = use_state(&cx, || 0);
-
- use_future(&cx, || {
- let count = count.for_async();
- async move {
- loop {
- tokio::time::sleep(Duration::from_millis(1000)).await;
- *count.modify() += 1;
- }
- }
- });
-
- cx.render(rsx! {
- div {
- h1 { "High-Five counter: {count}" }
- button {
- onclick: move |_| count.set(0),
- "Click me!"
- }
- }
- })
-}
diff --git a/packages/desktop/src/assets/default_icon.bin b/packages/desktop/src/assets/default_icon.bin
new file mode 100644
index 000000000..2d4898f0c
Binary files /dev/null and b/packages/desktop/src/assets/default_icon.bin differ
diff --git a/packages/desktop/src/assets/default_icon.png b/packages/desktop/src/assets/default_icon.png
new file mode 100644
index 000000000..d0742ea8a
Binary files /dev/null and b/packages/desktop/src/assets/default_icon.png differ
diff --git a/packages/desktop/src/cfg.rs b/packages/desktop/src/cfg.rs
index ad85cfc0f..c5d6eef50 100644
--- a/packages/desktop/src/cfg.rs
+++ b/packages/desktop/src/cfg.rs
@@ -1,3 +1,4 @@
+use wry::application::window::Icon;
use wry::{
application::{
event_loop::EventLoop,
@@ -11,14 +12,14 @@ use wry::{
pub(crate) type DynEventHandlerFn = dyn Fn(&mut EventLoop<()>, &mut WebView);
pub struct DesktopConfig {
- pub window: WindowBuilder,
- pub file_drop_handler: Option bool>>,
- pub protocos: Vec,
+ pub(crate) window: WindowBuilder,
+ pub(crate) file_drop_handler: Option bool>>,
+ pub(crate) protocols: Vec,
pub(crate) pre_rendered: Option,
pub(crate) event_handler: Option>,
}
-pub type WryProtocl = (
+pub(crate) type WryProtocol = (
String,
Box WryResult + 'static>,
);
@@ -31,7 +32,7 @@ impl DesktopConfig {
Self {
event_handler: None,
window,
- protocos: Vec::new(),
+ protocols: Vec::new(),
file_drop_handler: None,
pre_rendered: None,
}
@@ -71,11 +72,25 @@ impl DesktopConfig {
self
}
- pub fn with_custom_protocol(mut self, name: String, handler: F) -> Self
+ pub fn with_custom_protocol(&mut self, name: String, handler: F) -> &mut Self
where
F: Fn(&HttpRequest) -> WryResult + 'static,
{
- self.protocos.push((name, Box::new(handler)));
+ self.protocols.push((name, Box::new(handler)));
+ self
+ }
+
+ pub fn with_icon(&mut self, icon: Icon) -> &mut Self {
+ self.window.window.window_icon = Some(icon);
+ self
+ }
+}
+
+impl DesktopConfig {
+ pub(crate) fn with_default_icon(mut self) -> Self {
+ let bin: &[u8] = include_bytes!("./assets/default_icon.bin");
+ let rgba = Icon::from_rgba(bin.to_owned(), 460, 460).expect("image parse failed");
+ self.window.window.window_icon = Some(rgba);
self
}
}
@@ -85,3 +100,31 @@ impl Default for DesktopConfig {
Self::new()
}
}
+
+// dirty trick, avoid introducing `image` at runtime
+// TODO: use serde when `Icon` impl serde
+//
+// This function should only be enabled when generating new icons.
+//
+// #[test]
+// #[ignore]
+// fn prepare_default_icon() {
+// use image::io::Reader as ImageReader;
+// use image::ImageFormat;
+// use std::fs::File;
+// use std::io::Cursor;
+// use std::io::Write;
+// use std::path::PathBuf;
+// let png: &[u8] = include_bytes!("default_icon.png");
+// let mut reader = ImageReader::new(Cursor::new(png));
+// reader.set_format(ImageFormat::Png);
+// let icon = reader.decode().unwrap();
+// let bin = PathBuf::from(file!())
+// .parent()
+// .unwrap()
+// .join("default_icon.bin");
+// println!("{:?}", bin);
+// let mut file = File::create(bin).unwrap();
+// file.write_all(icon.as_bytes()).unwrap();
+// println!("({}, {})", icon.width(), icon.height())
+// }
diff --git a/packages/desktop/src/controller.rs b/packages/desktop/src/controller.rs
new file mode 100644
index 000000000..8715c74f0
--- /dev/null
+++ b/packages/desktop/src/controller.rs
@@ -0,0 +1,107 @@
+use crate::desktop_context::DesktopContext;
+use crate::user_window_events::UserWindowEvent;
+use dioxus_core::*;
+use std::{
+ collections::{HashMap, VecDeque},
+ sync::atomic::AtomicBool,
+ sync::{Arc, RwLock},
+};
+use wry::{
+ self,
+ application::{event_loop::ControlFlow, event_loop::EventLoopProxy, window::WindowId},
+ webview::WebView,
+};
+
+pub(super) struct DesktopController {
+ pub(super) webviews: HashMap,
+ pub(super) sender: futures_channel::mpsc::UnboundedSender,
+ pub(super) pending_edits: Arc>>,
+ pub(super) quit_app_on_close: bool,
+ pub(super) is_ready: Arc,
+}
+
+impl DesktopController {
+ // Launch the virtualdom on its own thread managed by tokio
+ // returns the desktop state
+ pub(super) fn new_on_tokio(
+ root: Component,
+ props: P,
+ proxy: EventLoopProxy,
+ ) -> Self {
+ let edit_queue = Arc::new(RwLock::new(VecDeque::new()));
+ let pending_edits = edit_queue.clone();
+
+ let (sender, receiver) = futures_channel::mpsc::unbounded::();
+ let return_sender = sender.clone();
+
+ let desktop_context_proxy = proxy.clone();
+ std::thread::spawn(move || {
+ // We create the runtime as multithreaded, so you can still "spawn" onto multiple threads
+ let runtime = tokio::runtime::Builder::new_multi_thread()
+ .enable_all()
+ .build()
+ .unwrap();
+
+ runtime.block_on(async move {
+ let mut dom =
+ VirtualDom::new_with_props_and_scheduler(root, props, (sender, receiver));
+
+ let window_context = DesktopContext::new(desktop_context_proxy);
+
+ dom.base_scope().provide_context(window_context);
+
+ let edits = dom.rebuild();
+
+ edit_queue
+ .write()
+ .unwrap()
+ .push_front(serde_json::to_string(&edits.edits).unwrap());
+
+ // Make sure the window is ready for any new updates
+ proxy.send_event(UserWindowEvent::Update).unwrap();
+
+ loop {
+ dom.wait_for_work().await;
+ let mut muts = dom.work_with_deadline(|| false);
+
+ while let Some(edit) = muts.pop() {
+ edit_queue
+ .write()
+ .unwrap()
+ .push_front(serde_json::to_string(&edit.edits).unwrap());
+ }
+
+ let _ = proxy.send_event(UserWindowEvent::Update);
+ }
+ })
+ });
+
+ Self {
+ pending_edits,
+ sender: return_sender,
+ webviews: HashMap::new(),
+ is_ready: Arc::new(AtomicBool::new(false)),
+ quit_app_on_close: true,
+ }
+ }
+
+ pub(super) fn close_window(&mut self, window_id: WindowId, control_flow: &mut ControlFlow) {
+ self.webviews.remove(&window_id);
+
+ if self.webviews.is_empty() && self.quit_app_on_close {
+ *control_flow = ControlFlow::Exit;
+ }
+ }
+
+ pub(super) fn try_load_ready_webviews(&mut self) {
+ if self.is_ready.load(std::sync::atomic::Ordering::Relaxed) {
+ let mut queue = self.pending_edits.write().unwrap();
+ let (_id, view) = self.webviews.iter_mut().next().unwrap();
+
+ while let Some(edit) = queue.pop_back() {
+ view.evaluate_script(&format!("window.interpreter.handleEdits({})", edit))
+ .unwrap();
+ }
+ }
+ }
+}
diff --git a/packages/desktop/src/desktop_context.rs b/packages/desktop/src/desktop_context.rs
index 48c82f5a8..e1b726d73 100644
--- a/packages/desktop/src/desktop_context.rs
+++ b/packages/desktop/src/desktop_context.rs
@@ -1,100 +1,118 @@
-use std::cell::RefCell;
+use std::rc::Rc;
-use dioxus::prelude::Scope;
-use dioxus_core as dioxus;
-use dioxus_core::{Context, Element, LazyNodes, NodeFactory, Properties};
-use dioxus_core_macro::Props;
+use dioxus_core::ScopeState;
+use wry::application::event_loop::EventLoopProxy;
-/*
-This module provides a set of Dioxus components to easily manage windows, tabs, etc.
+use crate::user_window_events::UserWindowEvent;
+use UserWindowEvent::*;
-Windows can be created anywhere in the tree, making them very flexible for things like modals, etc.
+type ProxyType = EventLoopProxy;
-*/
-pub struct DesktopContext {}
+/// Desktop-Window handle api context
+///
+/// you can use this context control some window event
+///
+/// you can use `cx.consume_context::` to get this context
+///
+/// ```rust
+/// let desktop = cx.consume_context::().unwrap();
+/// ```
+#[derive(Clone)]
+pub struct DesktopContext {
+ proxy: ProxyType,
+}
impl DesktopContext {
- fn add_window(&mut self) {
- //
+ pub(crate) fn new(proxy: ProxyType) -> Self {
+ Self { proxy }
}
- fn close_window(&mut self) {
- //
+
+ /// trigger the drag-window event
+ ///
+ /// Moves the window with the left mouse button until the button is released.
+ ///
+ /// you need use it in `onmousedown` event:
+ /// ```rust
+ /// onmousedown: move |_| { desktop.drag_window(); }
+ /// ```
+ pub fn drag(&self) {
+ let _ = self.proxy.send_event(DragWindow);
+ }
+
+ /// set window minimize state
+ pub fn set_minimized(&self, minimized: bool) {
+ let _ = self.proxy.send_event(Minimize(minimized));
+ }
+
+ /// set window maximize state
+ pub fn set_maximized(&self, maximized: bool) {
+ let _ = self.proxy.send_event(Maximize(maximized));
+ }
+
+ /// toggle window maximize state
+ pub fn toggle_maximized(&self) {
+ let _ = self.proxy.send_event(MaximizeToggle);
+ }
+
+ /// set window visible or not
+ pub fn set_visible(&self, visible: bool) {
+ let _ = self.proxy.send_event(Visible(visible));
+ }
+
+ /// close window
+ pub fn close(&self) {
+ let _ = self.proxy.send_event(CloseWindow);
+ }
+
+ /// set window to focus
+ pub fn focus(&self) {
+ let _ = self.proxy.send_event(FocusWindow);
+ }
+
+ /// change window to fullscreen
+ pub fn set_fullscreen(&self, fullscreen: bool) {
+ let _ = self.proxy.send_event(Fullscreen(fullscreen));
+ }
+
+ /// set resizable state
+ pub fn set_resizable(&self, resizable: bool) {
+ let _ = self.proxy.send_event(Resizable(resizable));
+ }
+
+ /// set the window always on top
+ pub fn set_always_on_top(&self, top: bool) {
+ let _ = self.proxy.send_event(AlwaysOnTop(top));
+ }
+
+ // set cursor visible or not
+ pub fn set_cursor_visible(&self, visible: bool) {
+ let _ = self.proxy.send_event(CursorVisible(visible));
+ }
+
+ // set cursor grab
+ pub fn set_cursor_grab(&self, grab: bool) {
+ let _ = self.proxy.send_event(CursorGrab(grab));
+ }
+
+ /// set window title
+ pub fn set_title(&self, title: &str) {
+ let _ = self.proxy.send_event(SetTitle(String::from(title)));
+ }
+
+ /// change window to borderless
+ pub fn set_decorations(&self, decoration: bool) {
+ let _ = self.proxy.send_event(SetDecorations(decoration));
+ }
+
+ /// opens DevTool window
+ pub fn devtool(&self) {
+ let _ = self.proxy.send_event(DevTool);
}
}
-enum WindowHandlers {
- Resized(Box),
- Moved(Box),
- CloseRequested(Box),
- Destroyed(Box),
- DroppedFile(Box),
- HoveredFile(Box),
- HoverFileCancelled(Box),
- ReceivedTimeText(Box),
- Focused(Box),
-}
-
-#[derive(Props)]
-pub struct WebviewWindowProps<'a> {
- onclose: &'a dyn FnMut(()),
-
- onopen: &'a dyn FnMut(()),
-
- /// focuse me
- onfocused: &'a dyn FnMut(()),
-
- children: Element,
-}
-
-/// A handle to a
-///
-///
-///
-///
-///
-///
-///
-///
-///
-pub fn WebviewWindow(cx: Scope) -> Element {
- let dtcx = cx.consume_state::>()?;
-
- cx.use_hook(|_| {});
-
- // render the children directly
- todo!()
- // cx.render(LazyNodes::new(move |f: NodeFactory| {
- // f.fragment_from_iter(cx.children())
- // }))
-}
-
-pub struct WindowHandle {}
-
-/// Get a handle to the current window from inside a component
-pub fn use_current_window(cx: Scope) -> Option {
- todo!()
-}
-
-#[test]
-fn syntax_works() {
- use dioxus_core as dioxus;
- use dioxus_core::prelude::*;
- use dioxus_core_macro::*;
- use dioxus_hooks::*;
- use dioxus_html as dioxus_elements;
-
- static App: Component = |cx| {
- cx.render(rsx! {
- // left window
- WebviewWindow {
- onclose: move |evt| {}
- onopen: move |evt| {}
- onfocused: move |evt| {}
-
- div {
-
- }
- }
- })
- };
+/// use this function can get the `DesktopContext` context.
+pub fn use_window(cx: &ScopeState) -> &Rc {
+ cx.use_hook(|_| cx.consume_context::())
+ .as_ref()
+ .unwrap()
}
diff --git a/packages/desktop/src/events.rs b/packages/desktop/src/events.rs
index 760bf7662..44126dd63 100644
--- a/packages/desktop/src/events.rs
+++ b/packages/desktop/src/events.rs
@@ -1,5 +1,4 @@
-//! Convert a serialized event to an event Trigger
-//!
+//! Convert a serialized event to an event trigger
use std::any::Any;
use std::sync::Arc;
@@ -7,27 +6,49 @@ use std::sync::Arc;
use dioxus_core::{ElementId, EventPriority, UserEvent};
use dioxus_html::on::*;
+#[derive(serde::Serialize, serde::Deserialize)]
+pub(crate) struct IpcMessage {
+ method: String,
+ params: serde_json::Value,
+}
+
+impl IpcMessage {
+ pub(crate) fn method(&self) -> &str {
+ self.method.as_str()
+ }
+
+ pub(crate) fn params(self) -> serde_json::Value {
+ self.params
+ }
+}
+
+pub(crate) fn parse_ipc_message(payload: &str) -> Option {
+ match serde_json::from_str(payload) {
+ Ok(message) => Some(message),
+ Err(e) => {
+ log::error!("could not parse IPC message, error: {}", e);
+ None
+ }
+ }
+}
+
#[derive(serde::Serialize, serde::Deserialize)]
struct ImEvent {
event: String,
mounted_dom_id: u64,
- // scope: u64,
contents: serde_json::Value,
}
pub fn trigger_from_serialized(val: serde_json::Value) -> UserEvent {
- let ims: Vec = serde_json::from_value(val).unwrap();
-
let ImEvent {
event,
mounted_dom_id,
contents,
- } = ims.into_iter().next().unwrap();
+ } = serde_json::from_value(val).unwrap();
- // let scope_id = ScopeId(scope as usize);
let mounted_dom_id = Some(ElementId(mounted_dom_id as usize));
- let name = event_name_from_typ(&event);
+ let name = event_name_from_type(&event);
let event = make_synthetic_event(&event, contents);
UserEvent {
@@ -105,7 +126,7 @@ fn make_synthetic_event(name: &str, val: serde_json::Value) -> Arc &'static str {
+fn event_name_from_type(typ: &str) -> &'static str {
match typ {
"copy" => "copy",
"cut" => "cut",
diff --git a/packages/desktop/src/index.html b/packages/desktop/src/index.html
index 88fcba12a..292a1ae6a 100644
--- a/packages/desktop/src/index.html
+++ b/packages/desktop/src/index.html
@@ -1,22 +1,15 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+ });
+
+
diff --git a/packages/desktop/src/lib.rs b/packages/desktop/src/lib.rs
index 93c175cc6..e84baa034 100644
--- a/packages/desktop/src/lib.rs
+++ b/packages/desktop/src/lib.rs
@@ -1,78 +1,30 @@
-//! Dioxus Desktop Renderer
-//!
-//! Render the Dioxus VirtualDom using the platform's native WebView implementation.
-//!
-//! # Desktop
-//!
-//! One of Dioxus' killer features is the ability to quickly build a native desktop app that looks and feels the same across platforms. Apps built with Dioxus are typically <5mb in size and use existing system resources, so they won't hog extreme amounts of RAM or memory.
-//!
-//! Dioxus Desktop is built off Tauri. Right now there aren't any Dioxus abstractions over keyboard shortcuts, menubar, handling, etc, so you'll want to leverage Tauri - mostly [Wry](http://github.com/tauri-apps/wry/) and [Tao](http://github.com/tauri-apps/tao)) directly. The next major release of Dioxus-Desktop will include components and hooks for notifications, global shortcuts, menubar, etc.
-//!
-//!
-//! ## Getting Set up
-//!
-//! Getting Set up with Dioxus-Desktop is quite easy. Make sure you have Rust and Cargo installed, and then create a new project:
-//!
-//! ```shell
-//! $ cargo new --bin demo
-//! $ cd app
-//! ```
-//!
-//! Add Dioxus with the `desktop` feature:
-//!
-//! ```shell
-//! $ cargo add dioxus --features desktop
-//! ```
-//!
-//! Edit your `main.rs`:
-//!
-//! ```rust
-//! // main.rs
-//! use dioxus::prelude::*;
-//!
-//! fn main() {
-//! dioxus::desktop::launch(app);
-//! }
-//!
-//! fn app(cx: Scope) -> Element {
-//! cx.render(rsx!{
-//! div {
-//! "hello world!"
-//! }
-//! })
-//! }
-//! ```
-//!
-//!
-//! To configure the webview, menubar, and other important desktop-specific features, checkout out some of the launch configuration in the [API reference](https://docs.rs/dioxus-desktop/).
-//!
-//! ## Future Steps
-//!
-//! Make sure to read the [Dioxus Guide](https://dioxuslabs.com/guide) if you already haven't!
+#![doc = include_str!("readme.md")]
+#![doc(html_logo_url = "https://avatars.githubusercontent.com/u/79236386")]
+#![doc(html_favicon_url = "https://avatars.githubusercontent.com/u/79236386")]
pub mod cfg;
+mod controller;
+pub mod desktop_context;
pub mod escape;
pub mod events;
+mod protocol;
+mod user_window_events;
use cfg::DesktopConfig;
+use controller::DesktopController;
+pub use desktop_context::use_window;
use dioxus_core::*;
-use std::{
- collections::{HashMap, VecDeque},
- sync::atomic::AtomicBool,
- sync::{Arc, RwLock},
-};
+use events::parse_ipc_message;
use tao::{
event::{Event, StartCause, WindowEvent},
event_loop::{ControlFlow, EventLoop},
- window::{Window, WindowId},
+ window::Window,
};
pub use wry;
pub use wry::application as tao;
-use wry::{
- application::event_loop::EventLoopProxy,
- webview::RpcRequest,
- webview::{WebView, WebViewBuilder},
-};
+use wry::webview::WebViewBuilder;
+
+use crate::events::trigger_from_serialized;
/// Launch the WebView and run the event loop.
///
@@ -149,7 +101,7 @@ pub fn launch_with_props(
props: P,
builder: impl FnOnce(&mut DesktopConfig) -> &mut DesktopConfig,
) {
- let mut cfg = DesktopConfig::default();
+ let mut cfg = DesktopConfig::default().with_default_icon();
builder(&mut cfg);
let event_loop = EventLoop::with_user_event();
@@ -174,24 +126,26 @@ pub fn launch_with_props(
let mut webview = WebViewBuilder::new(window)
.unwrap()
+ .with_transparent(cfg.window.window.transparent)
.with_url("dioxus://index.html/")
.unwrap()
- .with_rpc_handler(move |_window: &Window, req: RpcRequest| {
- match req.method.as_str() {
- "user_event" => {
- let event = events::trigger_from_serialized(req.params.unwrap());
- log::trace!("User event: {:?}", event);
- sender.unbounded_send(SchedulerMsg::Event(event)).unwrap();
- }
- "initialize" => {
- is_ready.store(true, std::sync::atomic::Ordering::Relaxed);
- let _ = proxy.send_event(UserWindowEvent::Update);
- }
- "browser_open" => {
- let data = req.params.unwrap();
- log::trace!("Open browser: {:?}", data);
- if let Some(arr) = data.as_array() {
- if let Some(temp) = arr[0].as_object() {
+ .with_ipc_handler(move |_window: &Window, payload: String| {
+ parse_ipc_message(&payload)
+ .map(|message| match message.method() {
+ "user_event" => {
+ let event = trigger_from_serialized(message.params());
+ log::trace!("User event: {:?}", event);
+ sender.unbounded_send(SchedulerMsg::Event(event)).unwrap();
+ }
+ "initialize" => {
+ is_ready.store(true, std::sync::atomic::Ordering::Relaxed);
+ let _ = proxy
+ .send_event(user_window_events::UserWindowEvent::Update);
+ }
+ "browser_open" => {
+ let data = message.params();
+ log::trace!("Open browser: {:?}", data);
+ if let Some(temp) = data.as_object() {
if temp.contains_key("href") {
let url = temp.get("href").unwrap().as_str().unwrap();
if let Err(e) = webbrowser::open(url) {
@@ -200,30 +154,13 @@ pub fn launch_with_props(
}
}
}
- }
- _ => {}
- }
- None
- })
- .with_custom_protocol(String::from("dioxus"), move |request| {
- // Any content that that uses the `dioxus://` scheme will be shuttled through this handler as a "special case"
- // For now, we only serve two pieces of content which get included as bytes into the final binary.
- let path = request.uri().replace("dioxus://", "");
-
- if path.trim_end_matches('/') == "index.html" {
- wry::http::ResponseBuilder::new()
- .mimetype("text/html")
- .body(include_bytes!("./index.html").to_vec())
- } else if path.trim_end_matches('/') == "index.html/index.js" {
- wry::http::ResponseBuilder::new()
- .mimetype("text/javascript")
- .body(include_bytes!("../../jsinterpreter/interpreter.js").to_vec())
- } else {
- wry::http::ResponseBuilder::new()
- .status(wry::http::status::StatusCode::NOT_FOUND)
- .body(format!("Not found: {}", path).as_bytes().to_vec())
- }
+ _ => (),
+ })
+ .unwrap_or_else(|| {
+ log::warn!("invalid IPC message received");
+ });
})
+ .with_custom_protocol(String::from("dioxus"), protocol::desktop_handler)
.with_file_drop_handler(move |window, evet| {
file_handler
.as_ref()
@@ -231,10 +168,32 @@ pub fn launch_with_props(
.unwrap_or_default()
});
- for (name, handler) in cfg.protocos.drain(..) {
+ for (name, handler) in cfg.protocols.drain(..) {
webview = webview.with_custom_protocol(name, handler)
}
+ if cfg!(debug_assertions) {
+ // in debug, we are okay with the reload menu showing and dev tool
+ webview = webview.with_dev_tool(true);
+ } else {
+ // in release mode, we don't want to show the dev tool or reload menus
+ webview = webview.with_initialization_script(
+ r#"
+ if (document.addEventListener) {
+ document.addEventListener('contextmenu', function(e) {
+ alert("You've tried to open context menu");
+ e.preventDefault();
+ }, false);
+ } else {
+ document.attachEvent('oncontextmenu', function() {
+ alert("You've tried to open context menu");
+ window.event.returnValue = false;
+ });
+ }
+ "#,
+ )
+ }
+
desktop.webviews.insert(window_id, webview.build().unwrap());
}
@@ -253,11 +212,8 @@ pub fn launch_with_props(
_ => {}
},
- Event::UserEvent(_evt) => {
- //
- match _evt {
- UserWindowEvent::Update => desktop.try_load_ready_webviews(),
- }
+ Event::UserEvent(user_event) => {
+ user_window_events::handler(user_event, &mut desktop, control_flow)
}
Event::MainEventsCleared => {}
Event::Resumed => {}
@@ -268,98 +224,3 @@ pub fn launch_with_props(
}
})
}
-
-pub enum UserWindowEvent {
- Update,
-}
-
-pub struct DesktopController {
- pub proxy: EventLoopProxy,
- pub webviews: HashMap,
- pub sender: futures_channel::mpsc::UnboundedSender,
- pub pending_edits: Arc>>,
- pub quit_app_on_close: bool,
- pub is_ready: Arc,
-}
-
-impl DesktopController {
- // Launch the virtualdom on its own thread managed by tokio
- // returns the desktop state
- pub fn new_on_tokio(
- root: Component,
- props: P,
- evt: EventLoopProxy,
- ) -> Self {
- let edit_queue = Arc::new(RwLock::new(VecDeque::new()));
- let pending_edits = edit_queue.clone();
-
- let (sender, receiver) = futures_channel::mpsc::unbounded::();
- let return_sender = sender.clone();
- let proxy = evt.clone();
-
- std::thread::spawn(move || {
- // We create the runtime as multithreaded, so you can still "spawn" onto multiple threads
- let runtime = tokio::runtime::Builder::new_multi_thread()
- .enable_all()
- .build()
- .unwrap();
-
- runtime.block_on(async move {
- let mut dom =
- VirtualDom::new_with_props_and_scheduler(root, props, (sender, receiver));
-
- let edits = dom.rebuild();
-
- edit_queue
- .write()
- .unwrap()
- .push_front(serde_json::to_string(&edits.edits).unwrap());
-
- loop {
- dom.wait_for_work().await;
- let mut muts = dom.work_with_deadline(|| false);
-
- while let Some(edit) = muts.pop() {
- edit_queue
- .write()
- .unwrap()
- .push_front(serde_json::to_string(&edit.edits).unwrap());
- }
-
- let _ = evt.send_event(UserWindowEvent::Update);
- }
- })
- });
-
- Self {
- pending_edits,
- sender: return_sender,
- proxy,
- webviews: HashMap::new(),
- is_ready: Arc::new(AtomicBool::new(false)),
- quit_app_on_close: true,
- }
- }
-
- pub fn close_window(&mut self, window_id: WindowId, control_flow: &mut ControlFlow) {
- self.webviews.remove(&window_id);
-
- if self.webviews.is_empty() && self.quit_app_on_close {
- *control_flow = ControlFlow::Exit;
- }
- }
-
- pub fn try_load_ready_webviews(&mut self) {
- if self.is_ready.load(std::sync::atomic::Ordering::Relaxed) {
- let mut queue = self.pending_edits.write().unwrap();
- let (_id, view) = self.webviews.iter_mut().next().unwrap();
-
- while let Some(edit) = queue.pop_back() {
- view.evaluate_script(&format!("window.interpreter.handleEdits({})", edit))
- .unwrap();
- }
- } else {
- println!("waiting for ready");
- }
- }
-}
diff --git a/packages/desktop/src/protocol.rs b/packages/desktop/src/protocol.rs
new file mode 100644
index 000000000..c8f007c1d
--- /dev/null
+++ b/packages/desktop/src/protocol.rs
@@ -0,0 +1,47 @@
+use std::path::Path;
+use wry::{
+ http::{status::StatusCode, Request, Response, ResponseBuilder},
+ Result,
+};
+
+pub(super) fn desktop_handler(request: &Request) -> Result {
+ // Any content that uses the `dioxus://` scheme will be shuttled through this handler as a "special case".
+ // For now, we only serve two pieces of content which get included as bytes into the final binary.
+ let path = request.uri().replace("dioxus://", "");
+
+ // all assets should be called from index.html
+ let trimmed = path.trim_start_matches("index.html/");
+
+ if trimmed.is_empty() {
+ ResponseBuilder::new()
+ .mimetype("text/html")
+ .body(include_bytes!("./index.html").to_vec())
+ } else if trimmed == "index.js" {
+ ResponseBuilder::new()
+ .mimetype("text/javascript")
+ .body(dioxus_interpreter_js::INTERPRETER_JS.as_bytes().to_vec())
+ } else {
+ let path_buf = Path::new(trimmed).canonicalize()?;
+ let cur_path = Path::new(".").canonicalize()?;
+
+ if !path_buf.starts_with(cur_path) {
+ return ResponseBuilder::new()
+ .status(StatusCode::FORBIDDEN)
+ .body(String::from("Forbidden").into_bytes());
+ }
+
+ if !path_buf.exists() {
+ return ResponseBuilder::new()
+ .status(StatusCode::NOT_FOUND)
+ .body(String::from("Not Found").into_bytes());
+ }
+
+ let mime = mime_guess::from_path(&path_buf).first_or_octet_stream();
+
+ // do not let path searching to go two layers beyond the caller level
+ let data = std::fs::read(path_buf)?;
+ let meta = format!("{}", mime);
+
+ ResponseBuilder::new().mimetype(&meta).body(data)
+ }
+}
diff --git a/packages/desktop/src/readme.md b/packages/desktop/src/readme.md
new file mode 100644
index 000000000..dc034fe67
--- /dev/null
+++ b/packages/desktop/src/readme.md
@@ -0,0 +1,51 @@
+Dioxus Desktop Renderer
+
+Render the Dioxus VirtualDom using the platform's native WebView implementation.
+
+# Desktop
+
+One of Dioxus' killer features is the ability to quickly build a native desktop app that looks and feels the same across platforms. Apps built with Dioxus are typically <5mb in size and use existing system resources, so they won't hog extreme amounts of RAM or memory.
+
+Dioxus Desktop is built off Tauri. Right now there aren't any Dioxus abstractions over keyboard shortcuts, menubar, handling, etc, so you'll want to leverage Tauri - mostly [Wry](http://github.com/tauri-apps/wry/) and [Tao](http://github.com/tauri-apps/tao)) directly. The next major release of Dioxus-Desktop will include components and hooks for notifications, global shortcuts, menubar, etc.
+
+
+## Getting Set up
+
+Getting Set up with Dioxus-Desktop is quite easy. Make sure you have Rust and Cargo installed, and then create a new project:
+
+```shell
+$ cargo new --bin demo
+$ cd app
+```
+
+Add Dioxus with the `desktop` feature:
+
+```shell
+$ cargo add dioxus --features desktop
+```
+
+Edit your `main.rs`:
+
+```rust
+// main.rs
+use dioxus::prelude::*;
+
+fn main() {
+ dioxus::desktop::launch(app);
+}
+
+fn app(cx: Scope) -> Element {
+ cx.render(rsx!{
+ div {
+ "hello world!"
+ }
+ })
+}
+```
+
+
+To configure the webview, menubar, and other important desktop-specific features, checkout out some of the launch configuration in the [API reference](https://docs.rs/dioxus-desktop/).
+
+## Future Steps
+
+Make sure to read the [Dioxus Guide](https://dioxuslabs.com/guide) if you already haven't!
\ No newline at end of file
diff --git a/packages/desktop/src/user_window_events.rs b/packages/desktop/src/user_window_events.rs
new file mode 100644
index 000000000..bde215d48
--- /dev/null
+++ b/packages/desktop/src/user_window_events.rs
@@ -0,0 +1,73 @@
+use wry::application::event_loop::ControlFlow;
+use wry::application::window::Fullscreen as WryFullscreen;
+
+use crate::controller::DesktopController;
+
+#[derive(Debug)]
+pub(crate) enum UserWindowEvent {
+ Update,
+
+ CloseWindow,
+ DragWindow,
+ FocusWindow,
+
+ Visible(bool),
+ Minimize(bool),
+ Maximize(bool),
+ MaximizeToggle,
+ Resizable(bool),
+ AlwaysOnTop(bool),
+ Fullscreen(bool),
+
+ CursorVisible(bool),
+ CursorGrab(bool),
+
+ SetTitle(String),
+ SetDecorations(bool),
+
+ DevTool,
+}
+
+use UserWindowEvent::*;
+
+pub(super) fn handler(
+ user_event: UserWindowEvent,
+ desktop: &mut DesktopController,
+ control_flow: &mut ControlFlow,
+) {
+ // currently dioxus-desktop supports a single window only,
+ // so we can grab the only webview from the map;
+ let webview = desktop.webviews.values().next().unwrap();
+ let window = webview.window();
+
+ match user_event {
+ Update => desktop.try_load_ready_webviews(),
+ CloseWindow => *control_flow = ControlFlow::Exit,
+ DragWindow => {
+ // if the drag_window has any errors, we don't do anything
+ window.fullscreen().is_none().then(|| window.drag_window());
+ }
+ Visible(state) => window.set_visible(state),
+ Minimize(state) => window.set_minimized(state),
+ Maximize(state) => window.set_maximized(state),
+ MaximizeToggle => window.set_maximized(!window.is_maximized()),
+ Fullscreen(state) => {
+ if let Some(handle) = window.current_monitor() {
+ window.set_fullscreen(state.then(|| WryFullscreen::Borderless(Some(handle))));
+ }
+ }
+ FocusWindow => window.set_focus(),
+ Resizable(state) => window.set_resizable(state),
+ AlwaysOnTop(state) => window.set_always_on_top(state),
+
+ CursorVisible(state) => window.set_cursor_visible(state),
+ CursorGrab(state) => {
+ let _ = window.set_cursor_grab(state);
+ }
+
+ SetTitle(content) => window.set_title(&content),
+ SetDecorations(state) => window.set_decorations(state),
+
+ DevTool => webview.devtool(),
+ }
+}
diff --git a/packages/fermi/Cargo.toml b/packages/fermi/Cargo.toml
new file mode 100644
index 000000000..48fe377c7
--- /dev/null
+++ b/packages/fermi/Cargo.toml
@@ -0,0 +1,14 @@
+[package]
+name = "fermi"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+dioxus-core = { path = "../core" }
+im-rc = { version = "15.0.0", features = ["serde"] }
+log = "0.4.14"
+
+[dev-dependencies]
+closure = "0.3.0"
diff --git a/packages/fermi/README.md b/packages/fermi/README.md
new file mode 100644
index 000000000..0923aa6f6
--- /dev/null
+++ b/packages/fermi/README.md
@@ -0,0 +1,92 @@
+
+
+
Fermi ⚛
+
+ Atom-based global state management solution for Dioxus
+
+
-
@@ -45,9 +43,11 @@