use crate::reconcile::DynamicRegionCells;
use krab_core::signal::{create_effect_scoped, on_cleanup, EffectHandle};
use std::cell::{Cell, RefCell};
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsCast;
use web_sys::{console, Element, Node as WebNode};
type EventClosure = Closure<dyn FnMut(web_sys::Event)>;
type EventClosureMap = std::collections::HashMap<u32, Vec<(String, EventClosure)>>;
type DynamicRegionMap = std::collections::HashMap<u32, DynamicRegionCells>;
type AttributeEffectMap = std::collections::HashMap<u32, Vec<EffectHandle>>;
thread_local! {
static EVENT_CLOSURES: RefCell<EventClosureMap> = RefCell::new(EventClosureMap::new());
static NEXT_DOM_ID: std::cell::Cell<u32> = const { std::cell::Cell::new(1) };
static DYNAMIC_REGIONS: RefCell<DynamicRegionMap> = RefCell::new(DynamicRegionMap::new());
static ATTRIBUTE_EFFECTS: RefCell<AttributeEffectMap> = RefCell::new(AttributeEffectMap::new());
}
#[doc(hidden)]
pub fn attribute_effect_count() -> usize {
ATTRIBUTE_EFFECTS.with(|effects| effects.borrow().len())
}
fn detach_dynamic_attributes(real_el: &Element) {
let Some(id) = node_expando_id(real_el.as_ref(), "__krab_attr_id") else {
return;
};
let Some(handles) = ATTRIBUTE_EFFECTS.with(|effects| effects.borrow_mut().remove(&id)) else {
return;
};
for handle in &handles {
handle.dispose();
}
}
pub(crate) fn bind_dynamic_attributes(
real_el: &Element,
v_el: &krab_core::Element,
hydrating: bool,
) {
detach_dynamic_attributes(real_el);
let mut handles = Vec::new();
for attr in &v_el.attributes {
let Some(source) = attr.dynamic.clone() else {
continue;
};
let element = real_el.clone();
let name = attr.name.clone();
let adopting = Cell::new(hydrating);
handles.push(create_effect_scoped(move || {
let value = source();
apply_dynamic_attribute(&element, &name, value.as_deref(), adopting.replace(false));
}));
}
if handles.is_empty() {
return;
}
let id = NEXT_DOM_ID.with(|id| {
let v = id.get();
id.set(v + 1);
v
});
let _ = js_sys::Reflect::set(
real_el.as_ref(),
&JsValue::from_str("__krab_attr_id"),
&JsValue::from_f64(id as f64),
);
ATTRIBUTE_EFFECTS.with(|effects| effects.borrow_mut().insert(id, handles));
}
fn apply_dynamic_attribute(element: &Element, name: &str, value: Option<&str>, adopting: bool) {
if element.get_attribute(name).as_deref() != value {
let result = match value {
Some(value) => element.set_attribute(name, value),
None => element.remove_attribute(name),
};
if let Err(err) = result {
console::error_1(
&format!(
"{{\"scope\":\"dynamic_attribute\",\"detail\":\"attribute write failed\",\"attribute\":\"{name}\",\"error\":\"{err:?}\"}}"
)
.into(),
);
}
}
if adopting {
return;
}
let tag = element.tag_name().to_ascii_lowercase();
let property: Option<(&str, JsValue)> = match (tag.as_str(), name) {
("input" | "textarea" | "select", "value") => {
Some(("value", JsValue::from_str(value.unwrap_or(""))))
}
("input", "checked") => Some(("checked", JsValue::from_bool(value.is_some()))),
("option", "selected") => Some(("selected", JsValue::from_bool(value.is_some()))),
_ => None,
};
if let Some((key, wanted)) = property {
let key = JsValue::from_str(key);
let current = js_sys::Reflect::get(element.as_ref(), &key).unwrap_or(JsValue::UNDEFINED);
if current != wanted {
let _ = js_sys::Reflect::set(element.as_ref(), &key, &wanted);
}
}
}
#[doc(hidden)]
pub fn event_closure_count() -> usize {
EVENT_CLOSURES.with(|closures| closures.borrow().len())
}
#[doc(hidden)]
pub fn dynamic_region_count() -> usize {
DYNAMIC_REGIONS.with(|regions| regions.borrow().len())
}
fn detach_element_events(real_el: &Element) {
let Some(id) = node_expando_id(real_el.as_ref(), "__krab_id") else {
return;
};
let Some(pairs) = EVENT_CLOSURES.with(|closures| closures.borrow_mut().remove(&id)) else {
return;
};
for (name, closure) in &pairs {
let _ = real_el.remove_event_listener_with_callback(name, closure.as_ref().unchecked_ref());
}
}
pub(crate) fn attach_element_events(real_el: &Element, v_el: &krab_core::Element, scope: &str) {
detach_element_events(real_el);
let mut node_closures = Vec::new();
for event in &v_el.events {
let name = event.name.clone();
let callback = event.callback.clone();
let closure =
Closure::wrap(Box::new(move |e: web_sys::Event| callback(e)) as Box<dyn FnMut(_)>);
if let Err(err) =
real_el.add_event_listener_with_callback(&name, closure.as_ref().unchecked_ref())
{
console::error_1(
&format!(
"{{\"scope\":\"{scope}\",\"detail\":\"failed to attach event listener\",\"event\":\"{name}\",\"error\":\"{err:?}\"}}"
)
.into(),
);
}
node_closures.push((name, closure));
}
if node_closures.is_empty() {
return;
}
let id = NEXT_DOM_ID.with(|id| {
let v = id.get();
id.set(v + 1);
v
});
let _ = js_sys::Reflect::set(
real_el.as_ref(),
&JsValue::from_str("__krab_id"),
&JsValue::from_f64(id as f64),
);
EVENT_CLOSURES.with(|v| v.borrow_mut().insert(id, node_closures));
}
fn node_expando_id(target: &JsValue, key: &str) -> Option<u32> {
js_sys::Reflect::get(target, &JsValue::from_str(key))
.ok()
.and_then(|value| value.as_f64())
.map(|value| value as u32)
}
pub(crate) fn release_dom_node_resources(node: &WebNode) {
if let Some(element) = node.dyn_ref::<Element>() {
detach_element_events(element);
detach_dynamic_attributes(element);
}
if let Some(region) = take_dynamic_region(node) {
dispose_region_effect(®ion);
}
let child_nodes = node.child_nodes();
for index in 0..child_nodes.length() {
if let Some(child) = child_nodes.item(index) {
release_dom_node_resources(&child);
}
}
}
pub(crate) fn register_dynamic_region(anchor: &WebNode, cells: &DynamicRegionCells) {
let id = NEXT_DOM_ID.with(|id| {
let v = id.get();
id.set(v + 1);
v
});
let _ = js_sys::Reflect::set(
anchor.as_ref(),
&JsValue::from_str("__krab_region"),
&JsValue::from_f64(id as f64),
);
DYNAMIC_REGIONS.with(|regions| regions.borrow_mut().insert(id, cells.clone()));
}
pub(crate) fn take_dynamic_region(node: &WebNode) -> Option<DynamicRegionCells> {
let id = node_expando_id(node.as_ref(), "__krab_region")?;
DYNAMIC_REGIONS.with(|regions| regions.borrow_mut().remove(&id))
}
pub(crate) fn dispose_region_effect(cells: &DynamicRegionCells) {
let handle = cells.effect.borrow_mut().take();
if let Some(handle) = handle {
handle.dispose();
}
}
pub(crate) fn own_region_effect_by_enclosing_effect(cells: &DynamicRegionCells) {
let effect = cells.effect.clone();
on_cleanup(move || {
let handle = effect.borrow_mut().take();
if let Some(handle) = handle {
handle.dispose();
}
});
}