Feat: begin WIP on html macro

packages/core/src/changelist.rs

@@ -19,11 +19,9 @@
 //!
 //!
 
-
-
 use bumpalo::Bump;
 
-use crate::innerlude::{Listener};
+use crate::innerlude::Listener;
 
 /// The `Edit` represents a single modifcation of the renderer tree.
 ///
@@ -308,14 +306,19 @@ impl<'a> EditMachine<'a> {
         self.forcing_new_listeners = previous;
     }
 
-    pub fn new_event_listener(&mut self, _listener: &Listener) {
+    pub fn new_event_listener(&mut self, listener: &Listener) {
         debug_assert!(self.traversal_is_committed());
-        todo!("Event listener not wired up yet");
-        // debug!("emit: new_event_listener({:?})", listener);
-        // let (a, b) = listener.get_callback_parts();
-        // debug_assert!(a != 0);
+        // todo!("Event listener not wired up yet");
+        log::debug!("emit: new_event_listener({:?})", listener);
+        let (a, b) = listener.get_callback_parts();
+        debug_assert!(a != 0);
         // let event_id = self.ensure_string(listener.event);
-        // self.emitter.new_event_listener(event_id.into(), a, b);
+        self.emitter.push(Edit::NewEventListener {
+            event_type: listener.event.into(),
+            a,
+            b,
+        });
+        // self.emitter.new_event_listener(listener.event.into(), a, b);
     }
 
     pub fn update_event_listener(&mut self, listener: &Listener) {
@@ -326,19 +329,25 @@ impl<'a> EditMachine<'a> {
             return;
         }
 
-        // debug!("emit: update_event_listener({:?})", listener);
-        todo!("Event listener not wired up yet");
-        // let (a, b) = listener.get_callback_parts();
-        // debug_assert!(a != 0);
-        let _event_id = self.ensure_string(listener.event);
+        log::debug!("emit: update_event_listener({:?})", listener);
+        // todo!("Event listener not wired up yet");
+        let (a, b) = listener.get_callback_parts();
+        debug_assert!(a != 0);
+        self.emitter.push(Edit::UpdateEventListener {
+            event_type: listener.event.into(),
+            a,
+            b,
+        });
         // self.emitter.update_event_listener(event_id.into(), a, b);
     }
 
-    pub fn remove_event_listener(&mut self, event: &str) {
+    pub fn remove_event_listener(&mut self, event: &'a str) {
         debug_assert!(self.traversal_is_committed());
+        self.emitter
+            .push(Edit::RemoveEventListener { event_type: event });
         // debug!("emit: remove_event_listener({:?})", event);
-        let _event_id = self.ensure_string(event);
-        todo!("Event listener not wired up yet");
+        // let _event_id = self.ensure_string(event);
+        // todo!("Event listener not wired up yet");
         // self.emitter.remove_event_listener(event_id.into());
     }
 

packages/core/src/dodriodiff.rs

@@ -63,13 +63,9 @@ pub struct DiffMachine<'a> {
     need_to_diff: FxHashSet<Index>,
 }
 
-enum NeedToDiff {
-    PropsChanged,
-    Subscription,
-}
-
 impl<'a> DiffMachine<'a> {
     pub fn new(bump: &'a Bump) -> Self {
+        log::debug!("starsting diff machine");
         Self {
             change_list: EditMachine::new(bump),
             immediate_queue: Vec::new(),
@@ -83,6 +79,7 @@ impl<'a> DiffMachine<'a> {
     }
 
     pub fn diff_node(&mut self, old: &VNode<'a>, new: &VNode<'a>) {
+        log::debug!("Diffing nodes");
         /*
         For each valid case, we "commit traversal", meaning we save this current position in the tree.
         Then, we diff and queue an edit event (via chagelist). s single trees - when components show up, we save that traversal and then re-enter later.
@@ -876,6 +873,7 @@ impl<'a> DiffMachine<'a> {
                 children,
                 namespace,
             }) => {
+                log::info!("Creating {:#?}", node);
                 if let Some(namespace) = namespace {
                     self.change_list.create_element_ns(tag_name, namespace);
                 } else {
@@ -1001,7 +999,6 @@ enum KeyedPrefixResult {
 }
 
 mod support {
-    
 
     // // Get or create the template.
     // //

packages/core/src/events.rs

@@ -6,6 +6,7 @@
 //! The goal here is to provide a consistent event interface across all renderer types
 use generational_arena::Index;
 
+#[derive(Debug)]
 pub struct EventTrigger {
     pub component_id: Index,
     pub listener_id: u32,
@@ -18,6 +19,7 @@ impl EventTrigger {
     }
 }
 
+#[derive(Debug)]
 pub enum VirtualEvent {
     // Real events
     ClipboardEvent(ClipboardEvent),
@@ -42,19 +44,35 @@ pub enum VirtualEvent {
 
 // these should reference the underlying event
 
+#[derive(Debug)]
 pub struct ClipboardEvent {}
+#[derive(Debug)]
 pub struct CompositionEvent {}
+#[derive(Debug)]
 pub struct KeyboardEvent {}
+#[derive(Debug)]
 pub struct FocusEvent {}
+#[derive(Debug)]
 pub struct FormEvent {}
+#[derive(Debug)]
 pub struct GenericEvent {}
+#[derive(Debug)]
 pub struct MouseEvent {}
+#[derive(Debug)]
 pub struct PointerEvent {}
+#[derive(Debug)]
 pub struct SelectionEvent {}
+#[derive(Debug)]
 pub struct TouchEvent {}
+#[derive(Debug)]
 pub struct UIEvent {}
+#[derive(Debug)]
 pub struct WheelEvent {}
+#[derive(Debug)]
 pub struct MediaEvent {}
+#[derive(Debug)]
 pub struct ImageEvent {}
+#[derive(Debug)]
 pub struct AnimationEvent {}
+#[derive(Debug)]
 pub struct TransitionEvent {}

packages/core/src/nodebuilder.rs

@@ -1070,7 +1070,8 @@ pub fn attr<'a>(name: &'static str, value: &'a str) -> Attribute<'a> {
 ///     // do something when a click happens...
 /// });
 /// ```
-pub fn on<'a, 'b, F: 'static>(
+pub fn on<'a, 'b>(
+    // pub fn on<'a, 'b, F: 'static>(
     bump: &'a Bump,
     event: &'static str,
     callback: impl Fn(()) + 'a,

packages/core/src/nodes.rs

@@ -3,8 +3,6 @@
 //!
 //! These VNodes should be *very* cheap and *very* fast to construct - building a full tree should be insanely quick.
 
-
-
 use bumpalo::Bump;
 pub use vcomponent::VComponent;
 pub use velement::VElement;
@@ -97,7 +95,7 @@ mod vnode {
 
 mod velement {
     use super::*;
-    use std::{fmt::Debug};
+    use std::fmt::Debug;
 
     #[derive(Debug)]
     pub struct VElement<'a> {
@@ -199,6 +197,29 @@ mod velement {
                 .finish()
         }
     }
+    pub(crate) type ListenerCallback<'a> = &'a (dyn Fn(()));
+    union CallbackFatPtr<'a> {
+        callback: ListenerCallback<'a>,
+        parts: (u32, u32),
+    }
+    impl Listener<'_> {
+        #[inline]
+        pub(crate) fn get_callback_parts(&self) -> (u32, u32) {
+            assert_eq!(
+                std::mem::size_of::<ListenerCallback>(),
+                std::mem::size_of::<CallbackFatPtr>()
+            );
+
+            unsafe {
+                let fat = CallbackFatPtr {
+                    callback: self.callback,
+                };
+                let (a, b) = fat.parts;
+                debug_assert!(a != 0);
+                (a, b)
+            }
+        }
+    }
 
     /// The key for keyed children.
     ///
@@ -265,9 +286,7 @@ mod vtext {
 /// Only supports the functional syntax
 mod vcomponent {
     use crate::innerlude::FC;
-    use std::{marker::PhantomData};
-
-    
+    use std::marker::PhantomData;
 
     #[derive(Debug)]
     pub struct VComponent<'src> {

packages/core/src/scope.rs

@@ -219,10 +219,29 @@ impl ActiveFrame {
     }
 }
 
-#[cfg(test)]
+// #[cfg(test)]
 mod tests {
     use super::*;
 
+    static ListenerTest: FC<()> = |ctx, props| {
+        ctx.view(html! {
+            <div onclick={|_| println!("Hell owlrld")}>
+                "hello"
+            </div>
+        })
+    };
+
+    #[test]
+    fn check_listeners() -> Result<()> {
+        let mut scope = Scope::new::<(), ()>(ListenerTest, (), None);
+        scope.run::<()>();
+
+        let nodes = scope.new_frame();
+        dbg!(nodes);
+
+        Ok(())
+    }
+
     #[test]
     fn test_scope() {
         let example: FC<()> = |ctx, props| {