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
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

use std::{collections::HashMap, sync::Arc};

use crate::{CommandId, DefaultKeybinding, WhenExpr};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
/// A command that should be forwarded to the host OS when supported (e.g. menu integration).
pub enum OsAction {
    Cut,
    Copy,
    Paste,
    SelectAll,
    Undo,
    Redo,
}

#[derive(Default)]
/// Registry of known commands and their metadata.
///
/// Apps typically populate this during startup and use it to drive keybinding resolution,
/// command palettes, and menu surfaces.
pub struct CommandRegistry {
    commands: HashMap<CommandId, CommandMeta>,
}

#[derive(Debug, Clone)]
/// Metadata describing a command (title, keybindings, visibility, routing scope).
pub struct CommandMeta {
    pub title: Arc<str>,
    pub description: Option<Arc<str>>,
    pub category: Option<Arc<str>>,
    pub keywords: Vec<Arc<str>>,
    pub default_keybindings: Vec<DefaultKeybinding>,
    pub when: Option<WhenExpr>,
    pub os_action: Option<OsAction>,
    pub scope: CommandScope,
    pub hidden: bool,
    pub repeatable: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
/// Routing scope for a command.
pub enum CommandScope {
    /// Routed through the focused UI node (with bubbling), per ADR 0020.
    Widget,
    /// Handled at the window/app driver boundary (e.g. create/close windows, toggle overlays).
    Window,
    /// Global, cross-window command handled by the app.
    App,
}

impl CommandMeta {
    pub fn new(title: impl Into<Arc<str>>) -> Self {
        Self {
            title: title.into(),
            description: None,
            category: None,
            keywords: Vec::new(),
            default_keybindings: Vec::new(),
            when: None,
            os_action: None,
            scope: CommandScope::Window,
            hidden: false,
            repeatable: false,
        }
    }

    pub fn with_description(mut self, description: impl Into<Arc<str>>) -> Self {
        self.description = Some(description.into());
        self
    }

    pub fn with_category(mut self, category: impl Into<Arc<str>>) -> Self {
        self.category = Some(category.into());
        self
    }

    pub fn with_keywords(
        mut self,
        keywords: impl IntoIterator<Item = impl Into<Arc<str>>>,
    ) -> Self {
        self.keywords = keywords.into_iter().map(Into::into).collect();
        self
    }

    pub fn with_default_keybindings(
        mut self,
        bindings: impl IntoIterator<Item = DefaultKeybinding>,
    ) -> Self {
        self.default_keybindings = bindings.into_iter().collect();
        self
    }

    pub fn with_when(mut self, when: WhenExpr) -> Self {
        self.when = Some(when);
        self
    }

    pub fn with_os_action(mut self, os_action: OsAction) -> Self {
        self.os_action = Some(os_action);
        self
    }

    pub fn with_scope(mut self, scope: CommandScope) -> Self {
        self.scope = scope;
        self
    }

    pub fn hidden(mut self) -> Self {
        self.hidden = true;
        self
    }

    pub fn repeatable(mut self) -> Self {
        self.repeatable = true;
        self
    }
}

impl CommandRegistry {
    pub fn register(&mut self, id: CommandId, meta: CommandMeta) {
        self.commands.insert(id, meta);
    }

    pub fn get(&self, id: CommandId) -> Option<&CommandMeta> {
        self.commands.get(&id)
    }

    pub fn iter(&self) -> impl Iterator<Item = (&CommandId, &CommandMeta)> {
        self.commands.iter()
    }
}