Crate dioxus_fullstack_core 

Dioxus Fullstack Core

Dioxus-fullstack-core provides types, traits, hooks, contexts for dioxus-fullstack. Libraries that need to integrate with dioxus-fullstack should rely on this crate instead of the full-fledged renderer for quicker build times.

Usage

To start using this crate, you can run the following command:

cargo add dioxus-fullstack-hooks

Then you can use hooks like use_server_future in your components:

use dioxus::prelude::*;


fn App() -> Element {
    let mut article_id = use_signal(|| 0);

    // `use_server_future` will spawn a task that runs on the server and serializes the result to send to the client.
    // The future will rerun any time the
    // Since we bubble up the suspense with `?`, the server will wait for the future to resolve before rendering
    let article = use_server_future(move || fetch_article(article_id()))?;

    rsx! {
        "{article().unwrap()}"
    }
}

async fn fetch_article(id: u32) -> String {
    format!("Article {}", id)
}

Re-exports

pub use error::*;

pub use httperror::*;

Modules

document

On the client, we use the FullstackWebDocument implementation to render the head for any elements that were not rendered on the server.

error

Error types and utilities.

history

A history provider for fullstack apps that is compatible with hydration.

httperror

Structs

DioxusServerState

HydrationContext

Data shared between the frontend and the backend for hydration of server functions.

Loader

A Loader is a signal that represents a value that is loaded asynchronously.

LoaderHandle

SerializeContextEntry

An entry into the serialized context. The order entries are created in must be consistent between the server and the client.

SerializedHydrationData

Data that was serialized on the server for hydration on the client. This includes extra information about the types and sources of the serialized data in debug mode

StreamingContext

The context dioxus fullstack provides for the status of streaming responses on the server

Enums

LoaderState

Loading

StreamingStatus

The status of the streaming response

TakeDataError

An error that can occur when trying to take data from the server

Functions

commit_initial_chunk

Commit the initial chunk of the response. This will be called automatically if you are using the dioxus router when the suspense boundary above the router is resolved. Otherwise, you will need to call this manually to start the streaming part of the response.

current_status

Get the current status of the streaming response. This method is reactive and will cause the current reactive context to rerun when the status changes.

head_element_hydration_entry

Create a new entry in the serialize context for the head element hydration

init_error_boundary

Initializes an error boundary context that is compatible with hydration.

is_hydrating

Check if the client is currently rendering a component for hydration. Always returns true on the server.

serialize_context

Get or insert the current serialize context. On the client, the hydration context this returns will always return TakeDataError::DataNotAvailable if hydration of the current chunk is finished.

use_loader

A hook to create a resource that loads data asynchronously.

use_server_cached

This allows you to send data from the server to the client during hydration.

use_server_future

Runs a future and returns a result with a resource if the future is finished or a suspended error if it is still running. The future may run on the server during hydration.