openipc-web 0.1.28

WebAssembly bindings for openipc-rs
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

use js_sys::{Object, Reflect, Uint8Array};
use openipc_core::FecCounters;
use wasm_bindgen::prelude::*;

pub(crate) fn raw_payload_object(payload: openipc_core::RoutePayload) -> Result<Object, JsValue> {
    let object = Object::new();
    Reflect::set(
        &object,
        &JsValue::from_str("data"),
        &Uint8Array::from(payload.data.as_slice()),
    )?;
    Reflect::set(
        &object,
        &JsValue::from_str("packetSeq"),
        &JsValue::from_str(&payload.packet_seq.to_string()),
    )?;
    set_number(&object, "routeId", payload.route_id.raw() as f64)?;
    set_number(&object, "channelId", payload.channel_id.raw() as f64)?;
    Ok(object)
}

pub(crate) fn set_number(object: &Object, key: &str, value: f64) -> Result<(), JsValue> {
    Reflect::set(object, &JsValue::from_str(key), &JsValue::from_f64(value))?;
    Ok(())
}

pub(crate) fn now_ms() -> f64 {
    #[cfg(target_arch = "wasm32")]
    {
        web_sys::window()
            .and_then(|window| window.performance())
            .map(|performance| performance.now())
            .unwrap_or_else(js_sys::Date::now)
    }
    #[cfg(not(target_arch = "wasm32"))]
    {
        0.0
    }
}

pub(crate) fn elapsed_ms(start_ms: f64) -> f64 {
    let elapsed = now_ms() - start_ms;
    if elapsed.is_finite() && elapsed >= 0.0 {
        elapsed
    } else {
        0.0
    }
}

pub(crate) fn counters_json(counters: FecCounters) -> String {
    format!(
        r#"{{"totalPackets":{},"recoveredPackets":{},"lostPackets":{},"badPackets":{}}}"#,
        counters.total_packets,
        counters.recovered_packets,
        counters.lost_packets,
        counters.bad_packets
    )
}

pub(crate) fn counters_object(counters: FecCounters) -> Result<Object, JsValue> {
    let object = Object::new();
    set_number(&object, "totalPackets", counters.total_packets as f64)?;
    set_number(
        &object,
        "recoveredPackets",
        counters.recovered_packets as f64,
    )?;
    set_number(&object, "lostPackets", counters.lost_packets as f64)?;
    set_number(&object, "badPackets", counters.bad_packets as f64)?;
    Ok(object)
}

pub(crate) fn escape_json_str(value: &str) -> String {
    let mut out = String::with_capacity(value.len());
    for ch in value.chars() {
        match ch {
            '"' => out.push_str("\\\""),
            '\\' => out.push_str("\\\\"),
            '\n' => out.push_str("\\n"),
            '\r' => out.push_str("\\r"),
            '\t' => out.push_str("\\t"),
            _ => out.push(ch),
        }
    }
    out
}

pub(crate) fn ms_from_js(now_ms: f64) -> u64 {
    if now_ms.is_finite() && now_ms > 0.0 {
        now_ms.min(u64::MAX as f64) as u64
    } else {
        0
    }
}

pub(crate) fn parse_hex_u64(input: &str) -> Result<u64, JsValue> {
    let trimmed = input.trim();
    let hex = trimmed
        .strip_prefix("0x")
        .or_else(|| trimmed.strip_prefix("0X"))
        .unwrap_or(trimmed);
    u64::from_str_radix(hex, 16)
        .map_err(|err| JsValue::from_str(&format!("invalid nonce hex: {err}")))
}