jsbind 0.1.44

Bindings for basic JS types required for webbind
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

use crate::utils::*;
use crate::{any::Any, array::Uint8Array};
use alloc::string::String;

/// JavaScript `TextEncoder` (`new TextEncoder()`).
#[derive(Clone, Debug, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct TextEncoder {
    inner: emlite::Val,
}
bind!(TextEncoder);
impl_dyn_cast!(TextEncoder);

impl Default for TextEncoder {
    fn default() -> Self {
        Self::new()
    }
}

impl TextEncoder {
    /// `new TextEncoder()` (always UTF-8 in browsers/Node).
    pub fn new() -> Self {
        emlite::Val::global("TextEncoder").new(&[]).as_::<Self>()
    }

    /// `encoder.encode(str)` → `Uint8Array`
    pub fn encode(&self, s: &str) -> Uint8Array {
        self.inner.call("encode", &[s.into()]).as_::<Uint8Array>()
    }

    /// `encoder.encodeInto(src, dst)` → `{ read, written }`
    pub fn encode_into(&self, src: &str, dst: &mut Uint8Array) -> (usize, usize) {
        let res = self
            .inner
            .call("encodeInto", &[src.into(), dst.clone().into()]);
        let read = res.get("read").as_::<u32>() as usize;
        let written = res.get("written").as_::<u32>() as usize;
        (read, written)
    }
}

/// JavaScript `TextDecoder`
#[derive(Clone, Debug, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct TextDecoder {
    inner: emlite::Val,
}
bind!(TextDecoder);
impl_dyn_cast!(TextDecoder);

impl TextDecoder {
    /// `new TextDecoder(label?, options?)`
    pub fn new(label: Option<String>, opts: Option<&Any>) -> Self {
        let ctor = emlite::Val::global("TextDecoder");
        match (label, opts) {
            (Some(l), Some(o)) => ctor.new(&[l.into(), o.clone()]).as_::<Self>(),
            (Some(l), None) => ctor.new(&[l.into()]).as_::<Self>(),
            (None, Some(o)) => ctor.new(&[o.clone()]).as_::<Self>(),
            (None, None) => ctor.new(&[]).as_::<Self>(),
        }
    }

    /// `decoder.decode(input)` – UTF-8 → `String`.
    pub fn decode(&self, bytes: &Uint8Array) -> Option<String> {
        self.inner.call("decode", &[bytes.clone().into()]).as_()
    }
}