Add streams/web module

Cargo.toml

@@ -18,6 +18,7 @@ members = [
   "modules/llrt_perf_hooks",
   "modules/llrt_process",
   "modules/llrt_stream",
+  "modules/llrt_stream_web",
   "modules/llrt_timers",
   "modules/llrt_url",
   "modules/llrt_zlib",

libs/llrt_utils/src/bytes.rs

@@ -1,7 +1,11 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 use rquickjs::{
-    ArrayBuffer, Coerced, Ctx, Exception, FromJs, IntoJs, Object, Result, TypedArray, Value,
+    atom::PredefinedAtom,
+    class::{Trace, Tracer},
+    function::Constructor,
+    ArrayBuffer, Coerced, Ctx, Exception, FromJs, IntoJs, JsLifetime, Object, Result, TypedArray,
+    Value,
 };
 
 use crate::error_messages::ERROR_MSG_ARRAY_BUFFER_DETACHED;
@@ -22,6 +26,52 @@ pub enum ObjectBytes<'js> {
     Vec(Vec<u8>),
 }
 
+// Requires manual implementation because rquickjs hasn't implemented JsLifetime for f32 or f64
+unsafe impl<'js> JsLifetime<'js> for ObjectBytes<'js> {
+    type Changed<'to> = ObjectBytes<'to>;
+}
+
+impl<'js> Trace<'js> for ObjectBytes<'js> {
+    fn trace<'a>(&self, tracer: Tracer<'a, 'js>) {
+        match self {
+            ObjectBytes::U8Array(a) => a.trace(tracer),
+            ObjectBytes::I8Array(a) => a.trace(tracer),
+            ObjectBytes::U16Array(a) => a.trace(tracer),
+            ObjectBytes::I16Array(a) => a.trace(tracer),
+            ObjectBytes::U32Array(a) => a.trace(tracer),
+            ObjectBytes::I32Array(a) => a.trace(tracer),
+            ObjectBytes::U64Array(a) => a.trace(tracer),
+            ObjectBytes::I64Array(a) => a.trace(tracer),
+            ObjectBytes::F32Array(a) => a.trace(tracer),
+            ObjectBytes::F64Array(a) => a.trace(tracer),
+            ObjectBytes::DataView(d) => d.trace(tracer),
+            ObjectBytes::Vec(v) => v.trace(tracer),
+        }
+    }
+}
+
+impl<'js> IntoJs<'js> for ObjectBytes<'js> {
+    fn into_js(self, ctx: &Ctx<'js>) -> Result<Value<'js>> {
+        match self {
+            ObjectBytes::U8Array(a) => a.into_js(ctx),
+            ObjectBytes::I8Array(a) => a.into_js(ctx),
+            ObjectBytes::U16Array(a) => a.into_js(ctx),
+            ObjectBytes::I16Array(a) => a.into_js(ctx),
+            ObjectBytes::U32Array(a) => a.into_js(ctx),
+            ObjectBytes::I32Array(a) => a.into_js(ctx),
+            ObjectBytes::U64Array(a) => a.into_js(ctx),
+            ObjectBytes::I64Array(a) => a.into_js(ctx),
+            ObjectBytes::F32Array(a) => a.into_js(ctx),
+            ObjectBytes::F64Array(a) => a.into_js(ctx),
+            ObjectBytes::DataView(d) => {
+                let ctor: Constructor = ctx.globals().get(PredefinedAtom::DataView)?;
+                ctor.construct((d,))
+            },
+            ObjectBytes::Vec(v) => v.into_js(ctx),
+        }
+    }
+}
+
 impl<'js> From<ObjectBytes<'js>> for Vec<u8> {
     fn from(value: ObjectBytes<'js>) -> Self {
         value.into_bytes()

libs/llrt_utils/src/primordials.rs

@@ -13,8 +13,15 @@ pub struct BasePrimordials<'js> {
     pub constructor_date: Constructor<'js>,
     pub constructor_error: Constructor<'js>,
     pub constructor_type_error: Constructor<'js>,
+    pub constructor_range_error: Constructor<'js>,
     pub constructor_regexp: Constructor<'js>,
+    pub constructor_uint8array: Constructor<'js>,
+    pub constructor_arraybuffer: Constructor<'js>,
     pub constructor_proxy: Constructor<'js>,
+    pub constructor_object: Constructor<'js>,
+    pub constructor_bool: Constructor<'js>,
+    pub constructor_number: Constructor<'js>,
+    pub constructor_string: Constructor<'js>,
 
     // Prototypes
     pub prototype_object: Object<'js>,
@@ -28,7 +35,6 @@ pub struct BasePrimordials<'js> {
     pub function_array_from: Function<'js>,
     pub function_array_buffer_is_view: Function<'js>,
     pub function_get_own_property_descriptor: Function<'js>,
-    pub function_number: Function<'js>,
     pub function_parse_int: Function<'js>,
     pub function_parse_float: Function<'js>,
     pub function_symbol_for: Function<'js>,
@@ -61,7 +67,7 @@ impl<'js> Primordial<'js> for BasePrimordials<'js> {
     fn new(ctx: &Ctx<'js>) -> Result<Self> {
         let globals = ctx.globals();
 
-        let constructor_object: Object = globals.get(PredefinedAtom::Object)?;
+        let constructor_object: Constructor = globals.get(PredefinedAtom::Object)?;
         let prototype_object: Object = constructor_object.get(PredefinedAtom::Prototype)?;
 
         let constructor_proxy: Constructor = globals.get(PredefinedAtom::Proxy)?;
@@ -81,8 +87,12 @@ impl<'js> Primordial<'js> for BasePrimordials<'js> {
         let constructor_regexp: Constructor = globals.get(PredefinedAtom::RegExp)?;
         let prototype_regexp: Object = constructor_regexp.get(PredefinedAtom::Prototype)?;
 
+        let constructor_uint8array: Constructor = globals.get(PredefinedAtom::Uint8Array)?;
+        let constructor_arraybuffer: Constructor = globals.get(PredefinedAtom::ArrayBuffer)?;
+
         let constructor_error: Constructor = globals.get(PredefinedAtom::Error)?;
         let constructor_type_error: Constructor = ctx.globals().get(PredefinedAtom::TypeError)?;
+        let constructor_range_error: Constructor = ctx.globals().get(PredefinedAtom::RangeError)?;
         let prototype_error: Object = constructor_error.get(PredefinedAtom::Prototype)?;
 
         let constructor_array: Object = globals.get(PredefinedAtom::Array)?;
@@ -91,12 +101,16 @@ impl<'js> Primordial<'js> for BasePrimordials<'js> {
         let constructor_array_buffer: Object = globals.get(PredefinedAtom::ArrayBuffer)?;
         let function_array_buffer_is_view: Function = constructor_array_buffer.get("isView")?;
 
-        let function_number: Function = globals.get(PredefinedAtom::Number)?;
-        let function_parse_float: Function = function_number.get("parseFloat")?;
-        let function_parse_int: Function = function_number.get("parseInt")?;
+        let constructor_bool: Constructor = globals.get(PredefinedAtom::Boolean)?;
+
+        let constructor_number: Constructor = globals.get(PredefinedAtom::Number)?;
+        let function_parse_float: Function = constructor_number.get("parseFloat")?;
+        let function_parse_int: Function = constructor_number.get("parseInt")?;
+
+        let constructor_string: Constructor = globals.get(PredefinedAtom::String)?;
 
-        let symbol_constructor: Function = globals.get(PredefinedAtom::Symbol)?;
-        let function_symbol_for: Function = symbol_constructor.get(PredefinedAtom::For)?;
+        let constructor_symbol: Constructor = globals.get(PredefinedAtom::Symbol)?;
+        let function_symbol_for: Function = constructor_symbol.get(PredefinedAtom::For)?;
 
         let symbol_custom_inspect: Symbol<'js> =
             function_symbol_for.call((CUSTOM_INSPECT_SYMBOL_DESCRIPTION,))?;
@@ -108,7 +122,14 @@ impl<'js> Primordial<'js> for BasePrimordials<'js> {
             constructor_proxy,
             constructor_error,
             constructor_type_error,
+            constructor_range_error,
             constructor_regexp,
+            constructor_uint8array,
+            constructor_arraybuffer,
+            constructor_object,
+            constructor_bool,
+            constructor_number,
+            constructor_string,
             prototype_object,
             prototype_date,
             prototype_regexp,
@@ -121,7 +142,6 @@ impl<'js> Primordial<'js> for BasePrimordials<'js> {
             function_parse_float,
             function_parse_int,
             function_symbol_for,
-            function_number,
             symbol_custom_inspect,
         })
     }

llrt_core/src/module_builder.rs

@@ -15,6 +15,7 @@ use crate::modules::{
     path::PathModule,
     perf_hooks::PerfHooksModule,
     process::ProcessModule,
+    stream_web::StreamWebModule,
     tty::TtyModule,
     url::UrlModule,
     util::UtilModule,
@@ -95,6 +96,8 @@ impl Default for ModuleBuilder {
             .with_global(crate::modules::navigator::init)
             .with_global(crate::modules::url::init)
             .with_module(UrlModule)
+            .with_module(StreamWebModule)
+            .with_global(crate::modules::stream_web::init)
             .with_global(crate::modules::http::init)
             .with_global(crate::modules::exceptions::init)
             .with_module(LlrtHexModule)

llrt_core/src/modules/console.rs

@@ -4,6 +4,7 @@ use std::{
     collections::HashSet,
     fmt::Write as FormatWrite,
     io::{stderr, stdout, IsTerminal, Write},
+    ops::Deref,
     sync::atomic::{AtomicBool, AtomicUsize, Ordering},
 };
 
@@ -716,7 +717,7 @@ impl<'js> FormatOptions<'js> {
         let object_filter = Filter::new().private().string().symbol();
 
         let custom_inspect_symbol = primordials.symbol_custom_inspect.clone();
-        let number_function = primordials.function_number.clone();
+        let number_function = primordials.constructor_number.deref().clone();
 
         let options = FormatOptions {
             color,

llrt_core/src/modules/mod.rs

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 pub use llrt_modules::{
     abort, assert, buffer, child_process, crypto, events, exceptions, fs, http, navigator, net, os,
-    path, perf_hooks, process, tty, url, zlib,
+    path, perf_hooks, process, stream_web, tty, url, zlib,
 };
 
 pub mod console;

llrt_core/src/utils/clone.rs

@@ -8,9 +8,8 @@ use llrt_utils::{
 };
 use rquickjs::{
     atom::PredefinedAtom,
-    function::This,
-    function::{Constructor, Opt},
-    Array, Ctx, Function, IntoJs, Null, Object, Result, Type, Value,
+    function::{Constructor, Opt, This},
+    Array, ArrayBuffer, Ctx, Function, IntoJs, Null, Object, Result, Type, Value,
 };
 
 use super::hash;
@@ -343,11 +342,17 @@ fn append_transfer_value<'js>(
     object_key: Option<String>,
     array_index: Option<usize>,
 ) -> Result<()> {
+    let value = if let Some(ab) = ArrayBuffer::from_value(value.clone()) {
+        ab.get::<_, Function>("transfer")?.call((This(ab),))?
+    } else {
+        value.clone()
+    };
+
     tape.push(TapeItem {
         parent,
         object_key,
         array_index,
-        value: TapeValue::Value(value.clone()),
+        value: TapeValue::Value(value),
     });
     Ok(())
 }

llrt_core/src/vm.rs

@@ -218,11 +218,6 @@ fn init(ctx: &Ctx<'_>) -> Result<()> {
     let number_proto: Object = number.get(PredefinedAtom::Prototype)?;
     number_proto.set(PredefinedAtom::ToString, Func::from(number_to_string))?;
 
-    let readable_stream_stub = ctx.eval::<Value,_>(
-            r#"class ReadableStream{constructor(){throw Error(`ReadableStream is not supported via global scope. Enable this by adding this to your code:\nimport { ReadableStream } from "stream";\nglobalThis.ReadableStream = ReadableStream;`)}};"#
-    )?;
-
-    globals.set("ReadableStream", readable_stream_stub)?;
     globals.set("global", ctx.globals())?;
     globals.set("self", ctx.globals())?;
     globals.set("load", Func::from(load))?;

llrt_modules/Cargo.toml

@@ -25,6 +25,7 @@ all = [
   "path",
   "perf-hooks",
   "process",
+  "stream-web",
   "timers",
   "url",
   "zlib",
@@ -47,6 +48,7 @@ os = ["llrt_os"]
 path = ["llrt_path"]
 process = ["llrt_process"]
 perf-hooks = ["llrt_perf_hooks"]
+stream-web = ["llrt_stream_web"]
 timers = ["llrt_timers"]
 url = ["llrt_url"]
 zlib = ["llrt_zlib"]
@@ -68,6 +70,7 @@ llrt_os = { version = "0.4.0-beta", path = "../modules/llrt_os", optional = true
 llrt_path = { version = "0.4.0-beta", path = "../modules/llrt_path", optional = true }
 llrt_process = { version = "0.4.0-beta", path = "../modules/llrt_process", optional = true }
 llrt_perf_hooks = { version = "0.4.0-beta", path = "../modules/llrt_perf_hooks", optional = true }
+llrt_stream_web = { version = "0.4.0-beta", path = "../modules/llrt_stream_web", optional = true }
 llrt_timers = { version = "0.4.0-beta", path = "../modules/llrt_timers", optional = true }
 llrt_url = { version = "0.4.0-beta", path = "../modules/llrt_url", optional = true }
 llrt_utils = { version = "0.4.0-beta", path = "../libs/llrt_utils" }

llrt_modules/src/lib.rs

@@ -34,6 +34,8 @@ mod modules {
     pub use llrt_perf_hooks as perf_hooks;
     #[cfg(feature = "process")]
     pub use llrt_process as process;
+    #[cfg(feature = "stream-web")]
+    pub use llrt_stream_web as stream_web;
     #[cfg(feature = "timers")]
     pub use llrt_timers as timers;
     #[cfg(feature = "tty")]

modules/llrt_abort/src/abort_signal.rs

@@ -69,6 +69,15 @@ impl<'js> AbortSignal<'js> {
         Ok(())
     }
 
+    pub fn remove_on_abort(
+        this: This<Class<'js, Self>>,
+        ctx: Ctx<'js>,
+        listener: Function<'js>,
+    ) -> Result<()> {
+        Self::remove_event_listener_str(this, &ctx, "abort", listener)?;
+        Ok(())
+    }
+
     pub fn throw_if_aborted(&self, ctx: Ctx<'js>) -> Result<()> {
         if self.aborted {
             return Err(ctx.throw(
@@ -141,18 +150,18 @@ impl<'js> AbortSignal<'js> {
 
     #[qjs(set, rename = "reason")]
     pub fn set_reason(&mut self, reason: Opt<Value<'js>>) {
-        if let Some(new_reason) = reason.0 {
-            self.reason.replace(new_reason);
-        } else {
-            self.reason.take();
-        }
+        match reason.0 {
+            Some(new_reason) if !new_reason.is_undefined() => self.reason.replace(new_reason),
+            _ => self.reason.take(),
+        };
     }
 
     #[qjs(skip)]
     pub fn send_aborted(this: This<Class<'js, Self>>, ctx: Ctx<'js>) -> Result<()> {
         let mut borrow = this.borrow_mut();
         borrow.aborted = true;
         let reason = get_reason_or_dom_exception(&ctx, borrow.reason.as_ref(), "AbortError")?;
+        borrow.reason = Some(reason.clone());
         borrow.sender.send(reason);
         drop(borrow);
         Self::emit_str(this, &ctx, "abort", vec![], false)?;

modules/llrt_abort/src/lib.rs

@@ -16,6 +16,7 @@ pub fn init(ctx: &Ctx<'_>) -> Result<()> {
     Class::<AbortSignal>::define(&globals)?;
 
     AbortSignal::add_event_emitter_prototype(ctx)?;
+    AbortSignal::add_event_target_prototype(ctx)?;
 
     Ok(())
 }

modules/llrt_events/src/lib.rs

@@ -194,6 +194,16 @@ where
         }
     }
 
+    fn remove_event_listener_str(
+        this: This<Class<'js, Self>>,
+        ctx: &Ctx<'js>,
+        event: &str,
+        listener: Function<'js>,
+    ) -> Result<Class<'js, Self>> {
+        let event = to_event(ctx, event)?;
+        Self::remove_event_listener(this, ctx.clone(), event, listener)
+    }
+
     fn remove_event_listener(
         this: This<Class<'js, Self>>,
         ctx: Ctx<'js>,