fret-runtime 0.1.0

Runtime abstractions and scheduling surfaces for host integration in Fret.
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

use std::collections::HashMap;

use fret_core::AppWindowId;

/// Window-scoped command availability snapshots published by the app layer.
///
/// This is a data-only integration seam used by cross-surface command gating (menus, command
/// palette, shortcuts) without depending on UI-kit or app-specific model types.
#[derive(Debug, Default)]
pub struct WindowCommandAvailabilityService {
    by_window: HashMap<AppWindowId, WindowCommandAvailability>,
}

impl WindowCommandAvailabilityService {
    pub fn snapshot(&self, window: AppWindowId) -> Option<&WindowCommandAvailability> {
        self.by_window.get(&window)
    }

    pub fn set_snapshot(&mut self, window: AppWindowId, availability: WindowCommandAvailability) {
        self.by_window.insert(window, availability);
    }

    pub fn update_snapshot(
        &mut self,
        window: AppWindowId,
        f: impl FnOnce(&mut WindowCommandAvailability),
    ) {
        let availability = self.by_window.entry(window).or_default();
        f(availability);
    }

    pub fn set_edit_availability(&mut self, window: AppWindowId, can_undo: bool, can_redo: bool) {
        self.update_snapshot(window, |availability| {
            availability.edit_can_undo = can_undo;
            availability.edit_can_redo = can_redo;
        });
    }

    pub fn set_router_availability(
        &mut self,
        window: AppWindowId,
        can_back: bool,
        can_forward: bool,
    ) {
        self.update_snapshot(window, |availability| {
            availability.router_can_back = can_back;
            availability.router_can_forward = can_forward;
        });
    }

    pub fn remove_window(&mut self, window: AppWindowId) {
        self.by_window.remove(&window);
    }
}

/// Minimal command availability surface (v1).
///
/// This is intentionally conservative: it only captures state that is hard to infer at the runner
/// boundary and is needed for native OS menus to present correct enable/disable states.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WindowCommandAvailability {
    pub edit_can_undo: bool,
    pub edit_can_redo: bool,
    pub router_can_back: bool,
    pub router_can_forward: bool,
}

impl Default for WindowCommandAvailability {
    fn default() -> Self {
        Self {
            edit_can_undo: true,
            edit_can_redo: true,
            router_can_back: false,
            router_can_forward: false,
        }
    }
}