Developer Tools

use dioxus_devtools::connect;

fn main() {
    // Connect to devserver and handle messages
    connect(|msg| {
        match msg {
            DevserverMsg::HotReload(hot_reload) => {
                println!("Hot reload: {} templates updated", hot_reload.templates.len());
            }
            DevserverMsg::Shutdown => {
                println!("Devserver shutting down");
            }
        }
    });
    
    // Your app code...
}

pub enum DevserverMsg {
    /// Hot reload message with template updates
    HotReload(HotReloadMsg),
    
    /// Server is shutting down
    Shutdown,
}

pub struct HotReloadMsg {
    /// Updated RSX templates
    pub templates: Vec<HotReloadedTemplate>,
    
    /// Jump table for code patching (Subsecond)
    pub jump_table: Option<Vec<JumpTableEntry>>,
    
    /// Target build ID
    pub for_build_id: Option<u64>,
    
    /// Target process ID
    pub for_pid: Option<u32>,
}

use dioxus_devtools::{apply_changes, HotReloadMsg};

fn handle_hot_reload(dom: &VirtualDom, msg: &HotReloadMsg) {
    // Apply template changes to the VirtualDOM
    apply_changes(dom, msg);
    
    // The VirtualDOM will automatically re-render affected components
}

use dioxus_devtools::connect_subsecond;

fn main() {
    // Automatically handles code patches
    connect_subsecond();
    
    // Your app continues running with hot-patched code
}

use dioxus::prelude::*;

fn debug_component() -> Element {
    let dom = use_hook(|| VirtualDom::new(inner_app));
    
    // Inspect scopes
    if let Some(scope) = dom.get_scope(ScopeId(1)) {
        println!("Scope height: {}", scope.height());
        println!("Scope name: {}", scope.name());
    }
    
    rsx! { "Debug info logged" }
}

use dioxus::prelude::*;

#[component]
fn DebuggableComponent() -> Element {
    let count = use_signal(|| 0);
    
    // Access scope for debugging
    let scope = use_hook(|| current_scope_id());
    
    use_effect(move || {
        println!("Component rendered with count: {}", count());
    });
    
    rsx! {
        button { 
            onclick: move |_| count += 1,
            "Count: {count}"
        }
    }
}

use tracing::{info, debug, trace};
use tracing_subscriber;

fn main() {
    // Enable tracing
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::DEBUG)
        .init();
    
    // VirtualDOM operations are automatically traced
    let mut dom = VirtualDom::new(app);
    dom.rebuild_in_place();  // Emits trace events
}

use std::time::Instant;
use dioxus::prelude::*;

#[component]
fn ProfiledComponent() -> Element {
    let render_count = use_signal(|| 0);
    
    use_effect(move || {
        let start = Instant::now();
        render_count += 1;
        let duration = start.elapsed();
        println!("Render #{}: {:?}", render_count(), duration);
    });
    
    rsx! { "Profiled component" }
}

use dioxus::prelude::*;

fn profile_memory() {
    let dom = VirtualDom::new(app);
    
    // Count scopes
    let scope_count = dom.scopes.len();
    println!("Active scopes: {}", scope_count);
    
    // Inspect runtime state
    let runtime = dom.runtime();
    let task_count = runtime.tasks.borrow().len();
    println!("Active tasks: {}", task_count);
}

use dioxus::prelude::*;
use dioxus_devtools::DevserverMsg;

#[derive(Clone)]
struct DevToolsState {
    connected: Signal<bool>,
    messages: Signal<Vec<String>>,
}

#[component]
fn DevToolsPanel() -> Element {
    let state = use_context::<DevToolsState>();
    
    rsx! {
        div { class: "devtools-panel",
            h2 { "DevTools" }
            
            if state.connected() {
                div { "Connected to devserver" }
            } else {
                div { "Disconnected" }
            }
            
            div { class: "messages",
                for msg in state.messages() {
                    div { "{msg}" }
                }
            }
        }
    }
}

use dioxus_devtools::{connect_at, DevserverMsg};

fn custom_devtools_handler() {
    let endpoint = "ws://localhost:8080/_dioxus".to_string();
    
    connect_at(endpoint, |msg| {
        match msg {
            DevserverMsg::HotReload(reload_msg) => {
                // Custom handling
                log::info!("Hot reload: {} files changed", reload_msg.templates.len());
                
                // Show notification
                show_notification("Code updated!");
            }
            DevserverMsg::Shutdown => {
                log::warn!("Devserver disconnected");
            }
        }
    });
}

use dioxus_devtools::serve_subsecond;

#[tokio::main]
async fn main() {
    serve_subsecond(app_main).await;
}

async fn app_main() {
    // Your application logic
    // Changes to this function will be hot-patched
    println!("App running!");
    
    loop {
        // Your event loop
        tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    }
}

use dioxus_devtools::serve_subsecond_with_args;

#[tokio::main]
async fn main() {
    let config = AppConfig { port: 3000 };
    serve_subsecond_with_args(config, app_main).await;
}

async fn app_main(config: AppConfig) {
    println!("Starting server on port {}", config.port);
    // Implementation...
}

ws://localhost:8080/_dioxus?aslr_reference={ref}&build_id={id}&pid={pid}

{
  "HotReload": {
    "templates": [
      {
        "key": {
          "file": "src/app.rs",
          "line": 10,
          "column": 5,
          "index": 0
        },
        "template": { /* VNode data */ }
      }
    ],
    "jump_table": null,
    "for_build_id": 12345,
    "for_pid": 67890
  }
}

// Check if connected to devserver
let endpoint = dioxus_cli_config::devserver_ws_endpoint();
if endpoint.is_none() {
    eprintln!("Not running under dx serve");
}

use subsecond::PatchError;

let result = unsafe { subsecond::apply_patch(jump_table) };
match result {
    Ok(_) => println!("Patch applied successfully"),
    Err(PatchError::LoadError(e)) => eprintln!("Failed to load patch: {}", e),
    Err(PatchError::SymbolError(e)) => eprintln!("Symbol error: {}", e),
}