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

use jellyflow_core::core::{
    CanvasPoint, CanvasRect, CanvasSize, Graph, GraphId, Group, GroupId, Node, NodeId, NodeKindKey,
};

pub(super) struct DragFixture {
    pub(super) graph: Graph,
    pub(super) enabled: NodeId,
    pub(super) disabled: NodeId,
    pub(super) hidden: NodeId,
    pub(super) missing: NodeId,
    pub(super) selected_low: NodeId,
    pub(super) selected_high: NodeId,
    pub(super) child_in_selected_group: NodeId,
    pub(super) selected_group: GroupId,
}

pub(super) fn drag_fixture() -> DragFixture {
    let mut graph = Graph::new(GraphId::from_u128(1));
    let selected_low = NodeId::from_u128(5);
    let enabled = NodeId::from_u128(10);
    let disabled = NodeId::from_u128(20);
    let hidden = NodeId::from_u128(30);
    let missing = NodeId::from_u128(40);
    let selected_high = NodeId::from_u128(60);
    let child_in_selected_group = NodeId::from_u128(70);
    let selected_group = GroupId::from_u128(100);

    graph.nodes.insert(
        selected_low,
        node(CanvasPoint { x: 0.0, y: 0.0 }, None, false),
    );
    graph
        .nodes
        .insert(enabled, node(CanvasPoint { x: 10.0, y: 20.0 }, None, false));
    graph.nodes.insert(
        disabled,
        node(CanvasPoint { x: 200.0, y: 0.0 }, Some(false), false),
    );
    graph
        .nodes
        .insert(hidden, node(CanvasPoint { x: 10.0, y: 20.0 }, None, true));
    graph.nodes.insert(
        selected_high,
        node(CanvasPoint { x: 100.0, y: 0.0 }, None, false),
    );
    graph.groups.insert(
        selected_group,
        Group {
            title: "Selected Group".to_owned(),
            rect: CanvasRect {
                origin: CanvasPoint { x: 280.0, y: -20.0 },
                size: CanvasSize {
                    width: 80.0,
                    height: 80.0,
                },
            },
            color: None,
        },
    );
    graph.nodes.insert(
        child_in_selected_group,
        node_with_parent(
            CanvasPoint { x: 300.0, y: 0.0 },
            None,
            false,
            selected_group,
        ),
    );

    DragFixture {
        graph,
        enabled,
        disabled,
        hidden,
        missing,
        selected_low,
        selected_high,
        child_in_selected_group,
        selected_group,
    }
}

fn node_with_parent(
    pos: CanvasPoint,
    draggable: Option<bool>,
    hidden: bool,
    parent: GroupId,
) -> Node {
    let mut node = node(pos, draggable, hidden);
    node.parent = Some(parent);
    node
}

fn node(pos: CanvasPoint, draggable: Option<bool>, hidden: bool) -> Node {
    Node {
        kind: NodeKindKey::new("test.node"),
        kind_version: 1,
        pos,
        origin: None,
        selectable: None,
        focusable: None,
        draggable,
        connectable: None,
        deletable: None,
        parent: None,
        extent: None,
        expand_parent: None,
        size: None,
        hidden,
        collapsed: false,
        ports: Vec::new(),
        data: serde_json::Value::Null,
    }
}