From 0e0819d2846a845d56fbbbf48a786dbae63a3be6 Mon Sep 17 00:00:00 2001 From: Evan Almloff Date: Fri, 22 Sep 2023 09:19:54 -0500 Subject: [PATCH] further simplify spread example --- examples/spread.rs | 223 +++++++++++---------------------------------- 1 file changed, 54 insertions(+), 169 deletions(-) diff --git a/examples/spread.rs b/examples/spread.rs index a59fdf8f9..76b324f28 100644 --- a/examples/spread.rs +++ b/examples/spread.rs @@ -1,191 +1,76 @@ -//! Example: SSR +//! Example: README.md showcase //! -//! This example shows how we can render the Dioxus Virtualdom using SSR. +//! The example from the README.md. -use dioxus::core::{Attribute, HasAttributesBox}; -use dioxus::html::GlobalAttributesExtension; -use dioxus::html::{AudioExtension, ExtendedAudioMarker, ExtendedGlobalAttributesMarker}; -use dioxus::prelude::*; +use dioxus::{ + core::{exports::bumpalo::Bump, Attribute, HasAttributesBox}, + html::{ExtendedGlobalAttributesMarker, GlobalAttributesExtension}, + prelude::*, +}; fn main() { - // We can render VirtualDoms - let mut vdom = VirtualDom::new(app); - let _ = vdom.rebuild(); - println!("{}", dioxus_ssr::render(&vdom)); + dioxus_desktop::launch(app); } fn app(cx: Scope) -> Element { - cx.render(rsx!(Foo { - autoplay: true, - controls: true, - src: "https://www.w3schools.com/tags/horse.ogg", - width: "100", - })) + cx.render(::dioxus::core::LazyNodes::new( + move |__cx: &::dioxus::core::ScopeState| -> ::dioxus::core::VNode { + static TEMPLATE: ::dioxus::core::Template = ::dioxus::core::Template { + name: "src/main.rs:15:15:289", + roots: &[::dioxus::core::TemplateNode::Dynamic { id: 0usize }], + node_paths: &[&[0u8]], + attr_paths: &[], + }; + ::dioxus::core::VNode { + parent: None, + key: None, + template: std::cell::Cell::new(TEMPLATE), + root_ids: dioxus::core::exports::bumpalo::collections::Vec::with_capacity_in( + 1usize, + __cx.bump(), + ) + .into(), + dynamic_nodes: __cx.bump().alloc([__cx.component( + Component, + Props { + bump: __cx.bump(), + attributes: Vec::new(), + } + .width("hello"), + "Component", + )]), + dynamic_attrs: __cx.bump().alloc([]), + } + }, + )) } -pub struct FooProps<'a> { - pub open: Option<&'a str>, +#[derive(Props)] +struct Props<'a> { + bump: &'a Bump, attributes: Vec>, } -// ----- -impl<'a> FooProps<'a> { - #[doc = "\nCreate a builder for building `FooProps`.\nOn the builder, call `.open(...)`(optional) to set the values of the fields.\nFinally, call `.build()` to create the instance of `FooProps`.\n "] - #[allow(dead_code)] - pub fn builder(cx: &'a ScopeState) -> FooPropsBuilder<'a, ((),)> { - FooPropsBuilder { - bump: cx.bump(), - fields: ((),), - attributes: Vec::new(), - _phantom: core::default::Default::default(), - } - } -} -#[must_use] -#[doc(hidden)] -#[allow(dead_code, non_camel_case_types, non_snake_case)] -pub struct FooPropsBuilder<'a, TypedBuilderFields> { - bump: &'a ::dioxus::core::exports::bumpalo::Bump, - fields: TypedBuilderFields, - attributes: Vec>, - _phantom: core::marker::PhantomData<&'a ()>, -} -//impl<'a, TypedBuilderFields, > Clone for FooPropsBuilder<'a, TypedBuilderFields, > where TypedBuilderFields: Clone { fn clone(&self) -> Self { Self { fields: self.fields.clone(), attributes: self.attributes, _phantom: Default::default() } } } -impl<'a> dioxus::prelude::Properties<'a> for FooProps<'a> { - type Builder = FooPropsBuilder<'a, ((),)>; - const IS_STATIC: bool = false; - fn builder(cx: &'a ScopeState) -> Self::Builder { - FooProps::builder(cx) - } - unsafe fn memoize(&self, _other: &Self) -> bool { - false - } -} -#[doc(hidden)] -#[allow(dead_code, non_camel_case_types, non_snake_case)] -pub trait FooPropsBuilder_Optional { - fn into_value T>(self, default: F) -> T; -} -impl FooPropsBuilder_Optional for () { - fn into_value T>(self, default: F) -> T { - default() - } -} -impl FooPropsBuilder_Optional for (T,) { - fn into_value T>(self, _: F) -> T { - self.0 - } -} -#[allow(dead_code, non_camel_case_types, missing_docs)] -impl<'a> FooPropsBuilder<'a, ((),)> { - pub fn open( - self, - open: &'a str, - ) -> FooPropsBuilder< - 'a, - (( - Option<&'a str>, - // pub attributes: Vec>, - ),), - > { - let open = (Some(open),); - let (_,) = self.fields; - FooPropsBuilder { - bump: self.bump, - fields: (open,), - attributes: self.attributes, - _phantom: self._phantom, - } - } -} -#[doc(hidden)] -#[allow(dead_code, non_camel_case_types, non_snake_case)] -pub enum FooPropsBuilder_Error_Repeated_field_open {} -#[doc(hidden)] -#[allow(dead_code, non_camel_case_types, missing_docs)] -impl<'a> - FooPropsBuilder< - 'a, - (( - Option<&'a str>, - // pub attributes: Vec>, - ),), - > -{ - #[deprecated(note = "Repeated field open")] - pub fn open( - self, - _: FooPropsBuilder_Error_Repeated_field_open, - ) -> FooPropsBuilder< - 'a, - (( - Option<&'a str>, - // pub attributes: Vec>, - ),), - > { - self - } -} -#[allow(dead_code, non_camel_case_types, missing_docs)] -impl<'a, __open: FooPropsBuilder_Optional>> FooPropsBuilder<'a, (__open,)> { - pub fn build(self) -> FooProps<'a> { - let (open,) = self.fields; - let open = FooPropsBuilder_Optional::into_value(open, || Default::default()); - FooProps { - open, - attributes: self.attributes, - } - } -} -// ----- - -impl<'a, A> HasAttributesBox<'a, FooPropsBuilder<'a, (A,)>> for FooPropsBuilder<'a, (A,)> { +impl<'a> HasAttributesBox<'a, Props<'a>> for Props<'a> { fn push_attribute( - self, + mut self, name: &'a str, ns: Option<&'static str>, attr: impl IntoAttributeValue<'a>, volatile: bool, ) -> Self { - let mut attrs = self.attributes; - // We insert attributes so that the list is binary-searchable - if let Err(index) = attrs.binary_search_by(|probe| probe.name.cmp(name)) { - attrs.insert( - index, - Attribute::new(name, attr.into_value(self.bump), ns, volatile), - ); - } - FooPropsBuilder { - bump: self.bump, - fields: self.fields, - attributes: attrs, - _phantom: self._phantom, - } + self.attributes.push(Attribute { + name, + namespace: ns, + value: attr.into_value(self.bump), + volatile, + }); + self } } -impl ExtendedGlobalAttributesMarker for FooPropsBuilder<'_, (A,)> {} -impl ExtendedAudioMarker for FooPropsBuilder<'_, (A,)> {} -#[allow(non_snake_case)] -pub fn Foo<'a>(cx: Scope<'a, FooProps<'a>>) -> Element<'a> { - let attributes = &cx.props.attributes; - render! { - // rsx! { - // audio { - // ...attributes, - // } - // } - ::dioxus::core::LazyNodes::new(move |__cx: &::dioxus::core::ScopeState| -> ::dioxus::core::VNode { - static TEMPLATE: ::dioxus::core::Template = ::dioxus::core::Template { name: concat!(file!(), ":", line!(), ":", column!(), ":", "123" ), roots: &[::dioxus::core::TemplateNode::Element { tag: dioxus_elements::audio::TAG_NAME, namespace: dioxus_elements::audio::NAME_SPACE, attrs: &[::dioxus::core::TemplateAttribute::Dynamic { id: 0usize }], children: &[] }], node_paths: &[], attr_paths: &[&[0u8]] }; - let attrs = vec![(&**attributes).into()]; - ::dioxus::core::VNode { - parent: None, - key: None, - template: std::cell::Cell::new(TEMPLATE), - root_ids: dioxus::core::exports::bumpalo::collections::Vec::new_in(__cx.bump()).into(), - dynamic_nodes: __cx.bump().alloc([]), - dynamic_attrs: __cx.bump().alloc(attrs), - } - }) - } +impl ExtendedGlobalAttributesMarker for Props<'_> {} + +fn Component<'a>(cx: Scope<'a, Props<'a>>) -> Element<'a> { + todo!() }