feat!: DomToken's csr state doesn't require Default

Author: EqualMa

packages/frender-dom-tokens/src/chain.rs

@@ -3,7 +3,7 @@ use frender_const::{ConstUsize, KnownConstUsizeAdd};
 use crate::{
     constness::{HasConstKnownPossibleDomTokens, IsConstUsize},
     dom_token::UniqueDomTokenArrayVec,
-    ChainableDomTokens, DomTokens,
+    ChainableDomTokens, DomTokens, DomTokensStateUnmount,
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -24,29 +24,51 @@ where
     };
 }
 
+impl<A: DomTokensStateUnmount, B: DomTokensStateUnmount> DomTokensStateUnmount for (A, B) {
+    fn dom_tokens_state_unmount(
+        (state_a, state_b): &mut Self,
+        dom_token_list: &mut impl crate::DomTokenList,
+    ) {
+        A::dom_tokens_state_unmount(state_a, dom_token_list);
+        B::dom_tokens_state_unmount(state_b, dom_token_list);
+    }
+}
+
 impl<A: ChainableDomTokens, B: ChainableDomTokens> DomTokens for Chain<A, B>
 where
     Self: HasConstKnownPossibleDomTokens,
 {
-    type UpdateWithState = (A::UpdateWithState, B::UpdateWithState);
+    type State = (A::State, B::State);
+
+    fn dom_tokens_render_init(
+        Self(a, b): Self,
+        dom_token_list: &mut impl crate::DomTokenList,
+    ) -> Self::State {
+        _ = Self::ASSERT_KNOWN_NOT_DUP;
+        (
+            A::dom_tokens_render_init(a, dom_token_list),
+            B::dom_tokens_render_init(b, dom_token_list),
+        )
+    }
 
-    fn update_with_state(
+    fn dom_tokens_render_init_with_old_state(
         Self(a, b): Self,
         dom_token_list: &mut impl crate::DomTokenList,
-        (state_a, state_b): &mut Self::UpdateWithState,
+        (old_state_a, old_state_b): &mut Self::State,
     ) {
         _ = Self::ASSERT_KNOWN_NOT_DUP;
-        A::update_with_state(a, dom_token_list, state_a);
-        B::update_with_state(b, dom_token_list, state_b);
+        A::dom_tokens_render_init_with_old_state(a, dom_token_list, old_state_a);
+        B::dom_tokens_render_init_with_old_state(b, dom_token_list, old_state_b);
     }
 
-    fn remove_with_state(
+    fn dom_tokens_render_update(
+        Self(a, b): Self,
         dom_token_list: &mut impl crate::DomTokenList,
-        (state_a, state_b): &mut Self::UpdateWithState,
+        (state_a, state_b): &mut Self::State,
     ) {
         _ = Self::ASSERT_KNOWN_NOT_DUP;
-        A::remove_with_state(dom_token_list, state_a);
-        B::remove_with_state(dom_token_list, state_b);
+        A::dom_tokens_render_update(a, dom_token_list, state_a);
+        B::dom_tokens_render_update(b, dom_token_list, state_b);
     }
 
     type DomTokensIntoAsyncStrIter = async_str_iter::chain::Chain<

packages/frender-dom-tokens/src/constness.rs

@@ -1,9 +1,13 @@
+use std::marker::PhantomData;
+
+use csr::State;
 pub use frender_const::ConstUsize;
 
 use frender_common::const_utils::put_at;
 
 use crate::{
-    dom_token::UniqueDomTokenArrayVec, ChainableDomTokens, DomToken, DomTokens, UniqueDomTokenArray,
+    dom_token::UniqueDomTokenArrayVec, ChainableDomTokens, DomToken, DomTokens,
+    DomTokensStateUnmount, UniqueDomTokenArray,
 };
 
 mod sealed {
@@ -192,35 +196,42 @@ pub mod ssr {
     }
 }
 
+pub mod csr {
+    use std::marker::PhantomData;
+
+    use crate::DomTokensStateUnmount;
+
+    use super::HasConstDomTokens;
+
+    pub struct State<T: ?Sized + HasConstDomTokens>(pub(super) PhantomData<T>);
+
+    impl<T: ?Sized + HasConstDomTokens> DomTokensStateUnmount for State<T> {
+        fn dom_tokens_state_unmount(_: &mut Self, dom_token_list: &mut impl crate::DomTokenList) {
+            T::DOM_TOKENS
+                .as_ref()
+                .iter()
+                .for_each(|t| dom_token_list.remove_1(*t))
+        }
+    }
+}
+
 impl<T: ?Sized + HasConstDomTokens> DomTokens for ConstDomTokens<T> {
-    type UpdateWithState = bool; // whether updated
+    type State = State<T>;
 
-    fn update_with_state(
+    fn dom_tokens_render_init(
         _: Self,
         dom_token_list: &mut impl crate::DomTokenList,
-        state: &mut Self::UpdateWithState,
-    ) {
-        if *state {
-            return;
-        }
-        *state = true;
+    ) -> Self::State {
         T::DOM_TOKENS
             .as_ref()
             .iter()
-            .for_each(|t| dom_token_list.add_1(*t))
+            .for_each(|t| dom_token_list.add_1(*t));
+
+        State(PhantomData)
     }
 
-    fn remove_with_state(
-        dom_token_list: &mut impl crate::DomTokenList,
-        state: &mut Self::UpdateWithState,
-    ) {
-        if *state {
-            *state = false;
-            T::DOM_TOKENS
-                .as_ref()
-                .iter()
-                .for_each(|t| dom_token_list.remove_1(*t))
-        }
+    fn dom_tokens_render_update(_: Self, _: &mut impl crate::DomTokenList, _: &mut Self::State) {
+        // Does nothing
     }
 
     type DomTokensIntoAsyncStrIter = ssr::ConstDomTokensIntoAsyncStrIter<T>;

packages/frender-dom-tokens/src/either.rs

@@ -1,11 +1,11 @@
 use async_str_iter::either::IterEither;
-use frender_common::either::EitherState;
+use csr::State;
 use frender_const::{ConstUsize, KnownConstUsizeAdd};
 
 use crate::{
     constness::{HasConstKnownPossibleDomTokens, IsConstUsize},
     dom_token::UniqueDomTokenArrayVec,
-    ChainableDomTokens, DomTokens,
+    ChainableDomTokens, DomTokens, DomTokensStateUnmount,
 };
 
 #[derive(Debug, Clone, Copy)]
@@ -14,47 +14,87 @@ pub enum EitherDomTokens<A, B> {
     B(B),
 }
 
+pub mod csr {
+    use crate::DomTokensStateUnmount;
+
+    pub enum State<A, B> {
+        A(A),
+        B(B),
+    }
+
+    impl<A: DomTokensStateUnmount, B: DomTokensStateUnmount> DomTokensStateUnmount for State<A, B> {
+        fn dom_tokens_state_unmount(
+            state: &mut Self,
+            dom_token_list: &mut impl crate::DomTokenList,
+        ) {
+            match state {
+                State::A(state) => A::dom_tokens_state_unmount(state, dom_token_list),
+                State::B(state) => B::dom_tokens_state_unmount(state, dom_token_list),
+            }
+        }
+    }
+}
+
 impl<L: DomTokens, R: DomTokens> DomTokens for EitherDomTokens<L, R> {
-    type UpdateWithState = EitherState<L::UpdateWithState, R::UpdateWithState>;
+    type State = State<L::State, R::State>;
+
+    fn dom_tokens_render_init(
+        this: Self,
+        dom_token_list: &mut impl crate::DomTokenList,
+    ) -> Self::State {
+        match this {
+            EitherDomTokens::A(this) => State::A(L::dom_tokens_render_init(this, dom_token_list)),
+            EitherDomTokens::B(this) => State::B(R::dom_tokens_render_init(this, dom_token_list)),
+        }
+    }
 
-    fn update_with_state(
+    fn dom_tokens_render_init_with_old_state(
         this: Self,
         dom_token_list: &mut impl crate::DomTokenList,
-        state: &mut Self::UpdateWithState,
+        old_state: &mut Self::State,
     ) {
         match this {
-            EitherDomTokens::A(this) => {
-                let state = match state {
-                    EitherState::Left { inner: state } => state,
-                    EitherState::Right { inner: old_state } => {
-                        R::remove_with_state(dom_token_list, old_state);
-                        state.get_left_or_insert_default()
-                    }
-                };
-
-                L::update_with_state(this, dom_token_list, state)
-            }
-            EitherDomTokens::B(this) => {
-                let state = match state {
-                    EitherState::Right { inner: state } => state,
-                    EitherState::Left { inner: old_state } => {
-                        L::remove_with_state(dom_token_list, old_state);
-                        state.get_right_or_insert_default()
-                    }
-                };
-
-                R::update_with_state(this, dom_token_list, state)
-            }
+            EitherDomTokens::A(this) => match old_state {
+                State::A(old_state) => {
+                    L::dom_tokens_render_init_with_old_state(this, dom_token_list, old_state)
+                }
+                State::B(_) => {
+                    // Already unmounted
+                    *old_state = State::A(L::dom_tokens_render_init(this, dom_token_list))
+                }
+            },
+            EitherDomTokens::B(this) => match old_state {
+                State::B(old_state) => {
+                    R::dom_tokens_render_init_with_old_state(this, dom_token_list, old_state)
+                }
+                State::A(_) => {
+                    // Already unmounted
+                    *old_state = State::B(R::dom_tokens_render_init(this, dom_token_list))
+                }
+            },
         }
     }
 
-    fn remove_with_state(
+    fn dom_tokens_render_update(
+        this: Self,
         dom_token_list: &mut impl crate::DomTokenList,
-        state: &mut Self::UpdateWithState,
+        state: &mut Self::State,
     ) {
-        match state {
-            EitherState::Left { inner: state } => L::remove_with_state(dom_token_list, state),
-            EitherState::Right { inner: state } => R::remove_with_state(dom_token_list, state),
+        match this {
+            EitherDomTokens::A(this) => match state {
+                State::A(state) => L::dom_tokens_render_update(this, dom_token_list, state),
+                State::B(old_state) => {
+                    <R::State>::dom_tokens_state_unmount(old_state, dom_token_list);
+                    *state = State::A(L::dom_tokens_render_init(this, dom_token_list))
+                }
+            },
+            EitherDomTokens::B(this) => match state {
+                State::B(state) => R::dom_tokens_render_update(this, dom_token_list, state),
+                State::A(old_state) => {
+                    <L::State>::dom_tokens_state_unmount(old_state, dom_token_list);
+                    *state = State::B(R::dom_tokens_render_init(this, dom_token_list))
+                }
+            },
         }
     }
 

packages/frender-dom-tokens/src/empty.rs

@@ -4,20 +4,31 @@ use frender_const::ConstUsize;
 
 use crate::{
     constness::HasConstKnownPossibleDomTokens, dom_token::UniqueDomTokenArrayVec,
-    ChainableDomTokens, DomTokens,
+    ChainableDomTokens, DomTokens, DomTokensStateUnmount,
 };
 
+impl DomTokensStateUnmount for () {
+    fn dom_tokens_state_unmount((): &mut Self, _: &mut impl crate::DomTokenList) {}
+}
+
 impl DomTokens for Empty {
-    type UpdateWithState = ();
+    type State = ();
 
-    fn update_with_state(
+    fn dom_tokens_render_init(Self: Self, _: &mut impl crate::DomTokenList) -> Self::State {}
+
+    fn dom_tokens_render_init_with_old_state(
         Self: Self,
         _: &mut impl crate::DomTokenList,
-        (): &mut Self::UpdateWithState,
+        (): &mut Self::State,
     ) {
     }
 
-    fn remove_with_state(_: &mut impl crate::DomTokenList, (): &mut Self::UpdateWithState) {}
+    fn dom_tokens_render_update(
+        Self: Self,
+        _: &mut impl crate::DomTokenList,
+        (): &mut Self::State,
+    ) {
+    }
 
     type DomTokensIntoAsyncStrIter = async_str_iter::empty::Empty;
 

packages/frender-dom-tokens/src/erase_const_known.rs

@@ -12,21 +12,29 @@ use crate::{
 pub struct EraseConstKnownPossibleDomTokens<T>(pub T);
 
 impl<T: DomTokens> DomTokens for EraseConstKnownPossibleDomTokens<T> {
-    type UpdateWithState = T::UpdateWithState;
+    type State = T::State;
 
-    fn update_with_state(
-        this: Self,
+    fn dom_tokens_render_init(
+        Self(this): Self,
+        dom_token_list: &mut impl crate::DomTokenList,
+    ) -> Self::State {
+        T::dom_tokens_render_init(this, dom_token_list)
+    }
+
+    fn dom_tokens_render_init_with_old_state(
+        Self(this): Self,
         dom_token_list: &mut impl crate::DomTokenList,
-        state: &mut Self::UpdateWithState,
+        old_state: &mut Self::State,
     ) {
-        T::update_with_state(this.0, dom_token_list, state);
+        T::dom_tokens_render_init_with_old_state(this, dom_token_list, old_state)
     }
 
-    fn remove_with_state(
+    fn dom_tokens_render_update(
+        Self(this): Self,
         dom_token_list: &mut impl crate::DomTokenList,
-        state: &mut Self::UpdateWithState,
+        state: &mut Self::State,
     ) {
-        T::remove_with_state(dom_token_list, state);
+        T::dom_tokens_render_update(this, dom_token_list, state)
     }
 
     type DomTokensIntoAsyncStrIter = T::DomTokensIntoAsyncStrIter;