261 lines
8.0 KiB
Rust
261 lines
8.0 KiB
Rust
//! Items related to Nodes in the RealDom
|
|
|
|
use rustc_hash::{FxHashMap, FxHashSet};
|
|
use shipyard::Component;
|
|
use std::{
|
|
any::Any,
|
|
fmt::{Debug, Display},
|
|
};
|
|
|
|
/// A element node in the RealDom
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct ElementNode<V: FromAnyValue = ()> {
|
|
/// The [tag](https://developer.mozilla.org/en-US/docs/Web/API/Element/tagName) of the element
|
|
pub tag: String,
|
|
/// The [namespace](https://developer.mozilla.org/en-US/docs/Web/API/Element/namespaceURI) of the element
|
|
pub namespace: Option<String>,
|
|
/// The attributes of the element
|
|
pub attributes: FxHashMap<OwnedAttributeDiscription, OwnedAttributeValue<V>>,
|
|
/// The events the element is listening for
|
|
pub listeners: FxHashSet<String>,
|
|
}
|
|
|
|
impl ElementNode {
|
|
/// Create a new element node
|
|
pub fn new(tag: impl Into<String>, namespace: impl Into<Option<String>>) -> Self {
|
|
Self {
|
|
tag: tag.into(),
|
|
namespace: namespace.into(),
|
|
attributes: Default::default(),
|
|
listeners: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A text node in the RealDom
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct TextNode {
|
|
/// The text of the node
|
|
pub text: String,
|
|
/// The events the node is listening for
|
|
pub listeners: FxHashSet<String>,
|
|
}
|
|
|
|
impl TextNode {
|
|
/// Create a new text node
|
|
pub fn new(text: String) -> Self {
|
|
Self {
|
|
text,
|
|
listeners: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A type of node with data specific to the node type.
|
|
#[derive(Debug, Clone, Component)]
|
|
pub enum NodeType<V: FromAnyValue = ()> {
|
|
/// A text node
|
|
Text(TextNode),
|
|
/// An element node
|
|
Element(ElementNode<V>),
|
|
/// A placeholder node. This can be used as a cheaper placeholder for a node that will be created later
|
|
Placeholder,
|
|
}
|
|
|
|
impl<V: FromAnyValue, S: Into<String>> From<S> for NodeType<V> {
|
|
fn from(text: S) -> Self {
|
|
Self::Text(TextNode::new(text.into()))
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> From<TextNode> for NodeType<V> {
|
|
fn from(text: TextNode) -> Self {
|
|
Self::Text(text)
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> From<ElementNode<V>> for NodeType<V> {
|
|
fn from(element: ElementNode<V>) -> Self {
|
|
Self::Element(element)
|
|
}
|
|
}
|
|
|
|
/// A discription of an attribute on a DOM node, such as `id` or `href`.
|
|
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
|
|
pub struct OwnedAttributeDiscription {
|
|
/// The name of the attribute.
|
|
pub name: String,
|
|
/// The namespace of the attribute used to identify what kind of attribute it is.
|
|
///
|
|
/// For renderers that use HTML, this can be used to identify if the attribute is a style attribute.
|
|
/// Instead of parsing the style attribute every time a style is changed, you can set an attribute with the `style` namespace.
|
|
pub namespace: Option<String>,
|
|
}
|
|
|
|
impl From<String> for OwnedAttributeDiscription {
|
|
fn from(name: String) -> Self {
|
|
Self {
|
|
name,
|
|
namespace: None,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<S: Into<String>, N: Into<String>> From<(S, N)> for OwnedAttributeDiscription {
|
|
fn from(name: (S, N)) -> Self {
|
|
Self {
|
|
name: name.0.into(),
|
|
namespace: Some(name.1.into()),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// An attribute on a DOM node, such as `id="my-thing"` or
|
|
/// `href="https://example.com"`.
|
|
#[derive(Clone, Copy, Debug)]
|
|
pub struct OwnedAttributeView<'a, V: FromAnyValue = ()> {
|
|
/// The discription of the attribute.
|
|
pub attribute: &'a OwnedAttributeDiscription,
|
|
|
|
/// The value of the attribute.
|
|
pub value: &'a OwnedAttributeValue<V>,
|
|
}
|
|
|
|
/// The value of an attribute on a DOM node. This contains non-text values to allow users to skip parsing attribute values in some cases.
|
|
#[derive(Clone)]
|
|
pub enum OwnedAttributeValue<V: FromAnyValue = ()> {
|
|
/// A string value. This is the most common type of attribute.
|
|
Text(String),
|
|
/// A floating point value.
|
|
Float(f64),
|
|
/// An integer value.
|
|
Int(i64),
|
|
/// A boolean value.
|
|
Bool(bool),
|
|
/// A custom value specific to the renderer
|
|
Custom(V),
|
|
}
|
|
|
|
impl<V: FromAnyValue> From<String> for OwnedAttributeValue<V> {
|
|
fn from(value: String) -> Self {
|
|
Self::Text(value)
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> From<f64> for OwnedAttributeValue<V> {
|
|
fn from(value: f64) -> Self {
|
|
Self::Float(value)
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> From<i64> for OwnedAttributeValue<V> {
|
|
fn from(value: i64) -> Self {
|
|
Self::Int(value)
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> From<bool> for OwnedAttributeValue<V> {
|
|
fn from(value: bool) -> Self {
|
|
Self::Bool(value)
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> From<V> for OwnedAttributeValue<V> {
|
|
fn from(value: V) -> Self {
|
|
Self::Custom(value)
|
|
}
|
|
}
|
|
|
|
/// Something that can be converted from a borrowed [Any] value.
|
|
pub trait FromAnyValue: Clone + 'static {
|
|
/// Convert from an [Any] value.
|
|
fn from_any_value(value: &dyn Any) -> Self;
|
|
}
|
|
|
|
impl FromAnyValue for () {
|
|
fn from_any_value(_: &dyn Any) -> Self {}
|
|
}
|
|
|
|
impl<V: FromAnyValue> Debug for OwnedAttributeValue<V> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Text(arg0) => f.debug_tuple("Text").field(arg0).finish(),
|
|
Self::Float(arg0) => f.debug_tuple("Float").field(arg0).finish(),
|
|
Self::Int(arg0) => f.debug_tuple("Int").field(arg0).finish(),
|
|
Self::Bool(arg0) => f.debug_tuple("Bool").field(arg0).finish(),
|
|
Self::Custom(_) => f.debug_tuple("Any").finish(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> Display for OwnedAttributeValue<V> {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
Self::Text(arg0) => f.write_str(arg0),
|
|
Self::Float(arg0) => f.write_str(&arg0.to_string()),
|
|
Self::Int(arg0) => f.write_str(&arg0.to_string()),
|
|
Self::Bool(arg0) => f.write_str(&arg0.to_string()),
|
|
Self::Custom(_) => f.write_str("custom"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(feature = "dioxus")]
|
|
impl<V: FromAnyValue> From<&dioxus_core::AttributeValue> for OwnedAttributeValue<V> {
|
|
fn from(value: &dioxus_core::AttributeValue) -> Self {
|
|
match value {
|
|
dioxus_core::AttributeValue::Text(text) => Self::Text(text.clone()),
|
|
dioxus_core::AttributeValue::Float(float) => Self::Float(*float),
|
|
dioxus_core::AttributeValue::Int(int) => Self::Int(*int),
|
|
dioxus_core::AttributeValue::Bool(bool) => Self::Bool(*bool),
|
|
dioxus_core::AttributeValue::Any(any) => Self::Custom(V::from_any_value(any.as_any())),
|
|
dioxus_core::AttributeValue::None => panic!("None attribute values result in removing the attribute, not converting it to a None value."),
|
|
_ => panic!("Unsupported attribute value type"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<V: FromAnyValue> OwnedAttributeValue<V> {
|
|
/// Attempt to convert the attribute value to a string.
|
|
pub fn as_text(&self) -> Option<&str> {
|
|
match self {
|
|
OwnedAttributeValue::Text(text) => Some(text),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Attempt to convert the attribute value to a float.
|
|
pub fn as_float(&self) -> Option<f64> {
|
|
match self {
|
|
OwnedAttributeValue::Float(float) => Some(*float),
|
|
OwnedAttributeValue::Int(int) => Some(*int as f64),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Attempt to convert the attribute value to an integer.
|
|
pub fn as_int(&self) -> Option<i64> {
|
|
match self {
|
|
OwnedAttributeValue::Float(float) => Some(*float as i64),
|
|
OwnedAttributeValue::Int(int) => Some(*int),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Attempt to convert the attribute value to a boolean.
|
|
pub fn as_bool(&self) -> Option<bool> {
|
|
match self {
|
|
OwnedAttributeValue::Bool(bool) => Some(*bool),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
/// Attempt to convert the attribute value to a custom value.
|
|
pub fn as_custom(&self) -> Option<&V> {
|
|
match self {
|
|
OwnedAttributeValue::Custom(custom) => Some(custom),
|
|
_ => None,
|
|
}
|
|
}
|
|
}
|