boa_cli 0.22.0

Boa is a Javascript lexer, parser and compiler written in Rust. Currently, it has support for some of the language.
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

use boa_engine::{
    Context, JsNativeError, JsObject, JsResult, JsValue, NativeFunction, js_string,
    object::ObjectInitializer, property::Attribute, string::JsStrVariant,
};

fn storage(_: &JsValue, args: &[JsValue], _: &mut Context) -> JsResult<JsValue> {
    let Some(value) = args.first() else {
        return Err(JsNativeError::typ()
            .with_message("expected string argument")
            .into());
    };

    let Some(string) = value.as_string() else {
        return Err(JsNativeError::typ()
            .with_message(format!("expected string, got {}", value.type_of()))
            .into());
    };

    let storage = if string.is_static() { "static" } else { "heap" };
    Ok(js_string!(storage).into())
}

fn encoding(_: &JsValue, args: &[JsValue], _: &mut Context) -> JsResult<JsValue> {
    let Some(value) = args.first() else {
        return Err(JsNativeError::typ()
            .with_message("expected string argument")
            .into());
    };

    let Some(string) = value.as_string() else {
        return Err(JsNativeError::typ()
            .with_message(format!("expected string, got {}", value.type_of()))
            .into());
    };

    let str = string.as_str();
    let encoding = match str.variant() {
        JsStrVariant::Latin1(_) => "latin1",
        JsStrVariant::Utf16(_) => "utf16",
    };
    Ok(js_string!(encoding).into())
}

fn summary(_: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
    let Some(value) = args.first() else {
        return Err(JsNativeError::typ()
            .with_message("expected string argument")
            .into());
    };

    let Some(string) = value.as_string() else {
        return Err(JsNativeError::typ()
            .with_message(format!("expected string, got {}", value.type_of()))
            .into());
    };

    let storage = if string.is_static() { "static" } else { "heap" };
    let encoding = match string.as_str().variant() {
        JsStrVariant::Latin1(_) => "latin1",
        JsStrVariant::Utf16(_) => "utf16",
    };

    let summary = ObjectInitializer::new(context)
        .property(js_string!("storage"), js_string!(storage), Attribute::all())
        .property(
            js_string!("encoding"),
            js_string!(encoding),
            Attribute::all(),
        )
        .build();

    Ok(summary.into())
}

pub(super) fn create_string(context: &mut Context) -> JsObject {
    ObjectInitializer::new(context)
        .function(
            NativeFunction::from_fn_ptr(storage),
            js_string!("storage"),
            1,
        )
        .function(
            NativeFunction::from_fn_ptr(encoding),
            js_string!("encoding"),
            1,
        )
        .function(
            NativeFunction::from_fn_ptr(summary),
            js_string!("summary"),
            1,
        )
        .build()
}