This macro is used to generate a impl Default block for any type with the function new_maybe_sync that takes a generic T
This macro is used to generate impl PartialEq blocks for any Readable type that takes a generic T
This macro is used to generate impl Display, and impl Debug blocks for any Readable type that takes a generic T
Start the hot reloading server with the current directory as the root
This macro is used to generate impl Display, impl Debug, impl PartialEq, and impl Eq blocks for any Readable type that takes a generic T
The rsx! macro makes it easy for developers to write jsx-style markup in their components.
The rsx! macro makes it easy for developers to write jsx-style markup in their components.
A helper macro for cloning multiple values at once
A helper macro for use_reactive that merges uses the closure syntax to elaborate the dependency array
This macro is used to generate impl Add, impl AddAssign, impl Sub, impl SubAssign, impl Mul, impl MulAssign, impl Div, and impl DivAssign blocks for any Writable type that takes a generic T
An attribute on a DOM node, such as id="my-thing" or href="https://example.com"
CopyValue is a wrapper around a value to make the value mutable and Copy.
The DragEvent interface is a DOM event that represents a drag and drop interaction. The user initiates a drag by
placing a pointer device (such as a mouse) on the touch surface and then dragging the pointer to a new location
(such as another DOM element). Applications are free to interpret a drag and drop interaction in an
application-specific way.
A handle to an effect.
A boundary that will capture any errors from child components
A wrapper around some generic data that handles the event’s state
The callback type generated by the rsx! macro when an on field is specified for components.
A form value that may either be a list of values or a single value
A signal that can be accessed from anywhere in the application and created in a static
A signal that can be accessed from anywhere in the application and created in a static
A builder for a fullstack app.
A read only signal that has been mapped to a new type.
A value that is memoized. This is useful for caching the result of a computation.
Pressed modifier keys.
An Element that has been rendered and allows reading and modifying information about it.
A synthetic event that wraps a web-style
MouseEvent
Data associated with a mouse event
Owner: Handles dropping generational boxes. The owner acts like a runtime lifetime guard. Any states that you create with an owner will be dropped when that owner is dropped.
A platform specific event.
A context for signal reads and writes to be directed to
A signal that can only be read from.
An iterator over the values of a Readable<Vec<T>>.
A global runtime that is shared across all scopes that provides the async runtime and context API
A guard for a new runtime. This must be used to override the current runtime when importing components from a dynamic library that has it’s own runtime.
A component’s unique identifier.
A component’s rendered state.
A serialized version of AnimationData
A serialized version of ClipboardData
A serialized version of CompositionData
A serialized version of DragData
A serialized version of FocusData
A serialized form data object
A serialized version of ImageData
A serialized version of KeyboardData
A serialized version of MediaData
A serialized version of PointerData
A serialized version of ScrollData
A serialized version of SelectionData
A serialized version of ToggleData
A serialized version of TouchData
A serialized version of TransitionData
A serialized version of WheelData
Creates a new Signal. Signals are a Copy state management solution with automatic dependency tracking.
The data stored for tracking in a signal.
A thread safe storage. This is slower than the unsync storage, but allows you to share the value between threads.
A task’s unique identifier.
A static layout of a UI tree that describes a set of dynamic and static nodes.
The receiving end of an unbounded mpsc channel.
The transmission end of an unbounded mpsc channel.
A unsync storage. This is the default storage type.
This callback is not generic over a return type so you can hold a bunch of callbacks at once
A wrapper around the target platform’s evaluator.
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 virtual node system that progresses user events and diffs UI trees.
An iterator over the values of a Writable<Vec<T>>.
A mutable reference to a signal’s value.
A trait for any storage backing type.
Any component that implements the ComponentFn trait can be used as a component.
A dependency is a trait that can be used to determine if a effect or selector should be re-run.
A dependency is a trait that can be used to determine if a effect or selector should be re-run.
A struct that implements EvalProvider is sent through
ScopeState’s provide_context function
so that [
use_eval] can provide a platform agnostic interface for evaluating JavaScript code.
The platform’s evaluator.
A trait for any object that has the data for an animation event
A trait for anything that has a dynamic list of attributes
A trait for any object that has the data for a composition event
A trait for any object that has the data for a drag event
An object that has all the data for a form event
A trait for any object that has the data for an image event
A trait for any object that has the data for a mouse event
A trait for any object that has the data for a pointer event
A trait for touch point data
A converter between a platform specific event and a general event. All code in a renderer that has a large binary size should be placed in this trait. Each of these functions should be snipped in high levels of optimization.
A interaction that contains data about the location of the event.
A interaction that contains data about the location of the event.
A value that can be converted into an attribute value
A trait that allows various items to be converted into a dynamic node for the rsx macro
A interaction that contains data about the current state of the keyboard modifiers.
A interaction that contains data about the pointer button(s) that triggered the event.
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 the Properties trait automatically as guarantee that your memoization strategy is safe.
An extension trait for Readable<Option> that provides some convenience methods.
An extension trait for Readable<Vec> that provides some convenience methods.
An Element that has been rendered and allows reading and modifying information about it.
A trait for a storage backing type. (RefCell, RwLock, etc.)
A enhanced version of the From trait that allows with more flexibility.
A enhanced version of the Into trait that allows with more flexibility.
A trait to allow results to be thrown upwards to the nearest Error Boundary
A trait for converting a type into a platform-specific config:
A trait for states that can be read from like
crate::Signal, or
crate::GlobalSignal. You may choose to accept this trait as a parameter instead of the concrete type to allow for more flexibility in your API. For example, instead of creating two functions, one that accepts a
crate::Signal and one that accepts a
crate::GlobalSignal, you can create one function that accepts a
Writable type.
An extension trait for Writable<Option> that provides some convenience methods.
An extension trait for Writable<Vec> that provides some convenience methods.
Create a new error boundary component.
Create inline fragments using Component syntax.
Consume context from the current scope
Consume context from the current scope
Returns the current owner. This owner will be used to drop any Copy state that is created by the generational-box crate.
Get the current scope id
Get a struct that can execute any JavaScript.
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
Check if the current scope has a context
Launch your application without any additional configuration. See
LaunchBuilder for more options.
Mark the current scope as dirty, causing it to re-render
Mark the current scope as dirty, causing it to re-render
abort
onanimationend
onanimationiteration
onanimationstart
onblur
canplay
canplaythrough
onchange
Execute a callback when a button is clicked.
oncompositionend
oncompositionstart
oncompositionupdate
oncontextmenu
oncopy
oncut
ondrag
ondragend
ondragenter
ondragexit
ondragleave
ondragover
ondragstart
ondrop
durationchange
emptied
encrypted
ended
onerror
onfocus
gotpointercapture
oninput handler
oninvalid
onkeydown
onkeypress
onkeyup
onload
loadeddata
loadedmetadata
loadstart
lostpointercapture
mounted
onmousedown
onmouseenter
onmouseleave
onmousemove
onmouseout
onmouseover
onmouseup
onpaste
pause
play
playing
pointercancel
pointerdown
pointerenter
pointerleave
pointermove
pointerout
pointerover
pointerup
progress
ratechange
onreset
onscroll
seeked
seeking
select
selectionchange
selectstart
stalled
onsubmit
suspend
timeupdate
ontoggle
touchcancel
touchend
touchmove
touchstart
transitionend
volumechange
waiting
Called when the mouse wheel is rotated over an element.
Get the parent of the current scope if it exists
Provide context to the current scope
Provide a context to the root scope
Informs the scheduler that this task is no longer needed and should be removed.
Schedule an update for the current component
Schedule an update for any component given its
ScopeId.
Spawns the future but does not return the [TaskId]
Spawn a future that Dioxus won’t clean up when this component is unmounted
Start a new future on the same thread as the rest of the VirtualDom.
Suspended the current component on a specific task and then return None
Consume context from the current scope
Consume some context in the tree, providing a sharable handle to the value
Push this function to be run after the next render
A hook that allows you to insert a “before render” function.
A callback that’s always current
Consume some context in the tree, providing a sharable handle to the value
Provide some context via the tree and return a reference to it
Maintain a handle over a future that can be paused, resumed, and canceled.
Get a handle to a coroutine higher in the tree
Analagous to use_context_provider and use_context,
but used for coroutines specifically
See the docs for
use_coroutine for more details.
Creates a callback that will be run before the component is removed.
This can be used to clean up side effects from the component
(created with
use_effect).
use_effect will subscribe to any changes in the signal values it captures
effects will always run after first mount and then whenever the signal values change
If the use_effect call was skipped due to an early return, the effect will no longer activate.
Provide an error boundary to catch errors from child components
A hook that allows you to spawn a future.
This future will not run on the server
The future is spawned on the next call to wait_for_next_render which means that it will not run on the server.
To run a future on the server, you should use spawn directly.
use_future won’t return a value.
If you want to return a value from a future, use use_resource instead.
Store a value between renders. The foundational hook for all other hooks.
A hook that uses before/after lifecycle hooks to determine if the hook was run
Use a hook with a cleanup function
Creates a new Memo. The memo will be run immediately and whenever any signal it reads changes.
Takes some non-reactive data, and a closure and returns a closure that will subscribe to that non-reactive data as if it were reactive.
A memo that resolves to a value asynchronously.
Similar to
use_future but
use_resource returns a value.
See
Resource for more details.
Creates a new Signal. Signals are a Copy state management solution with automatic dependency tracking.
Creates a new `Send + Sync`` Signal. Signals are a Copy state management solution with automatic dependency tracking.
Wait for the next render to complete
Run a closure with the given owner.