pub mod abort;
#[cfg(feature = "audio")]
pub mod audio;
#[cfg(feature = "audio")]
mod audio_worklet;
#[cfg(feature = "battery")]
pub mod battery;
pub mod blob;
#[cfg(feature = "canvas")]
pub mod canvas2d;
#[cfg(feature = "clipboard")]
pub mod clipboard;
pub mod compression;
pub mod cookies;
pub mod crypto;
pub mod dialogs;
pub mod dom;
pub mod domexception;
pub mod event_interfaces;
pub mod events;
pub mod eventsource;
pub mod fetch;
pub mod file;
pub mod file_reader;
pub mod formdata;
pub mod fsutil;
pub mod geometry;
#[doc(hidden)]
pub mod gpu_ext;
pub mod headers;
#[cfg(feature = "audio")]
pub mod hrtf;
pub mod http;
pub mod image;
#[cfg(feature = "indexeddb")]
pub mod indexeddb;
mod interface_tags;
#[cfg(feature = "audio")]
pub mod mediadevices;
#[cfg(feature = "audio")]
pub mod mediastream;
pub mod mime;
pub mod navigator;
#[cfg(feature = "audio")]
pub mod osc;
pub mod path2d;
pub mod performance;
pub mod permissions;
#[cfg(feature = "audio")]
pub mod pcm;
pub mod platform;
pub mod report_error;
pub mod request;
pub mod serialize;
#[cfg(feature = "storages")]
pub mod storage;
pub mod streams;
pub mod textcodec;
pub mod uievents;
pub mod url;
pub mod urlpattern;
pub mod util;
pub mod websocket;
pub mod xhr;
pub mod xmlser;
use core::ffi::c_void;
use util::*;
const BOOTSTRAP_JS: &str = include_str!("../bootstrap.js");
#[cfg(test)]
pub mod testing {
use crate::api::{Context, Error};
pub fn ctx() -> Context {
let c = Context::new();
unsafe {
assert_eq!(crate::ffi::redjs_web_install(c.raw()), 0);
assert_eq!(crate::ffi::redjs_webshim_install(c.raw(), core::ptr::null(), 0, core::ptr::null(), 0), 0);
}
c
}
pub fn s(c: &Context, src: &str) -> String {
match c.eval(src) {
Ok(v) => c.to_rust_string(v).unwrap_or_else(|_| "<unstringifiable>".into()),
Err(Error::Exception(e)) => {
let (m, _) = c.error_info(e);
panic!("eval threw:\n {src}\n → {m}")
}
Err(e) => panic!("eval failed:\n {src}\n → {e}"),
}
}
pub fn ok(c: &Context, src: &str) {
let got = s(c, src);
assert_eq!(got, "true", "expected true from: {src}");
}
pub fn throws(c: &Context, src: &str) -> String {
match c.eval(src) {
Err(Error::Exception(e)) => c.error_info(e).0,
Err(e) => panic!("expected a JS exception, got {e}: {src}"),
Ok(v) => {
let shown = c.to_rust_string(v).unwrap_or_else(|_| "<unstringifiable>".into());
panic!("expected a throw from `{src}`, but it returned {shown}")
}
}
}
}
#[crate::host_fn]
unsafe fn print(g: *mut c_void, cf: *mut c_void) -> u64 {
let level = dec_f64(cf_arg(cf, 0)).unwrap_or(0.0) as i32;
let msg = read_string(g, cf_arg(cf, 1)).unwrap_or_default();
match level {
2 => eprintln!("[js:warn] {msg}"),
3 => eprintln!("[js:error] {msg}"),
_ => println!("[js] {msg}"),
}
UNDEF
}
pub(crate) fn forget(gone: crate::context::Gone) {
util::forget_state(gone);
abort::forget(gone);
#[cfg(feature = "battery")]
battery::forget(gone);
blob::forget(gone);
#[cfg(feature = "canvas")]
canvas2d::forget(gone);
#[cfg(feature = "clipboard")]
clipboard::forget(gone);
domexception::forget(gone);
file::forget(gone);
file_reader::forget(gone);
#[cfg(feature = "audio")]
{
audio::forget(gone);
mediadevices::forget(gone);
mediastream::forget(gone);
}
compression::forget(gone);
dialogs::forget(gone);
event_interfaces::forget(gone);
eventsource::forget(gone);
fetch::forget(gone);
formdata::forget(gone);
fsutil::forget(gone);
geometry::forget(gone);
headers::forget(gone);
#[cfg(feature = "indexeddb")]
indexeddb::forget(gone);
navigator::forget(gone);
path2d::forget(gone);
permissions::forget(gone);
platform::forget(gone);
report_error::forget(gone);
serialize::forget(gone);
#[cfg(feature = "storages")]
storage::forget(gone);
streams::forget(gone);
uievents::forget(gone);
url::forget(gone);
urlpattern::forget(gone);
if let Some(ext) = gpu_ext::get() {
ext.forget(gone);
}
websocket::forget(gone);
xhr::forget(gone);
}
pub unsafe fn install(g: *mut c_void, scripts_root: &str, assets_root: &str) -> i32 {
crate::context::ensure(g);
if has_state(g) {
return 0; }
if !crate::web::has_scheduler(g) || !performance::clock_installed(g) {
return 2;
}
fsutil::set_roots(g, scripts_root, assets_root);
{
let n16: Vec<u16> = "__rjs_print".encode_utf16().collect();
let mut f = UNDEF;
crate::glue::rjs_function_create(g, n16.as_ptr(), n16.len(), 2, print as *const c_void, &mut f);
define(g, crate::glue::rjs_global(g), "__rjs_print", f, 2);
}
let s_performance = atom_priv(g, "redjs#performance");
let s_crypto = atom_priv(g, "redjs#crypto");
let s_subtle_crypto = atom_priv(g, "redjs#subtleCrypto");
let s_listeners = atom_priv(g, "redjs#listeners");
let s_event = atom_priv(g, "redjs#event");
let s_image = atom_priv(g, "redjs#imageBitmap");
let s_image_request = atom_priv(g, "redjs#imageRequest");
let s_usp = atom_priv(g, "redjs#searchParams");
let s_iter_target = atom_priv(g, "redjs#iterTarget");
let a_type = atom(g, "type");
let a_cb = atom(g, "callback");
let a_flags = atom(g, "flags");
let a_handle_event = atom(g, "handleEvent");
let json_parse = {
let global = crate::glue::rjs_global(g);
let json = get(g, global, "JSON");
let parse = get(g, json, "parse");
crate::ffi::redjs_protect(g, parse);
parse
};
let global_proxy = get(g, crate::glue::rjs_global(g), "globalThis");
crate::ffi::redjs_protect(g, global_proxy);
let st = put_state(g, WebState {
g,
global_proxy,
s_performance,
s_crypto,
s_subtle_crypto,
s_listeners,
s_event,
s_image,
s_image_request,
s_usp,
s_iter_target,
a_type,
a_cb,
a_flags,
a_handle_event,
event: Class { ctor: UNDEF, proto: UNDEF },
custom_event: Class { ctor: UNDEF, proto: UNDEF },
event_target: Class { ctor: UNDEF, proto: UNDEF },
blob_class: core::ptr::null_mut(),
blob: Class { ctor: UNDEF, proto: UNDEF },
url_class: core::ptr::null_mut(),
url: Class { ctor: UNDEF, proto: UNDEF },
usp_class: core::ptr::null_mut(),
usp: Class { ctor: UNDEF, proto: UNDEF },
usp_iter_class: core::ptr::null_mut(),
usp_iter_proto: UNDEF,
bitmap_class: core::ptr::null_mut(),
bitmap: Class { ctor: UNDEF, proto: UNDEF },
image: Class { ctor: UNDEF, proto: UNDEF },
response_class: core::ptr::null_mut(),
response: Class { ctor: UNDEF, proto: UNDEF },
document: UNDEF,
elements: UNDEF,
json_parse,
});
let st_mut = st as *const WebState as *mut WebState;
let (event, custom_event, event_target) = events::install(g);
let ev_proto = event.proto;
(*st_mut).event = event;
(*st_mut).custom_event = custom_event;
let et_proto = event_target.proto;
(*st_mut).event_target = event_target;
performance::install(g, et_proto);
domexception::install(g);
textcodec::install(g);
let (blob_cls, blob) = blob::install(g);
(*st_mut).blob_class = blob_cls;
(*st_mut).blob = blob;
file::install(g);
let (url_cls, url, usp_cls, usp, usp_iter_cls, usp_iter_proto) = url::install(g);
(*st_mut).url_class = url_cls;
(*st_mut).url = url;
(*st_mut).usp_class = usp_cls;
(*st_mut).usp = usp;
(*st_mut).usp_iter_class = usp_iter_cls;
(*st_mut).usp_iter_proto = usp_iter_proto;
let (bitmap_cls, bitmap, image) = image::install(g, et_proto);
(*st_mut).bitmap_class = bitmap_cls;
(*st_mut).bitmap = bitmap;
(*st_mut).image = image;
let (resp_cls, response) = fetch::install(g);
(*st_mut).response_class = resp_cls;
(*st_mut).response = response;
let (document, elements) = dom::install(g, et_proto);
(*st_mut).document = document;
(*st_mut).elements = elements;
crypto::install(g);
formdata::install(g);
geometry::install(g);
path2d::install(g);
xmlser::install(g);
dialogs::install(g);
streams::install(g);
compression::install(g);
if streams::install_surface(g) != 0 {
return 1;
}
blob::install_stream(g);
uievents::install(g, ev_proto);
report_error::install(g, ev_proto);
event_interfaces::install(g, ev_proto);
urlpattern::install(g);
serialize::install(g);
navigator::install(g);
#[cfg(feature = "battery")]
battery::install(g, et_proto);
if let Some(ext) = gpu_ext::get() {
ext.install(g);
}
#[cfg(feature = "audio")]
{
audio::install(g);
mediadevices::install(g, et_proto);
mediastream::install(g);
}
abort::install(g, et_proto);
permissions::install(g, et_proto);
websocket::install(g, ev_proto, et_proto);
xhr::install(g, ev_proto, et_proto);
eventsource::install(g, et_proto);
file_reader::install(g, et_proto);
#[cfg(feature = "clipboard")]
clipboard::install(g, et_proto);
#[cfg(feature = "storages")]
if storage::install(g, ev_proto) != 0 {
return 1;
}
#[cfg(feature = "indexeddb")]
indexeddb::install(g, ev_proto, et_proto);
platform::install(g, et_proto);
#[cfg(feature = "canvas")]
canvas2d::install(g, et_proto);
let mut out = 0u64;
let url_name = "redjs/bootstrap.js";
let rc = crate::glue::rjs_eval8(
g,
BOOTSTRAP_JS.as_ptr(),
BOOTSTRAP_JS.len(),
url_name.as_ptr(),
url_name.len(),
&mut out,
);
if rc == 1 {
let (mut msg, mut stack) = (0u64, 0u64);
crate::glue::rjs_error_info(g, out, &mut msg, &mut stack);
let m = read_string(g, msg).unwrap_or_default();
eprintln!("[redjs] bootstrap.js failed: {m}");
return 1;
}
0
}
#[cfg(test)]
mod console_tests {
use super::testing::{ctx, ok};
#[test]
fn console_formats_like_a_browser_console() {
let c = ctx();
ok(&c, "Object.defineProperty(globalThis, '__rjs_print', { value: function (l, m) { globalThis.__got = m; }, configurable: true, writable: true }), true");
ok(&c, "console.log('%cinfo%c %s', 'background:#0BC;\\n color:white', '', 'hello'), __got === 'info hello'");
ok(&c, "console.error('boom:', new TypeError('bad')), __got.indexOf('boom: TypeError: bad\\n') === 0");
ok(&c, "console.log({ e: new Error('x'), n: 1n }), __got === '{\"e\":\"Error: x\",\"n\":\"1n\"}'");
ok(&c, "console.log('%d items', '42.9', 'extra'), __got === '42 items extra'");
ok(&c, "console.log('100%% %s', 'done'), __got === '100% done'");
ok(&c, "console.log('%c'), __got === '%c'");
}
}