bnto-core 0.1.3

Core WASM engine library for Bnto — shared types, traits, and orchestration
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

// Editor mutations — all state changes that push undo snapshots.

use std::collections::HashMap;

use crate::metadata::NodeTypeInfo;

use super::types::{EditorModel, EditorNode, EditorSnapshot};

impl EditorModel {
    /// Add a node with defaults populated from engine metadata.
    pub fn add_node(&mut self, node_type: &str, info: &NodeTypeInfo) {
        self.push_undo();
        let id = format!("{}-{}", node_type, self.nodes.len() + 1);
        self.nodes.push(EditorNode {
            id,
            node_type: node_type.to_string(),
            label: info.label.clone(),
            params: HashMap::new(),
            expanded: false,
        });
        self.selected_index = Some(self.nodes.len() - 1);
        self.dirty = true;
    }

    /// Add a node with pre-populated default parameter values from metadata.
    pub fn add_node_with_defaults(
        &mut self,
        node_type: &str,
        info: &NodeTypeInfo,
        param_defaults: &[(String, serde_json::Value)],
    ) {
        self.push_undo();
        let id = format!("{}-{}", node_type, self.nodes.len() + 1);
        let params: HashMap<String, serde_json::Value> = param_defaults.iter().cloned().collect();
        self.nodes.push(EditorNode {
            id,
            node_type: node_type.to_string(),
            label: info.label.clone(),
            params,
            expanded: false,
        });
        self.selected_index = Some(self.nodes.len() - 1);
        self.dirty = true;
    }

    /// Remove the node at the given index.
    pub fn remove_node(&mut self, index: usize) {
        if index >= self.nodes.len() {
            return;
        }
        self.push_undo();
        self.nodes.remove(index);
        self.selected_index = if self.nodes.is_empty() {
            None
        } else {
            Some(index.min(self.nodes.len() - 1))
        };
        self.dirty = true;
    }

    /// Swap nodes at positions `from` and `to`.
    pub fn reorder(&mut self, from: usize, to: usize) {
        if from >= self.nodes.len() || to >= self.nodes.len() || from == to {
            return;
        }
        self.push_undo();
        self.nodes.swap(from, to);
        self.selected_index = Some(to);
        self.dirty = true;
    }

    /// Update a single parameter value on the node at `index`.
    pub fn update_param(&mut self, index: usize, key: &str, value: serde_json::Value) {
        if index >= self.nodes.len() {
            return;
        }
        self.push_undo();
        self.nodes[index].params.insert(key.to_string(), value);
        self.dirty = true;
    }

    /// Undo the last mutation.
    pub fn undo(&mut self) {
        if let Some(snapshot) = self.undo_stack.pop() {
            let current = EditorSnapshot::capture(self);
            self.redo_stack.push(current);
            self.restore(&snapshot);
        }
    }

    /// Redo the last undone mutation.
    pub fn redo(&mut self) {
        if let Some(snapshot) = self.redo_stack.pop() {
            let current = EditorSnapshot::capture(self);
            self.undo_stack.push(current);
            self.restore(&snapshot);
        }
    }

    /// Mark the model as clean (after a successful save).
    pub fn mark_clean(&mut self) {
        self.dirty = false;
    }

    fn push_undo(&mut self) {
        self.undo_stack.push(EditorSnapshot::capture(self));
        self.redo_stack.clear();
    }

    fn restore(&mut self, snapshot: &EditorSnapshot) {
        self.recipe_name = snapshot.recipe_name.clone();
        self.recipe_description = snapshot.recipe_description.clone();
        self.nodes = snapshot.nodes.clone();
        self.selected_index = if self.nodes.is_empty() {
            None
        } else {
            self.selected_index.map(|i| i.min(self.nodes.len() - 1))
        };
    }
}