use crate::dom_types;
use crate::dom_types::{AtValue, El, Namespace, Node, Text};
use wasm_bindgen::JsCast;
use web_sys::Document;
fn set_style(el_ws: &web_sys::Node, style: &dom_types::Style) {
el_ws
.dyn_ref::<web_sys::Element>()
.expect("Problem casting Node as Element while setting style")
.set_attribute("style", &style.to_string())
.expect("Problem setting style");
}
pub(crate) fn assign_ws_nodes_to_el<Ms>(document: &Document, el: &mut El<Ms>) {
el.node_ws = Some(make_websys_el(el, document));
for mut child in &mut el.children {
assign_ws_nodes(document, &mut child);
}
}
pub(crate) fn assign_ws_nodes<Ms>(document: &Document, node: &mut Node<Ms>)
where
Ms: 'static,
{
match node {
Node::Element(el) => assign_ws_nodes_to_el(document, el),
Node::Text(text) => {
text.node_ws = Some(
document
.create_text_node(&text.text)
.dyn_into::<web_sys::Node>()
.expect("Problem casting Text as Node."),
);
}
Node::Empty => (),
}
}
fn node_to_element(el_ws: &web_sys::Node) -> Result<&web_sys::Element, &'static str> {
if let web_sys::Node::ELEMENT_NODE = el_ws.node_type() {
el_ws
.dyn_ref::<web_sys::Element>()
.ok_or("Problem casting Node as Element")
} else {
Err("Node isn't Element!")
}
}
fn set_attr_value(el_ws: &web_sys::Node, at: &dom_types::At, at_value: &AtValue) {
match at_value {
AtValue::Some(value) => {
node_to_element(el_ws)
.and_then(|element| {
element
.set_attribute(at.as_str(), value)
.map_err(|_| "Problem setting an atrribute.")
})
.unwrap_or_else(|err| {
crate::error(err);
});
}
AtValue::None => {
node_to_element(el_ws)
.and_then(|element| {
element
.set_attribute(at.as_str(), "")
.map_err(|_| "Problem setting an atrribute.")
})
.unwrap_or_else(|err| {
crate::error(err);
});
}
AtValue::Ignored => {
node_to_element(el_ws)
.and_then(|element| {
element
.remove_attribute(at.as_str())
.map_err(|_| "Problem removing an atrribute.")
})
.unwrap_or_else(|err| {
crate::error(err);
});
}
}
}
pub(crate) fn make_websys_el<Ms>(
el_vdom: &mut El<Ms>,
document: &web_sys::Document,
) -> web_sys::Node {
let tag = el_vdom.tag.as_str();
let el_ws = match el_vdom.namespace {
Some(ref ns) => document
.create_element_ns(Some(ns.as_str()), tag)
.expect("Problem creating web-sys element with namespace"),
None => document
.create_element(tag)
.expect("Problem creating web-sys element"),
};
for (at, attr_value) in &el_vdom.attrs.vals {
set_attr_value(&el_ws, at, attr_value);
}
if let Some(ns) = &el_vdom.namespace {
el_ws
.dyn_ref::<web_sys::Element>()
.expect("Problem casting Node as Element while setting an attribute")
.set_attribute("xmlns", ns.as_str())
.expect("Problem setting xlmns attribute");
}
if el_vdom.style.vals.keys().len() > 0 {
set_style(&el_ws, &el_vdom.style)
}
el_ws.into()
}
pub fn attach_text_node(text: &mut Text, parent: &web_sys::Node) {
let node_ws = text.node_ws.take().expect("Missing websys node for Text");
parent
.append_child(&node_ws)
.expect("Problem appending text node");
text.node_ws.replace(node_ws);
}
pub fn attach_children<Ms>(el_vdom: &mut El<Ms>) {
let el_ws = el_vdom
.node_ws
.as_ref()
.expect("Missing websys el in attach_children");
for child in &mut el_vdom.children {
match child {
Node::Element(child_el) => attach_el_and_children(child_el, el_ws),
Node::Text(child_text) => attach_text_node(child_text, el_ws),
Node::Empty => (),
}
}
}
pub fn attach_el_and_children<Ms>(el_vdom: &mut El<Ms>, parent: &web_sys::Node) {
let el_ws = el_vdom
.node_ws
.as_ref()
.expect("Missing websys el in attach_el_and_children");
if parent.append_child(el_ws).is_err() {
crate::error("Minor problem with html element (append)");
}
for child in &mut el_vdom.children {
match child {
Node::Element(child_el) => attach_el_and_children(child_el, el_ws),
Node::Text(child_text) => attach_text_node(child_text, el_ws),
Node::Empty => (),
}
}
set_default_element_state(el_ws, el_vdom);
if let Some(mount_actions) = &mut el_vdom.hooks.did_mount {
(mount_actions.actions)(el_ws);
}
}
fn set_default_element_state<Ms>(el_ws: &web_sys::Node, el_vdom: &El<Ms>) {
if let Some(at_value) = el_vdom.attrs.vals.get(&dom_types::At::AutoFocus) {
match at_value {
AtValue::Some(_) | AtValue::None => el_ws
.dyn_ref::<web_sys::HtmlElement>()
.expect("Problem casting Node as HtmlElement while focusing")
.focus()
.expect("Problem focusing to an element."),
AtValue::Ignored => (),
}
}
if let Some(textarea) = el_ws.dyn_ref::<web_sys::HtmlTextAreaElement>() {
if let Some(AtValue::Some(value)) = el_vdom.attrs.vals.get(&dom_types::At::Value) {
textarea.set_value(value);
}
}
}
pub fn _remove_children(el: &web_sys::Node) {
while let Some(child) = el.last_child() {
el.remove_child(&child).expect("Problem removing child");
}
}
pub fn patch_el_details<Ms>(old: &mut El<Ms>, new: &mut El<Ms>, old_el_ws: &web_sys::Node) {
if let Some(update_actions) = &mut new.hooks.did_update {
(update_actions.actions)(old_el_ws)
}
if old.attrs != new.attrs {
for (key, new_val) in &new.attrs.vals {
match old.attrs.vals.get(key) {
Some(old_val) => {
if old_val != new_val {
set_attr_value(old_el_ws, key, new_val);
}
}
None => {
set_attr_value(old_el_ws, key, new_val);
}
}
match key {
dom_types::At::Value => match new_val {
AtValue::Some(new_val) => crate::util::set_value(old_el_ws, new_val),
AtValue::None | AtValue::Ignored => crate::util::set_value(old_el_ws, ""),
},
dom_types::At::Checked => match new_val {
AtValue::Some(_) | AtValue::None => crate::util::set_checked(old_el_ws, true),
AtValue::Ignored => crate::util::set_checked(old_el_ws, false),
},
_ => Ok(()),
}
.unwrap_or_else(|err| {
crate::error(err);
})
}
for name in old.attrs.vals.keys() {
if new.attrs.vals.get(name).is_none() {
match old_el_ws.dyn_ref::<web_sys::Element>() {
Some(el) => el
.remove_attribute(name.as_str())
.expect("Removing an attribute"),
None => {
crate::error("Minor error on html element (setting attrs)");
}
}
}
}
}
if old.style != new.style {
set_style(old_el_ws, &new.style)
}
}
pub fn to_input(target: &web_sys::EventTarget) -> &web_sys::HtmlInputElement {
target
.dyn_ref::<web_sys::HtmlInputElement>()
.expect("Unable to cast as an input element")
}
pub fn to_textarea(target: &web_sys::EventTarget) -> &web_sys::HtmlTextAreaElement {
target
.dyn_ref::<web_sys::HtmlTextAreaElement>()
.expect("Unable to cast as a textarea element")
}
pub fn to_select(target: &web_sys::EventTarget) -> &web_sys::HtmlSelectElement {
target
.dyn_ref::<web_sys::HtmlSelectElement>()
.expect("Unable to cast as a select element")
}
pub fn to_html_el(target: &web_sys::EventTarget) -> &web_sys::HtmlElement {
target
.dyn_ref::<web_sys::HtmlElement>()
.expect("Unable to cast as an HTML element")
}
pub fn to_kbevent(event: &web_sys::Event) -> &web_sys::KeyboardEvent {
event
.dyn_ref::<web_sys::KeyboardEvent>()
.expect("Unable to cast as a keyboard event")
}
pub fn to_mouse_event(event: &web_sys::Event) -> &web_sys::MouseEvent {
event
.dyn_ref::<web_sys::MouseEvent>()
.expect("Unable to cast as a mouse event")
}
impl<Ms> From<&web_sys::Element> for El<Ms> {
fn from(ws_el: &web_sys::Element) -> Self {
let mut el = match ws_el.tag_name().to_lowercase().as_ref() {
"svg" => El::empty_svg(ws_el.tag_name().to_lowercase().into()),
_ => El::empty(ws_el.tag_name().to_lowercase().into()),
};
let mut attrs = dom_types::Attrs::empty();
ws_el
.get_attribute_names()
.for_each(&mut |attr_name, _, _| {
let attr_name = attr_name
.as_string()
.expect("problem converting attr to string");
if let Some(attr_val) = ws_el.get_attribute(&attr_name) {
attrs.add(attr_name.into(), &attr_val);
}
});
el.attrs = attrs;
let svg_tags = [
"line",
"rect",
"circle",
"ellipse",
"polygon",
"polyline",
"mesh",
"path",
"defs",
"g",
"marker",
"mask",
"pattern",
"svg",
"switch",
"symbol",
"unknown",
"linear_gradient",
"radial_gradient",
"mesh_gradient",
"stop",
"image",
"r#use",
"altGlyph",
"altGlyphDef",
"altGlyphItem",
"glyph",
"glyphRef",
"textPath",
"text",
"tref",
"tspan",
"clipPath",
"cursor",
"filter",
"foreignObject",
"hathpath",
"meshPatch",
"meshRow",
"view",
"colorProfile",
"animage",
"animateColor",
"animateMotion",
"animateTransform",
"discard",
"mpath",
"set",
"desc",
"metadata",
"title",
"feBlend",
"feColorMatrix",
"feComponentTransfer",
"feComposite",
"feConvolveMatrix",
"feDiffuseLighting",
"feDisplacementMap",
"feDropShadow",
"feFlood",
"feFuncA",
"feFuncB",
"feFuncG",
"feFuncR",
"feGaussianBlur",
"feImage",
"feMerge",
"feMergeNode",
"feMorphology",
"feOffset",
"feSpecularLighting",
"feTile",
"feTurbulence",
"font",
"hkern",
"vkern",
"hatch",
"solidcolor",
];
if svg_tags.contains(&ws_el.tag_name().to_lowercase().as_str()) {
el.namespace = Some(Namespace::Svg);
}
if let Some(ns) = ws_el.namespace_uri() {
if ns != "http://www.w3.org/1999/xhtml" {
el.namespace = Some(ns.into());
}
}
let children = ws_el.child_nodes();
for i in 0..children.length() {
let child = children
.get(i)
.expect("Can't find child in raw html element.");
if let Some(child_vdom) = node_from_ws(&child) {
el.children.push(child_vdom);
}
}
el
}
}
impl<Ms> From<&web_sys::Element> for Node<Ms> {
fn from(ws_el: &web_sys::Element) -> Node<Ms> {
Node::Element(ws_el.into())
}
}
pub fn node_from_ws<Ms>(node: &web_sys::Node) -> Option<Node<Ms>> {
match node.node_type() {
web_sys::Node::ELEMENT_NODE => {
let ws_el = node
.dyn_ref::<web_sys::Element>()
.expect("Problem casting Node as Element");
Some(ws_el.into())
}
web_sys::Node::TEXT_NODE => Some(Node::new_text(
node.text_content().expect("Can't find text"),
)),
_ => {
crate::error("Unexpected node type found from raw html");
None
}
}
}
pub(crate) fn insert_node(
node: &web_sys::Node,
parent: &web_sys::Node,
next: Option<web_sys::Node>,
) {
match next {
Some(n) => {
parent
.insert_before(node, Some(&n))
.expect("Problem inserting node");
}
None => {
parent.append_child(node).expect("Problem inserting node");
}
};
}
pub(crate) fn remove_node(node: &web_sys::Node, parent: &web_sys::Node) {
parent
.remove_child(node)
.expect("Problem removing old el_ws when updating to empty");
}
pub(crate) fn replace_child(new: &web_sys::Node, old: &web_sys::Node, parent: &web_sys::Node) {
parent
.replace_child(new, old)
.expect("Problem replacing element");
}