use crate::hydration::node_hydration_id;
use crate::resources::{
attach_element_events, bind_dynamic_attributes, dispose_region_effect,
own_region_effect_by_enclosing_effect, register_dynamic_region, release_dom_node_resources,
take_dynamic_region,
};
use krab_core::signal::{create_effect_scoped, EffectHandle};
use krab_core::Node;
use std::cell::{Cell, RefCell};
use std::collections::{HashMap, VecDeque};
use std::rc::Rc;
use wasm_bindgen::JsCast;
use web_sys::{console, Element, Node as WebNode};
pub(crate) fn replace_dom_node(parent: &WebNode, old: &WebNode, v_node: &Node, scope: &str) {
let Some(new_node) = create_dom_node(v_node) else {
return;
};
release_dom_node_resources(old);
if let Err(err) = parent.replace_child(&new_node, old) {
console::error_1(
&format!(
"{{\"scope\":\"{scope}\",\"detail\":\"replace_child failed\",\"error\":\"{err:?}\"}}"
)
.into(),
);
}
}
pub(crate) fn append_dom_node(parent: &WebNode, v_node: &Node, scope: &str) {
let Some(new_node) = create_dom_node(v_node) else {
return;
};
if let Err(err) = parent.append_child(&new_node) {
console::error_1(
&format!(
"{{\"scope\":\"{scope}\",\"detail\":\"append_child failed\",\"error\":\"{err:?}\"}}"
)
.into(),
);
}
}
#[derive(Clone)]
pub(crate) struct DynamicRegionCells {
pub(crate) rendered: Rc<RefCell<Vec<WebNode>>>,
pub(crate) current_vnode: Rc<RefCell<Option<Node>>>,
pub(crate) anchor: Rc<RefCell<Option<WebNode>>>,
pub(crate) empty_position: Rc<RefCell<Option<EmptyRunPosition>>>,
pub(crate) effect: Rc<RefCell<Option<EffectHandle>>>,
}
type EmptyRunPosition = (Element, Option<WebNode>);
pub(crate) fn update_dynamic_region(cells: &DynamicRegionCells, new_v_node: Node) {
let previous_nodes = cells.rendered.borrow().clone();
let previous_vnode = cells.current_vnode.borrow_mut().take();
let anchor_node = {
let existing = cells.anchor.borrow().clone();
match existing {
Some(anchor) => anchor,
None => {
let Some(document) = web_sys::window().and_then(|w| w.document()) else {
*cells.current_vnode.borrow_mut() = Some(new_v_node);
return;
};
let created: WebNode = document.create_comment("krab-dynamic").into();
let inserted = if let Some(last) = previous_nodes.last() {
last.parent_node().map(|parent| {
parent
.insert_before(&created, last.next_sibling().as_ref())
.is_ok()
})
} else if let Some((parent, next)) = cells.empty_position.borrow().as_ref() {
let next_ok = next
.as_ref()
.filter(|n| n.parent_node().as_deref() == Some(parent.as_ref()));
Some(parent.insert_before(&created, next_ok).is_ok())
} else {
None
};
match inserted {
Some(true) => {}
Some(false) => {
console::warn_1(
&"{\"scope\":\"dynamic_region\",\"detail\":\"anchor insert failed; region update skipped\"}"
.into(),
);
*cells.current_vnode.borrow_mut() = Some(new_v_node);
return;
}
None => {
*cells.current_vnode.borrow_mut() = Some(new_v_node);
return;
}
}
register_dynamic_region(&created, cells);
*cells.anchor.borrow_mut() = Some(created.clone());
created
}
}
};
let Some(parent) = anchor_node
.parent_node()
.and_then(|node| node.dyn_into::<Element>().ok())
else {
*cells.current_vnode.borrow_mut() = Some(new_v_node);
return;
};
let next = reconcile_range(
&parent,
previous_nodes,
previous_vnode.as_slice(),
std::slice::from_ref(&new_v_node),
Some(&anchor_node),
);
match next {
Some(nodes) => *cells.rendered.borrow_mut() = nodes,
None => {
let stale = std::mem::take(&mut *cells.rendered.borrow_mut());
for node in &stale {
remove_tracked_node(&parent, node);
}
let mut fresh_tracked = Vec::new();
for (insert, tracked) in create_run_nodes(&new_v_node) {
let _ = parent.insert_before(&insert, Some(&anchor_node));
fresh_tracked.push(tracked);
}
*cells.rendered.borrow_mut() = fresh_tracked;
}
}
*cells.current_vnode.borrow_mut() = Some(new_v_node);
}
fn patch_dom(
_parent: &WebNode,
real_node: &WebNode,
old_vnode: &Node,
new_vnode: &Node,
) -> Option<WebNode> {
match (old_vnode, new_vnode) {
(Node::Text(old_text), Node::Text(new_text)) => {
if old_text != new_text {
real_node.set_text_content(Some(new_text));
}
Some(real_node.clone())
}
(Node::Comment(old_text), Node::Comment(new_text)) => {
if old_text != new_text {
real_node.set_text_content(Some(new_text));
}
Some(real_node.clone())
}
(Node::Element(old_el), Node::Element(new_el)) if old_el.tag == new_el.tag => {
let el = real_node.dyn_ref::<Element>()?;
for old_attr in &old_el.attributes {
if !new_el.attributes.iter().any(|a| a.name == old_attr.name) {
let _ = el.remove_attribute(&old_attr.name);
}
}
for new_attr in new_el.attributes.iter().filter(|a| !a.is_dynamic()) {
let old_attr = old_el
.attributes
.iter()
.find(|a| a.name == new_attr.name && !a.is_dynamic());
if old_attr.map(|a| &a.value) != Some(&new_attr.value) {
let _ = el.set_attribute(&new_attr.name, &new_attr.value);
}
}
if old_el.attributes.iter().any(|a| a.is_dynamic())
|| new_el.attributes.iter().any(|a| a.is_dynamic())
{
bind_dynamic_attributes(el, new_el, false);
}
if !old_el.events.is_empty() || !new_el.events.is_empty() {
attach_element_events(el, new_el, "patch_dom");
}
patch_children(el, &old_el.children, &new_el.children)?;
Some(real_node.clone())
}
_ => None,
}
}
fn flatten_children<'a>(nodes: &'a [Node], out: &mut Vec<&'a Node>) {
for node in nodes {
match node {
Node::Fragment(children) => flatten_children(children, out),
other => out.push(other),
}
}
}
fn reconcile_key(node: &Node) -> Option<&str> {
node_hydration_id(node)
}
fn patch_children(el: &Element, old_children: &[Node], new_children: &[Node]) -> Option<()> {
let child_nodes = el.child_nodes();
let existing: Vec<WebNode> = (0..child_nodes.length())
.filter_map(|index| child_nodes.item(index))
.collect();
reconcile_range(el, existing, old_children, new_children, None).map(|_| ())
}
fn reconcile_range(
el: &Element,
existing_nodes: Vec<WebNode>,
old_children: &[Node],
new_children: &[Node],
anchor: Option<&WebNode>,
) -> Option<Vec<WebNode>> {
let mut old_flat: Vec<&Node> = Vec::new();
flatten_children(old_children, &mut old_flat);
let mut new_flat: Vec<&Node> = Vec::new();
flatten_children(new_children, &mut new_flat);
let mut existing: Vec<Option<WebNode>> = existing_nodes.into_iter().map(Some).collect();
if existing.len() != old_flat.len() {
return None;
}
let mut consumed = vec![false; existing.len()];
let mut placed: Vec<WebNode> = Vec::with_capacity(new_flat.len());
let mut keyed_sources: HashMap<&str, VecDeque<usize>> = HashMap::new();
for (index, old) in old_flat.iter().enumerate() {
if let Some(key) = reconcile_key(old) {
keyed_sources.entry(key).or_default().push_back(index);
}
}
let run_start: Option<WebNode> = existing
.first()
.and_then(|node| node.clone())
.or_else(|| anchor.cloned());
for (target_index, new_child) in new_flat.iter().enumerate() {
let keyed_source = reconcile_key(new_child)
.and_then(|key| keyed_sources.get_mut(key))
.and_then(VecDeque::pop_front);
let source_index = keyed_source.or_else(|| {
let positional = target_index;
let free = positional < consumed.len() && !consumed[positional];
let unkeyed = old_flat
.get(positional)
.is_some_and(|old| reconcile_key(old).is_none());
(free && unkeyed).then_some(positional)
});
match source_index {
Some(source) => {
consumed[source] = true;
let node = existing[source].clone()?;
if patch_dom(el, &node, old_flat[source], new_child).is_none() {
let (replacement, tracked) = create_tracked_child(new_child)?;
remove_region_content(el, &node);
release_dom_node_resources(&node);
el.replace_child(&replacement, &node).ok()?;
existing[source] = Some(tracked);
}
let node = existing[source].clone()?;
place_before(el, &node, placed.last(), run_start.as_ref());
placed.push(node);
}
None => {
let (created, tracked) = create_tracked_child(new_child)?;
place_before(el, &created, placed.last(), run_start.as_ref());
placed.push(tracked);
}
}
}
for (index, node) in existing.iter().enumerate() {
if consumed[index] {
continue;
}
if let Some(node) = node {
remove_tracked_node(el, node);
}
}
Some(placed)
}
fn place_before(
el: &Element,
node: &WebNode,
previous: Option<&WebNode>,
run_start: Option<&WebNode>,
) {
let target = match previous {
Some(previous) => previous.next_sibling(),
None => run_start.cloned().or_else(|| el.first_child()),
};
if target.as_ref() == Some(node) {
return;
}
let _ = el.insert_before(node, target.as_ref());
}
#[cfg(all(feature = "web", target_arch = "wasm32"))]
#[doc(hidden)]
pub fn build_dom_for_test(node: &Node) -> Option<WebNode> {
create_dom_node(node)
}
fn create_element_node(document: &web_sys::Document, el: &krab_core::Element) -> Option<WebNode> {
let element = match document.create_element(&el.tag) {
Ok(element) => element,
Err(err) => {
console::error_1(
&format!(
"{{\"scope\":\"create_dom_node\",\"detail\":\"create_element failed\",\"tag\":\"{}\",\"error\":\"{:?}\"}}",
el.tag, err
)
.into(),
);
return Some(document.create_comment("krab-create-element-error").into());
}
};
for attr in el.attributes.iter().filter(|a| !a.is_dynamic()) {
if let Err(err) = element.set_attribute(&attr.name, &attr.value) {
console::error_1(
&format!(
"{{\"scope\":\"create_dom_node\",\"detail\":\"set_attribute failed\",\"attribute\":\"{}\",\"error\":\"{:?}\"}}",
attr.name, err
)
.into(),
);
}
}
attach_element_events(&element, el, "create_dom_node");
bind_dynamic_attributes(&element, el, false);
for child in &el.children {
let Some(child_node) = create_dom_node(child) else {
continue;
};
if let Err(err) = element.append_child(&child_node) {
console::error_1(
&format!(
"{{\"scope\":\"create_dom_node\",\"detail\":\"append child failed\",\"error\":\"{err:?}\"}}"
)
.into(),
);
}
}
Some(element.into())
}
fn create_dom_node(v_node: &Node) -> Option<WebNode> {
let document = web_sys::window().and_then(|w| w.document())?;
match v_node {
Node::Element(el) => create_element_node(&document, el),
Node::Text(text) => Some(document.create_text_node(text).into()),
Node::Comment(text) => Some(document.create_comment(text).into()),
Node::Fragment(nodes) => {
let frag = document.create_document_fragment();
for node in nodes {
if let Some(child_node) = create_dom_node(node) {
if let Err(err) = frag.append_child(&child_node) {
console::error_1(
&format!(
"{{\"scope\":\"create_dom_node\",\"detail\":\"append fragment child failed\",\"error\":\"{:?}\"}}",
err
)
.into(),
);
}
}
}
Some(frag.into())
}
Node::Dynamic(f) => {
let anchor: WebNode = document.create_comment("krab-dynamic").into();
let cells = DynamicRegionCells {
rendered: Rc::new(RefCell::new(Vec::new())),
current_vnode: Rc::new(RefCell::new(None)),
anchor: Rc::new(RefCell::new(Some(anchor.clone()))),
empty_position: Rc::new(RefCell::new(None)),
effect: Rc::new(RefCell::new(None)),
};
register_dynamic_region(&anchor, &cells);
let f = f.clone();
let first_run = Rc::new(Cell::new(true));
let initial_inserts: Rc<RefCell<Vec<WebNode>>> = Rc::new(RefCell::new(Vec::new()));
let effect_cells = cells.clone();
let inserts_for_effect = initial_inserts.clone();
let handle = create_effect_scoped(move || {
let new_v_node = f();
if first_run.get() {
first_run.set(false);
let mut inserts = Vec::new();
let mut tracked = Vec::new();
for (insert, track) in create_run_nodes(&new_v_node) {
inserts.push(insert);
tracked.push(track);
}
*inserts_for_effect.borrow_mut() = inserts;
*effect_cells.rendered.borrow_mut() = tracked;
*effect_cells.current_vnode.borrow_mut() = Some(new_v_node);
return;
}
update_dynamic_region(&effect_cells, new_v_node);
});
*cells.effect.borrow_mut() = Some(handle);
own_region_effect_by_enclosing_effect(&cells);
let container = document.create_document_fragment();
for node in initial_inserts.borrow().iter() {
let _ = container.append_child(node);
}
let _ = container.append_child(&anchor);
Some(container.into())
}
}
}
fn create_tracked_child(new_child: &Node) -> Option<(WebNode, WebNode)> {
let created = create_dom_node(new_child)?;
let tracked = if matches!(new_child, Node::Dynamic(_)) {
created.last_child()?
} else {
created.clone()
};
Some((created, tracked))
}
fn create_run_nodes(node: &Node) -> Vec<(WebNode, WebNode)> {
let mut flat: Vec<&Node> = Vec::new();
flatten_children(std::slice::from_ref(node), &mut flat);
flat.iter()
.filter_map(|child| create_tracked_child(child))
.collect()
}
fn remove_region_content(el: &Element, node: &WebNode) {
let Some(region) = take_dynamic_region(node) else {
return;
};
dispose_region_effect(®ion);
for inner in region.rendered.borrow().iter() {
remove_tracked_node(el, inner);
}
}
fn remove_tracked_node(el: &Element, node: &WebNode) {
remove_region_content(el, node);
release_dom_node_resources(node);
let _ = el.remove_child(node);
}