34bdcd15cf
* create the dynamic value pool * assign ids to dynamic formatted segments * separate the rendering and literal pools * rsx output compiles again * more examples compiling with new rsx expansion * update template body explanation * all workspace examples compile * fix formatted segments in keys * start hot reload diffing * fix component literal hot reloading * start integrate new hot reloading with the CLI * simple hot reloads working * Fix hot reloading blocks with components * implement hot reloading for if chains * Fix hot reloading after a template requires a full rebuild * Fix hot reloading any attribute values * remove unsafe from hot reload utils * Fix hot reloading empty rsx * add more hot reloading tests * reorganize hot reload module * fix web hydration * fix empty rsx nodes in autoformatting * fix tests * remove path sorting logic from core * make template names more consistent in debug mode * fix quote_as_hot_reload_literal for explicitly typed literals * fix can_be_shorthand for string literals * fix formatted single dynamic expression * Fix usize component properties and playwright tests * remove default implementation for TemplateBody * add a bunch more comments for diffing, scoring and why this scoring system is optimal |
||
---|---|---|
.. | ||
.vscode | ||
docs | ||
src | ||
tests | ||
Cargo.toml | ||
README.md |
dioxus-core
dioxus-core
provides a fast and featureful VirtualDom implementation for Rust.
# tokio::runtime::Runtime::new().unwrap().block_on(async {
use dioxus_core::prelude::*;
use dioxus_core::*;
let mut vdom = VirtualDom::new(app);
let real_dom = SomeRenderer::new();
loop {
tokio::select! {
evt = real_dom.event() => vdom.handle_event("onclick", evt, ElementId(0), true),
_ = vdom.wait_for_work() => {}
}
vdom.render_immediate(&mut real_dom.apply())
}
# fn app() -> Element { VNode::empty() }
# struct SomeRenderer; impl SomeRenderer { fn new() -> SomeRenderer { SomeRenderer } async fn event(&self) -> std::rc::Rc<dyn std::any::Any> { unimplemented!() } fn apply(&self) -> Mutations { Mutations::default() } }
# });
Features
A virtualdom is an efficient and flexible tree data structure that allows you to manage state for a graphical user interface. The Dioxus VirtualDom is perhaps the most fully-featured virtualdom implementation in Rust and powers renderers running across Web, Desktop, Mobile, SSR, TUI, LiveView, and more. When you use the Dioxus VirtualDom, you immediately enable users of your renderer to leverage the wide ecosystem of Dioxus components, hooks, and associated tooling.
Some features of dioxus-core
include:
- UI components are just functions
- State is provided by hooks
- Deep integration with async
- Strong focus on performance
- Integrated hotreloading support
- Extensible system for UI elements and their attributes
If you are just starting, check out the Guides first.
Understanding the implementation
dioxus-core
is designed to be a lightweight crate that. It exposes a number of flexible primitives without being deeply concerned about the intracices of state management itself. We provide a number of useful abstractions built on these primitives in the dioxus-hooks
crate as well as the dioxus-signals
crate.
The important abstractions to understand are:
- The [
VirtualDom
] - The [
Component
] and its [Properties
] - Handling events
- Working with async
- Suspense
Usage
The dioxus
crate exports the rsx
macro which transforms a helpful, simpler syntax of Rust.
First, start with your app:
# use dioxus::dioxus_core::Mutations;
use dioxus::prelude::*;
// First, declare a root component
fn app() -> Element {
rsx!{
div { "hello world" }
}
}
fn main() {
// Next, create a new VirtualDom using this app as the root component.
let mut dom = VirtualDom::new(app);
// The initial render of the dom will generate a stream of edits for the real dom to apply
let mutations = dom.rebuild_to_vec();
}
Contributing
- Check out the website section on contributing.
- Report issues on our issue tracker.
- Join the discord and ask questions!
License
This project is licensed under the MIT license.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in Dioxus by you, shall be licensed as MIT, without any additional terms or conditions.