jellyflow-runtime 0.3.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
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

use jellyflow_core::core::{Edge, EdgeLabelAnchor, EdgeRouteKind};
use serde::{Deserialize, Serialize};

use super::{
    BezierEdgeOptions, EdgeHitTestOptions, EdgePath, EdgePosition, SmoothStepEdgeOptions,
    bezier_edge_path, edge_path_contains_point, smoothstep_edge_path, straight_edge_path,
};

/// Effective route kind used by runtime geometry projections.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ResolvedEdgeRouteKind {
    Straight,
    Orthogonal,
    Bezier,
    SmoothStep,
}

impl From<EdgeRouteKind> for ResolvedEdgeRouteKind {
    fn from(value: EdgeRouteKind) -> Self {
        match value {
            EdgeRouteKind::Straight => Self::Straight,
            EdgeRouteKind::Orthogonal => Self::Orthogonal,
            EdgeRouteKind::Bezier => Self::Bezier,
            EdgeRouteKind::SmoothStep => Self::SmoothStep,
        }
    }
}

impl From<ResolvedEdgeRouteKind> for EdgeRouteKind {
    fn from(value: ResolvedEdgeRouteKind) -> Self {
        match value {
            ResolvedEdgeRouteKind::Straight => Self::Straight,
            ResolvedEdgeRouteKind::Orthogonal => Self::Orthogonal,
            ResolvedEdgeRouteKind::Bezier => Self::Bezier,
            ResolvedEdgeRouteKind::SmoothStep => Self::SmoothStep,
        }
    }
}

/// Adapter-facing interaction facts for an edge.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct EdgeInteractionFacts {
    pub selectable: bool,
    pub selected: bool,
    pub focusable: bool,
    pub deletable: bool,
    pub reconnect_source: bool,
    pub reconnect_target: bool,
}

impl EdgeInteractionFacts {
    pub fn can_reconnect(self) -> bool {
        self.reconnect_source || self.reconnect_target
    }
}

/// Renderer-neutral route and interaction facts for one edge.
#[derive(Debug, Clone, PartialEq)]
pub struct EdgeRouteFacts {
    pub kind: ResolvedEdgeRouteKind,
    pub endpoints: EdgePosition,
    pub path: EdgePath,
    pub label_anchor: EdgeLabelAnchor,
    pub hit_test: EdgeHitTestOptions,
    pub interaction: EdgeInteractionFacts,
}

impl EdgeRouteFacts {
    pub fn with_hit_test(mut self, hit_test: EdgeHitTestOptions) -> Self {
        self.hit_test = hit_test;
        self
    }

    pub fn with_interaction(mut self, interaction: EdgeInteractionFacts) -> Self {
        self.interaction = interaction;
        self
    }

    pub fn contains_point(&self, point: jellyflow_core::core::CanvasPoint) -> bool {
        edge_path_contains_point(&self.path, point, self.hit_test)
    }
}

/// Resolves the route style and path for an edge from persisted view hints.
pub fn resolve_edge_route_path(edge: &Edge, endpoints: EdgePosition) -> Option<EdgeRouteFacts> {
    let kind = edge
        .view
        .route_kind
        .map(ResolvedEdgeRouteKind::from)
        .unwrap_or(ResolvedEdgeRouteKind::Bezier);
    let path = match kind {
        ResolvedEdgeRouteKind::Straight => straight_edge_path(endpoints.source, endpoints.target),
        ResolvedEdgeRouteKind::Orthogonal | ResolvedEdgeRouteKind::SmoothStep => {
            smoothstep_edge_path(
                endpoints.source,
                endpoints.target,
                SmoothStepEdgeOptions::default(),
            )
        }
        ResolvedEdgeRouteKind::Bezier => bezier_edge_path(
            endpoints.source,
            endpoints.target,
            BezierEdgeOptions::default(),
        ),
    }?;

    Some(EdgeRouteFacts {
        kind,
        endpoints,
        path,
        label_anchor: edge.view.label_anchor.unwrap_or(EdgeLabelAnchor::Center),
        hit_test: EdgeHitTestOptions::default(),
        interaction: EdgeInteractionFacts {
            selectable: false,
            selected: false,
            focusable: false,
            deletable: false,
            reconnect_source: false,
            reconnect_target: false,
        },
    })
}