Module dioxus_core::prelude

The purpose of this module is to alleviate imports of many common types

This includes types like Scope, Element, and Component.

Re-exports

• pub use crate::innerlude::AnyValue;
• pub use crate::innerlude::EventHandler;

Structs

• Event
  A wrapper around some generic data that handles the event’s state
• LazyNodes
  A concrete type provider for closures that build VNode structures.
• Runtime
  A global runtime that is shared across all scopes that provides the async runtime and context API
• RuntimeGuard
  A gaurd 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.
• ScopeId
  A component’s unique identifier.
• ScopeState
  A component’s state separate from its props.
• Scoped
  A wrapper around a component’s ScopeState and properties. The ScopeState provides the majority of methods for the VirtualDom and component state.
• TaskId
  A task’s unique identifier.
• Template
  A static layout of a UI tree that describes a set of dynamic and static nodes.
• VNode
  A reference to a template along with any context needed to hydrate it
• VirtualDom
  A virtual node system that progresses user events and diffs UI trees.

Enums

• TemplateAttribute
  An attribute of the TemplateNode, created at compile time
• TemplateNode
  A statically known node in a layout.

Traits

• IntoAttributeValue
  A value that can be converted into an attribute value
• IntoDynNode
  A trait that allows various items to be converted into a dynamic node for the rsx macro
• Properties
  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.
• Throw
  A trait to allow results to be thrown upwards to the nearest Error Boundary

Functions

• Fragment
  Create inline fragments using Component syntax.
• consume_context
  Consume context from the current scope
• consume_context_from_scope
  Consume context from the current scope
• current_scope_id
  Get the current scope id
• fc_to_builder
  This utility function launches the builder method so rsx! and html! macros can use the typed-builder pattern to initialize a component’s props.
• has_context
  Check if the current scope has a context
• provide_context
  Provide context to the current scope
• provide_context_to_scope
  Provide context to the the given scope
• provide_root_context
  Provide a context to the root scope
• push_future
  Pushes the future onto the poll queue to be polled after the component renders.
• remove_future
  Informs the scheduler that this task is no longer needed and should be removed.
• schedule_update_any
  Schedule an update for any component given its ScopeId.
• spawn
  Spawns the future but does not return the TaskId
• spawn_forever
  Spawn a future that Dioxus won’t clean up when this component is unmounted
• suspend
  Suspends the current component
• throw
  Throw an error into the nearest error boundary

Type Aliases

• Component
  A Component is a function that takes a Scope and returns an Element.
• Element
  An Element is a possibly-none VNode created by calling render on Scope or ScopeState.
• Scope
  A wrapper around the Scoped object that contains a reference to the ScopeState and properties for a given component.