Move builder into new file and some fn typedefs into a separate file

Author: AlterionX

src/vdom.rs

@@ -21,19 +21,23 @@ use crate::{
     websys_bridge,
 };
 
+mod alias;
+mod builder;
+
+pub use alias::*;
+pub use builder::{Builder as AppBuilder, Init, Initializer, UrlHandling};
+
 pub enum Effect<Ms, GMs> {
     Msg(Ms),
     Cmd(Box<dyn Future<Item = Ms, Error = Ms> + 'static>),
     GMsg(GMs),
     GCmd(Box<dyn Future<Item = GMs, Error = GMs> + 'static>),
 }
-
 impl<Ms, GMs> From<Ms> for Effect<Ms, GMs> {
     fn from(message: Ms) -> Self {
         Effect::Msg(message)
     }
 }
-
 impl<Ms: 'static, OtherMs: 'static, GMs> MessageMapper<Ms, OtherMs> for Effect<Ms, GMs> {
     type SelfWithOtherMs = Effect<OtherMs, GMs>;
     fn map_message(self, f: impl FnOnce(Ms) -> OtherMs + 'static + Clone) -> Effect<OtherMs, GMs> {
@@ -53,47 +57,6 @@ pub enum ShouldRender {
     Skip,
 }
 
-//type InitFn<Ms, Mdl, ElC, GMs> =
-//    Box<dyn FnOnce(routing::Url, &mut OrdersContainer<Ms, Mdl, ElC, GMs>) -> Mdl>;
-type InitFn<Ms, Mdl, ElC, GMs> =
-    Box<dyn FnOnce(routing::Url, &mut OrdersContainer<Ms, Mdl, ElC, GMs>) -> Init<Mdl>>;
-type UpdateFn<Ms, Mdl, ElC, GMs> = fn(Ms, &mut Mdl, &mut OrdersContainer<Ms, Mdl, ElC, GMs>);
-type SinkFn<Ms, Mdl, ElC, GMs> = fn(GMs, &mut Mdl, &mut OrdersContainer<Ms, Mdl, ElC, GMs>);
-type ViewFn<Mdl, ElC> = fn(&Mdl) -> ElC;
-type RoutesFn<Ms> = fn(routing::Url) -> Option<Ms>;
-type WindowEvents<Ms, Mdl> = fn(&Mdl) -> Vec<events::Listener<Ms>>;
-type MsgListeners<Ms> = Vec<Box<dyn Fn(&Ms)>>;
-
-/// Used for handling initial routing.
-pub enum UrlHandling {
-    PassToRoutes,
-    None,
-    // todo: Expand later, as-required
-}
-
-/// Used as a flexible wrapper for the init function.
-pub struct Init<Mdl> {
-    //    init: InitFn<Ms, Mdl, ElC, GMs>,
-    model: Mdl,
-    url_handling: UrlHandling,
-}
-
-impl<Mdl> Init<Mdl> {
-    pub const fn new(model: Mdl) -> Self {
-        Self {
-            model,
-            url_handling: UrlHandling::PassToRoutes,
-        }
-    }
-
-    pub const fn new_with_url_handling(model: Mdl, url_handling: UrlHandling) -> Self {
-        Self {
-            model,
-            url_handling,
-        }
-    }
-}
-
 pub struct Mailbox<Message: 'static> {
     func: Rc<dyn Fn(Message)>,
 }
@@ -170,169 +133,18 @@ impl<Ms: 'static + Clone, Mdl: 'static, ElC: View<Ms>, GMs> ::std::fmt::Debug
     }
 }
 
-pub trait MountPoint {
-    fn element(self) -> Element;
-}
-
-impl MountPoint for &str {
-    fn element(self) -> Element {
-        util::document().get_element_by_id(self).unwrap_or_else(|| {
-            panic!(
-                "Can't find element with id={:?} - app cannot be mounted!\n\
-                 (Id defaults to \"app\", or can be set with the .mount() method)",
-                self
-            )
-        })
-    }
-}
-
-impl MountPoint for Element {
-    fn element(self) -> Element {
-        self
-    }
-}
-
-impl MountPoint for web_sys::HtmlElement {
-    fn element(self) -> Element {
-        self.into()
-    }
-}
-
-/// Used to create and store initial app configuration, ie items passed by the app creator
-pub struct AppBuilder<Ms: 'static + Clone, Mdl: 'static, ElC: View<Ms>, GMs> {
-    init: InitFn<Ms, Mdl, ElC, GMs>,
-    update: UpdateFn<Ms, Mdl, ElC, GMs>,
-    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> AppBuilder<Ms, Mdl, ElC, GMs> {
-    /// Choose the element where the application will be mounted.
-    /// The default one is the element with `id` = "app".
-    ///
-    /// # Examples
-    ///
-    /// ```rust,no_run
-    /// // argument is `&str`
-    /// mount("another_id")
-    ///
-    /// // argument is `HTMLElement`
-    /// // NOTE: Be careful with mounting into body,
-    /// // it can cause hard-to-debug bugs when there are other scripts in the body.
-    /// mount(seed::body())
-    ///
-    /// // argument is `Element`
-    /// mount(seed::body().querySelector("section").unwrap().unwrap())
-    /// ```
-    pub fn mount(mut self, mount_point: impl MountPoint) -> Self {
-        self.mount_point = Some(mount_point.element());
-        self
-    }
-
-    #[deprecated(since = "0.3.3", note = "please use `mount` instead")]
-    pub fn mount_el(mut self, el: Element) -> Self {
-        self.mount_point = Some(el);
-        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);
-        self
-    }
-
-    /// Registers a function which decides how window events will be handled.
-    pub fn window_events(mut self, evts: WindowEvents<Ms, Mdl>) -> Self {
-        self.window_events = Some(evts);
-        self
-    }
-
-    /// Registers a sink function.
-    ///
-    /// The sink function is a function which can update the model based
-    /// on global messages. Consider to use a sink function when a
-    /// submodule needs to trigger changes in other modules.
-    pub fn sink(mut self, sink: SinkFn<Ms, Mdl, ElC, GMs>) -> Self {
-        self.sink = Some(sink);
-        self
-    }
-
-    /// Turn this [`AppBuilder`] into an [`App`] which is ready to run.
-    ///
-    /// [`AppBuilder`]: struct.AppBuilder.html
-    /// [`App`]: struct.App.html
-    pub fn finish(mut self) -> App<Ms, Mdl, ElC, GMs> {
-        if self.mount_point.is_none() {
-            self = self.mount("app")
-        }
-
-        let app = App::new(
-            self.update,
-            self.sink,
-            self.view,
-            self.mount_point.unwrap(),
-            self.takeover_mount,
-            self.routes,
-            self.window_events,
-        );
-
-        let mut initial_orders = OrdersContainer::new(app.clone());
-        let mut init = (self.init)(routing::initial_url(), &mut initial_orders);
-
-        match init.url_handling {
-            UrlHandling::PassToRoutes => {
-                let url = routing::initial_url();
-                if let Some(r) = self.routes {
-                    (self.update)(r(url).unwrap(), &mut init.model, &mut initial_orders);
-                }
-            }
-            UrlHandling::None => (),
-        };
-
-        app.cfg.initial_orders.replace(Some(initial_orders));
-        app.data.model.replace(Some(init.model));
-
-        app
-    }
-}
-
 /// We use a struct instead of series of functions, in order to avoid passing
 /// repetitive sequences of parameters.
 impl<Ms: Clone, Mdl, ElC: View<Ms> + 'static, GMs: 'static> App<Ms, Mdl, ElC, GMs> {
-    pub fn build(
-        init: impl FnOnce(routing::Url, &mut OrdersContainer<Ms, Mdl, ElC, GMs>) -> Init<Mdl> + 'static,
+    pub fn build<I: FnOnce(routing::Url, &mut OrdersContainer<Ms, Mdl, ElC, GMs>) -> Init<Mdl>>(
+        init: I,
         update: UpdateFn<Ms, Mdl, ElC, GMs>,
         view: ViewFn<Mdl, ElC>,
-    ) -> AppBuilder<Ms, Mdl, ElC, GMs> {
+    ) -> AppBuilder<Ms, Mdl, ElC, GMs, I> {
         // Allows panic messages to output to the browser console.error.
         console_error_panic_hook::set_once();
 
-        AppBuilder {
-            init: Box::new(init),
-            update,
-            view,
-            sink: None,
-            mount_point: None,
-            takeover_mount: false,
-            routes: None,
-            window_events: None,
-        }
+        AppBuilder::new(init, update, view)
     }
 
     #[allow(clippy::too_many_arguments)]

src/vdom/alias.rs

@@ -0,0 +1,8 @@
+use crate::{events, orders::OrdersContainer, routing};
+
+pub type UpdateFn<Ms, Mdl, ElC, GMs> = fn(Ms, &mut Mdl, &mut OrdersContainer<Ms, Mdl, ElC, GMs>);
+pub type SinkFn<Ms, Mdl, ElC, GMs> = fn(GMs, &mut Mdl, &mut OrdersContainer<Ms, Mdl, ElC, GMs>);
+pub type ViewFn<Mdl, ElC> = fn(&Mdl) -> ElC;
+pub type RoutesFn<Ms> = fn(routing::Url) -> Option<Ms>;
+pub type WindowEvents<Ms, Mdl> = fn(&Mdl) -> Vec<events::Listener<Ms>>;
+pub type MsgListeners<Ms> = Vec<Box<dyn Fn(&Ms)>>;