Crate dioxus_core
source ·Expand description
§dioxus-core
dioxus-core
provides a fast and featureful VirtualDom implementation for Rust.
use dioxus_core::prelude::*;
let vdom = VirtualDom::new(app);
let real_dom = SomeRenderer::new();
loop {
select! {
evt = real_dom.event() => vdom.handle_event(evt),
_ = vdom.wait_for_work() => {}
}
vdom.render(&mut real_dom)
}
§Features
A virtualdom is an efficient and flexible tree datastructure 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 proivde 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 itsProperties
- 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::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.
Re-exports§
pub use crate::innerlude::vdom_is_rendering;
pub use crate::innerlude::AnyValue;
Modules§
- The purpose of this module is to alleviate imports of many common types
Structs§
- An attribute on a DOM node, such as
id="my-thing"
orhref="https://example.com"
- An instance of an error captured by a descendant component.
- An Element’s unique identifier.
- A wrapper around some generic data that handles the event’s state
- A static list of mutations that can be applied to the DOM. Note: this list does not contain any
Any
attribute values - A struct that ignores all mutations
- A global runtime that is shared across all scopes that provides the async runtime and context API
- A component’s unique identifier.
- A component’s rendered state.
- A task’s unique identifier.
- A static layout of a UI tree that describes a set of dynamic and static nodes.
- An instance of a child component
- A reference to a template along with any context needed to hydrate it
- A reference to a template along with any context needed to hydrate it
- A placeholder node, used by suspense and fragments
- A text node
- A virtual node system that progresses user events and diffs UI trees.
Enums§
- Any of the built-in values that the Dioxus VirtualDom supports as dynamic attributes on elements
- A node created at runtime
- A
Mutation
represents a single instruction for the renderer to use to modify the UI tree to match the state of the Dioxus VirtualDom. - The actual state of the component’s most recent computation
- An attribute of the TemplateNode, created at compile time
- A statically known node in a layout.
Traits§
- Any component that implements the
ComponentFn
trait can be used as a component. - A trait for anything that has a dynamic list of attributes
- A trait that allows various items to be converted into a dynamic node for the rsx macro
- Every “Props” used for a component must implement the
Properties
trait. This trait gives some hints to Dioxus on how to memoize the props and some additional optimizations that can be made. We strongly encourage using the derive macro to implement theProperties
trait automatically as guarantee that your memoization strategy is safe. - Something that can handle the mutations that are generated by the diffing process and apply them to the Real DOM
Functions§
- Create inline fragments using Component syntax.
- This utility function launches the builder method so rsx! and html! macros can use the typed-builder pattern to initialize a component’s props.
- Get the current render since the inception of this component
- Schedule an update for the current component
- Schedule an update for any component given its
ScopeId
. - Store a value between renders. The foundational hook for all other hooks.