lcsa-core 0.1.0

Local context substrate for AI-native software - typed signals for clipboard, selection, and focus
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

use serde::{Deserialize, Serialize};
use std::fmt;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SignalUnsupportedReason {
    PlatformNotSupported,
    BackendNotImplemented,
    RequiresX11Display,
    RequiresAccessibilityPermission,
    RuntimeDependencyMissing,
}

impl SignalUnsupportedReason {
    pub fn as_str(self) -> &'static str {
        match self {
            SignalUnsupportedReason::PlatformNotSupported => "platform_not_supported",
            SignalUnsupportedReason::BackendNotImplemented => "backend_not_implemented",
            SignalUnsupportedReason::RequiresX11Display => "requires_x11_display",
            SignalUnsupportedReason::RequiresAccessibilityPermission => {
                "requires_accessibility_permission"
            }
            SignalUnsupportedReason::RuntimeDependencyMissing => "runtime_dependency_missing",
        }
    }
}

impl fmt::Display for SignalUnsupportedReason {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "status", content = "reason", rename_all = "snake_case")]
pub enum SignalSupport {
    Supported,
    Unsupported(SignalUnsupportedReason),
}

impl SignalSupport {
    pub fn as_str(self) -> String {
        match self {
            SignalSupport::Supported => "supported".to_string(),
            SignalSupport::Unsupported(reason) => format!("unsupported:{}", reason.as_str()),
        }
    }
}

impl fmt::Display for SignalSupport {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            SignalSupport::Supported => f.write_str("supported"),
            SignalSupport::Unsupported(reason) => write!(f, "unsupported:{reason}"),
        }
    }
}

impl SignalSupport {
    pub fn is_supported(self) -> bool {
        matches!(self, SignalSupport::Supported)
    }
}