98 data phx ref support

crates/core/Cargo.toml

@@ -15,20 +15,12 @@ publish.workspace = true
 
 
 [lib]
-crate-type = [
-    "staticlib",
-    "rlib",
-    "cdylib"
-]
+crate-type = ["staticlib", "rlib", "cdylib"]
 name = "liveview_native_core"
 
 [features]
 default = ["liveview-channels-tls"]
-liveview-channels = [
-    "phoenix_channels_client",
-    "reqwest",
-    "uniffi/tokio",
-]
+liveview-channels = ["phoenix_channels_client", "reqwest", "uniffi/tokio"]
 liveview-channels-tls = [
     "liveview-channels",
     "reqwest/native-tls-vendored",
@@ -38,18 +30,21 @@ liveview-channels-tls = [
 
 # This is for support of phoenix-channnels-client in for wasm.
 browser = [
-#"liveview-channels",
-#"phoenix_channels_client/browser",
+    #"liveview-channels",
+    #"phoenix_channels_client/browser",
 ]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+futures = "0.3.31"
 cranelift-entity = { version = "0.114" }
 fixedbitset = { version = "0.4" }
 fxhash = { version = "0.2" }
 html5gum = { git = "https://github.com/liveviewnative/html5gum", branch = "lvn" }
-petgraph = { version = "0.6", default-features = false, features = ["graphmap"] }
+petgraph = { version = "0.6", default-features = false, features = [
+    "graphmap",
+] }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0" }
 smallstr = { version = "0.3", features = ["union"] }
@@ -69,7 +64,7 @@ Inflector = "0.11"
 paste = { version = "1.0" }
 pretty_assertions = { version = "1.4.0" }
 text-diff = { version = "0.4.0" }
-uniffi = { workspace = true, features = ["bindgen-tests", "tokio"]}
+uniffi = { workspace = true, features = ["bindgen-tests", "tokio"] }
 tokio = { version = "1.42", features = ["full"] }
 env_logger = "0.11.1"
 

crates/core/src/diff/patch.rs

@@ -1,5 +1,6 @@
 use super::traversal::MoveTo;
 use crate::dom::*;
+use crate::live_socket::dom_locking::*;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum Patch {
@@ -125,20 +126,31 @@ impl Patch {
     {
         match self {
             Self::InsertBefore { before, node: data } => {
-                let node = doc.insert_before(data.clone(), before);
-                let parent = doc
-                    .document()
-                    .parent(node)
-                    .expect("inserted node should have parent");
-                Some(PatchResult::Add { node, parent, data })
+                let d = doc.document();
+                let parent = d.parent(before).expect("inserted node should have parent");
+                let speculative = BeforePatch::Add { parent };
+
+                if doc.document().can_complete_change(&speculative) {
+                    let node = doc.insert_before(data.clone(), before);
+                    Some(PatchResult::Add { node, parent, data })
+                } else {
+                    None
+                }
             }
             Self::InsertAfter { after, node: data } => {
-                let node = doc.insert_after(data.clone(), after);
                 let parent = doc
                     .document()
-                    .parent(node)
+                    .parent(after)
                     .expect("inserted node should have parent");
-                Some(PatchResult::Add { node, parent, data })
+
+                let speculative = BeforePatch::Add { parent };
+
+                if doc.document().can_complete_change(&speculative) {
+                    let node = doc.insert_after(data.clone(), after);
+                    Some(PatchResult::Add { node, parent, data })
+                } else {
+                    None
+                }
             }
             Self::Create { node } => {
                 let node = doc.push_node(node);
@@ -183,11 +195,18 @@ impl Patch {
             }
             Self::PrependBefore { before } => {
                 let node = stack.pop().unwrap();
+
                 let d = doc.document_mut();
-                d.insert_before(node, before);
                 let parent = d.parent(before).expect("inserted node should have parent");
-                let data = d.get(node).clone();
-                Some(PatchResult::Add { node, parent, data })
+                let speculative = BeforePatch::Add { parent };
+
+                if d.can_complete_change(&speculative) {
+                    d.insert_before(node, before);
+                    let data = d.get(node).clone();
+                    Some(PatchResult::Add { node, parent, data })
+                } else {
+                    None
+                }
             }
             Self::Append { node: data } => {
                 let node = doc.append(data.clone());
@@ -198,62 +217,115 @@ impl Patch {
                 })
             }
             Self::AppendTo { parent, node: data } => {
-                let node = doc.append_child(parent, data.clone());
-                Some(PatchResult::Add { node, parent, data })
+                let speculative = BeforePatch::Add { parent };
+
+                if doc.document().can_complete_change(&speculative) {
+                    let node = doc.append_child(parent, data.clone());
+                    Some(PatchResult::Add { node, parent, data })
+                } else {
+                    None
+                }
             }
             Self::AppendAfter { after } => {
-                let node = stack.pop().unwrap();
                 let d = doc.document_mut();
-                d.insert_after(node, after);
                 let parent = d.parent(after).expect("inserted node should have parent");
-                let data = d.get(node).clone();
-                Some(PatchResult::Add { node, parent, data })
+
+                let speculative = BeforePatch::Add { parent };
+
+                if d.can_complete_change(&speculative) {
+                    let node = stack.pop().unwrap();
+                    d.insert_after(node, after);
+                    let data = d.get(node).clone();
+                    Some(PatchResult::Add { node, parent, data })
+                } else {
+                    None
+                }
             }
             Self::Remove { node } => {
                 let data = doc.document().get(node).clone();
                 let parent = doc.document_mut().parent(node);
-                doc.remove(node);
-                parent.map(|parent| PatchResult::Remove { node, parent, data })
+
+                let speculative = BeforePatch::Remove { node };
+                if doc.document().can_complete_change(&speculative) {
+                    doc.remove(node);
+                    parent.map(|parent| PatchResult::Remove { node, parent, data })
+                } else {
+                    None
+                }
             }
             Self::Replace { node, replacement } => {
                 let data = doc.document().get(node).clone();
                 let parent = doc.document_mut().parent(node)?;
-                doc.replace(node, replacement);
-                Some(PatchResult::Replace { node, parent, data })
+
+                let speculative = BeforePatch::Replace { node };
+
+                if doc.document().can_complete_change(&speculative) {
+                    doc.replace(node, replacement);
+                    Some(PatchResult::Replace { node, parent, data })
+                } else {
+                    None
+                }
             }
             Self::AddAttribute { name, value } => {
                 doc.set_attribute(name, value);
                 let node = doc.insertion_point();
-                let data = doc.document().get(node).clone();
-                Some(PatchResult::Change { node, data })
+
+                let speculative = BeforePatch::Change { node };
+
+                if doc.document().can_complete_change(&speculative) {
+                    let data = doc.document().get(node).clone();
+                    Some(PatchResult::Change { node, data })
+                } else {
+                    None
+                }
             }
             Self::AddAttributeTo { node, name, value } => {
-                let data = doc.document().get(node).clone();
-                let mut guard = doc.insert_guard();
-                guard.set_insertion_point(node);
-                guard.set_attribute(name, value);
-                Some(PatchResult::Change { node, data })
+                let speculative = BeforePatch::Change { node };
+                if doc.document().can_complete_change(&speculative) {
+                    let data = doc.document().get(node).clone();
+                    let mut guard = doc.insert_guard();
+                    guard.set_insertion_point(node);
+                    guard.set_attribute(name, value);
+                    Some(PatchResult::Change { node, data })
+                } else {
+                    None
+                }
             }
             Self::UpdateAttribute { node, name, value } => {
-                let data = doc.document().get(node).clone();
-                let mut guard = doc.insert_guard();
-                guard.set_insertion_point(node);
-                guard.set_attribute(name, value);
-                Some(PatchResult::Change { node, data })
+                let speculative = BeforePatch::Change { node };
+                if doc.document().can_complete_change(&speculative) {
+                    let data = doc.document().get(node).clone();
+                    let mut guard = doc.insert_guard();
+                    guard.set_insertion_point(node);
+                    guard.set_attribute(name, value);
+                    Some(PatchResult::Change { node, data })
+                } else {
+                    None
+                }
             }
             Self::RemoveAttributeByName { node, name } => {
-                let data = doc.document().get(node).clone();
-                let mut guard = doc.insert_guard();
-                guard.set_insertion_point(node);
-                guard.remove_attribute(name);
-                Some(PatchResult::Change { node, data })
+                let speculative = BeforePatch::Change { node };
+                if doc.document().can_complete_change(&speculative) {
+                    let data = doc.document().get(node).clone();
+                    let mut guard = doc.insert_guard();
+                    guard.set_insertion_point(node);
+                    guard.remove_attribute(name);
+                    Some(PatchResult::Change { node, data })
+                } else {
+                    None
+                }
             }
             Self::SetAttributes { node, attributes } => {
-                let data = doc.document().get(node).clone();
-                let mut guard = doc.insert_guard();
-                guard.set_insertion_point(node);
-                guard.replace_attributes(attributes);
-                Some(PatchResult::Change { node, data })
+                let speculative = BeforePatch::Change { node };
+                if doc.document().can_complete_change(&speculative) {
+                    let data = doc.document().get(node).clone();
+                    let mut guard = doc.insert_guard();
+                    guard.set_insertion_point(node);
+                    guard.replace_attributes(attributes);
+                    Some(PatchResult::Change { node, data })
+                } else {
+                    None
+                }
             }
             Self::Move(MoveTo::Node(node)) => {
                 doc.set_insertion_point(node);

crates/core/src/dom/attribute.rs

@@ -4,13 +4,36 @@ use smallstr::SmallString;
 
 use crate::InternedString;
 
+#[macro_export]
+macro_rules! attr {
+    ($name:literal) => {
+        Attribute::new($name, None)
+    };
+    ($name:literal= $value:expr) => {
+        Attribute::new($name, Some($value.to_string()))
+    };
+    ($namespace:literal : $name:literal) => {
+        Attribute {
+            name: AttributeName::new_with_namespace($namespace, $name),
+            value: None,
+        }
+    };
+    ($namespace:literal : $name:literal = $value:expr) => {
+        Attribute {
+            name: AttributeName::new_with_namespace($namespace, $name),
+            value: Some($value.to_string()),
+        }
+    };
+}
+
 /// Represents the fully-qualified name of an attribute
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, uniffi::Record)]
 pub struct AttributeName {
     /// This is used by svg attributes, e.g. `xlink-href`
     pub namespace: Option<String>,
     pub name: String,
 }
+
 impl fmt::Display for AttributeName {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         if let Some(ref ns) = self.namespace {
@@ -62,6 +85,7 @@ pub struct Attribute {
     pub name: AttributeName,
     pub value: Option<String>,
 }
+
 impl Attribute {
     /// Creates a new attribute with the given name and value
     ///