fix: really big bug around hooks

packages/desktop/src/cfg.rs

@@ -1,14 +1,7 @@
-use std::ops::{Deref, DerefMut};
-
 use dioxus_core::DomEdit;
 use wry::{
-    application::{
-        error::OsError,
-        event_loop::{EventLoop, EventLoopWindowTarget},
-        menu::MenuBar,
-        window::{Fullscreen, Icon, Window, WindowBuilder},
-    },
-    webview::{RpcRequest, RpcResponse, WebView},
+    application::{event_loop::EventLoop, window::WindowBuilder},
+    webview::WebView,
 };
 
 pub struct DesktopConfig<'a> {
@@ -22,7 +15,7 @@ impl<'a> DesktopConfig<'a> {
     /// Initializes a new `WindowBuilder` with default values.
     #[inline]
     pub fn new() -> Self {
-        let mut window = WindowBuilder::new().with_title("Dioxus app");
+        let window = WindowBuilder::new().with_title("Dioxus app");
         Self {
             event_handler: None,
             window,
@@ -41,13 +34,24 @@ impl<'a> DesktopConfig<'a> {
         self
     }
 
-    pub fn with_window(&mut self, f: impl FnOnce(WindowBuilder) -> WindowBuilder) -> &mut Self {
+    pub fn with_window(
+        &mut self,
+        configure: impl FnOnce(WindowBuilder) -> WindowBuilder,
+    ) -> &mut Self {
         // gots to do a swap because the window builder only takes itself as muy self
         // I wish more people knew about returning &mut Self
         let mut builder = WindowBuilder::default().with_title("Dioxus App");
         std::mem::swap(&mut self.window, &mut builder);
-        builder = f(builder);
+        builder = configure(builder);
         std::mem::swap(&mut self.window, &mut builder);
         self
     }
+
+    pub fn with_event_handler(
+        &mut self,
+        handler: impl Fn(&mut EventLoop<()>, &mut WebView) + 'static,
+    ) -> &mut Self {
+        self.event_handler = Some(Box::new(handler));
+        self
+    }
 }

packages/desktop/src/dom.rs

@@ -1,31 +0,0 @@
-//! webview dom
-
-use dioxus_core::DomEdit;
-
-// pub struct WebviewRegistry {}
-
-// impl WebviewRegistry {
-//     pub fn new() -> Self {
-//         Self {}
-//     }
-// }
-
-pub struct WebviewDom<'bump> {
-    pub edits: Vec<DomEdit<'bump>>,
-    pub node_counter: u64,
-    // pub registry: WebviewRegistry,
-}
-impl WebviewDom<'_> {
-    pub fn new() -> Self {
-        Self {
-            edits: Vec::new(),
-            node_counter: 0,
-            // registry,
-        }
-    }
-
-    // // Finish using the dom (for its edit list) and give back the node and event registry
-    // pub fn consume(self) -> WebviewRegistry {
-    //     self.registry
-    // }
-}

packages/desktop/src/err.rs

@@ -1 +0,0 @@
-

packages/desktop/src/escape.rs

@@ -16,7 +16,8 @@ use std::fmt::{self, Write};
 ///
 /// view.eval(&format!("callback({});", web_view::escape(string)));
 /// ```
-pub fn escape(string: &str) -> Escaper {
+#[allow(unused)]
+pub fn escape_js_string(string: &str) -> Escaper {
     Escaper(string)
 }
 
@@ -76,6 +77,6 @@ impl<'a> fmt::Display for Escaper<'a> {
 #[test]
 fn test() {
     let plain = "ABC \n\r' abc \\  \u{2028}   \u{2029}123";
-    let escaped = escape(plain).to_string();
+    let escaped = escape_js_string(plain).to_string();
     assert!(escaped == "'ABC \\n\\r\\' abc \\\\  \\u2028   \\u2029123'");
 }

packages/desktop/src/events.rs

@@ -1,10 +1,10 @@
 //! Convert a serialized event to an event Trigger
 //!
 
+use std::any::Any;
 use std::sync::Arc;
-use std::{any::Any, rc::Rc};
 
-use dioxus_core::{ElementId, EventPriority, ScopeId, UserEvent};
+use dioxus_core::{ElementId, EventPriority, UserEvent};
 use dioxus_html::on::*;
 
 #[derive(serde::Serialize, serde::Deserialize)]
@@ -16,11 +16,11 @@ struct ImEvent {
 }
 
 pub fn trigger_from_serialized(val: serde_json::Value) -> UserEvent {
-    let mut ims: Vec<ImEvent> = serde_json::from_value(val).unwrap();
+    let ims: Vec<ImEvent> = serde_json::from_value(val).unwrap();
+
     let ImEvent {
         event,
         mounted_dom_id,
-        // scope,
         contents,
     } = ims.into_iter().next().unwrap();
 

packages/desktop/src/lib.rs

@@ -3,41 +3,31 @@
 //! Render the Dioxus VirtualDom using the platform's native WebView implementation.
 //!
 
-use std::borrow::BorrowMut;
-use std::cell::{Cell, RefCell};
-use std::collections::{HashMap, VecDeque};
-use std::ops::{Deref, DerefMut};
-use std::rc::Rc;
-use std::sync::atomic::AtomicBool;
-use std::sync::mpsc::channel;
-use std::sync::{Arc, RwLock};
+mod cfg;
+mod escape;
+mod events;
+// mod desktop_context;
 
 use cfg::DesktopConfig;
 use dioxus_core::*;
-use serde::{Deserialize, Serialize};
-
-pub use wry;
-
-use wry::application::accelerator::{Accelerator, SysMods};
-use wry::application::event::{ElementState, Event, StartCause, WindowEvent};
-use wry::application::event_loop::{self, ControlFlow, EventLoop, EventLoopWindowTarget};
-use wry::application::keyboard::{Key, KeyCode, ModifiersState};
-use wry::application::menu::{MenuBar, MenuItem, MenuItemAttributes};
-use wry::application::window::{Fullscreen, WindowId};
-use wry::webview::{WebView, WebViewBuilder};
+use std::{
+    collections::{HashMap, VecDeque},
+    sync::atomic::AtomicBool,
+    sync::{Arc, RwLock},
+};
+use tokio::task::LocalSet;
 use wry::{
-    application::menu,
-    application::window::{Window, WindowBuilder},
-    webview::{RpcRequest, RpcResponse},
+    application::{
+        accelerator::{Accelerator, SysMods},
+        event::{Event, StartCause, WindowEvent},
+        event_loop::{ControlFlow, EventLoop, EventLoopWindowTarget},
+        keyboard::{KeyCode, ModifiersState},
+        menu::{MenuBar, MenuItem},
+        window::{Window, WindowId},
+    },
+    webview::RpcRequest,
+    webview::{WebView, WebViewBuilder},
 };
-
-mod cfg;
-mod desktop_context;
-mod dom;
-mod escape;
-mod events;
-
-static HTML_CONTENT: &'static str = include_str!("./index.html");
 
 pub fn launch(
     root: FC<()>,
@@ -54,7 +44,7 @@ pub fn launch_with_props<P: Properties + 'static + Send + Sync>(
     run(root, props, builder)
 }
 
-#[derive(Serialize)]
+#[derive(serde::Serialize)]
 struct Response<'a> {
     pre_rendered: Option<String>,
     edits: Vec<DomEdit<'a>>,
@@ -65,93 +55,43 @@ pub fn run<T: 'static + Send + Sync>(
     props: T,
     user_builder: impl for<'a, 'b> FnOnce(&'b mut DesktopConfig<'a>) -> &'b mut DesktopConfig<'a>,
 ) {
-    // Generate the config
-    let mut cfg = DesktopConfig::new();
-    user_builder(&mut cfg);
-    let DesktopConfig {
-        window: window_cfg,
-        manual_edits,
-        pre_rendered,
-        ..
-    } = cfg;
-
-    // All of our webview windows are stored in a way that we can look them up later
-    // The "DesktopContext" will provide functionality for spawning these windows
-    let mut webviews = HashMap::<WindowId, WebView>::new();
-    let event_loop = EventLoop::new();
-
-    let props_shared = Cell::new(Some(props));
-
-    // create local modifier state
-    let modifiers = ModifiersState::default();
+    let mut desktop_cfg = DesktopConfig::new();
+    user_builder(&mut desktop_cfg);
 
+    let mut state = DesktopController::new_on_tokio(root, props);
     let quit_hotkey = Accelerator::new(SysMods::Cmd, KeyCode::KeyQ);
-
-    let edit_queue = Arc::new(RwLock::new(VecDeque::new()));
-    let is_ready: Arc<AtomicBool> = Default::default();
-
-    let mut frame = 0;
+    let modifiers = ModifiersState::default();
+    let event_loop = EventLoop::new();
 
     event_loop.run(move |window_event, event_loop, control_flow| {
         *control_flow = ControlFlow::Wait;
 
         match window_event {
-            Event::NewEvents(StartCause::Init) => {
-                let window = create_window(event_loop, &window_cfg);
-                let window_id = window.id();
-                let sender =
-                    launch_vdom_with_tokio(root, props_shared.take().unwrap(), edit_queue.clone());
-                let webview = create_webview(window, is_ready.clone(), sender);
-                webviews.insert(window_id, webview);
-            }
+            Event::NewEvents(StartCause::Init) => state.new_window(&desktop_cfg, event_loop),
 
             Event::WindowEvent {
                 event, window_id, ..
             } => match event {
                 WindowEvent::CloseRequested => *control_flow = ControlFlow::Exit,
-                WindowEvent::Destroyed { .. } => {
-                    webviews.remove(&window_id);
-                    if webviews.is_empty() {
-                        *control_flow = ControlFlow::Exit;
-                    }
-                }
-                WindowEvent::Moved(pos) => {
-                    //
-                }
+                WindowEvent::Destroyed { .. } => state.close_window(window_id, control_flow),
 
                 WindowEvent::KeyboardInput { event, .. } => {
                     if quit_hotkey.matches(&modifiers, &event.physical_key) {
-                        webviews.remove(&window_id);
-                        if webviews.is_empty() {
-                            *control_flow = ControlFlow::Exit;
-                        }
+                        state.close_window(window_id, control_flow);
                     }
                 }
 
                 WindowEvent::Resized(_) | WindowEvent::Moved(_) => {
-                    if let Some(view) = webviews.get_mut(&window_id) {
+                    if let Some(view) = state.webviews.get_mut(&window_id) {
                         let _ = view.resize();
                     }
                 }
-                // TODO: we want to shuttle all of these events into the user's app
+
+                // TODO: we want to shuttle all of these events into the user's app or provide some handler
                 _ => {}
             },
 
-            Event::MainEventsCleared => {
-                // I hate this ready hack but it's needed to wait for the "onload" to occur
-                // We can't run any initializion scripts because the window isn't ready yet?
-                if is_ready.load(std::sync::atomic::Ordering::Relaxed) {
-                    let mut queue = edit_queue.write().unwrap();
-                    let (id, view) = webviews.iter_mut().next().unwrap();
-                    while let Some(edit) = queue.pop_back() {
-                        view.evaluate_script(&format!("window.interpreter.handleEdits({})", edit))
-                            .unwrap();
-                    }
-                } else {
-                    println!("waiting for onload {:?}", frame);
-                    frame += 1;
-                }
-            }
+            Event::MainEventsCleared => state.try_load_ready_webviews(),
             Event::Resumed => {}
             Event::Suspended => {}
             Event::LoopDestroyed => {}
@@ -161,121 +101,160 @@ pub fn run<T: 'static + Send + Sync>(
     })
 }
 
-// Create a new tokio runtime on a dedicated thread and then launch the apps VirtualDom.
-pub(crate) fn launch_vdom_with_tokio<P: Send + 'static>(
-    root: FC<P>,
-    props: P,
-    edit_queue: Arc<RwLock<VecDeque<String>>>,
-) -> futures_channel::mpsc::UnboundedSender<SchedulerMsg> {
-    let (sender, receiver) = futures_channel::mpsc::unbounded::<SchedulerMsg>();
-    let return_sender = sender.clone();
+pub struct DesktopController {
+    webviews: HashMap<WindowId, WebView>,
+    sender: futures_channel::mpsc::UnboundedSender<SchedulerMsg>,
+    pending_edits: Arc<RwLock<VecDeque<String>>>,
+    quit_app_on_close: bool,
+    is_ready: Arc<AtomicBool>,
+}
 
-    std::thread::spawn(move || {
-        // We create the runtim as multithreaded, so you can still "spawn" onto multiple threads
-        let runtime = tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
+impl DesktopController {
+    // Launch the virtualdom on its own thread managed by tokio
+    // returns the desktop state
+    pub fn new_on_tokio<P: Send + 'static>(root: FC<P>, props: P) -> Self {
+        let edit_queue = Arc::new(RwLock::new(VecDeque::new()));
+        let pending_edits = edit_queue.clone();
+
+        let (sender, receiver) = futures_channel::mpsc::unbounded::<SchedulerMsg>();
+        let return_sender = sender.clone();
+
+        std::thread::spawn(move || {
+            // We create the runtim as multithreaded, so you can still "spawn" onto multiple threads
+            let runtime = tokio::runtime::Builder::new_multi_thread()
+                .enable_all()
+                .build()
+                .unwrap();
+
+            runtime.block_on(async move {
+                // LocalSet::new().block_on(&runtime, async move {
+                let mut dom =
+                    VirtualDom::new_with_props_and_scheduler(root, props, sender, receiver);
+
+                let edits = dom.rebuild();
+
+                edit_queue
+                    .write()
+                    .unwrap()
+                    .push_front(serde_json::to_string(&edits.edits).unwrap());
+
+                loop {
+                    dom.wait_for_work().await;
+                    let mut muts = dom.work_with_deadline(|| false);
+                    while let Some(edit) = muts.pop() {
+                        log::debug!("found mutations {:?}", muts);
+                        edit_queue
+                            .write()
+                            .unwrap()
+                            .push_front(serde_json::to_string(&edit.edits).unwrap());
+                    }
+                }
+            })
+        });
+
+        Self {
+            pending_edits,
+            sender: return_sender,
+
+            webviews: HashMap::new(),
+            is_ready: Arc::new(AtomicBool::new(false)),
+            quit_app_on_close: true,
+        }
+    }
+
+    pub fn new_window(&mut self, cfg: &DesktopConfig, event_loop: &EventLoopWindowTarget<()>) {
+        let builder = cfg.window.clone().with_menu({
+            // create main menubar menu
+            let mut menu_bar_menu = MenuBar::new();
+
+            // create `first_menu`
+            let mut first_menu = MenuBar::new();
+
+            first_menu.add_native_item(MenuItem::About("Todos".to_string()));
+            first_menu.add_native_item(MenuItem::Services);
+            first_menu.add_native_item(MenuItem::Separator);
+            first_menu.add_native_item(MenuItem::Hide);
+            first_menu.add_native_item(MenuItem::HideOthers);
+            first_menu.add_native_item(MenuItem::ShowAll);
+
+            first_menu.add_native_item(MenuItem::Quit);
+            first_menu.add_native_item(MenuItem::CloseWindow);
+
+            // create second menu
+            let mut second_menu = MenuBar::new();
+
+            // second_menu.add_submenu("Sub menu", true, my_sub_menu);
+            second_menu.add_native_item(MenuItem::Copy);
+            second_menu.add_native_item(MenuItem::Paste);
+            second_menu.add_native_item(MenuItem::SelectAll);
+
+            menu_bar_menu.add_submenu("First menu", true, first_menu);
+            menu_bar_menu.add_submenu("Second menu", true, second_menu);
+
+            menu_bar_menu
+        });
+
+        let window = builder.build(event_loop).unwrap();
+        let window_id = window.id();
+
+        let (is_ready, sender) = (self.is_ready.clone(), self.sender.clone());
+
+        let webview = WebViewBuilder::new(window)
+            .unwrap()
+            .with_url("wry://index.html")
+            .unwrap()
+            .with_rpc_handler(move |_window: &Window, req: RpcRequest| {
+                match req.method.as_str() {
+                    "user_event" => {
+                        let event = events::trigger_from_serialized(req.params.unwrap());
+                        log::debug!("User event: {:?}", event);
+                        sender.unbounded_send(SchedulerMsg::UiEvent(event)).unwrap();
+                    }
+                    "initialize" => {
+                        is_ready.store(true, std::sync::atomic::Ordering::Relaxed);
+                    }
+                    _ => {}
+                }
+                // response always driven through eval.
+                // unfortunately, it seems to be pretty slow, so we might want to look into an RPC form
+                None
+            })
+            // Any content that that uses the `wry://` scheme will be shuttled through this handler as a "special case"
+            // For now, we only serve two pieces of content which get included as bytes into the final binary.
+            .with_custom_protocol("wry".into(), move |request| {
+                let path = request.uri().replace("wry://", "");
+                let (data, meta) = match path.as_str() {
+                    "index.html" => (include_bytes!("./index.html").to_vec(), "text/html"),
+                    "index.html/index.js" => {
+                        (include_bytes!("./index.js").to_vec(), "text/javascript")
+                    }
+                    _ => unimplemented!("path {}", path),
+                };
+
+                wry::http::ResponseBuilder::new().mimetype(meta).body(data)
+            })
             .build()
             .unwrap();
 
-        runtime.block_on(async move {
-            let mut dom = VirtualDom::new_with_props_and_scheduler(root, props, sender, receiver);
+        self.webviews.insert(window_id, webview);
+    }
 
-            let edits = dom.rebuild();
+    pub fn close_window(&mut self, window_id: WindowId, control_flow: &mut ControlFlow) {
+        self.webviews.remove(&window_id);
 
-            edit_queue
-                .write()
-                .unwrap()
-                .push_front(serde_json::to_string(&edits.edits).unwrap());
+        if self.webviews.is_empty() && self.quit_app_on_close {
+            *control_flow = ControlFlow::Exit;
+        }
+    }
 
-            loop {
-                dom.wait_for_work().await;
-                let mut muts = dom.work_with_deadline(|| false);
-                while let Some(edit) = muts.pop() {
-                    edit_queue
-                        .write()
-                        .unwrap()
-                        .push_front(serde_json::to_string(&edit.edits).unwrap());
-                }
+    pub fn try_load_ready_webviews(&mut self) {
+        if self.is_ready.load(std::sync::atomic::Ordering::Relaxed) {
+            let mut queue = self.pending_edits.write().unwrap();
+            let (_id, view) = self.webviews.iter_mut().next().unwrap();
+            while let Some(edit) = queue.pop_back() {
+                view.evaluate_script(&format!("window.interpreter.handleEdits({})", edit))
+                    .unwrap();
             }
-        })
-    });
-
-    return_sender
-}
-
-fn build_menu() -> MenuBar {
-    // create main menubar menu
-    let mut menu_bar_menu = MenuBar::new();
-
-    // create `first_menu`
-    let mut first_menu = MenuBar::new();
-
-    first_menu.add_native_item(MenuItem::About("Todos".to_string()));
-    first_menu.add_native_item(MenuItem::Services);
-    first_menu.add_native_item(MenuItem::Separator);
-    first_menu.add_native_item(MenuItem::Hide);
-    first_menu.add_native_item(MenuItem::HideOthers);
-    first_menu.add_native_item(MenuItem::ShowAll);
-
-    first_menu.add_native_item(MenuItem::Quit);
-    first_menu.add_native_item(MenuItem::CloseWindow);
-
-    // create second menu
-    let mut second_menu = MenuBar::new();
-
-    // second_menu.add_submenu("Sub menu", true, my_sub_menu);
-    second_menu.add_native_item(MenuItem::Copy);
-    second_menu.add_native_item(MenuItem::Paste);
-    second_menu.add_native_item(MenuItem::SelectAll);
-
-    menu_bar_menu.add_submenu("First menu", true, first_menu);
-    menu_bar_menu.add_submenu("Second menu", true, second_menu);
-
-    menu_bar_menu
-}
-
-fn create_window(event_loop: &EventLoopWindowTarget<()>, cfg: &WindowBuilder) -> Window {
-    let builder = cfg.clone().with_menu(build_menu());
-    builder.build(event_loop).unwrap()
-}
-
-fn create_webview(
-    window: Window,
-    is_ready: Arc<AtomicBool>,
-    sender: futures_channel::mpsc::UnboundedSender<SchedulerMsg>,
-) -> WebView {
-    WebViewBuilder::new(window)
-        .unwrap()
-        .with_url("wry://index.html")
-        .unwrap()
-        .with_rpc_handler(move |_window: &Window, mut req: RpcRequest| {
-            match req.method.as_str() {
-                "user_event" => {
-                    let event = events::trigger_from_serialized(req.params.unwrap());
-                    log::debug!("User event: {:?}", event);
-                    sender.unbounded_send(SchedulerMsg::UiEvent(event)).unwrap();
-                }
-                "initialize" => {
-                    is_ready.store(true, std::sync::atomic::Ordering::Relaxed);
-                }
-                _ => {}
-            }
-            // always driven through eval
-            None
-        })
-        // .with_initialization_script(include_str!("./index.js"))
-        // Any content that that uses the `wry://` scheme will be shuttled through this handler as a "special case"
-        // For now, we only serve two pieces of content which get included as bytes into the final binary.
-        .with_custom_protocol("wry".into(), move |request| {
-            let path = request.uri().replace("wry://", "");
-            let (data, meta) = match path.as_str() {
-                "index.html" => (include_bytes!("./index.html").to_vec(), "text/html"),
-                "index.html/index.js" => (include_bytes!("./index.js").to_vec(), "text/javascript"),
-                _ => unimplemented!("path {}", path),
-            };
-
-            wry::http::ResponseBuilder::new().mimetype(meta).body(data)
-        })
-        .build()
-        .unwrap()
+        }
+    }
 }