use crate::host::{invoke, with_host, JsObj};
use fusevm::Value;
pub const CLASSES: &[&str] = &[
"ReadableStream",
"ReadableStreamTee",
"ReadableStreamDefaultReader",
"ReadableStreamBYOBReader",
"ReadableStreamBYOBRequest",
"ReadableByteStreamController",
"ReadableStreamDefaultController",
"TransformStream",
"TransformStreamDefaultController",
"WritableStream",
"WritableStreamDefaultWriter",
"WritableStreamDefaultController",
"ByteLengthQueuingStrategy",
"CountQueuingStrategy",
"TextEncoderStream",
"TextDecoderStream",
"CompressionStream",
"DecompressionStream",
];
pub const METHODS: &[&str] = &[];
pub fn is_class(name: &str) -> bool {
CLASSES.contains(&name)
}
pub fn is_global_class(name: &str) -> bool {
name != "ReadableStreamTee" && is_class(name)
}
thread_local! {
static PORT: std::cell::RefCell<Option<Value>> = const { std::cell::RefCell::new(None) };
}
fn port() -> Result<Value, String> {
if let Some(p) = PORT.with(|p| p.borrow().clone()) {
return Ok(p);
}
let factory = crate::eval_internal(include_str!("webstreams.js"))?;
let (node_error, promise_state) = with_host(|h| {
(
h.alloc(JsObj::Builtin("util.@@nodeError".into())),
h.alloc(JsObj::Builtin("util.@@promiseState".into())),
)
});
let made = invoke(&factory, vec![node_error, promise_state], None)?;
PORT.with(|p| *p.borrow_mut() = Some(made.clone()));
Ok(made)
}
pub fn constant(name: &str) -> Option<Value> {
if !is_class(name) {
return None;
}
let web = crate::builtins::get_property(&port().ok()?, "web").ok()?;
crate::builtins::get_property(&web, name).ok()
}
fn internal(name: &str) -> Result<Value, String> {
crate::builtins::get_property(&port()?, name)
}
fn brand(check: &str, v: &Value) -> Result<bool, String> {
if PORT.with(|p| p.borrow().is_none()) {
return Ok(false);
}
let f = internal(check)?;
let r = invoke(&f, vec![v.clone()], None)?;
Ok(with_host(|h| h.truthy(&r)))
}
pub fn is_readable_stream(v: &Value) -> Result<bool, String> {
brand("isReadableStream", v)
}
pub fn is_writable_stream(v: &Value) -> Result<bool, String> {
brand("isWritableStream", v)
}
pub fn readable_stream_cancel(args: &[Value]) -> Result<Value, String> {
let f = internal("readableStreamCancel")?;
invoke(&f, args.to_vec(), None)
}