Convert takeover_mount to an enum BootstrapBehavior

Author: AlterionX

src/vdom.rs

@@ -25,7 +25,7 @@ mod alias;
 mod builder;
 
 pub use alias::*;
-pub use builder::{Builder as AppBuilder, Init, Initializer, UrlHandling};
+pub use builder::{BootstrapBehavior, Builder as AppBuilder, Init, Initializer, UrlHandling};
 
 pub enum Effect<Ms, GMs> {
     Msg(Ms),
@@ -105,12 +105,12 @@ where
 {
     document: web_sys::Document,
     mount_point: web_sys::Element,
-    takeover_mount: bool,
     pub update: UpdateFn<Ms, Mdl, ElC, GMs>,
     pub sink: Option<SinkFn<Ms, Mdl, ElC, GMs>>,
     view: ViewFn<Mdl, ElC>,
     window_events: Option<WindowEvents<Ms, Mdl>>,
     initial_orders: RefCell<Option<OrdersContainer<Ms, Mdl, ElC, GMs>>>,
+    bootstrap_behavior: RefCell<Option<BootstrapBehavior>>,
 }
 
 pub struct App<Ms: Clone, Mdl, ElC, GMs = ()>
@@ -153,7 +153,6 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GM
         sink: Option<SinkFn<Ms, Mdl, ElC, GMs>>,
         view: ViewFn<Mdl, ElC>,
         mount_point: Element,
-        takeover_mount: bool,
         routes: Option<RoutesFn<Ms>>,
         window_events: Option<WindowEvents<Ms, Mdl>>,
     ) -> Self {
@@ -164,12 +163,12 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GM
             cfg: Rc::new(AppCfg {
                 document,
                 mount_point,
-                takeover_mount,
                 update,
                 sink,
                 view,
                 window_events,
                 initial_orders: RefCell::new(None),
+                bootstrap_behavior: RefCell::new(None),
             }),
             data: Rc::new(AppData {
                 model: RefCell::new(None),
@@ -201,10 +200,11 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GM
     /// replacing them with the vdom if requested. Will otherwise ignore the original children of
     /// the mount point.
     fn bootstrap_vdom(&self) -> El<Ms> {
+        let bootstrap_behavior = *self.cfg.bootstrap_behavior.borrow();
         let mut new = El::empty(dom_types::Tag::Placeholder);
 
         // Map the DOM's elements onto the virtual DOM if requested to takeover.
-        if self.cfg.takeover_mount {
+        if bootstrap_behavior == Some(BootstrapBehavior::Takeover) {
             // Construct a vdom from the root element. Subsequently strip the workspace so that we
             // can recreate it later - this is a kind of simple way to avoid missing nodes (but
             // not entirely correct).
@@ -227,7 +227,7 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GM
         patch::attach_listeners(&mut new, &self.mailbox());
 
         // Recreate the needed nodes. Only do this if requested to takeover the mount point.
-        let mut new = if self.cfg.takeover_mount {
+        let mut new = if bootstrap_behavior == Some(BootstrapBehavior::Takeover) {
             // TODO: Refer the TODO at the beginning of the function.
             let mut new_node = Node::Element(new);
             websys_bridge::assign_ws_nodes(&util::document(), &mut new_node);
@@ -269,6 +269,17 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GM
         new
     }
 
+    fn initial_update(&self) {
+        let queue = self
+            .cfg
+            .initial_orders
+            .replace(None)
+            .expect("initial_orders should be set in AppBuilder::finish")
+            .effects;
+        self.process_cmd_and_msg_queue(queue);
+        self.rerender_vdom();
+    }
+
     /// App initialization: Collect its fundamental components, setup, and perform
     /// an initial render.
     pub fn run(self) -> Self {
@@ -296,13 +307,7 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GM
         // render as per normal for seed behavior. -- Executed here to ensure that all state has
         // been initialized with a bootstrap version. The bootstrap will be replaced after first
         // render.
-        self.process_cmd_and_msg_queue_with_forced_render(
-            self.cfg
-                .initial_orders
-                .replace(None)
-                .expect("initial_orders should be set in AppBuilder::finish")
-                .effects,
-        );
+        self.initial_update();
 
         self
     }
@@ -330,10 +335,6 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GM
         self.process_cmd_and_msg_queue(queue);
     }
 
-    pub fn process_cmd_and_msg_queue_with_forced_render(&self, queue: VecDeque<Effect<Ms, GMs>>) {
-        self.process_cmd_and_msg_queue(queue);
-        self.rerender_vdom();
-    }
     pub fn process_cmd_and_msg_queue(&self, mut queue: VecDeque<Effect<Ms, GMs>>) {
         while let Some(effect) = queue.pop_front() {
             match effect {

src/vdom/builder.rs

@@ -10,49 +10,60 @@ use crate::{
 pub trait Initializer<Ms: Clone + 'static, Mdl, ElC: View<Ms>, GMs> {
     fn into_init(
         self,
-        routing_method: routing::Url,
+        url: routing::Url,
         orders: &mut OrdersContainer<Ms, Mdl, ElC, GMs>,
     ) -> Init<Mdl>;
 }
 impl<Ms: Clone + 'static, Mdl, ElC: View<Ms>, GMs, F> Initializer<Ms, Mdl, ElC, GMs> for F
 where
-    F: FnOnce(routing::Url, &mut OrdersContainer<Ms, Mdl, ElC, GMs>) -> Init<Mdl>,
+    F: for<'r, 'a> FnOnce(routing::Url, &'a mut OrdersContainer<Ms, Mdl, ElC, GMs>) -> Init<Mdl>,
 {
     fn into_init(
         self,
-        routing_method: routing::Url,
+        url: routing::Url,
         orders: &mut OrdersContainer<Ms, Mdl, ElC, GMs>,
     ) -> Init<Mdl> {
-        self(routing_method, orders)
+        self(url, orders)
     }
 }
 
 /// Used for handling initial routing.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum UrlHandling {
     PassToRoutes,
     None,
     // todo: Expand later, as-required
 }
 
+/// Used for determining behavior at startup.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum BootstrapBehavior {
+    Takeover,
+    Append,
+}
+
 /// Used as a flexible wrapper for the init function.
 pub struct Init<Mdl> {
     //    init: InitFn<Ms, Mdl, ElC, GMs>,
-    model: Mdl,
-    url_handling: UrlHandling,
+    pub model: Mdl,
+    pub url_handling: UrlHandling,
+    pub bootstrap_behavior: BootstrapBehavior,
 }
 
 impl<Mdl> Init<Mdl> {
     pub const fn new(model: Mdl) -> Self {
         Self {
             model,
             url_handling: UrlHandling::PassToRoutes,
+            bootstrap_behavior: BootstrapBehavior::Append,
         }
     }
 
     pub const fn new_with_url_handling(model: Mdl, url_handling: UrlHandling) -> Self {
         Self {
             model,
             url_handling,
+            bootstrap_behavior: BootstrapBehavior::Append,
         }
     }
 }
@@ -104,22 +115,24 @@ pub struct Builder<
     sink: Option<SinkFn<Ms, Mdl, ElC, GMs>>,
     view: ViewFn<Mdl, ElC>,
     mount_point: Option<Element>,
-    takeover_mount: bool,
     routes: Option<RoutesFn<Ms>>,
     window_events: Option<WindowEvents<Ms, Mdl>>,
 }
 
 impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static, I: Initializer<Ms, Mdl, ElC, GMs>>
     Builder<Ms, Mdl, ElC, GMs, I>
 {
-    pub fn new(init: I, update: UpdateFn<Ms, Mdl, ElC, GMs>, view: ViewFn<Mdl, ElC>) -> Self {
+    pub(super) fn new(
+        init: I,
+        update: UpdateFn<Ms, Mdl, ElC, GMs>,
+        view: ViewFn<Mdl, ElC>,
+    ) -> Self {
         Self {
             init,
             update,
             view,
             sink: None,
             mount_point: None,
-            takeover_mount: false,
             routes: None,
             window_events: None,
         }
@@ -153,18 +166,6 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static, I: Initializer<Ms, M
         self
     }
 
-    /// Allows for the [`App`] to takeover all the children of the mount point. The default
-    /// behavior is that the [`App`] ignores the children and leaves them in place. The new
-    /// behavior can be useful if SSR is implemented.
-    ///
-    /// As of right now, nodes found in the root will be destroyed and recreated once. This can
-    /// cause duplicated scripts, css, and other tags that should not otherwise be duplicated.
-    /// Unrecognized tags are also converted into spans, so take note.
-    pub fn takeover_mount(mut self, should_takeover: bool) -> Self {
-        self.takeover_mount = should_takeover;
-        self
-    }
-
     /// Registers a function which maps URLs to messages.
     pub fn routes(mut self, routes: RoutesFn<Ms>) -> Self {
         self.routes = Some(routes);
@@ -201,7 +202,6 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static, I: Initializer<Ms, M
             self.sink,
             self.view,
             self.mount_point.unwrap(),
-            self.takeover_mount,
             self.routes,
             self.window_events,
         );
@@ -222,6 +222,9 @@ impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static, I: Initializer<Ms, M
         };
 
         app.cfg.initial_orders.replace(Some(initial_orders));
+        app.cfg
+            .bootstrap_behavior
+            .replace(Some(init.bootstrap_behavior));
         app.data.model.replace(Some(init.model));
 
         app