1use std::collections::HashMap;
2use std::marker::PhantomData;
3use std::sync::Arc;
4
5use leptos::prelude::*;
6
7use crate::anchor::{InputAnchor, OutputAnchor};
8use crate::menu::{Category, NodeMenuItem, TypedNodeDef, TypedPort};
9use crate::node::Node;
10use crate::types::*;
11
12type PortSlot = Arc<dyn Fn(String) -> AnyView + Send + Sync>;
14
15fn render_port<T: PortType>(
17 node_id: &str,
18 port: &TypedPort<T>,
19 port_slots: &HashMap<String, PortSlot>,
20 global_slots: &PortTypeSlots,
21 is_input: bool,
22) -> AnyView {
23 let port_id = format!("{}_{}", node_id, port.id);
24 let port_type = port.port_type.clone();
25 let marker: PhantomData<(String, String)> = PhantomData;
26
27 let slot_content = port_slots
29 .get(&port.id)
30 .map(|s| s(port.label.clone()))
31 .or_else(|| {
32 let key = (port.port_type.type_id(), port.direction);
33 global_slots.get(&key).map(|s| s(port.label.clone()))
34 });
35
36 if is_input {
37 if let Some(content) = slot_content {
38 view! { <InputAnchor id=port_id port_type=port_type _marker=marker>{content}</InputAnchor> }.into_any()
39 } else {
40 let lbl = port.label.clone();
41 view! { <InputAnchor id=port_id port_type=port_type _marker=marker label=lbl /> }
42 .into_any()
43 }
44 } else {
45 if let Some(content) = slot_content {
46 view! { <OutputAnchor id=port_id port_type=port_type _marker=marker>{content}</OutputAnchor> }.into_any()
47 } else {
48 let lbl = port.label.clone();
49 view! { <OutputAnchor id=port_id port_type=port_type _marker=marker label=lbl /> }
50 .into_any()
51 }
52 }
53}
54
55type DynamicPortsFn<T> = Arc<dyn Fn(String) -> Signal<Vec<TypedPort<T>>> + Send + Sync>;
58
59type CustomRendererFn = Arc<dyn Fn(String, RwSignal<Position>) -> AnyView + Send + Sync>;
61
62type RendererFn = Arc<
64 dyn Fn(String, RwSignal<Position>, &PortTypeSlots, &Option<HeaderRenderer>) -> AnyView
65 + Send
66 + Sync,
67>;
68
69pub struct NodeTypeBuilder<T: PortType> {
70 typed_def: TypedNodeDef<T>,
71 body: Option<Arc<dyn Fn(String) -> AnyView + Send + Sync>>,
73 port_slots: HashMap<String, PortSlot>,
75 dynamic_inputs: Option<DynamicPortsFn<T>>,
77 dynamic_outputs: Option<DynamicPortsFn<T>>,
79 custom_renderer: Option<CustomRendererFn>,
81 _marker: PhantomData<T>,
82}
83
84impl<T: PortType> NodeTypeBuilder<T> {
85 pub fn new(def: TypedNodeDef<T>) -> Self {
86 Self {
87 typed_def: def,
88 body: None,
89 port_slots: HashMap::new(),
90 dynamic_inputs: None,
91 dynamic_outputs: None,
92 custom_renderer: None,
93 _marker: PhantomData,
94 }
95 }
96
97 pub fn body(mut self, f: impl Fn(String) -> AnyView + Send + Sync + 'static) -> Self {
99 self.body = Some(Arc::new(f));
100 self
101 }
102
103 pub fn dynamic_inputs(
107 mut self,
108 f: impl Fn(String) -> Signal<Vec<TypedPort<T>>> + Send + Sync + 'static,
109 ) -> Self {
110 self.dynamic_inputs = Some(Arc::new(f));
111 self
112 }
113
114 pub fn dynamic_outputs(
116 mut self,
117 f: impl Fn(String) -> Signal<Vec<TypedPort<T>>> + Send + Sync + 'static,
118 ) -> Self {
119 self.dynamic_outputs = Some(Arc::new(f));
120 self
121 }
122
123 pub fn port_slot(
125 mut self,
126 port_id: &str,
127 f: impl Fn(String) -> AnyView + Send + Sync + 'static,
128 ) -> Self {
129 self.port_slots.insert(port_id.to_string(), Arc::new(f));
130 self
131 }
132
133 pub fn custom_renderer(
136 mut self,
137 f: impl Fn(String, RwSignal<Position>) -> AnyView + Send + Sync + 'static,
138 ) -> Self {
139 self.custom_renderer = Some(Arc::new(f));
140 self
141 }
142
143 pub fn build(self) -> NodeTypeDef {
145 let menu_item = self.typed_def.to_menu_item();
146
147 if let Some(renderer) = self.custom_renderer {
148 return NodeTypeDef {
149 menu_item,
150 renderer: Arc::new(move |id, pos, _, _| renderer(id, pos)),
151 };
152 }
153
154 let typed_ports = self.typed_def.ports;
155 let label = self.typed_def.label;
156 let category = self.typed_def.category;
157 let body = self.body;
158 let port_slots = self.port_slots;
159 let dynamic_inputs = self.dynamic_inputs;
160 let dynamic_outputs = self.dynamic_outputs;
161
162 let renderer = Arc::new(
163 move |node_id: String,
164 position: RwSignal<Position>,
165 global_slots: &PortTypeSlots,
166 header_renderer: &Option<HeaderRenderer>| {
167 let label = label.clone();
168 let typed_ports = typed_ports.clone();
169 let body = body.clone();
170 let port_slots = port_slots.clone();
171 let global_slots = global_slots.clone();
172 let dynamic_inputs = dynamic_inputs.clone();
173 let dynamic_outputs = dynamic_outputs.clone();
174 let nid = node_id.clone();
175
176 let static_inputs: Vec<TypedPort<T>> = typed_ports
177 .iter()
178 .filter(|p| p.direction == PortDirection::Input)
179 .cloned()
180 .collect();
181 let static_outputs: Vec<TypedPort<T>> = typed_ports
182 .iter()
183 .filter(|p| p.direction == PortDirection::Output)
184 .cloned()
185 .collect();
186
187 let nid_in = nid.clone();
189 let ps1 = port_slots.clone();
190 let gs1 = global_slots.clone();
191 let dyn_in = dynamic_inputs.as_ref().map(|f| f(nid.clone()));
192 let inputs_fn = ViewFn::from(move || {
193 let mut views: Vec<AnyView> = static_inputs
194 .iter()
195 .map(|port| render_port::<T>(&nid_in, port, &ps1, &gs1, true))
196 .collect();
197
198 if let Some(ref dyn_signal) = dyn_in {
199 for port in &dyn_signal.get() {
200 views.push(render_port::<T>(&nid_in, port, &ps1, &gs1, true));
201 }
202 }
203
204 views.into_iter().collect_view().into_any()
205 });
206
207 let nid_out = nid.clone();
208 let ps2 = port_slots.clone();
209 let gs2 = global_slots.clone();
210 let dyn_out = dynamic_outputs.as_ref().map(|f| f(nid.clone()));
211 let outputs_fn = ViewFn::from(move || {
212 let mut views: Vec<AnyView> = static_outputs
213 .iter()
214 .map(|port| render_port::<T>(&nid_out, port, &ps2, &gs2, false))
215 .collect();
216
217 if let Some(ref dyn_signal) = dyn_out {
218 for port in &dyn_signal.get() {
219 views.push(render_port::<T>(&nid_out, port, &ps2, &gs2, false));
220 }
221 }
222
223 views.into_iter().collect_view().into_any()
224 });
225
226 let category = category.clone();
227 let accent = category
228 .as_ref()
229 .and_then(|c| c.color.clone())
230 .unwrap_or_default();
231 let custom_header = header_renderer.clone();
232 let header_content: Children = Box::new(move || {
233 if let Some(ref renderer) = custom_header {
234 return renderer(label.clone(), category.clone());
235 }
236 let cat_view = category.as_ref().map(|cat| {
238 let color = cat.color.clone().unwrap_or_else(|| "#71717a".into());
239 let name = cat.name.clone();
240 let style = format!(
241 "color: {color}; font-weight: 400; margin-left: auto; font-size: 10px;"
242 );
243 view! { <span style=style>{name}</span> }
244 });
245 view! {
246 <div style="display: flex; justify-content: space-between; align-items: center; width: 100%;">
247 <span>{label.clone()}</span>
248 {cat_view}
249 </div>
250 }.into_any()
251 });
252
253 let nid_body = node_id.clone();
254 let body_content: Children = body
255 .map(|b| Box::new(move || b(nid_body.clone())) as Children)
256 .unwrap_or_else(|| Box::new(|| ().into_any()));
257
258 let node_marker: PhantomData<(String, String, T)> = PhantomData;
259
260 view! {
261 <Node
262 id=node_id
263 position=position
264 _marker=node_marker
265 header=header_content
266 body=body_content
267 inputs=inputs_fn
268 outputs=outputs_fn
269 accent_color=accent
270 />
271 }
272 .into_any()
273 },
274 );
275
276 NodeTypeDef {
277 menu_item,
278 renderer,
279 }
280 }
281}
282
283pub type PortTypeSlots = HashMap<(String, PortDirection), PortSlot>;
285
286pub type HeaderRenderer = Arc<dyn Fn(String, Option<Category>) -> AnyView + Send + Sync>;
288
289#[derive(Clone)]
291pub struct NodeTypeDef {
292 pub menu_item: NodeMenuItem,
294 renderer: RendererFn,
296}
297
298impl NodeTypeDef {
299 pub fn custom(
301 menu_item: NodeMenuItem,
302 renderer: impl Fn(String, RwSignal<Position>) -> AnyView + Send + Sync + 'static,
303 ) -> Self {
304 Self {
305 menu_item,
306 renderer: Arc::new(move |id, pos, _, _| renderer(id, pos)),
307 }
308 }
309
310 pub fn render(
312 &self,
313 id: String,
314 position: RwSignal<Position>,
315 global_slots: &PortTypeSlots,
316 header_renderer: &Option<HeaderRenderer>,
317 ) -> AnyView {
318 (self.renderer)(id, position, global_slots, header_renderer)
319 }
320}
321
322#[derive(Clone, Default)]
324pub struct NodeTypeRegistry {
325 types: HashMap<String, NodeTypeDef>,
326 order: Vec<String>,
327 port_type_slots: HashMap<(String, PortDirection), PortSlot>,
329 header_renderer: Option<HeaderRenderer>,
331}
332
333impl NodeTypeRegistry {
334 pub fn new() -> Self {
335 Self::default()
336 }
337
338 pub fn set_header_renderer(
341 &mut self,
342 f: impl Fn(String, Option<Category>) -> AnyView + Send + Sync + 'static,
343 ) {
344 self.header_renderer = Some(Arc::new(f));
345 }
346
347 pub fn register_port_type_slot<T: PortType>(
350 &mut self,
351 port_type: T,
352 direction: PortDirection,
353 f: impl Fn(String) -> AnyView + Send + Sync + 'static,
354 ) {
355 self.port_type_slots
356 .insert((port_type.type_id(), direction), Arc::new(f));
357 }
358
359 pub fn register(&mut self, def: NodeTypeDef) {
360 let id = def.menu_item.id.clone();
361 self.order.push(id.clone());
362 self.types.insert(id, def);
363 }
364
365 pub fn menu_items(&self) -> Vec<NodeMenuItem> {
366 self.order
367 .iter()
368 .filter_map(|id| self.types.get(id).map(|d| d.menu_item.clone()))
369 .collect()
370 }
371
372 pub fn render(
373 &self,
374 type_id: &str,
375 node_id: String,
376 position: RwSignal<Position>,
377 ) -> Option<AnyView> {
378 self.types.get(type_id).map(|def| {
379 def.render(
380 node_id,
381 position,
382 &self.port_type_slots,
383 &self.header_renderer,
384 )
385 })
386 }
387
388 pub fn get(&self, type_id: &str) -> Option<&NodeTypeDef> {
389 self.types.get(type_id)
390 }
391}