fix native core, plasmo and dioxus-tui

packages/dioxus-tui/src/element.rs

@@ -3,45 +3,104 @@ use std::{
     fmt::{Display, Formatter},
 };
 
-use dioxus_core::{ElementId, Mutations, VirtualDom};
+use dioxus_core::{ElementId, WriteMutations};
 use dioxus_html::{
     geometry::euclid::{Point2D, Rect, Size2D},
     MountedData, MountedError, RenderedElementBacking,
 };
 
-use dioxus_native_core::NodeId;
+use dioxus_native_core::{dioxus::DioxusNativeCoreMutationWriter, NodeId};
 use plasmo::query::{ElementRef, Query};
 
-pub(crate) fn find_mount_events(mutations: &Mutations) -> Vec<ElementId> {
-    let mut mount_events = Vec::new();
-    for mutation in &mutations.edits {
-        if let dioxus_core::Mutation::NewEventListener {
-            name: "mounted",
-            id,
-        } = mutation
-        {
-            mount_events.push(*id);
-        }
-    }
-    mount_events
+pub(crate) struct DioxusTUIMutationWriter<'a> {
+    pub(crate) query: Query,
+    pub(crate) events: &'a mut Vec<(ElementId, &'static str, Box<dyn Any>, bool)>,
+    pub(crate) native_core_writer: DioxusNativeCoreMutationWriter<'a>,
 }
 
-// We need to queue the mounted events to give rink time to rendere and resolve the layout of elements after they are created
-pub(crate) fn create_mounted_events(
-    vdom: &VirtualDom,
-    events: &mut Vec<(ElementId, &'static str, Box<dyn Any>, bool)>,
-    mount_events: impl Iterator<Item = (ElementId, NodeId)>,
-) {
-    let query: Query = vdom
-        .base_scope()
-        .consume_context()
-        .expect("Query should be in context");
-    for (id, node_id) in mount_events {
-        let element = TuiElement {
-            query: query.clone(),
-            id: node_id,
-        };
-        events.push((id, "mounted", Box::new(MountedData::new(element)), false));
+impl WriteMutations for DioxusTUIMutationWriter<'_> {
+    fn register_template(&mut self, template: dioxus_core::prelude::Template) {
+        self.native_core_writer.register_template(template)
+    }
+
+    fn append_children(&mut self, id: ElementId, m: usize) {
+        self.native_core_writer.append_children(id, m)
+    }
+
+    fn assign_node_id(&mut self, path: &'static [u8], id: ElementId) {
+        self.native_core_writer.assign_node_id(path, id)
+    }
+
+    fn create_placeholder(&mut self, id: ElementId) {
+        self.native_core_writer.create_placeholder(id)
+    }
+
+    fn create_text_node(&mut self, value: &str, id: ElementId) {
+        self.native_core_writer.create_text_node(value, id)
+    }
+
+    fn hydrate_text_node(&mut self, path: &'static [u8], value: &str, id: ElementId) {
+        self.native_core_writer.hydrate_text_node(path, value, id)
+    }
+
+    fn load_template(&mut self, name: &'static str, index: usize, id: ElementId) {
+        self.native_core_writer.load_template(name, index, id)
+    }
+
+    fn replace_node_with(&mut self, id: ElementId, m: usize) {
+        self.native_core_writer.replace_node_with(id, m)
+    }
+
+    fn replace_placeholder_with_nodes(&mut self, path: &'static [u8], m: usize) {
+        self.native_core_writer
+            .replace_placeholder_with_nodes(path, m)
+    }
+
+    fn insert_nodes_after(&mut self, id: ElementId, m: usize) {
+        self.native_core_writer.insert_nodes_after(id, m)
+    }
+
+    fn insert_nodes_before(&mut self, id: ElementId, m: usize) {
+        self.native_core_writer.insert_nodes_before(id, m)
+    }
+
+    fn set_attribute(
+        &mut self,
+        name: &'static str,
+        ns: Option<&'static str>,
+        value: &dioxus_core::AttributeValue,
+        id: ElementId,
+    ) {
+        self.native_core_writer.set_attribute(name, ns, value, id)
+    }
+
+    fn set_node_text(&mut self, value: &str, id: ElementId) {
+        self.native_core_writer.set_node_text(value, id)
+    }
+
+    fn create_event_listener(&mut self, name: &'static str, id: ElementId) {
+        if name == "mounted" {
+            let element = TuiElement {
+                query: self.query.clone(),
+                id: self.native_core_writer.state.element_to_node_id(id),
+            };
+            self.events
+                .push((id, "mounted", Box::new(MountedData::new(element)), false));
+        } else {
+            self.native_core_writer.create_event_listener(name, id)
+        }
+    }
+
+    fn remove_event_listener(&mut self, name: &'static str, id: ElementId) {
+        self.native_core_writer.remove_event_listener(name, id)
+    }
+
+    fn remove_node(&mut self, id: ElementId) {
+        self.native_core_writer.remove_node(id)
+    }
+
+    fn push_root(&mut self, id: ElementId) {
+        self.native_core_writer.push_root(id)
     }
 }
 

packages/dioxus-tui/src/lib.rs

@@ -12,24 +12,20 @@ use std::{
     sync::{Arc, RwLock},
 };
 
-use dioxus_core::{Component, ElementId, VirtualDom};
+use dioxus_core::{Element, ElementId, ScopeId, VirtualDom};
 use dioxus_html::PlatformEventData;
 use dioxus_native_core::dioxus::{DioxusState, NodeImmutableDioxusExt};
 use dioxus_native_core::prelude::*;
 
-use element::{create_mounted_events, find_mount_events};
+use element::DioxusTUIMutationWriter;
 pub use plasmo::{query::Query, Config, RenderingMode, Size, TuiContext};
 use plasmo::{render, Driver};
 
-pub fn launch(app: Component<()>) {
+pub fn launch(app: fn() -> Element) {
     launch_cfg(app, Config::default())
 }
 
-pub fn launch_cfg(app: Component<()>, cfg: Config) {
-    launch_cfg_with_props(app, (), cfg);
-}
-
-pub fn launch_cfg_with_props<Props: 'static>(app: Component<Props>, props: Props, cfg: Config) {
+pub fn launch_cfg(app: fn() -> Element, cfg: Config) {
     dioxus_html::set_event_converter(Box::new(events::SerializedHtmlEventConverter));
 
     render(cfg, |rdom, taffy, event_tx| {
@@ -38,36 +34,16 @@ pub fn launch_cfg_with_props<Props: 'static>(app: Component<Props>, props: Props
             DioxusState::create(&mut rdom)
         };
         let dioxus_state = Rc::new(RwLock::new(dioxus_state));
-        let mut vdom = VirtualDom::new_with_props(app, props)
+        let mut vdom = VirtualDom::new(app)
             .with_root_context(TuiContext::new(event_tx))
             .with_root_context(Query::new(rdom.clone(), taffy.clone()))
             .with_root_context(DioxusElementToNodeId {
                 mapping: dioxus_state.clone(),
             });
-        let muts = vdom.rebuild();
 
-        let mut queued_events = Vec::new();
+        let queued_events = Vec::new();
 
-        {
-            let mut rdom = rdom.write().unwrap();
-            let mut dioxus_state = dioxus_state.write().unwrap();
-
-            // Find any mount events
-            let mounted = find_mount_events(&muts);
-
-            dioxus_state.apply_mutations(&mut rdom, muts);
-
-            // Send the mount events
-            create_mounted_events(
-                &vdom,
-                &mut queued_events,
-                mounted
-                    .iter()
-                    .map(|id| (*dbg!(id), dioxus_state.element_to_node_id(*id))),
-            );
-        }
-
-        DioxusRenderer {
+        let mut myself = DioxusRenderer {
             vdom,
             dioxus_state,
             queued_events,
@@ -80,7 +56,25 @@ pub fn launch_cfg_with_props<Props: 'static>(app: Component<Props>, props: Props
                 });
                 hot_reload_rx
             },
+        };
+
+        {
+            let mut rdom = rdom.write().unwrap();
+            let mut dioxus_state = myself.dioxus_state.write().unwrap();
+
+            let mut writer = DioxusTUIMutationWriter {
+                query: myself
+                    .vdom
+                    .in_runtime(|| ScopeId::ROOT.consume_context().unwrap()),
+                events: &mut myself.queued_events,
+                native_core_writer: dioxus_state.create_mutation_writer(&mut rdom),
+            };
+
+            // Find any mount events
+            myself.vdom.rebuild(&mut writer);
         }
+
+        myself
     })
     .unwrap();
 }
@@ -96,27 +90,19 @@ struct DioxusRenderer {
 
 impl Driver for DioxusRenderer {
     fn update(&mut self, rdom: &Arc<RwLock<RealDom>>) {
-        let muts = self.vdom.render_immediate();
-        {
-            let mut rdom = rdom.write().unwrap();
+        let mut rdom = rdom.write().unwrap();
+        let mut dioxus_state = self.dioxus_state.write().unwrap();
 
-            {
-                // Find any mount events
-                let mounted = find_mount_events(&muts);
+        let mut writer = DioxusTUIMutationWriter {
+            query: self
+                .vdom
+                .in_runtime(|| ScopeId::ROOT.consume_context().unwrap()),
+            events: &mut self.queued_events,
+            native_core_writer: dioxus_state.create_mutation_writer(&mut rdom),
+        };
 
-                let mut dioxus_state = self.dioxus_state.write().unwrap();
-                dioxus_state.apply_mutations(&mut rdom, muts);
-
-                // Send the mount events
-                create_mounted_events(
-                    &self.vdom,
-                    &mut self.queued_events,
-                    mounted
-                        .iter()
-                        .map(|id| (*id, dioxus_state.element_to_node_id(*id))),
-                );
-            }
-        }
+        // Find any mount events
+        self.vdom.render_immediate(&mut writer);
     }
 
     fn handle_event(