Struct Resource 

pub struct Resource<T, Ser = JsonSerdeCodec>
where
    T: Send + Sync + 'static,
{ /* private fields */ }

An asynchronous resource.

Resources allow asynchronously loading data and serializing it from the server to the client, so that it loads on the server, and is then deserialized on the client. This improves performance by beginning data loading on the server when the request is made, rather than beginning it on the client after WASM has been loaded.

You can access the value of the resource either synchronously using .get() or asynchronously using .await.

Implementations

impl<T> Resource<T, FromToStringCodec>

where FromToStringCodec: Encoder<T> + Decoder<T>, <FromToStringCodec as Encoder<T>>::Error: Debug, <FromToStringCodec as Decoder<T>>::Error: Debug, <<FromToStringCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug, <FromToStringCodec as Encoder<T>>::Encoded: IntoEncodedString, <FromToStringCodec as Decoder<T>>::Encoded: FromEncodedStr, T: Send + Sync,

pub fn new_str<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> Resource<T, FromToStringCodec>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new resource with the encoding FromToStringCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

pub fn new_str_blocking<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> Resource<T, FromToStringCodec>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new blocking resource with the encoding FromToStringCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

Blocking resources prevent any of the HTTP response from being sent until they have loaded. This is useful if you need their data to set HTML document metadata or information that needs to appear in HTTP headers.

impl<T> Resource<T>

where JsonSerdeCodec: Encoder<T> + Decoder<T>, <JsonSerdeCodec as Encoder<T>>::Error: Debug, <JsonSerdeCodec as Decoder<T>>::Error: Debug, <<JsonSerdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug, <JsonSerdeCodec as Encoder<T>>::Encoded: IntoEncodedString, <JsonSerdeCodec as Decoder<T>>::Encoded: FromEncodedStr, T: Send + Sync,

pub fn new<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> Resource<T>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new resource with the encoding JsonSerdeCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

pub fn new_blocking<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, ) -> Resource<T>

where S: PartialEq + Clone + Send + Sync + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new blocking resource with the encoding JsonSerdeCodec.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

Blocking resources prevent any of the HTTP response from being sent until they have loaded. This is useful if you need their data to set HTML document metadata or information that needs to appear in HTTP headers.

impl<T, Ser> Resource<T, Ser>

where Ser: Encoder<T> + Decoder<T>, <Ser as Encoder<T>>::Error: Debug, <Ser as Decoder<T>>::Error: Debug, <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug, <Ser as Encoder<T>>::Encoded: IntoEncodedString, <Ser as Decoder<T>>::Encoded: FromEncodedStr, T: Send + Sync,

pub fn new_with_options<S, Fut>( source: impl Fn() -> S + Send + Sync + 'static, fetcher: impl Fn(S) -> Fut + Send + Sync + 'static, blocking: bool, ) -> Resource<T, Ser>

where S: Send + Sync + Clone + PartialEq + 'static, T: Send + Sync + 'static, Fut: Future<Output = T> + Send + 'static,

Creates a new resource with the encoding Ser.

This takes a source function and a fetcher. The resource memoizes and reactively tracks the value returned by source. Whenever that value changes, it will run the fetcher to generate a new Future to load data.

On creation, if you are on the server, this will run the fetcher once to generate a Future whose value will be serialized from the server to the client. If you are on the client, the initial value will be deserialized without re-running that async task.

If blocking is true, this is a blocking resource.

Blocking resources prevent any of the HTTP response from being sent until they have loaded. This is useful if you need their data to set HTML document metadata or information that needs to appear in HTTP headers.

pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>

Synchronously, reactively reads the current value of the resource and applies the function f to its value if it is Some(_).

pub fn refetch(&self)

Re-runs the async function with the current source data.

impl<T, E, Ser> Resource<Result<T, E>, Ser>

where Ser: Encoder<Result<T, E>> + Decoder<Result<T, E>>, <Ser as Encoder<Result<T, E>>>::Error: Debug, <Ser as Decoder<Result<T, E>>>::Error: Debug, <<Ser as Decoder<Result<T, E>>>::Encoded as FromEncodedStr>::DecodingError: Debug, <Ser as Encoder<Result<T, E>>>::Encoded: IntoEncodedString, <Ser as Decoder<Result<T, E>>>::Encoded: FromEncodedStr, T: Send + Sync, E: Send + Sync + Clone,

pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>>

Applies the given function when a resource that returns Result<T, E> has resolved and loaded an Ok(_), rather than requiring nested .map() calls over the Option<Result<_, _>> returned by the resource.

This is useful when used with features like server functions, in conjunction with <ErrorBoundary/> and <Suspense/>, when these other components are left to handle the None and Err(_) states.

impl<T, Ser> Resource<T, Ser>

where T: Send + Sync + 'static,

pub fn by_ref(&self) -> AsyncDerivedRefFuture<T>

Returns a new Future that is ready when the resource has loaded, and accesses its inner value by reference.

Methods from Deref<Target = AsyncDerived<T>>

pub fn ready(&self) -> AsyncDerivedReadyFuture

Returns a Future that is ready when this resource has next finished loading.

pub fn by_ref(&self) -> AsyncDerivedRefFuture<T>

Returns a Future that resolves when the computation is finished, and accesses the inner value by reference rather than by cloning it.

Trait Implementations

impl<T, Ser> AddAnyAttr for Resource<T, Ser>

where T: RenderHtml + Send + Sync + Clone, Ser: Send + 'static,

type Output<SomeNewAttr: Attribute> = Box<dyn FnMut() -> Suspend<<T as AddAnyAttr>::Output<<<SomeNewAttr as Attribute>::CloneableOwned as Attribute>::CloneableOwned>> + Send>

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, attr: NewAttr, ) -> <Resource<T, Ser> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute, <Resource<T, Ser> as AddAnyAttr>::Output<NewAttr>: RenderHtml,

Adds an attribute to the view.

impl<T, Ser> Clone for Resource<T, Ser>

where T: Send + Sync + 'static,

fn clone(&self) -> Resource<T, Ser>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, Ser> Debug for Resource<T, Ser>

where T: Send + Sync + 'static,

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

Formats the value using the given formatter.

impl<T, Ser> DefinedAt for Resource<T, Ser>

where T: Send + Sync + 'static,

fn defined_at(&self) -> Option<&'static Location<'static>>

Returns the location at which the signal was defined. This is usually simply None in release mode.

impl<T, Ser> Deref for Resource<T, Ser>

where T: Send + Sync + 'static,

type Target = AsyncDerived<T>

The resulting type after dereferencing.

fn deref(&self) -> &<Resource<T, Ser> as Deref>::Target

Dereferences the value.

impl<T, Ser> From<ArcResource<T, Ser>> for Resource<T, Ser>

where T: Send + Sync,

fn from(arc_resource: ArcResource<T, Ser>) -> Resource<T, Ser>

Converts to this type from the input type.

impl<T, Ser> From<Resource<T, Ser>> for ArcResource<T, Ser>

where T: Send + Sync,

fn from(resource: Resource<T, Ser>) -> ArcResource<T, Ser>

Converts to this type from the input type.

impl<T, Ser> IntoFuture for Resource<T, Ser>

where T: Clone + Send + Sync + 'static,

type Output = T

The output that the future will produce on completion.

type IntoFuture = AsyncDerivedFuture<T>

Which kind of future are we turning this into?

fn into_future(self) -> <Resource<T, Ser> as IntoFuture>::IntoFuture

Creates a future from a value.

impl<T, Ser> Notify for Resource<T, Ser>

where T: Send + Sync + 'static,

fn notify(&self)

Notifies subscribers of a change in this signal.

impl<T, Ser> ReadUntracked for Resource<T, Ser>

where T: Send + Sync + 'static,

type Value = <AsyncDerived<T> as ReadUntracked>::Value

The guard type that will be returned, which can be dereferenced to the value.

fn try_read_untracked( &self, ) -> Option<<Resource<T, Ser> as ReadUntracked>::Value>

Returns the guard, or None if the signal has already been disposed.

fn read_untracked(&self) -> Self::Value

Returns the guard.

fn custom_try_read(&self) -> Option<Option<Self::Value>>

This is a backdoor to allow overriding the Read::try_read implementation despite it being auto implemented.

impl<T, Ser> Render for Resource<T, Ser>

where T: Render + Send + Sync + Clone, Ser: Send + 'static,

type State = RenderEffectState<SuspendState<T>>

The “view state” for this type, which can be retained between updates.

fn build(self) -> <Resource<T, Ser> as Render>::State

Creates the view for the first time, without hydrating from existing HTML.

fn rebuild(self, state: &mut <Resource<T, Ser> as Render>::State)

Updates the view with new data.

impl<T, Ser> RenderHtml for Resource<T, Ser>

where T: RenderHtml + Send + Sync + Clone, Ser: Send + 'static,

const MIN_LENGTH: usize = 0

The minimum length of HTML created when this view is rendered.

type AsyncOutput = Option<T>

The type of the view after waiting for all asynchronous data to load.

type Owned = Resource<T, Ser>

An equivalent value that is 'static.

fn dry_resolve(&mut self)

“Runs” the view without other side effects. For primitive types, this is a no-op. For reactive types, this can be used to gather data about reactivity or about asynchronous data that needs to be loaded.

fn resolve( self, ) -> impl Future<Output = <Resource<T, Ser> as RenderHtml>::AsyncOutput> + Send

Waits for any asynchronous sections of the view to load and returns the output.

fn to_html_with_buf( self, buf: &mut String, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

Renders a view to HTML, writing it into the given buffer.

fn to_html_async_with_buf<const OUT_OF_ORDER: bool>( self, buf: &mut StreamBuilder, position: &mut Position, escape: bool, mark_branches: bool, extra_attrs: Vec<AnyAttribute>, )

where Resource<T, Ser>: Sized,

Renders a view into a buffer of (synchronous or asynchronous) HTML chunks.

fn hydrate<const FROM_SERVER: bool>( self, cursor: &Cursor, position: &PositionState, ) -> <Resource<T, Ser> as Render>::State

Makes a set of DOM nodes rendered from HTML interactive.

fn into_owned(self) -> <Resource<T, Ser> as RenderHtml>::Owned

Convert into the equivalent value that is 'static.

const EXISTS: bool = true

Whether this should actually exist in the DOM, if it is the child of an element.

fn html_len(&self) -> usize

An estimated length for this view, when rendered to HTML.

fn to_html(self) -> String

where Self: Sized,

Renders a view to an HTML string.

fn to_html_branching(self) -> String

where Self: Sized,

Renders a view to HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_in_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML.

fn to_html_stream_in_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an in-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn to_html_stream_out_of_order(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML.

fn to_html_stream_out_of_order_branching(self) -> StreamBuilder

where Self: Sized,

Renders a view to an out-of-order stream of HTML with branch markers. This can be used to support libraries that diff HTML pages against one another, by marking sections of the view that branch to different types with marker comments.

fn hydrate_async( self, cursor: &Cursor, position: &PositionState, ) -> impl Future<Output = Self::State>

Asynchronously makes a set of DOM nodes rendered from HTML interactive.

fn hydrate_from<const FROM_SERVER: bool>(self, el: &Element) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element.

fn hydrate_from_position<const FROM_SERVER: bool>( self, el: &Element, position: Position, ) -> Self::State

where Self: Sized,

Hydrates using RenderHtml::hydrate, beginning at the given element and position.

impl<T, Ser> Track for Resource<T, Ser>

where T: Send + Sync + 'static,

fn track(&self)

Subscribes to this signal in the current reactive scope without doing anything with its value.

impl<T, Ser> Write for Resource<T, Ser>

where T: Send + Sync + 'static,

type Value = Option<T>

The type of the signal’s value.

fn try_write(&self) -> Option<impl UntrackableGuard>

Returns the guard, or None if the signal has already been disposed.

fn try_write_untracked(&self) -> Option<impl DerefMut>

or None if the signal has already been disposed.

fn write(&self) -> impl UntrackableGuard

Returns the guard.

fn write_untracked(&self) -> impl DerefMut

Returns a guard that will not notify subscribers when dropped.

impl<T, Ser> Copy for Resource<T, Ser>

where T: Send + Sync + 'static,