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

use std::collections::HashMap;
use std::sync::Arc;

use fret_core::AppWindowId;

use crate::CommandId;

/// Window-scoped per-command "action availability" snapshots published by the UI layer.
///
/// This is a data-only integration seam used by cross-surface command gating (menus, command
/// palette, shortcut help) without depending on `fret-ui` internals.
///
/// Semantics:
/// - `None`: no availability information is published for this window/command (treat as unknown).
/// - `Some(true)`: command is available along the current dispatch path.
/// - `Some(false)`: command is unavailable (blocked or not reachable) along the current dispatch path.
#[derive(Debug, Default)]
pub struct WindowCommandActionAvailabilityService {
    by_window: HashMap<AppWindowId, Arc<HashMap<CommandId, bool>>>,
}

impl WindowCommandActionAvailabilityService {
    pub fn snapshot(&self, window: AppWindowId) -> Option<&HashMap<CommandId, bool>> {
        self.by_window.get(&window).map(|m| m.as_ref())
    }

    pub fn snapshot_arc(&self, window: AppWindowId) -> Option<Arc<HashMap<CommandId, bool>>> {
        self.by_window.get(&window).cloned()
    }

    pub fn available(&self, window: AppWindowId, command: &CommandId) -> Option<bool> {
        self.by_window
            .get(&window)
            .and_then(|m| m.get(command).copied())
    }

    pub fn set_snapshot(&mut self, window: AppWindowId, availability: HashMap<CommandId, bool>) {
        self.by_window.insert(window, Arc::new(availability));
    }

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

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn available_default_is_none() {
        let svc = WindowCommandActionAvailabilityService::default();
        assert_eq!(
            svc.available(AppWindowId::default(), &CommandId::from("app.preferences")),
            None
        );
    }

    #[test]
    fn set_snapshot_publishes_values() {
        let mut svc = WindowCommandActionAvailabilityService::default();
        let window = AppWindowId::default();

        let mut snapshot: HashMap<CommandId, bool> = HashMap::new();
        snapshot.insert(CommandId::from("x"), true);
        snapshot.insert(CommandId::from("y"), false);

        svc.set_snapshot(window, snapshot);

        assert_eq!(svc.available(window, &CommandId::from("x")), Some(true));
        assert_eq!(svc.available(window, &CommandId::from("y")), Some(false));
        assert_eq!(svc.available(window, &CommandId::from("z")), None);
    }
}