beet_rsx 0.0.8

An Astro inspired templating system built with bevy
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

use crate::prelude::*;
use beet_core::prelude::*;
use beet_dom::prelude::*;
use bevy::scene::serde::SceneSerializer;
use ron;


pub fn apply_client_islands(world: &mut World) -> Result {
	let documents = world.run_system_cached(document_islands)?;
	let type_registry = world.resource::<AppTypeRegistry>();
	let type_registry = type_registry.read();
	let filter = world.resource::<ClientIslandRegistry>().filter();
	// println!("filter: {:?}", type_registry.get_type_data());
	let document_scenes = documents
		.into_iter()
		.map(|(document, islands)| {
			let scene = DynamicSceneBuilder::from_world(world)
				.with_component_filter(filter.clone())
				.extract_entities(islands.into_iter())
				.build();
			let scene_serializer = SceneSerializer::new(&scene, &type_registry);
			#[cfg(debug_assertions)]
			let scene = {
				let pretty_config = ron::ser::PrettyConfig::default()
					.indentor("  ".to_string())
					.new_line("\n".to_string());
				ron::ser::to_string_pretty(&scene_serializer, pretty_config)
					.expect("failed to serialize scene")
			};
			#[cfg(not(debug_assertions))]
			let scene = ron::ser::to_string(&scene_serializer)
				.expect("failed to serialize scene");
			(document, scene)
		})
		.collect::<Vec<_>>();
	drop(type_registry);

	let script_type = world
		.resource::<HtmlConstants>()
		.client_islands_script_type
		.clone();

	for (document, scene) in document_scenes.into_iter() {
		world.entity_mut(document).with_child((
			ElementNode::open(),
			NodeTag::new("script"),
			HtmlHoistDirective::Body,
			related!(
				Attributes[(
					AttributeKey::new("type"),
					TextNode::new(script_type.clone()),
				),]
			),
			children![TextNode::new(scene)],
		));
	}


	Ok(())
}


/// Returns each [`HtmlDocument`] entity and a list of its [`ClientIsland`] entities
fn document_islands(
	query: Query<Entity, Added<HtmlDocument>>,
	children: Query<&Children>,
	islands: Query<
		Entity,
		Or<(With<ClientLoadDirective>, With<ClientOnlyDirective>)>,
	>,
) -> Vec<(Entity, Vec<Entity>)> {
	query
		.iter()
		.filter_map(|document| {
			let islands = children
				.iter_descendants_inclusive(document)
				.filter(|e| islands.contains(*e))
				.collect::<Vec<_>>();
			if islands.is_empty() {
				None
			} else {
				Some((document, islands))
			}
		})
		.collect()
}

#[cfg(test)]
mod test {
	use crate::prelude::*;
	use beet_core::prelude::*;

	#[template]
	#[derive(Reflect)]
	pub fn MyTemplate(foo: u32) -> impl Bundle {
		let _ = foo;
		()
	}

	fn parse(app: &mut App, bundle: impl Bundle) -> Result<String> {
		let entity = app.world_mut().spawn((HtmlDocument, bundle)).id();

		app.update();
		let reg = app.world().resource::<AppTypeRegistry>();
		reg.read()
			.get_type_info(
				std::any::TypeId::of::<ClientIslandRoot<MyTemplate>>(),
			)
			.xpect_some();

		app.world_mut()
			.run_system_cached_with(render_fragment, entity)?
			.xok()
	}

	#[test]
	fn works() {
		let mut app = App::new();
		app.add_plugins(ApplyDirectivesPlugin::default());

		parse(&mut app, rsx! { <MyTemplate foo=3 client:only /> })
			.unwrap()
			.xpect_snapshot();
	}
}