use wasm_bindgen::prelude::*;
#[cfg(any(feature = "web", test))]
use krab_core::Node;
#[cfg(any(feature = "web", feature = "debug"))]
use web_sys::console;
#[cfg(feature = "web")]
use crate::reconcile::{
append_dom_node, replace_dom_node, update_dynamic_region, DynamicRegionCells,
};
#[cfg(feature = "web")]
use crate::resources::{
attach_element_events, bind_dynamic_attributes, own_region_effect_by_enclosing_effect,
release_dom_node_resources,
};
#[cfg(feature = "web")]
use crate::{ComponentFactory, IslandDefinition};
#[cfg(feature = "web")]
use krab_core::signal::create_effect_scoped;
#[cfg(feature = "web")]
use std::cell::{Cell, RefCell};
#[cfg(feature = "web")]
use std::collections::HashMap;
#[cfg(feature = "web")]
use std::rc::Rc;
#[cfg(feature = "web")]
use wasm_bindgen::JsCast;
#[cfg(feature = "web")]
use web_sys::{Element, Node as WebNode, NodeList};
#[cfg(all(feature = "web", not(target_arch = "wasm32")))]
use std::panic::{catch_unwind, AssertUnwindSafe};
#[cfg(feature = "web")]
const BOUNDARY_STATE_ATTR: &str = "data-krab-boundary-state";
#[cfg(feature = "web")]
const BOUNDARY_STATE_SSR: &str = "ssr";
#[cfg(feature = "web")]
fn boundary_is_hydrated(element: &Element) -> bool {
element
.get_attribute(BOUNDARY_STATE_ATTR)
.is_some_and(|state| state != BOUNDARY_STATE_SSR)
}
#[cfg(any(feature = "web", test))]
fn node_attribute_value<'a>(node: &'a Node, name: &str) -> Option<&'a str> {
let Node::Element(element) = node else {
return None;
};
element
.attributes
.iter()
.find(|attr| attr.name == name)
.map(|attr| attr.value.as_str())
}
#[cfg(any(feature = "web", test))]
fn boundary_state_from_factory_node(node: &Node) -> Option<&str> {
node_attribute_value(node, "data-krab-boundary-state")
}
#[cfg(feature = "web")]
pub(crate) fn node_hydration_id(node: &Node) -> Option<&str> {
node_attribute_value(node, krab_core::HYDRATION_NODE_ID_ATTR)
}
#[cfg(any(feature = "web", test))]
fn classify_boundary_state(factory_state: Option<&str>, mismatch_count: u32) -> &'static str {
match factory_state {
Some("decode-error") => "decode-error",
Some("error") => "error",
_ if mismatch_count > 0 => "patched",
_ => "ok",
}
}
#[cfg(feature = "web")]
#[derive(Debug, Clone)]
struct HydrationBoundary {
island: String,
id: String,
}
#[cfg(feature = "web")]
#[derive(Debug, Clone, Copy, Default)]
struct HydrationStats {
consumed: u32,
replacements: u32,
appends: u32,
removals: u32,
reorders: u32,
text_patches: u32,
marker_mismatches: u32,
}
#[cfg(feature = "web")]
impl HydrationStats {
fn with_consumed(mut self, consumed: u32) -> Self {
self.consumed = consumed;
self
}
fn merge(&mut self, other: Self) {
self.consumed += other.consumed;
self.replacements += other.replacements;
self.appends += other.appends;
self.removals += other.removals;
self.reorders += other.reorders;
self.text_patches += other.text_patches;
self.marker_mismatches += other.marker_mismatches;
}
fn mismatch_count(self) -> u32 {
self.replacements
+ self.appends
+ self.removals
+ self.reorders
+ self.text_patches
+ self.marker_mismatches
}
}
#[cfg(feature = "web")]
pub fn log_hydration_diagnostic(scope: &str, name: &str, detail: &str) {
let payload = serde_json::json!({
"scope": scope,
"island": name,
"detail": detail,
})
.to_string();
console::error_1(&payload.into());
}
#[cfg(feature = "web")]
fn log_hydration_boundary_diagnostic(
level: &str,
scope: &str,
boundary: &HydrationBoundary,
reason: &str,
detail: &str,
path: Option<&str>,
) {
let payload = serde_json::json!({
"scope": scope,
"island": boundary.island,
"boundary_id": boundary.id,
"reason": reason,
"detail": detail,
"path": path,
})
.to_string();
match level {
"error" => console::error_1(&payload.into()),
_ => console::warn_1(&payload.into()),
}
}
#[cfg(feature = "web")]
fn describe_dom_node(node: &WebNode) -> String {
if node.node_type() == 3 {
return format!("#text({})", node.text_content().unwrap_or_default());
}
if let Some(element) = node.dyn_ref::<Element>() {
return format!("<{}>", element.tag_name().to_lowercase());
}
format!("node_type:{}", node.node_type())
}
#[cfg(feature = "web")]
fn dom_hydration_id(node: &WebNode) -> Option<String> {
node.dyn_ref::<Element>()
.and_then(|element| element.get_attribute(krab_core::HYDRATION_NODE_ID_ATTR))
}
#[cfg(feature = "web")]
fn child_path(parent_path: &str, child_index: usize) -> String {
if parent_path.is_empty() {
child_index.to_string()
} else {
format!("{parent_path}.{child_index}")
}
}
#[cfg(feature = "web")]
fn extra_dom_path(parent_path: &str, child_index: u32) -> String {
if parent_path.is_empty() {
format!("extra@{child_index}")
} else {
format!("{parent_path}.extra@{child_index}")
}
}
#[cfg(feature = "web")]
fn find_dom_node_with_hydration_id(
node_list: &NodeList,
start_index: u32,
expected_id: &str,
) -> Option<u32> {
(start_index..node_list.length()).find(|index| {
node_list
.item(*index)
.and_then(|node| dom_hydration_id(&node))
.as_deref()
== Some(expected_id)
})
}
#[cfg(feature = "web")]
fn realign_node_by_hydration_id(
parent: &WebNode,
node_list: &NodeList,
index: u32,
expected_id: &str,
boundary: &HydrationBoundary,
path: &str,
) -> (Option<WebNode>, HydrationStats) {
let current_node = node_list.item(index);
if current_node.as_ref().and_then(dom_hydration_id).as_deref() == Some(expected_id) {
return (current_node, HydrationStats::default());
}
if let Some(found_index) = find_dom_node_with_hydration_id(node_list, index + 1, expected_id) {
let Some(found_node) = node_list.item(found_index) else {
return (current_node, HydrationStats::default());
};
if let Err(err) = parent.insert_before(&found_node, current_node.as_ref()) {
console::error_1(
&format!(
"{{\"scope\":\"hydrate_recursive\",\"detail\":\"insert_before failed\",\"error\":\"{:?}\"}}",
err
)
.into(),
);
return (current_node, HydrationStats::default());
}
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"marker_reordered_dom_node",
&format!(
"moved node with hydration marker {} from DOM index {} to {}",
expected_id, found_index, index
),
Some(path),
);
return (
Some(found_node),
HydrationStats {
reorders: 1,
..HydrationStats::default()
},
);
}
if let Some(current_node) = current_node {
if let Some(actual_id) = dom_hydration_id(¤t_node) {
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"element_marker_mismatch",
&format!(
"expected hydration marker {} but found {} at DOM index {}",
expected_id, actual_id, index
),
Some(path),
);
return (
Some(current_node),
HydrationStats {
marker_mismatches: 1,
..HydrationStats::default()
},
);
}
}
(node_list.item(index), HydrationStats::default())
}
#[cfg(feature = "web")]
fn island_factories() -> HashMap<&'static str, ComponentFactory> {
inventory::iter::<IslandDefinition>
.into_iter()
.map(|definition| (definition.name, definition.factory))
.collect()
}
#[cfg(feature = "web")]
const FALLBACK_HTML: &str = "<div role=\"alert\">Hydration fallback rendered.</div>";
#[cfg(feature = "web")]
fn hydrate_boundary(
element: &Element,
ordinal: u32,
factories: &HashMap<&'static str, ComponentFactory>,
) {
if boundary_is_hydrated(element) {
return;
}
let Some(name) = element.get_attribute("data-island") else {
console::warn_1(&format!("Island element at index {ordinal} missing data-island").into());
return;
};
let boundary_id_attr = element.get_attribute("data-krab-boundary-id");
let boundary = HydrationBoundary {
island: name.clone(),
id: boundary_id_attr
.clone()
.unwrap_or_else(|| format!("{name}:legacy-{ordinal}")),
};
if boundary_id_attr.is_none() {
log_hydration_boundary_diagnostic(
"warn",
"hydrate",
&boundary,
"missing_boundary_id",
"server markup missing data-krab-boundary-id; using DOM index fallback",
None,
);
}
let _ = element.set_attribute("data-krab-boundary", &boundary.island);
let _ = element.set_attribute("data-krab-boundary-id", &boundary.id);
let _ = element.set_attribute("data-krab-boundary-mismatches", "0");
let _ = element.set_attribute(BOUNDARY_STATE_ATTR, "hydrating");
let props_json = element
.get_attribute("data-props")
.unwrap_or_else(|| "{}".to_string());
let Some(factory) = factories.get(name.as_str()).copied() else {
let _ = element.set_attribute(BOUNDARY_STATE_ATTR, "missing-definition");
log_hydration_boundary_diagnostic(
"error",
"hydrate",
&boundary,
"missing_island_definition",
"no registered island definition found",
None,
);
return;
};
#[cfg(feature = "debug")]
console::log_1(&format!("Hydrating island: {name}").into());
#[cfg(target_arch = "wasm32")]
let node = factory(props_json);
#[cfg(not(target_arch = "wasm32"))]
let Ok(node) = catch_unwind(AssertUnwindSafe(|| factory(props_json))) else {
log_hydration_boundary_diagnostic(
"error",
"hydrate",
&boundary,
"factory_panic",
"factory panic captured",
None,
);
let _ = element.set_attribute(BOUNDARY_STATE_ATTR, "error");
element.set_inner_html(FALLBACK_HTML);
return;
};
let node = krab_core::annotate_hydration_tree(node, &boundary.id);
let factory_state = boundary_state_from_factory_node(&node);
let stats = hydrate_node(WebNode::from(element.clone()), &node, &boundary);
let mismatch_count = stats.mismatch_count();
let _ = element.set_attribute("data-krab-boundary-mismatches", &mismatch_count.to_string());
let _ = element.set_attribute(
BOUNDARY_STATE_ATTR,
classify_boundary_state(factory_state, mismatch_count),
);
if mismatch_count > 0 {
log_hydration_boundary_diagnostic(
"warn",
"hydrate",
&boundary,
"boundary_patched",
&format!(
"patched DOM during hydration (replacements={}, appends={}, removals={}, reorders={}, text_patches={})",
stats.replacements,
stats.appends,
stats.removals,
stats.reorders,
stats.text_patches
),
None,
);
}
}
#[cfg(feature = "web")]
#[wasm_bindgen(js_name = hydrate_within)]
pub fn hydrate_within(root: &web_sys::Element) {
let mut pass = HydrationPass::new();
hydrate_subtree(&mut pass, root);
}
#[cfg(feature = "web")]
#[wasm_bindgen(js_name = hydrate_island)]
pub fn hydrate_island(element: &web_sys::Element) -> Option<String> {
if !element.has_attribute("data-island") {
return None;
}
let mut pass = HydrationPass::new();
pass.hydrate(element);
element.get_attribute(BOUNDARY_STATE_ATTR)
}
#[cfg(feature = "web")]
#[wasm_bindgen(js_name = hydrate_within_selector)]
pub fn hydrate_within_selector(selector: &str) -> u32 {
let Some(document) = web_sys::window().and_then(|window| window.document()) else {
console::error_1(&"{\"scope\":\"hydrate\",\"detail\":\"missing document\"}".into());
return 0;
};
let matches = match document.query_selector_all(selector) {
Ok(matches) => matches,
Err(err) => {
log_hydration_diagnostic(
"hydrate",
"",
&format!("invalid selector {selector:?}: {err:?}"),
);
return 0;
}
};
let mut pass = HydrationPass::new();
for index in 0..matches.length() {
let Some(element) = matches
.item(index)
.and_then(|node| node.dyn_into::<Element>().ok())
else {
continue;
};
if !element.is_connected() {
continue;
}
hydrate_subtree(&mut pass, &element);
}
pass.failed
}
#[cfg(feature = "web")]
fn hydrate_subtree(pass: &mut HydrationPass, root: &Element) {
if root.has_attribute("data-island") {
pass.hydrate(root);
}
let islands = match root.query_selector_all("[data-island]") {
Ok(nodes) => nodes,
Err(err) => {
console::error_1(
&format!(
"{{\"scope\":\"hydrate\",\"detail\":\"query_selector_all failed\",\"error\":\"{err:?}\"}}"
)
.into(),
);
return;
}
};
for index in 0..islands.length() {
let Some(node) = islands.item(index) else {
console::warn_1(&format!("Missing island element at index {index}").into());
continue;
};
let Ok(element) = node.dyn_into::<Element>() else {
console::warn_1(&format!("Island node at index {index} is not an Element").into());
continue;
};
if !root.contains(Some(element.as_ref())) {
continue;
}
pass.hydrate(&element);
}
}
#[cfg(feature = "web")]
struct HydrationPass {
next_ordinal: u32,
failed: u32,
#[cfg(not(target_arch = "wasm32"))]
factories: HashMap<&'static str, ComponentFactory>,
#[cfg(target_arch = "wasm32")]
ordinal: Rc<Cell<u32>>,
#[cfg(target_arch = "wasm32")]
entry: Closure<dyn FnMut(Element)>,
}
#[cfg(feature = "web")]
impl HydrationPass {
fn new() -> Self {
let factories = island_factories();
#[cfg(target_arch = "wasm32")]
let ordinal = Rc::new(Cell::new(0u32));
#[cfg(target_arch = "wasm32")]
let entry = {
let ordinal = ordinal.clone();
Closure::<dyn FnMut(Element)>::new(move |element: Element| {
hydrate_boundary(&element, ordinal.get(), &factories);
})
};
Self {
next_ordinal: 0,
failed: 0,
#[cfg(not(target_arch = "wasm32"))]
factories,
#[cfg(target_arch = "wasm32")]
ordinal,
#[cfg(target_arch = "wasm32")]
entry,
}
}
fn hydrate(&mut self, element: &Element) {
let ordinal = self.next_ordinal;
self.next_ordinal += 1;
let already_claimed = boundary_is_hydrated(element);
#[cfg(target_arch = "wasm32")]
{
self.ordinal.set(ordinal);
let snapshot = krab_core::signal::snapshot_reactive_state();
if let Err(message) = crate::isolation::call_isolated(&self.entry, element) {
restore_after_trap(snapshot, element, ordinal);
contain_failed_boundary(element, ordinal, &message);
}
}
#[cfg(not(target_arch = "wasm32"))]
hydrate_boundary(element, ordinal, &self.factories);
if !already_claimed
&& element.get_attribute(BOUNDARY_STATE_ATTR).as_deref() == Some("error")
{
self.failed += 1;
}
}
}
#[cfg(all(feature = "web", target_arch = "wasm32"))]
fn contain_failed_boundary(element: &Element, ordinal: u32, message: &str) {
let _ = element.set_attribute(BOUNDARY_STATE_ATTR, "error");
let island = element.get_attribute("data-island").unwrap_or_default();
let boundary = HydrationBoundary {
id: element
.get_attribute("data-krab-boundary-id")
.unwrap_or_else(|| format!("{island}:legacy-{ordinal}")),
island,
};
log_hydration_boundary_diagnostic("error", "hydrate", &boundary, "island_panic", message, None);
let stale = element.child_nodes();
let stale: Vec<WebNode> = (0..stale.length())
.filter_map(|index| stale.item(index))
.collect();
element.set_inner_html(FALLBACK_HTML);
let snapshot = krab_core::signal::snapshot_reactive_state();
let release = Closure::<dyn FnMut(Element)>::new(move |_: Element| {
for node in &stale {
release_dom_node_resources(node);
}
});
if let Err(message) = crate::isolation::call_isolated(&release, element) {
restore_after_trap(snapshot, element, ordinal);
log_hydration_boundary_diagnostic(
"error",
"hydrate",
&boundary,
"island_cleanup_panic",
&message,
None,
);
}
}
#[cfg(all(feature = "web", target_arch = "wasm32"))]
fn restore_after_trap(
snapshot: krab_core::signal::ReactiveSnapshot,
element: &Element,
ordinal: u32,
) {
if krab_core::signal::restore_reactive_state(snapshot) {
return;
}
let island = element.get_attribute("data-island").unwrap_or_default();
let boundary = HydrationBoundary {
id: element
.get_attribute("data-krab-boundary-id")
.unwrap_or_else(|| format!("{island}:legacy-{ordinal}")),
island,
};
log_hydration_boundary_diagnostic(
"error",
"hydrate",
&boundary,
"reactive_state_unrecoverable",
"a trap left the reactive runtime's state borrowed; it could not be restored",
None,
);
}
#[cfg(feature = "web")]
#[wasm_bindgen(js_name = unmount)]
pub fn unmount(root: &web_sys::Element) {
release_dom_node_resources(root.as_ref());
let _ = root.remove_attribute(BOUNDARY_STATE_ATTR);
let Ok(boundaries) = root.query_selector_all(&format!("[{BOUNDARY_STATE_ATTR}]")) else {
return;
};
for index in 0..boundaries.length() {
let Some(element) = boundaries
.item(index)
.and_then(|node| node.dyn_into::<Element>().ok())
else {
continue;
};
let _ = element.remove_attribute(BOUNDARY_STATE_ATTR);
}
}
#[wasm_bindgen]
pub fn hydrate() {
#[cfg(feature = "debug")]
console::log_1(&"Hydrating Krab app...".into());
#[cfg(feature = "web")]
{
let Some(window) = web_sys::window() else {
console::error_1(&"{\"scope\":\"hydrate\",\"detail\":\"missing window\"}".into());
return;
};
let Some(document) = window.document() else {
console::error_1(&"{\"scope\":\"hydrate\",\"detail\":\"missing document\"}".into());
return;
};
let Some(root) = document.document_element() else {
console::error_1(
&"{\"scope\":\"hydrate\",\"detail\":\"missing document element\"}".into(),
);
return;
};
install_suspense_listener(&document);
hydrate_within(&root);
}
}
#[cfg(feature = "web")]
type DocumentListener = Closure<dyn FnMut(web_sys::Event)>;
#[cfg(feature = "web")]
type ElementHook = fn(&Element);
#[cfg(feature = "web")]
thread_local! {
static SUSPENSE_LISTENER: RefCell<Vec<DocumentListener>> = const { RefCell::new(Vec::new()) };
}
#[cfg(feature = "web")]
fn install_suspense_listener(document: &web_sys::Document) {
SUSPENSE_LISTENER.with(|slot| {
if !slot.borrow().is_empty() {
return;
}
let listeners: [(&str, ElementHook); 2] = [
("krab:suspense-resolving", unmount),
("krab:suspense-resolved", hydrate_within),
];
for (name, apply) in listeners {
let closure =
Closure::<dyn FnMut(web_sys::Event)>::new(move |event: web_sys::Event| {
for element in suspense_event_elements(&event) {
if element.is_connected() {
apply(&element);
}
}
});
match document.add_event_listener_with_callback(name, closure.as_ref().unchecked_ref())
{
Ok(()) => slot.borrow_mut().push(closure),
Err(err) => log_hydration_diagnostic(
"hydrate",
"",
&format!("could not listen for {name}: {err:?}"),
),
}
}
});
}
#[cfg(feature = "web")]
fn suspense_event_elements(event: &web_sys::Event) -> Vec<Element> {
let nodes = js_sys::Reflect::get(event, &JsValue::from_str("detail"))
.and_then(|detail| js_sys::Reflect::get(&detail, &JsValue::from_str("nodes")))
.unwrap_or(JsValue::UNDEFINED);
if !js_sys::Array::is_array(&nodes) {
return Vec::new();
}
js_sys::Array::from(&nodes)
.iter()
.filter_map(|node| node.dyn_into::<Element>().ok())
.collect()
}
#[cfg(feature = "web")]
fn hydrate_node(real_node: WebNode, v_node: &Node, boundary: &HydrationBoundary) -> HydrationStats {
hydrate_children(&real_node, std::slice::from_ref(v_node), boundary, "")
}
#[cfg(feature = "web")]
fn hydrate_children(
parent: &WebNode,
v_nodes: &[Node],
boundary: &HydrationBoundary,
parent_path: &str,
) -> HydrationStats {
let child_nodes = parent.child_nodes();
let mut dom_index = 0;
let mut stats = HydrationStats::default();
for (child_index, v_node) in v_nodes.iter().enumerate() {
let path = child_path(parent_path, child_index);
let child_stats =
hydrate_recursive(parent, &child_nodes, dom_index, v_node, boundary, &path);
dom_index += child_stats.consumed;
stats.merge(child_stats);
}
while child_nodes.length() > dom_index {
let Some(extra_node) = child_nodes.item(dom_index) else {
break;
};
let path = extra_dom_path(parent_path, dom_index);
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"unexpected_dom_node",
"removing extra DOM node that was not present in the expected tree",
Some(&path),
);
release_dom_node_resources(&extra_node);
if let Err(err) = parent.remove_child(&extra_node) {
console::error_1(
&format!(
"{{\"scope\":\"hydrate_recursive\",\"detail\":\"remove_child failed\",\"error\":\"{:?}\"}}",
err
)
.into(),
);
break;
}
stats.removals += 1;
}
stats
}
#[cfg(feature = "web")]
fn hydrate_element(
parent: &WebNode,
node_list: &NodeList,
index: u32,
v_node: &Node,
v_el: &krab_core::Element,
boundary: &HydrationBoundary,
path: &str,
) -> HydrationStats {
let (aligned_node_opt, alignment_stats) = match node_hydration_id(v_node) {
Some(expected_id) => {
realign_node_by_hydration_id(parent, node_list, index, expected_id, boundary, path)
}
None => (node_list.item(index), HydrationStats::default()),
};
let Some(real_node) = aligned_node_opt else {
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"missing_dom_node",
&format!(
"expected <{}> but DOM child was missing; appending",
v_el.tag
),
Some(path),
);
append_dom_node(parent, v_node, "hydrate_recursive");
let mut stats = HydrationStats {
consumed: 1,
appends: 1,
..HydrationStats::default()
};
stats.merge(alignment_stats);
return stats;
};
let matching_el = real_node
.dyn_ref::<Element>()
.filter(|real_el| real_el.tag_name().eq_ignore_ascii_case(&v_el.tag));
if let Some(real_el) = matching_el {
attach_element_events(real_el, v_el, "hydrate_recursive");
bind_dynamic_attributes(real_el, v_el, true);
if v_el.tag.eq_ignore_ascii_case("script") || v_el.tag.eq_ignore_ascii_case("style") {
let mut stats = HydrationStats::default().with_consumed(1);
stats.merge(alignment_stats);
return stats;
}
let mut stats =
hydrate_children(&real_node, &v_el.children, boundary, path).with_consumed(1);
stats.merge(alignment_stats);
return stats;
}
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"element_tag_mismatch",
&format!(
"expected <{}> but found {} at DOM index {}",
v_el.tag,
describe_dom_node(&real_node),
index
),
Some(path),
);
replace_dom_node(parent, &real_node, v_node, "hydrate_recursive");
let mut stats = HydrationStats {
consumed: 1,
replacements: 1,
..HydrationStats::default()
};
stats.merge(alignment_stats);
stats
}
#[cfg(feature = "web")]
fn hydrate_text(
parent: &WebNode,
real_node_opt: Option<WebNode>,
v_node: &Node,
text: &str,
boundary: &HydrationBoundary,
path: &str,
) -> HydrationStats {
const TEXT_NODE: u16 = 3;
let Some(real_node) = real_node_opt else {
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"missing_dom_node",
&format!("expected text {text:?} but DOM child was missing; appending"),
Some(path),
);
append_dom_node(parent, v_node, "hydrate_recursive");
return HydrationStats {
consumed: 1,
appends: 1,
..HydrationStats::default()
};
};
if real_node.node_type() != TEXT_NODE {
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"expected_text_found_non_text_node",
&format!(
"expected text {:?} but found {}; replacing node",
text,
describe_dom_node(&real_node)
),
Some(path),
);
replace_dom_node(parent, &real_node, v_node, "hydrate_recursive");
return HydrationStats {
consumed: 1,
replacements: 1,
..HydrationStats::default()
};
}
let actual = real_node.text_content().unwrap_or_default();
if actual == text {
return HydrationStats {
consumed: 1,
..HydrationStats::default()
};
}
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"text_content_mismatch",
&format!("expected text {text:?} but found {actual:?}; patching text node"),
Some(path),
);
real_node.set_text_content(Some(text));
HydrationStats {
consumed: 1,
text_patches: 1,
..HydrationStats::default()
}
}
#[cfg(feature = "web")]
fn hydrate_comment(
parent: &WebNode,
real_node_opt: Option<WebNode>,
text: &str,
boundary: &HydrationBoundary,
path: &str,
) -> HydrationStats {
const COMMENT_NODE: u16 = 8;
if real_node_opt
.as_ref()
.is_some_and(|node| node.node_type() == COMMENT_NODE)
{
return HydrationStats {
consumed: 1,
..HydrationStats::default()
};
}
log_hydration_boundary_diagnostic(
"warn",
"hydrate_recursive",
boundary,
"missing_comment_node",
"expected a comment marker; inserting one",
Some(path),
);
let Some(document) = web_sys::window().and_then(|window| window.document()) else {
return HydrationStats::default();
};
let comment = document.create_comment(text);
if let Err(err) = parent.insert_before(&comment, real_node_opt.as_ref()) {
console::error_1(
&format!(
"{{\"scope\":\"hydrate_recursive\",\"detail\":\"insert comment failed\",\"error\":\"{err:?}\"}}"
)
.into(),
);
return HydrationStats::default();
}
HydrationStats {
consumed: 1,
appends: 1,
..HydrationStats::default()
}
}
#[cfg(feature = "web")]
fn hydrate_recursive(
parent: &WebNode,
node_list: &NodeList,
index: u32,
v_node: &Node,
boundary: &HydrationBoundary,
path: &str,
) -> HydrationStats {
match v_node {
Node::Element(v_el) => {
hydrate_element(parent, node_list, index, v_node, v_el, boundary, path)
}
Node::Text(text) => {
hydrate_text(parent, node_list.item(index), v_node, text, boundary, path)
}
Node::Comment(text) => hydrate_comment(parent, node_list.item(index), text, boundary, path),
Node::Fragment(children) => {
let mut consumed = 0;
let mut stats = HydrationStats::default();
for (child_index, child) in children.iter().enumerate() {
let child_stats = hydrate_recursive(
parent,
node_list,
index + consumed,
child,
boundary,
&child_path(path, child_index),
);
consumed += child_stats.consumed;
stats.merge(child_stats);
}
stats
}
Node::Dynamic(f) => {
let cells = DynamicRegionCells {
rendered: Rc::new(RefCell::new(Vec::new())),
current_vnode: Rc::new(RefCell::new(None)),
anchor: Rc::new(RefCell::new(None)),
empty_position: Rc::new(RefCell::new(None)),
effect: Rc::new(RefCell::new(None)),
};
let stats_cell: Rc<Cell<HydrationStats>> =
Rc::new(Cell::new(HydrationStats::default()));
let f = f.clone();
let first_run = Rc::new(Cell::new(true));
let effect_cells = cells.clone();
let parent = parent.clone();
let node_list = node_list.clone();
let boundary = boundary.clone();
let path = path.to_string();
let stats_for_effect = stats_cell.clone();
let handle = create_effect_scoped(move || {
let new_v_node = f();
if first_run.get() {
first_run.set(false);
let stats = hydrate_recursive(
&parent,
&node_list,
index,
&new_v_node,
&boundary,
&path,
);
*effect_cells.rendered.borrow_mut() = (0..stats.consumed)
.filter_map(|offset| node_list.item(index + offset))
.collect();
*effect_cells.empty_position.borrow_mut() = parent
.dyn_ref::<Element>()
.cloned()
.map(|el| (el, node_list.item(index + stats.consumed)));
*effect_cells.current_vnode.borrow_mut() = Some(new_v_node);
stats_for_effect.set(stats);
return;
}
update_dynamic_region(&effect_cells, new_v_node);
});
*cells.effect.borrow_mut() = Some(handle);
own_region_effect_by_enclosing_effect(&cells);
stats_cell.get()
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use krab_core::{Attribute, Element, Node};
#[test]
fn boundary_state_from_factory_node_reads_decode_error_marker() {
let fallback = Node::Element(Element {
tag: "div".to_string(),
attributes: vec![Attribute::new(
"data-krab-boundary-state".to_string(),
"decode-error".to_string(),
)],
children: vec![],
events: vec![],
});
assert_eq!(
boundary_state_from_factory_node(&fallback),
Some("decode-error")
);
}
#[test]
fn classify_boundary_state_prefers_factory_error_and_patch_counts() {
assert_eq!(
classify_boundary_state(Some("decode-error"), 3),
"decode-error"
);
assert_eq!(classify_boundary_state(None, 2), "patched");
assert_eq!(classify_boundary_state(None, 0), "ok");
}
}