mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 16:03:10 +00:00
459 lines
18 KiB
Rust
459 lines
18 KiB
Rust
use crate::interfaces as web_api_interfaces;
|
|
use adapter::{
|
|
EnqueueChunkError, QueuingStrategyMembers, call_function_result, cancel_readable_stream,
|
|
close_stream, enqueue_chunk, initialize_transform_stream_object,
|
|
initialize_webidl_readable_stream_object, initialize_webidl_transform_stream_object,
|
|
initialize_webidl_writable_stream_object, new_readable_stream_object,
|
|
new_transform_stream_shell_object, parse_readable_stream_source_object,
|
|
parse_transform_stream_transformer_object, parse_writable_stream_sink_object,
|
|
readable_stream_byob_request_respond_callback,
|
|
readable_stream_byob_request_respond_with_new_view_callback,
|
|
readable_stream_byob_request_view_getter, readable_stream_is_byte_stream,
|
|
readable_stream_locked, rejected_promise_value, set_resolved_promise, stream_slot_object,
|
|
suppress_promise_unhandled_rejection, writable_stream_close_internal, writable_stream_locked,
|
|
writable_stream_snapshot,
|
|
};
|
|
use moli_v8_util::{
|
|
get_private_value, new_uint8_array_from_bytes, set_private_value, throw_range_error,
|
|
throw_type_error, v8_string, v8str,
|
|
};
|
|
use moli_webapi_declare::WebApiFunctionTemplate;
|
|
use moli_webapi_declare::WebApiInterfaceDescriptor;
|
|
use moli_webidl as webidl;
|
|
use objects::{
|
|
new_readable_stream_byob_reader_object, new_readable_stream_reader_object,
|
|
new_writable_stream_writer_object, readable_stream_byob_reader_read_callback,
|
|
readable_stream_reader_cancel_callback, readable_stream_reader_closed_getter,
|
|
readable_stream_reader_read_callback, readable_stream_reader_release_lock_callback,
|
|
release_readable_stream_reader, writable_stream_writer_abort_callback,
|
|
writable_stream_writer_close_callback, writable_stream_writer_closed_getter,
|
|
writable_stream_writer_desired_size_getter, writable_stream_writer_ready_getter,
|
|
writable_stream_writer_release_lock_callback, writable_stream_writer_write_callback,
|
|
};
|
|
use slots::*;
|
|
|
|
pub mod adapter;
|
|
mod compression;
|
|
mod constructors;
|
|
mod from;
|
|
mod objects;
|
|
mod readable;
|
|
mod runtime;
|
|
pub mod slots;
|
|
mod writable;
|
|
|
|
pub fn tee_fetch_body_stream<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
stream: v8::Local<'s, v8::Object>,
|
|
) -> Option<v8::Local<'s, v8::Array>> {
|
|
adapter::tee_readable_stream_with_cloned_branch(scope, stream).ok()
|
|
}
|
|
|
|
pub fn proxy_fetch_body_stream<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
stream: v8::Local<'s, v8::Object>,
|
|
) -> Option<v8::Local<'s, v8::Object>> {
|
|
let transform = new_transform_stream_shell_object(scope);
|
|
initialize_transform_stream_object(scope, transform, None, None, 1.0, None, 0.0, None);
|
|
let readable = stream_slot_object(scope, transform, TRANSFORM_STREAM_READABLE_SLOT)?;
|
|
let writable = stream_slot_object(scope, transform, TRANSFORM_STREAM_WRITABLE_SLOT)?;
|
|
// A proxy disturbs its input immediately, even when backpressure delays
|
|
// the first source read.
|
|
adapter::disturb_readable_stream(scope, stream);
|
|
let pipe = readable::start_internal_readable_stream_pipe_to(scope, stream, writable)?;
|
|
suppress_promise_unhandled_rejection(scope, pipe);
|
|
Some(readable)
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
enum StreamPrototypeInstaller {
|
|
ReadableStream,
|
|
WritableStream,
|
|
DefaultReader,
|
|
ByobReader,
|
|
ByobRequest,
|
|
DefaultWriter,
|
|
Controller,
|
|
QueuingStrategy,
|
|
TransformFamily,
|
|
Compression,
|
|
}
|
|
|
|
#[derive(Clone, Copy)]
|
|
pub struct StreamInterfaceSpec {
|
|
pub interface: WebApiInterfaceDescriptor,
|
|
constructor: Option<StreamConstructor>,
|
|
prototype_installer: StreamPrototypeInstaller,
|
|
}
|
|
|
|
type StreamConstructor =
|
|
for<'s, 'i> fn(&mut v8::PinScope<'s, 'i, ()>) -> v8::Local<'s, v8::FunctionTemplate>;
|
|
|
|
impl StreamInterfaceSpec {
|
|
pub fn has_constructor(&self) -> bool {
|
|
self.constructor.is_some()
|
|
}
|
|
}
|
|
|
|
/// The single catalog for Web-visible Streams interfaces.
|
|
///
|
|
/// Every entry is exposed in each realm Moli currently supports. The
|
|
/// constructor registry, worker realm profiles, and prototype installer consume
|
|
/// this table, so those surfaces cannot drift independently.
|
|
const STREAM_INTERFACE_SPECS: &[StreamInterfaceSpec] = &[
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::ReadableStream::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(readable_stream_constructor_callback)
|
|
.length(0)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::ReadableStream,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::ReadableStreamDefaultReader::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(readable_stream_default_reader_constructor_callback)
|
|
.length(1)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::DefaultReader,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::ReadableStreamDefaultController::DESCRIPTOR,
|
|
constructor: None,
|
|
prototype_installer: StreamPrototypeInstaller::Controller,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::WritableStream::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(writable_stream_constructor_callback)
|
|
.length(0)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::WritableStream,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::WritableStreamDefaultWriter::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(writable_stream_default_writer_constructor_callback)
|
|
.length(1)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::DefaultWriter,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::WritableStreamDefaultController::DESCRIPTOR,
|
|
constructor: None,
|
|
prototype_installer: StreamPrototypeInstaller::Controller,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::TransformStream::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(transform_stream_constructor_callback)
|
|
.length(0)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::TransformFamily,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::TransformStreamDefaultController::DESCRIPTOR,
|
|
constructor: None,
|
|
prototype_installer: StreamPrototypeInstaller::Controller,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::TextEncoderStream::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(text_encoder_stream_constructor_callback)
|
|
.length(0)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::TransformFamily,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::TextDecoderStream::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(text_decoder_stream_constructor_callback)
|
|
.length(0)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::TransformFamily,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::ByteLengthQueuingStrategy::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(byte_length_queuing_strategy_constructor_callback)
|
|
.length(1)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::QueuingStrategy,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::CountQueuingStrategy::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(count_queuing_strategy_constructor_callback)
|
|
.length(1)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::QueuingStrategy,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::CompressionStream::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(compression_stream_constructor_callback::<false>)
|
|
.length(1)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::Compression,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::DecompressionStream::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(compression_stream_constructor_callback::<true>)
|
|
.length(1)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::Compression,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::ReadableStreamBYOBReader::DESCRIPTOR,
|
|
constructor: Some(|scope| {
|
|
v8::FunctionTemplate::builder(readable_stream_byob_reader_constructor_callback)
|
|
.length(1)
|
|
.build(scope)
|
|
}),
|
|
prototype_installer: StreamPrototypeInstaller::ByobReader,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::ReadableStreamBYOBRequest::DESCRIPTOR,
|
|
constructor: None,
|
|
prototype_installer: StreamPrototypeInstaller::ByobRequest,
|
|
},
|
|
StreamInterfaceSpec {
|
|
interface: web_api_interfaces::ReadableByteStreamController::DESCRIPTOR,
|
|
constructor: None,
|
|
prototype_installer: StreamPrototypeInstaller::Controller,
|
|
},
|
|
];
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(name = "ReadableStream", enumerable)]
|
|
struct ReadableStreamConstructorDeclaration {
|
|
#[webapi(
|
|
static_method = "from",
|
|
length = 1,
|
|
callback = from::readable_stream_from_callback
|
|
)]
|
|
from: (),
|
|
}
|
|
|
|
pub fn interface_specs() -> &'static [StreamInterfaceSpec] {
|
|
STREAM_INTERFACE_SPECS
|
|
}
|
|
|
|
pub fn is_stream_interface(name: &str) -> bool {
|
|
stream_interface_spec(name).is_some()
|
|
}
|
|
|
|
fn stream_interface_spec(name: &str) -> Option<&'static StreamInterfaceSpec> {
|
|
STREAM_INTERFACE_SPECS
|
|
.iter()
|
|
.find(|spec| spec.interface.name() == name)
|
|
}
|
|
|
|
pub fn build_constructor_template<'s>(
|
|
scope: &mut v8::PinScope<'s, '_, ()>,
|
|
name: &str,
|
|
) -> Option<v8::Local<'s, v8::FunctionTemplate>> {
|
|
stream_interface_spec(name)?
|
|
.constructor
|
|
.map(|constructor| constructor(scope))
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::ReadableStream, enumerable)]
|
|
struct ReadableStreamPrototypeDeclaration {
|
|
#[webapi(method, length = 0, callback = readable_stream_get_reader_callback)]
|
|
get_reader: (),
|
|
#[webapi(returns_promise, method, length = 0, callback = readable_stream_cancel_callback)]
|
|
cancel: (),
|
|
#[webapi(method, length = 1, callback = readable_stream_pipe_through_callback)]
|
|
pipe_through: (),
|
|
#[webapi(returns_promise, method, length = 1, callback = readable_stream_pipe_to_callback)]
|
|
pipe_to: (),
|
|
#[webapi(method, length = 0, callback = readable_stream_tee_callback)]
|
|
tee: (),
|
|
#[webapi(accessor_property, getter = readable_stream_locked_getter)]
|
|
locked: (),
|
|
#[webapi(method, length = 0, callback = readable_stream_async_iterator_callback)]
|
|
values: (),
|
|
#[webapi(alias = "values", symbol = "asyncIterator")]
|
|
async_iterator: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::WritableStream, enumerable)]
|
|
struct WritableStreamPrototypeDeclaration {
|
|
#[webapi(method, length = 0, callback = writable_stream_get_writer_callback)]
|
|
get_writer: (),
|
|
#[webapi(method, returns_promise, length = 0, callback = writable_stream_abort_callback)]
|
|
abort: (),
|
|
#[webapi(method, returns_promise, length = 0, callback = writable_stream_close_callback)]
|
|
close: (),
|
|
#[webapi(accessor_property, getter = writable_stream_locked_getter)]
|
|
locked: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::ReadableStreamDefaultReader, enumerable)]
|
|
struct ReadableStreamDefaultReaderPrototypeDeclaration {
|
|
#[webapi(returns_promise, method, length = 0, callback = readable_stream_reader_read_callback)]
|
|
read: (),
|
|
#[webapi(method, length = 0, callback = readable_stream_reader_release_lock_callback)]
|
|
release_lock: (),
|
|
#[webapi(returns_promise, method, length = 0, callback = readable_stream_reader_cancel_callback)]
|
|
cancel: (),
|
|
#[webapi(returns_promise, accessor_property, getter = readable_stream_reader_closed_getter)]
|
|
closed: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::ReadableStreamBYOBReader, enumerable)]
|
|
struct ReadableStreamByobReaderPrototypeDeclaration {
|
|
#[webapi(returns_promise, method, length = 1, callback = readable_stream_byob_reader_read_callback)]
|
|
read: (),
|
|
#[webapi(method, length = 0, callback = readable_stream_reader_release_lock_callback)]
|
|
release_lock: (),
|
|
#[webapi(returns_promise, method, length = 0, callback = readable_stream_reader_cancel_callback)]
|
|
cancel: (),
|
|
#[webapi(returns_promise, accessor_property, getter = readable_stream_reader_closed_getter)]
|
|
closed: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::ReadableStreamBYOBRequest, enumerable)]
|
|
struct ReadableStreamByobRequestPrototypeDeclaration {
|
|
#[webapi(accessor_property, getter = readable_stream_byob_request_view_getter)]
|
|
view: (),
|
|
#[webapi(method, length = 1, callback = readable_stream_byob_request_respond_callback)]
|
|
respond: (),
|
|
#[webapi(
|
|
method,
|
|
length = 1,
|
|
callback = readable_stream_byob_request_respond_with_new_view_callback
|
|
)]
|
|
respond_with_new_view: (),
|
|
}
|
|
|
|
#[derive(WebApiFunctionTemplate)]
|
|
#[webapi(interface = web_api_interfaces::WritableStreamDefaultWriter, enumerable)]
|
|
struct WritableStreamDefaultWriterPrototypeDeclaration {
|
|
#[webapi(returns_promise, method, length = 0, callback = writable_stream_writer_write_callback)]
|
|
write: (),
|
|
#[webapi(returns_promise, method, length = 0, callback = writable_stream_writer_close_callback)]
|
|
close: (),
|
|
#[webapi(returns_promise, method, length = 0, callback = writable_stream_writer_abort_callback)]
|
|
abort: (),
|
|
#[webapi(method, length = 0, callback = writable_stream_writer_release_lock_callback)]
|
|
release_lock: (),
|
|
#[webapi(returns_promise, accessor_property, getter = writable_stream_writer_closed_getter)]
|
|
closed: (),
|
|
#[webapi(accessor_property, getter = writable_stream_writer_desired_size_getter)]
|
|
desired_size: (),
|
|
#[webapi(returns_promise, accessor_property, getter = writable_stream_writer_ready_getter)]
|
|
ready: (),
|
|
}
|
|
|
|
use compression::compression_stream_constructor_callback;
|
|
use constructors::{
|
|
byte_length_queuing_strategy_constructor_callback, count_queuing_strategy_constructor_callback,
|
|
readable_stream_constructor_callback, text_decoder_stream_constructor_callback,
|
|
text_encoder_stream_constructor_callback, transform_stream_constructor_callback,
|
|
writable_stream_constructor_callback,
|
|
};
|
|
use objects::{
|
|
readable_stream_byob_reader_constructor_callback,
|
|
readable_stream_default_reader_constructor_callback,
|
|
writable_stream_default_writer_constructor_callback,
|
|
};
|
|
pub use readable::{
|
|
is_readable_stream_object, new_readable_stream_from_array_buffer,
|
|
new_readable_stream_from_source, start_internal_readable_stream_pipe_to,
|
|
};
|
|
use readable::{
|
|
readable_stream_async_iterator_callback, readable_stream_cancel_callback,
|
|
readable_stream_get_reader_callback, readable_stream_locked_getter,
|
|
readable_stream_pipe_through_callback, readable_stream_pipe_to_callback,
|
|
readable_stream_tee_callback,
|
|
};
|
|
use writable::{
|
|
writable_stream_abort_callback, writable_stream_close_callback,
|
|
writable_stream_get_writer_callback, writable_stream_locked_getter,
|
|
};
|
|
|
|
pub fn is_writable_stream_object<'s>(
|
|
scope: &mut v8::PinScope<'s, '_>,
|
|
object: v8::Local<'s, v8::Object>,
|
|
) -> bool {
|
|
web_api_interfaces::WritableStream::is_instance(scope, object)
|
|
}
|
|
|
|
pub fn install_stream_template_bindings<'s>(
|
|
scope: &mut v8::PinScope<'s, '_, ()>,
|
|
template: v8::Local<'s, v8::FunctionTemplate>,
|
|
interface_name: &str,
|
|
) {
|
|
let Some(spec) = stream_interface_spec(interface_name) else {
|
|
return;
|
|
};
|
|
let prototype = template.prototype_template(scope);
|
|
match spec.prototype_installer {
|
|
StreamPrototypeInstaller::ReadableStream => {
|
|
ReadableStreamConstructorDeclaration::initialize_template(scope, template);
|
|
ReadableStreamPrototypeDeclaration::initialize_prototype_template(scope, prototype);
|
|
}
|
|
StreamPrototypeInstaller::WritableStream => {
|
|
WritableStreamPrototypeDeclaration::initialize_prototype_template(scope, prototype);
|
|
}
|
|
StreamPrototypeInstaller::DefaultReader => {
|
|
ReadableStreamDefaultReaderPrototypeDeclaration::initialize_prototype_template(
|
|
scope, prototype,
|
|
);
|
|
}
|
|
StreamPrototypeInstaller::ByobReader => {
|
|
ReadableStreamByobReaderPrototypeDeclaration::initialize_prototype_template(
|
|
scope, prototype,
|
|
);
|
|
}
|
|
StreamPrototypeInstaller::ByobRequest => {
|
|
ReadableStreamByobRequestPrototypeDeclaration::initialize_prototype_template(
|
|
scope, prototype,
|
|
);
|
|
}
|
|
StreamPrototypeInstaller::DefaultWriter => {
|
|
WritableStreamDefaultWriterPrototypeDeclaration::initialize_prototype_template(
|
|
scope, prototype,
|
|
);
|
|
}
|
|
StreamPrototypeInstaller::Controller => {
|
|
objects::install_stream_controller_template_bindings(scope, prototype, interface_name);
|
|
}
|
|
StreamPrototypeInstaller::QueuingStrategy => {
|
|
constructors::install_queuing_strategy_template_bindings(
|
|
scope,
|
|
prototype,
|
|
interface_name,
|
|
);
|
|
}
|
|
StreamPrototypeInstaller::TransformFamily => {
|
|
writable::install_transform_stream_template_bindings(scope, prototype, interface_name);
|
|
}
|
|
StreamPrototypeInstaller::Compression => {
|
|
compression::install_template_bindings(scope, prototype, interface_name);
|
|
}
|
|
}
|
|
}
|
|
|
|
use crate::abort_signal::ResolvedAbortSignal;
|
|
use runtime::{streams_owner_terminating, structured_clone_value};
|