Struct ViewTemplate

pub struct ViewTemplate<V> {
    view: V,
}

A view wrapper that uses a <template> node to optimize DOM node creation.

Rather than creating all of the DOM nodes each time it is built, this template will create a single <template> node once, then use .cloneNode(true) to clone that entire tree, and hydrate it to add event listeners and interactivity for this instance.

Fields

view: V

Implementations

impl<V> ViewTemplate<V>

where V: Render + ToTemplate + 'static,

pub fn new(view: V) -> ViewTemplate<V>

Creates a new view template.

Trait Implementations

impl<V> AddAnyAttr for ViewTemplate<V>

where V: RenderHtml + ToTemplate + 'static, <V as Render>::State: Mountable,

type Output<SomeNewAttr: Attribute> = ViewTemplate<V>

The new type once the attribute has been added.

fn add_any_attr<NewAttr>( self, _attr: NewAttr, ) -> <ViewTemplate<V> as AddAnyAttr>::Output<NewAttr>

where NewAttr: Attribute,

Adds an attribute to the view.

impl<V> Render for ViewTemplate<V>

where V: Render + RenderHtml + ToTemplate + 'static, <V as Render>::State: Mountable,

type State = <V as Render>::State

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

fn build(self) -> <ViewTemplate<V> as Render>::State

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

fn rebuild(self, state: &mut <ViewTemplate<V> as Render>::State)

Updates the view with new data.

impl<V> RenderHtml for ViewTemplate<V>

where V: RenderHtml + ToTemplate + 'static, <V as Render>::State: Mountable,

const MIN_LENGTH: usize = V::MIN_LENGTH

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

type AsyncOutput = <V as RenderHtml>::AsyncOutput

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

type Owned = <V as RenderHtml>::Owned

An equivalent value that is 'static.

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 hydrate<const FROM_SERVER: bool>( self, cursor: &Cursor, position: &PositionState, ) -> <ViewTemplate<V> as Render>::State

Makes a set of DOM nodes rendered from HTML interactive.

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.

async fn resolve(self) -> <ViewTemplate<V> as RenderHtml>::AsyncOutput

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

fn into_owned(self) -> <ViewTemplate<V> 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 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 Self: Sized,

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

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<V> ToTemplate for ViewTemplate<V>

where V: RenderHtml + ToTemplate + 'static, <V as Render>::State: Mountable,

const TEMPLATE: &'static str = V::TEMPLATE

The HTML content of the static template.

fn to_template( buf: &mut String, class: &mut String, style: &mut String, inner_html: &mut String, position: &mut Position, )

Renders a view type to a template. This does not take actual view data, but can be used for constructing part of an HTML <template> that corresponds to a view of a particular type.

const CLASS: &'static str = ""

The class attribute content known at compile time.

const STYLE: &'static str = ""

The style attribute content known at compile time.

const LEN: usize = _

The length of the template.

fn to_template_attribute( buf: &mut String, class: &mut String, style: &mut String, inner_html: &mut String, position: &mut Position, )

Renders a view type to a template in attribute position.