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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use crate::runtime::events::{
    NodeGraphGestureEvent, NodeResizeEnd, NodeResizeEndOutcome, NodeResizeStart, NodeResizeUpdate,
};
use crate::runtime::store::{DispatchError, DispatchOutcome, NodeGraphStore};

use super::planner::{plan_node_pointer_resize_with_policy_extent, plan_node_resize_with_context};
use super::session::{NodeResizeSession, NodeResizeSessionUpdateRequest};
use super::types::{
    NodePointerResizeRequest, NodeResizeContext, NodeResizePlan, NodeResizeRequest,
};

#[derive(Debug, Clone)]
pub struct NodeResizeSessionUpdateOutcome {
    pub update: NodeResizeUpdate,
    pub dispatch: DispatchOutcome,
}

#[derive(Debug, Clone)]
pub struct NodeResizeSessionOutcome {
    pub start: NodeResizeStart,
    pub update: Option<NodeResizeSessionUpdateOutcome>,
    pub end: NodeResizeEnd,
}

impl NodeResizeSessionOutcome {
    pub fn end_outcome(&self) -> NodeResizeEndOutcome {
        self.end.outcome
    }

    pub fn committed_update(&self) -> Option<&NodeResizeSessionUpdateOutcome> {
        self.update.as_ref()
    }
}

impl NodeGraphStore {
    /// Plans a node resize update against the store's current graph.
    pub fn plan_node_resize(&self, request: NodeResizeRequest) -> Option<NodeResizePlan> {
        plan_node_resize_with_context(self.graph(), self.resize_context(), request)
    }

    /// Commits a node resize update through the normal store dispatch path.
    pub fn apply_node_resize(
        &mut self,
        request: NodeResizeRequest,
    ) -> Result<Option<DispatchOutcome>, DispatchError> {
        let Some(plan) = self.plan_node_resize(request) else {
            return Ok(None);
        };
        self.dispatch_transaction(plan.transaction()).map(Some)
    }

    /// Plans a pointer-driven node resize update against the store's current graph.
    pub fn plan_node_pointer_resize(
        &self,
        request: NodePointerResizeRequest,
    ) -> Option<NodeResizePlan> {
        let interaction = self.resolved_interaction_state();
        let node_drag = interaction.node_drag_interaction();
        let node_origin = node_drag.node_origin.normalized();
        plan_node_pointer_resize_with_policy_extent(
            self.graph(),
            NodeResizeContext::new((node_origin.x, node_origin.y)),
            node_drag.node_extent,
            request,
        )
    }

    /// Commits a pointer-driven node resize update through the normal store dispatch path.
    pub fn apply_node_pointer_resize(
        &mut self,
        request: NodePointerResizeRequest,
    ) -> Result<Option<DispatchOutcome>, DispatchError> {
        let Some(plan) = self.plan_node_pointer_resize(request) else {
            return Ok(None);
        };
        self.dispatch_transaction(plan.transaction()).map(Some)
    }

    /// Emits the start event for a headless pointer-driven node resize session.
    pub fn start_node_resize_session(&mut self, session: NodeResizeSession) {
        self.emit_gesture(NodeGraphGestureEvent::NodeResizeStart(session.start()));
    }

    /// Commits one pointer-driven session update and emits the derived resize update event.
    pub fn apply_node_resize_session_update(
        &mut self,
        session: NodeResizeSession,
        request: NodeResizeSessionUpdateRequest,
    ) -> Result<Option<NodeResizeSessionUpdateOutcome>, DispatchError> {
        let Some(plan) = self.plan_node_pointer_resize(session.pointer_resize_request(request))
        else {
            return Ok(None);
        };
        let update = session.update(&plan, request);
        let dispatch = self.dispatch_transaction(plan.transaction())?;
        self.emit_gesture(NodeGraphGestureEvent::NodeResizeUpdate(update.clone()));

        Ok(Some(NodeResizeSessionUpdateOutcome { update, dispatch }))
    }

    /// Emits the end event for a headless pointer-driven node resize session.
    pub fn finish_node_resize_session(
        &mut self,
        session: NodeResizeSession,
        pointer: jellyflow_core::core::CanvasPoint,
        outcome: NodeResizeEndOutcome,
    ) {
        self.emit_gesture(NodeGraphGestureEvent::NodeResizeEnd(
            session.end(pointer, outcome),
        ));
    }

    /// Runs a one-update pointer resize session through start, commit/update, and end events.
    pub fn apply_node_resize_session(
        &mut self,
        session: NodeResizeSession,
        request: NodeResizeSessionUpdateRequest,
    ) -> Result<NodeResizeSessionOutcome, DispatchError> {
        let start = session.start();
        self.emit_gesture(NodeGraphGestureEvent::NodeResizeStart(start.clone()));
        let update = self.apply_node_resize_session_update(session, request)?;
        let outcome = if update.is_some() {
            NodeResizeEndOutcome::Committed
        } else {
            NodeResizeEndOutcome::NoOp
        };
        let end = session.end(request.current, outcome);
        self.emit_gesture(NodeGraphGestureEvent::NodeResizeEnd(end.clone()));

        Ok(NodeResizeSessionOutcome { start, update, end })
    }

    fn resize_context(&self) -> NodeResizeContext {
        let interaction = self.resolved_interaction_state();
        let node_drag = interaction.node_drag_interaction();
        let node_origin = node_drag.node_origin.normalized();
        NodeResizeContext::new((node_origin.x, node_origin.y))
    }
}