feat!: impl ssr for simply-typed html components

Author: EqualMa

Cargo.lock

@@ -14,6 +14,9 @@ mod prelude_names {
     #[cfg(feature = "csr")]
     pub(super) use frender_dom::Dom;
 
+    #[cfg(feature = "ssr")]
+    pub(super) use frender_ssr::AnySsrContext;
+
     pub(super) use super::{fn_wrapper, prelude_names, FnHookElement};
     pub(super) use crate::{ContextAndState, Rendered};
 }
@@ -22,6 +25,7 @@ pub mod new_fn_hook_element {
     use super::prelude_names::*;
 
     #[inline]
+    #[cfg(feature = "csr")]
     pub fn csr<HookData: HookPollNextUpdate + HookUnmount + Default, U, E: UpdateRenderState<Dom>>(
         use_hook: U,
     ) -> FnHookElement<HookData, fn_wrapper::FnMutOutputElement<U>, ()>
@@ -33,6 +37,24 @@ pub mod new_fn_hook_element {
             _phantom: std::marker::PhantomData,
         }
     }
+
+    #[inline]
+    #[cfg(feature = "ssr")]
+    pub fn ssr<
+        HookData: HookPollNextUpdate + HookUnmount + Default,
+        U,
+        E: for<'a> UpdateRenderState<AnySsrContext<'a>>,
+    >(
+        use_hook: U,
+    ) -> FnHookElement<HookData, fn_wrapper::FnMutOutputElement<U>, ()>
+    where
+        U: FnMut(Pin<&mut HookData>) -> E,
+    {
+        FnHookElement {
+            use_hook: fn_wrapper::FnMutOutputElement(use_hook),
+            _phantom: std::marker::PhantomData,
+        }
+    }
 }
 #[cfg(all(feature = "csr", feature = "ssr"))]
 pub fn new_fn_hook_element() {}

crates/frender-hook-element/src/element.rs

@@ -264,6 +264,16 @@ mod simple {
                     }
                 }
 
+                #[cfg(feature = "ssr")]
+                mod impl_ssr {
+                    #[allow(unused_imports)]
+                    use super::super::*;
+
+                    impl<Children> crate::imports::frender_html_simple::IntrinsicComponentSupportChildren<Children> for super::ComponentType {
+                        // TODO: some components are void or self closing
+                    }
+                }
+
                 #[inline(always)]
                 pub fn build<Children, Props>(
                     building: Building<Children, Props>,

crates/frender-html-components/src/element_macros.rs

@@ -1,11 +1,19 @@
+#[cfg(feature = "dom")]
 pub trait IntrinsicComponentWithElementType {
     type Element;
 }
 
-pub struct IntrinsicComponent<
-    C: frender_html_common::IntrinsicComponent + IntrinsicComponentWithElementType,
-    P,
->(pub C, pub P);
+#[cfg(feature = "ssr")]
+pub trait IntrinsicComponentSupportChildren<Children> {
+    #[inline]
+    fn wrap_children(
+        children: Children,
+    ) -> frender_ssr::element::html::HtmlElementChildren<Children> {
+        frender_ssr::element::html::HtmlElementChildren::Children(children)
+    }
+}
+
+pub struct IntrinsicComponent<C: frender_html_common::IntrinsicComponent, P>(pub C, pub P);
 
 #[cfg(feature = "dom")]
 mod dom {
@@ -37,3 +45,52 @@ mod dom {
         }
     }
 }
+
+#[cfg(feature = "ssr")]
+mod ssr {
+    use std::borrow::Cow;
+
+    use frender_core::UpdateRenderState;
+    use frender_html_common::IntrinsicComponent;
+    use frender_ssr::{AsyncWrite, IntoSsrData, SsrContext};
+
+    use super::IntrinsicComponentSupportChildren;
+
+    impl<W: AsyncWrite + Unpin, C: IntrinsicComponent, P> UpdateRenderState<SsrContext<W>>
+        for super::IntrinsicComponent<C, P>
+    where
+        C: IntrinsicComponentSupportChildren<P::Children>,
+        P: IntoSsrData<W>,
+    {
+        type State = ::frender_ssr::element::html::HtmlElementRenderState<
+            'static,
+            P::ChildrenRenderState,
+            P::Attrs,
+            W,
+        >;
+
+        fn initialize_render_state(self, ctx: &mut SsrContext<W>) -> Self::State {
+            let (children, attributes) = IntoSsrData::into_ssr_data(self.1);
+            ::frender_ssr::element::html::HtmlElement {
+                tag: Cow::Borrowed(C::INTRINSIC_TAG),
+                attributes,
+                children: C::wrap_children(children),
+            }
+            .initialize_render_state(ctx)
+        }
+
+        fn update_render_state(
+            self,
+            ctx: &mut SsrContext<W>,
+            state: std::pin::Pin<&mut Self::State>,
+        ) {
+            let (children, attributes) = IntoSsrData::into_ssr_data(self.1);
+            ::frender_ssr::element::html::HtmlElement {
+                tag: Cow::Borrowed(C::INTRINSIC_TAG),
+                attributes,
+                children: C::wrap_children(children),
+            }
+            .update_render_state(ctx, state)
+        }
+    }
+}

crates/frender-html-simple/src/component.rs

@@ -75,3 +75,27 @@ mod dom {
         }
     }
 }
+
+#[cfg(feature = "ssr")]
+mod ssr {
+    use frender_core::UpdateRenderState;
+    use frender_ssr::{attrs::IntoIteratorAttrs, AsyncWrite, IntoSsrData, SsrContext};
+
+    impl<W: AsyncWrite + Unpin, Children, Props> IntoSsrData<W> for super::ElementProps<Children, Props>
+    where
+        Children: UpdateRenderState<SsrContext<W>>,
+        Children::State: Unpin, // TODO: remove this restriction
+        Props: IntoIteratorAttrs<'static>,
+        Props::IntoIterAttrs: Unpin, // TODO: remove this restriction
+    {
+        type Children = Children;
+
+        type ChildrenRenderState = Children::State;
+
+        type Attrs = Props::IntoIterAttrs;
+
+        fn into_ssr_data(this: Self) -> (Self::Children, Self::Attrs) {
+            (this.children, Props::into_iter_attrs(this.other_props))
+        }
+    }
+}

crates/frender-html-simple/src/props.rs

@@ -34,6 +34,9 @@ impl FieldAsSimpleProp<'_> {
         let dom_init;
         let dom_update;
         let mut ssr_bounds = None;
+        let ssr_attrs_ty;
+        let ssr_attrs_impl;
+
         match &field.declaration {
             FieldDeclaration::Maybe(m) => {
                 assert!(m.no_cache.is_none(), "simply typed prop must have state");
@@ -62,6 +65,23 @@ impl FieldAsSimpleProp<'_> {
                     quote!(this.0),
                     quote!(&mut state.get_mut().0),
                 );
+
+                ssr_attrs_ty = quote! {
+                    ::core::option::IntoIter<
+                        #crate_path::frender_ssr::element::html::HtmlAttrPair<'a>
+                    >
+                };
+
+                let attr_name = m.to_html_prop_name(name);
+
+                ssr_attrs_impl = quote! {
+                    V::maybe_into_html_attribute_value(
+                        this.0
+                    ).map(|attr_value| (::std::borrow::Cow::Borrowed(#attr_name), attr_value.map_or(
+                            #crate_path::frender_ssr::element::html::HtmlAttributeValue::BooleanTrue,
+                            #crate_path::frender_ssr::element::html::HtmlAttributeValue::String,
+                    ))).into_iter()
+                };
             }
             FieldDeclaration::EventListener(e) => {
                 //
@@ -80,6 +100,16 @@ impl FieldAsSimpleProp<'_> {
                 dom_update = quote! {
                     V::update_dom_event_listener(this.0, dom_element, &mut state.get_mut().0)
                 };
+
+                ssr_attrs_ty = quote! {
+                    ::core::iter::Empty<
+                        #crate_path::frender_ssr::element::html::HtmlAttrPair<'a>
+                    >
+                };
+
+                ssr_attrs_impl = quote! {
+                    ::core::iter::empty()
+                };
             }
             FieldDeclaration::Full(_) => {
                 assert_eq!(
@@ -150,7 +180,14 @@ impl FieldAsSimpleProp<'_> {
                 }
             }),
             impl_ssr: Some(quote! {
-                // TODO:
+                impl<'a, V #ssr_bounds>
+                    #crate_path::frender_ssr::attrs::IntoIteratorAttrs<'a>
+                for super::props::#name<V> {
+                    type IntoIterAttrs = #ssr_attrs_ty;
+                    fn into_iter_attrs(this: Self) -> Self::IntoIterAttrs {
+                        #ssr_attrs_impl
+                    }
+                }
             }),
             field_info: {
                 let bounds = builder_fn_bounds.map(|b| quote!(: bounds![#b]));

crates/frender-intrinsic-component-macro/src/simple/field_as_simple_prop.rs

@@ -7,5 +7,7 @@ edition = "2021"
 
 [dependencies]
 frender-core = { path = "../frender-core", version = "0.1.0" }
+frender-html-common = { version = "0.1.0", path = "../frender-html-common" }
 futures-io = "0.3.25"
 html-escape = "0.2.13"
+pin-project-lite = "0.2.9"

crates/frender-ssr/Cargo.toml

@@ -0,0 +1,129 @@
+#![cfg(prototyping)] // TODO: remove
+
+use std::{io, pin::Pin, task::Poll};
+
+use futures_io::AsyncWrite;
+
+pub trait AsyncWritable {
+    fn poll_write_all<W: AsyncWrite>(
+        this: Pin<&mut Self>,
+        writer: Pin<&mut W>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<io::Result<()>>;
+}
+
+pub trait IntoAsyncWritable: Sized {
+    type AsyncWritable: AsyncWritable;
+    fn into_async_writable(this: Self) -> Self::AsyncWritable;
+}
+
+impl IntoAsyncWritable for () {
+    type AsyncWritable = Nothing;
+
+    fn into_async_writable(_: Self) -> Self::AsyncWritable {
+        Nothing
+    }
+}
+
+impl<A: IntoAsyncWritable, B: IntoAsyncWritable> IntoAsyncWritable for (A, B) {
+    type AsyncWritable = Chain<A::AsyncWritable, B::AsyncWritable>;
+
+    fn into_async_writable(this: Self) -> Self::AsyncWritable {
+        Chain {
+            a: A::into_async_writable(this.0),
+            b: B::into_async_writable(this.1),
+            stage: Stage::NoneDone,
+        }
+    }
+}
+
+enum Stage {
+    NoneDone,
+    ADone,
+    AllDone,
+    Error,
+}
+
+pub struct Nothing;
+
+impl AsyncWritable for Nothing {
+    fn poll_write_all<W: AsyncWrite>(
+        _: Pin<&mut Self>,
+        _: Pin<&mut W>,
+        _: &mut std::task::Context<'_>,
+    ) -> Poll<io::Result<()>> {
+        Poll::Ready(Ok(()))
+    }
+}
+
+pin_project_lite::pin_project!(
+    pub struct Chain<A, B> {
+        #[pin]
+        a: A,
+        #[pin]
+        b: B,
+        stage: Stage,
+    }
+);
+
+impl<A, B> Chain<A, B> {}
+
+impl<A: AsyncWritable, B: AsyncWritable> AsyncWritable for Chain<A, B> {
+    fn poll_write_all<W: AsyncWrite>(
+        this: Pin<&mut Self>,
+        mut writer: Pin<&mut W>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<io::Result<()>> {
+        let this = this.project();
+
+        macro_rules! continue_with {
+            ($e:expr, $next_stage:expr) => {
+                match $e {
+                    Poll::Ready(Ok(())) => {
+                        *this.stage = $next_stage;
+                    }
+                    err @ Poll::Ready(Err(_)) => {
+                        *this.stage = Stage::Error;
+                        return err;
+                    }
+                    Poll::Pending => return Poll::Pending,
+                }
+            };
+        }
+
+        if let Stage::Error = this.stage {
+            return Poll::Ready(Err(io::ErrorKind::Other.into()));
+        }
+
+        if let Stage::NoneDone = this.stage {
+            continue_with!(A::poll_write_all(this.a, writer.as_mut(), cx), Stage::ADone)
+        }
+
+        if let Stage::ADone = this.stage {
+            continue_with!(
+                B::poll_write_all(this.b, writer.as_mut(), cx),
+                Stage::AllDone
+            )
+        }
+
+        assert!(matches!(this.stage, Stage::AllDone));
+        Poll::Ready(Ok(()))
+    }
+}
+
+mod chain_macro {
+    macro_rules! Chain {
+        ($ty1:ty $(,)?) => {
+            $ty1
+        };
+        ($ty1:ty , $($ty:ty),+ $(,)?) => {
+            $crate::async_writable::Chain::<
+                $ty1,
+                $crate::async_writable::Chain![$($ty),+]
+            >
+        };
+    }
+    pub(crate) use Chain;
+}
+
+pub(crate) use chain_macro::*;