bun_runtime 0.1.0

Bao runtime integration — JS engine + Bun API + event loop
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

// @trace REQ-ENG-006 [api:node:trace_events]
//
// Node.js trace_events module stub. Bao does not implement Chrome trace event
// categories. createTracing() returns a disabled Tracing object;
// getEnabledCategories() returns empty string.

use ::std::ptr::NonNull;
use mozjs::jsapi::*;
use mozjs::jsval::{BooleanValue, ObjectValue, UndefinedValue};
use mozjs::rooted;
use mozjs::rust::wrappers2 as w2;

use crate::require::cache_builtin;

pub fn install(cx: &mut mozjs::context::JSContext) {
    rooted!(&in(cx) let obj = unsafe { w2::JS_NewPlainObject(cx) });
    if obj.get().is_null() {
        return;
    }

    unsafe {
        let raw_cx = cx.raw_cx();

        // createTracing(opts) — returns a Tracing object with enabled=false, categories=""
        let create_fn = JS_NewFunction(
            raw_cx,
            Some(trace_create_tracing),
            1,
            0,
            c"createTracing".as_ptr(),
        );
        if !create_fn.is_null() {
            let fn_obj = JS_GetFunctionObject(create_fn);
            if !fn_obj.is_null() {
                rooted!(&in(cx) let val = ObjectValue(fn_obj));
                let _ = JS_DefineProperty(
                    raw_cx,
                    obj.handle().into(),
                    c"createTracing".as_ptr(),
                    val.handle().into(),
                    JSPROP_ENUMERATE as u32,
                );
            }
        }

        // getEnabledCategories() — returns ""
        let get_fn = JS_NewFunction(
            raw_cx,
            Some(trace_get_enabled_categories),
            0,
            0,
            c"getEnabledCategories".as_ptr(),
        );
        if !get_fn.is_null() {
            let fn_obj = JS_GetFunctionObject(get_fn);
            if !fn_obj.is_null() {
                rooted!(&in(cx) let val = ObjectValue(fn_obj));
                let _ = JS_DefineProperty(
                    raw_cx,
                    obj.handle().into(),
                    c"getEnabledCategories".as_ptr(),
                    val.handle().into(),
                    JSPROP_ENUMERATE as u32,
                );
            }
        }
    }

    cache_builtin(cx, "trace_events", obj.get());
}

/// createTracing(opts) — returns { enabled: false, categories: "" }
#[allow(unsafe_op_in_unsafe_fn)]
unsafe extern "C" fn trace_create_tracing(
    cx: *mut JSContext,
    _argc: u32,
    vp: *mut mozjs::jsval::JSVal,
) -> bool {
    let args = mozjs::jsapi::CallArgs::from_vp(vp, _argc);
    let mut wrapped_cx = mozjs::context::JSContext::from_ptr(NonNull::new_unchecked(cx));
    let cx_ref = &mut wrapped_cx;

    rooted!(&in(cx_ref) let tracing_obj = mozjs_sys::jsapi::JS_NewPlainObject(cx));
    if tracing_obj.get().is_null() {
        args.rval().set(UndefinedValue());
        return true;
    }
    // enabled = false
    rooted!(&in(cx_ref) let en = BooleanValue(false));
    let _ = JS_DefineProperty(
        cx,
        tracing_obj.handle().into(),
        c"enabled".as_ptr(),
        en.handle().into(),
        JSPROP_ENUMERATE as u32,
    );

    // categories = ""
    let cat_str = JS_NewStringCopyZ(cx, c"".as_ptr());
    if !cat_str.is_null() {
        rooted!(&in(cx_ref) let cat_val = mozjs::jsval::StringValue(&*cat_str));
        let _ = JS_DefineProperty(
            cx,
            tracing_obj.handle().into(),
            c"categories".as_ptr(),
            cat_val.handle().into(),
            JSPROP_ENUMERATE as u32,
        );
    }
    args.rval().set(ObjectValue(tracing_obj.get()));
    true
}

/// getEnabledCategories() — returns ""
#[allow(unsafe_op_in_unsafe_fn)]
unsafe extern "C" fn trace_get_enabled_categories(
    cx: *mut JSContext,
    _argc: u32,
    vp: *mut mozjs::jsval::JSVal,
) -> bool {
    let args = mozjs::jsapi::CallArgs::from_vp(vp, _argc);
    let s = JS_NewStringCopyZ(cx, c"".as_ptr());
    if !s.is_null() {
        args.rval().set(mozjs::jsval::StringValue(&*s));
    } else {
        args.rval().set(UndefinedValue());
    }
    true
}