beet_dom 0.0.8

Utilities for dom rendering and interaction
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use crate::prelude::*;
use beet_core::prelude::*;
use bevy::ecs::system::SystemParam;


/// An attribute belonging to the target entity, which may be
/// an element or a node.
#[derive(Debug, Clone, Deref, Reflect, Component)]
#[reflect(Component)]
#[relationship(relationship_target = Attributes)]
pub struct AttributeOf(pub Entity);

impl AttributeOf {
	pub fn new(value: Entity) -> Self { Self(value) }
}

/// All attributes belonging to this entity, which may be
/// an element or a template.
#[derive(Debug, Clone, Deref, Reflect, Component)]
#[reflect(Component)]
#[relationship_target(relationship = AttributeOf,linked_spawn)]
pub struct Attributes(Vec<Entity>);


impl Attributes {
	/// returns the entity and value of the first attribute with the given key
	pub fn find<'a>(
		&self,
		attrs: &'a Query<(Entity, &AttributeKey, Option<&TextNode>)>,
		key: &str,
	) -> Option<(Entity, Option<&'a TextNode>)> {
		self.iter().find_map(|entity| {
			let (attr_entity, item_key, value) = attrs.get(entity).ok()?;
			if item_key.as_str() == key {
				Some((attr_entity, value))
			} else {
				None
			}
		})
	}
}

/// A helper [`SystemParam`] for getting attributes from an element
#[derive(SystemParam)]
pub struct FindAttribute<'w, 's> {
	elements: Query<'w, 's, (Entity, &'static Attributes)>,
	attributes: Query<
		'w,
		's,
		(Entity, &'static AttributeKey, Option<&'static TextNode>),
	>,
}

impl FindAttribute<'_, '_> {
	pub fn all<'a>(
		&'a self,
		entity: Entity,
	) -> Vec<(Entity, &'a AttributeKey, Option<&'a TextNode>)> {
		self.elements.get(entity).ok().map_or(vec![], |(_, attrs)| {
			attrs
				.iter()
				.filter_map(|attr| self.attributes.get(attr).ok())
				.collect()
		})
	}

	pub fn events<'a>(
		&'a self,
		entity: Entity,
	) -> Vec<(Entity, &'a AttributeKey)> {
		self.elements.get(entity).ok().map_or(vec![], |(_, attrs)| {
			attrs
				.iter()
				.filter_map(|attr| self.attributes.get(attr).ok())
				.filter(|(_, key, _)| key.is_event())
				.map(|(entity, key, _)| (entity, key))
				.collect()
		})
	}

	pub fn find(
		&self,
		entity: Entity,
		key: &str,
	) -> Option<(Entity, Option<&TextNode>)> {
		self.elements
			.get(entity)
			.ok()
			.and_then(|(_, attrs)| attrs.find(&self.attributes, key))
	}
	pub fn find_value(
		&self,
		entity: Entity,
		key: &str,
	) -> Option<(Entity, &TextNode)> {
		self.find(entity, key)
			.and_then(|(attr_entity, value)| value.map(|v| (attr_entity, v)))
	}


	/// Collect all classes from the attributes of the given entity.
	pub fn classes(&self, entity: Entity) -> Vec<String> {
		self.find(entity, "class").map_or(vec![], |(_, value)| {
			value
				.map(|text| {
					text.as_str().split_whitespace().map(String::from).collect()
				})
				.unwrap_or_default()
		})
	}
}

/// An attribute key represented as a string.
///
/// ## Example
/// ```ignore
/// rsx!{<span "hidden"=true />};
/// ```
#[derive(
	Debug, Clone, PartialEq, Eq, Hash, Deref, DerefMut, Reflect, Component,
)]
#[reflect(Component)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "tokens", derive(ToTokens))]
pub struct AttributeKey(pub String);

impl AttributeKey {
	pub fn new(value: impl Into<String>) -> Self { Self(value.into()) }
	/// If key starts with 'on' its considered an event
	pub fn is_event(&self) -> bool { self.0.starts_with("on") }
}