Struct SsrSharedContext 

pub struct SsrSharedContext { /* private fields */ }

The shared context that should be used on the server side.

Implementations

impl SsrSharedContext

pub fn new() -> Self

Creates a new shared context for rendering HTML on the server.

pub fn new_islands() -> Self

Creates a new shared context for rendering HTML on the server in “islands” mode.

This defaults to a mode in which the app is not hydrated, but allows you to opt into hydration for certain portions using SharedContext::set_is_hydrating.

pub async fn consume_buffers(&self) -> Vec<(SerializedDataId, String)>

Consume the data buffers, awaiting all async resources, returning both sync and async buffers. Useful to implement custom hydration contexts.

WARNING: this will clear the internal buffers, it should only be called once. A second call would return an empty vec![].

Trait Implementations

impl Debug for SsrSharedContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SsrSharedContext

fn default() -> SsrSharedContext

Returns the “default value” for a type.

impl SharedContext for SsrSharedContext

fn is_browser(&self) -> bool

Whether the application is running in the browser.

fn next_id(&self) -> SerializedDataId

Returns the next in a series of IDs that is unique to a particular request and response.

fn write_async(&self, id: SerializedDataId, fut: PinnedFuture<String>)

The given Future should resolve with some data that can be serialized from the server to the client. This will be polled as part of the process of building the HTTP response, not when it is first created.

fn read_data(&self, _id: &SerializedDataId) -> Option<String>

Reads the current value of some data from the shared context, if it has been sent from the server. This returns the serialized data as a String that should be deserialized.

fn await_data(&self, _id: &SerializedDataId) -> Option<String>

Returns a Future that resolves with a String that should be deserialized once the given piece of server data has resolved.

fn get_is_hydrating(&self) -> bool

Returns true if you are currently in a part of the application tree that should be hydrated.

fn set_is_hydrating(&self, is_hydrating: bool)

Sets whether you are currently in a part of the application tree that should be hydrated.

fn errors(&self, boundary_id: &SerializedDataId) -> Vec<(ErrorId, Error)>

Returns the set of errors that have been registered with a particular boundary.

fn register_error( &self, error_boundary_id: SerializedDataId, error_id: ErrorId, error: Error, )

Registers an error with the context to be shared from server to client.

fn take_errors(&self) -> Vec<(SerializedDataId, ErrorId, Error)>

Returns all errors that have been registered, removing them from the list.

fn seal_errors(&self, boundary_id: &SerializedDataId)

“Seals” an error boundary, preventing further errors from being registered for it.

fn pending_data(&self) -> Option<PinnedStream<String>>

Returns some Stream of HTML that contains JavaScript <script> tags defining all values being serialized from the server to the client, with their serialized values and any boilerplate needed to notify a running application that they exist; or None.

fn during_hydration(&self) -> bool

Whether the page is currently being hydrated.

fn hydration_complete(&self)

Tells the shared context that the hydration process is complete.

fn defer_stream(&self, wait_for: PinnedFuture<()>)

Adds a Future to the set of “blocking resources” that should prevent the server’s response stream from beginning until all are resolved. The Future returned by blocking resources will not resolve until every Future added by this method has resolved.

fn await_deferred(&self) -> Option<PinnedFuture<()>>

Returns a Future that will resolve when every Future added via defer_stream has resolved.

fn set_incomplete_chunk(&self, id: SerializedDataId)

Tells the client that this chunk is being sent from the server before all its data have loaded, and it may be in a fallback state.

fn get_incomplete_chunk(&self, id: &SerializedDataId) -> bool

Checks whether this chunk is being sent from the server before all its data have loaded.