amberjs 1.16.1

JavaScript/TypeScript runtime built with Rust and V8
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

// Remote Debug Server Module
//
// Provides WebSocket-based remote debugging capabilities


use anyhow::Result;
use std::net::SocketAddr;
use std::collections::{BTreeMap, HashMap};
use std::sync::{Arc, Mutex};
use tokio::net::{TcpListener, TcpStream};
use serde::{Deserialize, Serialize};
use std::sync::RwLock;
use std::net::TcpListener as StdTcpListener;
/// Debug server
pub struct DebugServer {
    addr: SocketAddr,
    listener: Option<TcpListener>,
    running: Arc<RwLock<bool>>,
}
impl DebugServer {
    pub async fn new(addr: SocketAddr) -> Result<Self> {
        Ok(Self {
            addr,
            listener: None,
            running: Arc::new(Mutex::new(false)))
        })
    }
    pub async fn start(&mut self) -> Result<()> {
        let listener: _ = TcpListener::bind(self.addr).await?;
        self.listener = Some(listener);
        *self.running.write().await = true;
        Ok(())
    }
    pub async fn stop(&mut self) -> Result<()> {
        *self.running.write().await = false;
        self.listener = None;
        Ok(())
    }
    pub async fn is_running(&self) -> bool {
        *self.running.read().await
    }
}
/// Session manager
pub struct SessionManager {
    sessions: std::collections::HashMap<String, Session>,
}
#[derive(Debug, Clone)]
struct Session {
    id: String,
    client_name: String,
    created_at: String,
}
impl SessionManager {
    pub fn new() -> Self {
        Self {
            sessions: std::collections::HashMap::new(),
        }
    }
    pub async fn create_session(&mut self, client_name: String) -> Result<String> {
        let session_id: _ = format!("session_{}", self.sessions.len());
        let session: _ = Session {
            id: session_id.clone(),
            client_name,
            created_at: "now".to_string(),
        };
        self.sessions.insert(session_id.clone(), session);
        Ok(session_id)
    }
    pub async fn get_session(&self, session_id: &str) -> Option<&Session> {
        self.sessions.get(session_id)
    }
    pub async fn close_session(&mut self, session_id: &str) -> Result<()> {
        self.sessions.remove(session_id);
        Ok(())
    }
}
/// WebSocket handler
pub struct WebSocketHandler {
    // WebSocket configuration
}
impl WebSocketHandler {
    pub fn new() -> Self {
        Self {}
    }
    pub async fn serialize_message(&self, message: &DebugProtocol) -> Result<String> {
        let json: _ = serde_json::to_string(message)?;
        Ok(json)
    }
    pub async fn deserialize_message(&self, data: &str) -> Result<DebugProtocol> {
        let message: DebugProtocol = serde_json::from_str(data)?;
        Ok(message)
    }
}
/// Debug protocol messages
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum DebugProtocol {
    SetBreakpoint {
        file: String,
        line: u32,
        condition: Option<String>,
    },
    RemoveBreakpoint {
        id: u32,
    },
    Continue,
    StepOver,
    StepInto,
    StepOut,
    Evaluate {
        expression: String,
    },
}
/// Session ID type
pub type SessionId = String;