jellyflow-runtime 0.2.0

Headless store, rules, schema, profile, and change pipeline for Jellyflow.
Documentation 
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

use std::collections::BTreeMap;

use crate::runtime::geometry::CanvasBounds;
use jellyflow_core::core::{CanvasRect, Graph, GroupId, NodeId};
use jellyflow_core::ops::GraphOp;

use super::candidates::DragCandidate;
use super::constraints::candidate_bounds_at;
use super::types::NodeDragItem;

pub(super) fn parent_expansion_ops(
    graph: &Graph,
    candidates: &[DragCandidate],
    items: &[NodeDragItem],
) -> Vec<GraphOp> {
    let item_targets = items
        .iter()
        .map(|item| (item.node, item.to))
        .collect::<BTreeMap<NodeId, _>>();
    let mut expanded_by_parent = BTreeMap::<GroupId, CanvasRect>::new();

    for candidate in candidates {
        if !candidate.expand_parent {
            continue;
        }
        let Some(parent) = candidate.parent else {
            continue;
        };
        let Some(target) = item_targets.get(&candidate.node).copied() else {
            continue;
        };
        let Some(parent_rect) = graph.groups.get(&parent).map(|group| group.rect) else {
            continue;
        };
        let Some(child_bounds) = candidate_bounds_at(*candidate, target) else {
            continue;
        };
        let current_rect = expanded_by_parent
            .get(&parent)
            .copied()
            .unwrap_or(parent_rect);
        let Some(expanded_rect) = expand_rect(current_rect, child_bounds.to_rect()) else {
            continue;
        };

        expanded_by_parent.insert(parent, expanded_rect);
    }

    expanded_by_parent
        .into_iter()
        .filter_map(|(id, to)| {
            let from = graph.groups.get(&id)?.rect;
            (from != to).then_some(GraphOp::SetGroupRect { id, from, to })
        })
        .collect()
}

fn expand_rect(parent: CanvasRect, child: CanvasRect) -> Option<CanvasRect> {
    let parent_bounds = CanvasBounds::from_rect(parent)?;
    let child_bounds = CanvasBounds::from_rect(child)?;
    Some(parent_bounds.union(child_bounds).to_rect())
}