Skip to main content

leptos_node_graph/
node_types.rs

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
12/// Override for a specific port's slot content. Takes the port label.
13type PortSlot = Arc<dyn Fn(String) -> AnyView + Send + Sync>;
14
15/// Render a single port as an InputAnchor or OutputAnchor.
16fn 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    // Resolve slot: per-port > global type > default label
28    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
55/// Builder for defining a node type.
56/// Function that produces a reactive port list for a specific node instance.
57type DynamicPortsFn<T> = Arc<dyn Fn(String) -> Signal<Vec<TypedPort<T>>> + Send + Sync>;
58
59/// Renderer function signature: (node_id, position) -> AnyView.
60type CustomRendererFn = Arc<dyn Fn(String, RwSignal<Position>) -> AnyView + Send + Sync>;
61
62/// Internal renderer: (node_id, position, global_port_type_slots, header_renderer) -> AnyView.
63type 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    /// Optional body content renderer. Receives node_id.
72    body: Option<Arc<dyn Fn(String) -> AnyView + Send + Sync>>,
73    /// Per-port children overrides (keyed by port id).
74    port_slots: HashMap<String, PortSlot>,
75    /// Dynamic input ports — called per node instance with node_id, returns reactive port list.
76    dynamic_inputs: Option<DynamicPortsFn<T>>,
77    /// Dynamic output ports — called per node instance with node_id, returns reactive port list.
78    dynamic_outputs: Option<DynamicPortsFn<T>>,
79    /// Fully custom renderer — if set, skips auto-rendering.
80    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    /// Set the body content. Receives node_id for per-instance customization.
98    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    /// Set dynamic input ports — a function called per node instance that returns
104    /// a reactive signal of ports. Ports are re-rendered when the signal changes.
105    /// Static ports from the TypedNodeDef are rendered first, dynamic ones after.
106    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    /// Set dynamic output ports — same as dynamic_inputs but for outputs.
115    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    /// Override a specific port's content. The function receives the port label.
124    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    /// Use a fully custom renderer instead of auto-generated ports.
134    /// Use this for nodes with dynamic port counts.
135    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    /// Build the node type definition.
144    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                // Build inputs ViewFn: static ports + optional dynamic ports
188                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                    // Default header: label left, colored category right
237                    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
283/// Global port type slots map.
284pub type PortTypeSlots = HashMap<(String, PortDirection), PortSlot>;
285
286/// Header renderer: (label, category) -> AnyView.
287pub type HeaderRenderer = Arc<dyn Fn(String, Option<Category>) -> AnyView + Send + Sync>;
288
289/// A registered node type: menu info + renderer.
290#[derive(Clone)]
291pub struct NodeTypeDef {
292    /// Menu item info (id, label, category, description, ports).
293    pub menu_item: NodeMenuItem,
294    /// Renderer function: (node_id, position, global_port_type_slots) -> AnyView.
295    renderer: RendererFn,
296}
297
298impl NodeTypeDef {
299    /// Create with a fully custom renderer (ignores global port type slots).
300    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    /// Render this node type.
311    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/// Registry of all available node types.
323#[derive(Clone, Default)]
324pub struct NodeTypeRegistry {
325    types: HashMap<String, NodeTypeDef>,
326    order: Vec<String>,
327    /// Global port type slot overrides.
328    port_type_slots: HashMap<(String, PortDirection), PortSlot>,
329    /// Global header renderer. If set, used for all auto-rendered nodes.
330    header_renderer: Option<HeaderRenderer>,
331}
332
333impl NodeTypeRegistry {
334    pub fn new() -> Self {
335        Self::default()
336    }
337
338    /// Set a global header renderer for all auto-rendered nodes.
339    /// Receives (label, category) and returns header content.
340    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    /// Register a global slot renderer for all ports of a given type and direction.
348    /// This applies to ALL nodes unless a specific port_slot override is set.
349    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}