dymokomi/luce-browser-engine
Source of release 0.6.1
0.6.1 / src / web / streams / readable_stream_operations_1.lucb
#==============================================================================================
#
# readable_stream_operations_1 - the abstract operations of readable streams and their
# default readers: acquiring, creating, teeing a byte stream, canceling, closing, erroring,
# reading
#
# DESCRIPTION:
# Port of Libraries/LibWeb/Streams/ReadableStreamOperations.cpp (lines 56-1258), as part
# of the ReadableStream stand-in of DESIGN.md §3.6 (region p2s): the operations of byte
# streams read by default readers. Default controllers (ReadableStreamDefaultTee,
# CreateReadableStream), BYOB readers and read-into requests, piping and streams from
# iterables are phase 4; a path that reaches one traps.
#
# Where a ReadableStream member has the snake name of an abstract operation (close,
# error, tee, cancel; ReadableStreamDefaultReader's read), the member keeps the name and
# the operation takes `_2`, as the skeleton generator names a later declaration
# (DESIGN.md §4.2).
#
# Copyright (c) 2022, Linus Groh <linusg@serenityos.org>
# Copyright (c) 2023, Matthew Olsson <mattco@serenityos.org>
# Copyright (c) 2023-2025, Shannon Booth <shannon@serenityos.org>
# Copyright (c) 2023-2024, Kenneth Myhra <kennethmyhra@serenityos.org>
# Copyright (c) 2025, Tim Flynn <trflynn89@ladybird.org>
# SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================
# mark: Creating ================================================================================
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:57 Web::Streams::acquire_readable_stream_default_reader.
## https://streams.spec.whatwg.org/#acquire-readable-stream-reader
pub func streams_acquire_readable_stream_default_reader(stream: StreamsReadableStream*) -> StreamsReadableStreamDefaultReader*!:
let realm = streams_readable_stream_realm(stream)
# 1. Let reader be a new ReadableStreamDefaultReader.
let reader = realm_create_streams_readable_stream_default_reader(realm, realm)
# 2. Perform ? SetUpReadableStreamDefaultReader(reader, stream).
try streams_set_up_readable_stream_default_reader(reader, stream)
# 3. Return reader.
return reader
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:114 Web::Streams::create_readable_byte_stream.
## https://streams.spec.whatwg.org/#abstract-opdef-createreadablebytestream
pub func streams_create_readable_byte_stream(realm: Realm*, start_algorithm: gc.Function0[JsValue]*, pull_algorithm: gc.Function0[JsPromiseCapability*]*, cancel_algorithm: gc.Function1[JsValue, JsPromiseCapability*]*) -> StreamsReadableStream*!:
# 1. Let stream be a new ReadableStream.
let stream = realm_create_streams_readable_stream(realm, realm)
# 2. Perform ! InitializeReadableStream(stream).
streams_initialize_readable_stream(stream)
# 3. Let controller be a new ReadableByteStreamController.
let controller = realm_create_streams_readable_byte_stream_controller(realm, realm)
# 4. Perform ? SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, undefined).
try streams_set_up_readable_byte_stream_controller(stream, controller, start_algorithm, pull_algorithm, cancel_algorithm, 0.0, js_undefined())
# 5. Return stream.
return stream
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:133 Web::Streams::initialize_readable_stream.
## https://streams.spec.whatwg.org/#initialize-readable-stream
pub func streams_initialize_readable_stream(stream: StreamsReadableStream*):
# 1. Set stream.[[state]] to "readable".
stream.m_state = StreamsReadableStreamState.readable
# 2. Set stream.[[reader]] and stream.[[storedError]] to undefined.
stream.m_reader = none
stream.m_stored_error = js_undefined()
# 3. Set stream.[[disturbed]] to false.
stream.m_disturbed = false
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:147 Web::Streams::is_readable_stream_locked.
## https://streams.spec.whatwg.org/#is-readable-stream-locked
pub func streams_is_readable_stream_locked(stream: StreamsReadableStream*) -> bool:
# 1. If stream.[[reader]] is undefined, return false.
if stream.m_reader == none:
return false
# 2. Return true.
return true
# mark: Teeing ==================================================================================
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:371 Web::Streams::readable_stream_tee.
## https://streams.spec.whatwg.org/#readable-stream-tee
pub func streams_readable_stream_tee_2(realm: Realm*, stream: StreamsReadableStream*, clone_for_branch2: bool) -> (StreamsReadableStream*, StreamsReadableStream*)!:
# 1. Assert: stream implements ReadableStream.
# 2. Assert: cloneForBranch2 is a boolean.
# 3. If stream.[[controller]] implements ReadableByteStreamController, return ? ReadableByteStreamTee(stream).
match stream.m_controller else trap("VERIFY: the stream has a controller"):
.streams_readable_byte_stream_controller(_): return try streams_readable_byte_stream_tee(realm, stream)
.streams_readable_stream_default_controller(_): _ = clone_for_branch2
# 4. Return ? ReadableStreamDefaultTee(stream, cloneForBranch2).
trap("unported (P4): Web::Streams::readable_stream_default_tee")
## `this_reader != params->reader` (and ==) on two ReadableStreamReader variants: the same reader.
func streams_readable_stream_reader_is(a: StreamsReadableStreamReader, b: StreamsReadableStreamReader) -> bool:
match a:
.streams_readable_stream_default_reader(default_reader):
match b:
.streams_readable_stream_default_reader(other): return default_reader == other
_: return false
.streams_readable_stream_byob_reader(byob_reader):
match b:
.streams_readable_stream_byob_reader(other): return byob_reader == other
_: return false
## The captures of readable_byte_stream_tee's forwardReaderError, `[&realm, params, cancel_promise]`.
struct StreamsReadableByteStreamTeeForwardReaderError:
var realm: Realm*
var params: StreamsReadableByteStreamTeeParams*
var cancel_promise: JsPromiseCapability*
## The captures of forwardReaderError's rejection steps, `[&realm, this_reader, params, cancel_promise]`.
struct StreamsReadableByteStreamTeeForwardReaderErrorOnRejection:
var realm: Realm*
var this_reader: StreamsReadableStreamReader
var params: StreamsReadableByteStreamTeeParams*
var cancel_promise: JsPromiseCapability*
## forwardReaderError's step 1: upon rejection of thisReader.[[closedPromise]] with reason r.
func streams_readable_byte_stream_tee_forward_reader_error_on_rejection(context: void*?, reason: JsValue) -> JsValue:
let captures = (StreamsReadableByteStreamTeeForwardReaderErrorOnRejection*)(context else trap("no captures"))
let params = captures.params
let controller1 = streams_readable_stream_byte_controller(params.branch1 else trap("VERIFY: branch1"))
let controller2 = streams_readable_stream_byte_controller(params.branch2 else trap("VERIFY: branch2"))
# 1. If thisReader is not reader, return.
if not streams_readable_stream_reader_is(captures.this_reader, params.reader):
return js_undefined()
# 2. Perform ! ReadableByteStreamControllerError(branch1.[[controller]], r).
streams_readable_byte_stream_controller_error_2(controller1, reason)
# 3. Perform ! ReadableByteStreamControllerError(branch2.[[controller]], r).
streams_readable_byte_stream_controller_error_2(controller2, reason)
# 4. If canceled1 is false or canceled2 is false, resolve cancelPromise with undefined.
if not params.canceled1 or not params.canceled2:
idl_resolve_promise(captures.realm, captures.cancel_promise, js_undefined())
return js_undefined()
## readable_byte_stream_tee's forwardReaderError, taking a thisReader argument.
func streams_readable_byte_stream_tee_forward_reader_error(context: void*?, this_reader: StreamsReadableStreamReader):
let captures = (StreamsReadableByteStreamTeeForwardReaderError*)(context else trap("no captures"))
# 1. Upon rejection of thisReader.[[closedPromise]] with reason r,
let closed_promise = match this_reader:
.streams_readable_stream_default_reader(underlying_reader) => underlying_reader.generic_reader.m_closed_promise
.streams_readable_stream_byob_reader(_) => trap("unported (P4): ReadableStreamBYOBReader's closed promise")
let on_rejection = new StreamsReadableByteStreamTeeForwardReaderErrorOnRejection(realm = captures.realm, this_reader = this_reader, params = captures.params, cancel_promise = captures.cancel_promise) else trap("out of memory")
_ = idl_upon_rejection(closed_promise else trap("VERIFY: a closed promise"), gc.create_function1(realm_heap(captures.realm), ak.Function1[JsValue, JsValue](call = streams_readable_byte_stream_tee_forward_reader_error_on_rejection, context = on_rejection)))
## The captures of readable_byte_stream_tee's pullWithDefaultReader and pullWithBYOBReader,
## `[&realm, &stream, params, cancel_promise, forward_reader_error]`.
struct StreamsReadableByteStreamTeePullWithReader:
var realm: Realm*
var stream: StreamsReadableStream*
var params: StreamsReadableByteStreamTeeParams*
var cancel_promise: JsPromiseCapability*
var forward_reader_error: gc.Function1[StreamsReadableStreamReader, unit]*
## readable_byte_stream_tee's pullWithDefaultReader.
func streams_readable_byte_stream_tee_pull_with_default_reader(context: void*?):
let captures = (StreamsReadableByteStreamTeePullWithReader*)(context else trap("no captures"))
let params = captures.params
# 1. If reader implements ReadableStreamBYOBReader,
match params.reader:
.streams_readable_stream_byob_reader(_):
# 1. Assert: reader.[[readIntoRequests]] is empty.
# 2. Perform ! ReadableStreamBYOBReaderRelease(reader).
# 3. Set reader to ! AcquireReadableStreamDefaultReader(stream).
# 4. Perform forwardReaderError, given reader.
trap("unported (P4): Web::Streams::readable_byte_stream_tee's pullWithDefaultReader after a BYOB reader")
_:
_ = 0
# 2. Let readRequest be a read request with the following items:
let read_request = heap_allocate_streams_readable_byte_stream_tee_default_read_request(realm_heap(captures.realm), captures.realm, captures.stream, params, captures.cancel_promise)
# 3. Perform ! ReadableStreamDefaultReaderRead(reader, readRequest).
let reader = match params.reader:
.streams_readable_stream_default_reader(default_reader) => default_reader
.streams_readable_stream_byob_reader(_) => trap("VERIFY: reader.get<GC::Ref<ReadableStreamDefaultReader>>()")
streams_readable_stream_default_reader_read_2(reader, read_request.streams_read_request())
## readable_byte_stream_tee's pullWithBYOBReader, given view and forBranch2: BYOB requests are phase 4.
func streams_readable_byte_stream_tee_pull_with_byob_reader(context: void*?, view: IdlArrayBufferView*, for_branch2: bool):
# 1. If reader implements ReadableStreamDefaultReader,
# 2. Assert: reader.[[readRequests]] is empty.
# 3. Perform ! ReadableStreamDefaultReaderRelease(reader).
# 4. Set reader to ! AcquireReadableStreamBYOBReader(stream).
# 5. Perform forwardReaderError, given reader.
# 2. Let byobBranch be branch2 if forBranch2 is true, and branch1 otherwise.
# 3. Let otherBranch be branch2 if forBranch2 is false, and branch1 otherwise.
# 4. Let readIntoRequest be a read-into request with the following items:
# 5. Perform ! ReadableStreamBYOBReaderRead(reader, view, 1, readIntoRequest).
_ = context
_ = view
_ = for_branch2
trap("unported (P4): Web::Streams::readable_byte_stream_tee's pullWithBYOBReader")
## The captures of readable_byte_stream_tee's pull1Algorithm and pull2Algorithm,
## `[&realm, params, pull_with_default_reader, pull_with_byob_reader]`.
struct StreamsReadableByteStreamTeePullAlgorithm:
var realm: Realm*
var params: StreamsReadableByteStreamTeeParams*
var pull_with_default_reader: gc.Function0[unit]*
var pull_with_byob_reader: gc.Function2[IdlArrayBufferView*, bool, unit]*
## readable_byte_stream_tee's pull1Algorithm.
func streams_readable_byte_stream_tee_pull1_algorithm(context: void*?) -> JsPromiseCapability*:
let captures = (StreamsReadableByteStreamTeePullAlgorithm*)(context else trap("no captures"))
let params = captures.params
let controller1 = streams_readable_stream_byte_controller(params.branch1 else trap("VERIFY: branch1"))
# 1. If reading is true,
if params.reading:
# 1. Set readAgainForBranch1 to true.
params.read_again_for_branch1 = true
# 2. Return a promise resolved with undefined.
return idl_create_resolved_promise(captures.realm, js_undefined())
# 2. Set reading to true.
params.reading = true
# 3. Let byobRequest be ! ReadableByteStreamControllerGetBYOBRequest(branch1.[[controller]]).
let byob_request = streams_readable_byte_stream_controller_get_byob_request(controller1)
# 4. If byobRequest is null, perform pullWithDefaultReader.
if byob_request == none:
ak.function0_call(&captures.pull_with_default_reader.function)
# 5. Otherwise, perform pullWithBYOBReader, given byobRequest.[[view]] and false.
else:
trap("unported (P4): Web::Streams::ReadableStreamBYOBRequest::view")
# 6. Return a promise resolved with undefined.
return idl_create_resolved_promise(captures.realm, js_undefined())
## readable_byte_stream_tee's pull2Algorithm.
func streams_readable_byte_stream_tee_pull2_algorithm(context: void*?) -> JsPromiseCapability*:
let captures = (StreamsReadableByteStreamTeePullAlgorithm*)(context else trap("no captures"))
let params = captures.params
let controller2 = streams_readable_stream_byte_controller(params.branch2 else trap("VERIFY: branch2"))
# 1. If reading is true,
if params.reading:
# 1. Set readAgainForBranch2 to true.
params.read_again_for_branch2 = true
# 2. Return a promise resolved with undefined.
return idl_create_resolved_promise(captures.realm, js_undefined())
# 2. Set reading to true.
params.reading = true
# 3. Let byobRequest be ! ReadableByteStreamControllerGetBYOBRequest(branch2.[[controller]]).
let byob_request = streams_readable_byte_stream_controller_get_byob_request(controller2)
# 4. If byobRequest is null, perform pullWithDefaultReader.
if byob_request == none:
ak.function0_call(&captures.pull_with_default_reader.function)
# 5. Otherwise, perform pullWithBYOBReader, given byobRequest.[[view]] and true.
else:
trap("unported (P4): Web::Streams::ReadableStreamBYOBRequest::view")
# 6. Return a promise resolved with undefined.
return idl_create_resolved_promise(captures.realm, js_undefined())
## The captures of readable_byte_stream_tee's cancel1Algorithm and cancel2Algorithm,
## `[&realm, &stream, params, cancel_promise]`.
struct StreamsReadableByteStreamTeeCancelAlgorithm:
var realm: Realm*
var stream: StreamsReadableStream*
var params: StreamsReadableByteStreamTeeParams*
var cancel_promise: JsPromiseCapability*
## Steps 3-4 shared by cancel1Algorithm and cancel2Algorithm: once both branches are canceled,
## cancel the stream with « reason1, reason2 »; return cancelPromise.
func streams_readable_byte_stream_tee_cancel_both(captures: StreamsReadableByteStreamTeeCancelAlgorithm*, other_canceled: bool) -> JsPromiseCapability*:
let params = captures.params
# 3. If canceled2 (canceled1) is true,
if other_canceled:
# 1. Let compositeReason be ! CreateArrayFromList(« reason1, reason2 »).
let reasons: JsValue[2] = [params.reason1, params.reason2]
let composite_reason = js_value_from_object((JsObject*)js_array_create_from(captures.realm, reasons))
# 2. Let cancelResult be ! ReadableStreamCancel(stream, compositeReason).
let cancel_result = streams_readable_stream_cancel_2(captures.stream, composite_reason)
# 3. Resolve cancelPromise with cancelResult.
idl_resolve_promise(captures.realm, captures.cancel_promise, js_value_from_object(js_promise_capability_promise(cancel_result)))
# 4. Return cancelPromise.
return captures.cancel_promise
## readable_byte_stream_tee's cancel1Algorithm, taking a reason argument.
func streams_readable_byte_stream_tee_cancel1_algorithm(context: void*?, reason: JsValue) -> JsPromiseCapability*:
let captures = (StreamsReadableByteStreamTeeCancelAlgorithm*)(context else trap("no captures"))
# 1. Set canceled1 to true.
captures.params.canceled1 = true
# 2. Set reason1 to reason.
captures.params.reason1 = reason
return streams_readable_byte_stream_tee_cancel_both(captures, captures.params.canceled2)
## readable_byte_stream_tee's cancel2Algorithm, taking a reason argument.
func streams_readable_byte_stream_tee_cancel2_algorithm(context: void*?, reason: JsValue) -> JsPromiseCapability*:
let captures = (StreamsReadableByteStreamTeeCancelAlgorithm*)(context else trap("no captures"))
# 1. Set canceled2 to true.
captures.params.canceled2 = true
# 2. Set reason2 to reason.
captures.params.reason2 = reason
return streams_readable_byte_stream_tee_cancel_both(captures, captures.params.canceled1)
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:516 Web::Streams::readable_byte_stream_tee:
## the two branches.
## https://streams.spec.whatwg.org/#abstract-opdef-readablebytestreamtee
pub func streams_readable_byte_stream_tee(realm: Realm*, stream: StreamsReadableStream*) -> (StreamsReadableStream*, StreamsReadableStream*)!:
let heap = realm_heap(realm)
# 1. Assert: stream implements ReadableStream.
# 2. Assert: stream.[[controller]] implements ReadableByteStreamController.
_ = streams_readable_stream_byte_controller(stream)
# 3. Let reader be ? AcquireReadableStreamDefaultReader(stream).
let reader = try streams_acquire_readable_stream_default_reader(stream)
# 4. Let reading be false.
# 5. Let readAgainForBranch1 be false.
# 6. Let readAgainForBranch2 be false.
# 7. Let canceled1 be false.
# 8. Let canceled2 be false.
# 9. Let reason1 be undefined.
# 10. Let reason2 be undefined.
# 11. Let branch1 be undefined.
# 12. Let branch2 be undefined.
let params = realm_create_streams_readable_byte_stream_tee_params(realm, .streams_readable_stream_default_reader(reader))
# 13. Let cancelPromise be a new promise.
let cancel_promise = idl_create_promise(realm)
# 14. Let forwardReaderError be the following steps, taking a thisReader argument:
let forward_captures = new StreamsReadableByteStreamTeeForwardReaderError(realm = realm, params = params, cancel_promise = cancel_promise) else trap("out of memory")
let forward_reader_error = gc.create_function1(heap, ak.Function1[StreamsReadableStreamReader, unit](call = streams_readable_byte_stream_tee_forward_reader_error, context = forward_captures))
# 15. Let pullWithDefaultReader be the following steps:
# 16. Let pullWithBYOBReader be the following steps, given view and forBranch2:
let pull_captures = new StreamsReadableByteStreamTeePullWithReader(realm = realm, stream = stream, params = params, cancel_promise = cancel_promise, forward_reader_error = forward_reader_error) else trap("out of memory")
let pull_with_default_reader = gc.create_function0(heap, ak.Function0[unit](call = streams_readable_byte_stream_tee_pull_with_default_reader, context = pull_captures))
let pull_with_byob_reader = gc.create_function2(heap, ak.Function2[IdlArrayBufferView*, bool, unit](call = streams_readable_byte_stream_tee_pull_with_byob_reader, context = pull_captures))
# 17. Let pull1Algorithm be the following steps:
# 18. Let pull2Algorithm be the following steps:
let pull_algorithm_captures = new StreamsReadableByteStreamTeePullAlgorithm(realm = realm, params = params, pull_with_default_reader = pull_with_default_reader, pull_with_byob_reader = pull_with_byob_reader) else trap("out of memory")
let pull1_algorithm = gc.create_function0(heap, ak.Function0[JsPromiseCapability*](call = streams_readable_byte_stream_tee_pull1_algorithm, context = pull_algorithm_captures))
let pull2_algorithm = gc.create_function0(heap, ak.Function0[JsPromiseCapability*](call = streams_readable_byte_stream_tee_pull2_algorithm, context = pull_algorithm_captures))
# AD-HOC: The read requests within the pull algorithms must be able to re-invoke the pull algorithms, so cache them here.
params.pull1_algorithm = pull1_algorithm
params.pull2_algorithm = pull2_algorithm
# 19. Let cancel1Algorithm be the following steps, taking a reason argument:
# 20. Let cancel2Algorithm be the following steps, taking a reason argument:
let cancel_captures = new StreamsReadableByteStreamTeeCancelAlgorithm(realm = realm, stream = stream, params = params, cancel_promise = cancel_promise) else trap("out of memory")
let cancel1_algorithm = gc.create_function1(heap, ak.Function1[JsValue, JsPromiseCapability*](call = streams_readable_byte_stream_tee_cancel1_algorithm, context = cancel_captures))
let cancel2_algorithm = gc.create_function1(heap, ak.Function1[JsValue, JsPromiseCapability*](call = streams_readable_byte_stream_tee_cancel2_algorithm, context = cancel_captures))
# 21. Let startAlgorithm be an algorithm that returns undefined.
let start_algorithm = gc.create_function0(heap, ak.Function0[JsValue](call = streams_readable_stream_start_algorithm_returning_undefined, context = none))
# 22. Set branch1 to ! CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm).
params.branch1 = streams_create_readable_byte_stream(realm, start_algorithm, pull1_algorithm, cancel1_algorithm) else trap("MUST: CreateReadableByteStream")
# 23. Set branch2 to ! CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm).
params.branch2 = streams_create_readable_byte_stream(realm, start_algorithm, pull2_algorithm, cancel2_algorithm) else trap("MUST: CreateReadableByteStream")
# 24. Perform forwardReaderError, given reader.
ak.function1_call(&forward_reader_error.function, .streams_readable_stream_default_reader(reader))
# 25. Return « branch1, branch2 ».
return (params.branch1 else trap("unreachable: branch1 was set"), params.branch2 else trap("unreachable: branch2 was set"))
# mark: Requests, canceling, closing, erroring ==================================================
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:772 Web::Streams::readable_stream_add_read_request.
## https://streams.spec.whatwg.org/#readable-stream-add-read-request
pub func streams_readable_stream_add_read_request(stream: StreamsReadableStream*, read_request: StreamsReadRequest*):
# 1. Assert: stream.[[reader]] implements ReadableStreamDefaultReader.
let reader = streams_readable_stream_default_reader_of(stream)
# 2. Assert: stream.[[state]] is "readable".
assert(stream.m_state == StreamsReadableStreamState.readable)
# 3. Append readRequest to stream.[[reader]].[[readRequests]].
ak.singly_linked_list_append(&reader.m_read_requests, read_request)
## `stream.reader()->get<GC::Ref<ReadableStreamDefaultReader>>()`: the stream's default reader (it must
## have one: VERIFY).
func streams_readable_stream_default_reader_of(stream: StreamsReadableStream*) -> StreamsReadableStreamDefaultReader*:
match stream.m_reader else trap("VERIFY: stream.reader().has_value()"):
.streams_readable_stream_default_reader(reader): return reader
.streams_readable_stream_byob_reader(_): trap("VERIFY: the stream's reader is a ReadableStreamDefaultReader")
## The closed promise of either kind of reader, `reader->visit([](auto reader) { return reader->closed_promise_capability(); })`.
func streams_readable_stream_reader_closed_promise(reader: StreamsReadableStreamReader) -> JsPromiseCapability*:
match reader:
.streams_readable_stream_default_reader(default_reader):
return default_reader.generic_reader.m_closed_promise else trap("VERIFY: the reader has a closed promise")
.streams_readable_stream_byob_reader(_):
trap("unported (P4): ReadableStreamBYOBReader's closed promise")
## readable_stream_cancel's fulfillment step: a step that returns undefined.
func streams_readable_stream_cancel_fulfillment_step(context: void*?, value: JsValue) -> JsValue:
return js_undefined()
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:787 Web::Streams::readable_stream_cancel.
## https://streams.spec.whatwg.org/#readable-stream-cancel
pub func streams_readable_stream_cancel_2(stream: StreamsReadableStream*, reason: JsValue) -> JsPromiseCapability*:
let realm = streams_readable_stream_realm(stream)
# 1. Set stream.[[disturbed]] to true.
stream.m_disturbed = true
# 2. If stream.[[state]] is "closed", return a promise resolved with undefined.
if stream.m_state == StreamsReadableStreamState.closed:
return idl_create_resolved_promise(realm, js_undefined())
# 3. If stream.[[state]] is "errored", return a promise rejected with stream.[[storedError]].
if stream.m_state == StreamsReadableStreamState.errored:
return idl_create_rejected_promise(realm, stream.m_stored_error)
# 4. Perform ! ReadableStreamClose(stream).
streams_readable_stream_close_2(stream)
# 5. Let reader be stream.[[reader]].
# 6. If reader is not undefined and reader implements ReadableStreamBYOBReader,
if let reader = stream.m_reader:
match reader:
.streams_readable_stream_byob_reader(_):
# 1. Let readIntoRequests be reader.[[readIntoRequests]].
# 2. Set reader.[[readIntoRequests]] to an empty list.
# 3. For each readIntoRequest of readIntoRequests,
# 1. Perform readIntoRequest’s close steps, given undefined.
trap("unported (P4): canceling a stream locked to a ReadableStreamBYOBReader")
_:
_ = 0
# 7. Let sourceCancelPromise be ! stream.[[controller]].[[CancelSteps]](reason).
let source_cancel_promise = match stream.m_controller else trap("VERIFY: the stream has a controller"):
.streams_readable_byte_stream_controller(controller) => streams_readable_byte_stream_controller_cancel_steps(controller, reason)
.streams_readable_stream_default_controller(_) => trap("unported (P4): Web::Streams::ReadableStreamDefaultController::cancel_steps")
# 8. Return the result of reacting to sourceCancelPromise with a fulfillment step that returns undefined.
return idl_upon_fulfillment(source_cancel_promise, gc.create_function1(gc.cell_heap(stream.cell()), ak.Function1[JsValue, JsValue](call = streams_readable_stream_cancel_fulfillment_step, context = none)))
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:836 Web::Streams::readable_stream_close.
## https://streams.spec.whatwg.org/#readable-stream-close
pub func streams_readable_stream_close_2(stream: StreamsReadableStream*):
let realm = streams_readable_stream_realm(stream)
# 1. Assert: stream.[[state]] is "readable".
assert(stream.m_state == StreamsReadableStreamState.readable)
# 2. Set stream.[[state]] to "closed".
stream.m_state = StreamsReadableStreamState.closed
# 3. Let reader be stream.[[reader]].
# 4. If reader is undefined, return.
let reader = stream.m_reader else return
# 5. Resolve reader.[[closedPromise]] with undefined.
idl_resolve_promise(realm, streams_readable_stream_reader_closed_promise(reader), js_undefined())
# 6. If reader implements ReadableStreamDefaultReader,
match reader:
.streams_readable_stream_default_reader(default_reader):
# 1. Let readRequests be reader.[[readRequests]].
# 2. Set reader.[[readRequests]] to an empty list.
var read_requests = default_reader.m_read_requests
default_reader.m_read_requests = ak.SinglyLinkedList[StreamsReadRequest*, ak.DefaultSizeCalculationPolicy[StreamsReadRequest*]]()
# 3. For each readRequest of readRequests,
for read_request in ak.singly_linked_list_begin(&read_requests):
# 1. Perform readRequest’s close steps.
streams_read_request_on_close(*read_request)
_:
return
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:873 Web::Streams::readable_stream_error.
## https://streams.spec.whatwg.org/#readable-stream-error
pub func streams_readable_stream_error_2(stream: StreamsReadableStream*, error_: JsValue):
let realm = streams_readable_stream_realm(stream)
# 1. Assert: stream.[[state]] is "readable".
assert(stream.m_state == StreamsReadableStreamState.readable)
# 2. Set stream.[[state]] to "errored".
stream.m_state = StreamsReadableStreamState.errored
# 3. Set stream.[[storedError]] to e.
stream.m_stored_error = error_
# 4. Let reader be stream.[[reader]].
# 5. If reader is undefined, return.
let reader = stream.m_reader else return
let closed_promise_capability = streams_readable_stream_reader_closed_promise(reader)
# 6. Reject reader.[[closedPromise]] with e.
idl_reject_promise(realm, closed_promise_capability, error_)
# 7. Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.
idl_mark_promise_as_handled(closed_promise_capability)
match reader:
# 8. If reader implements ReadableStreamDefaultReader,
.streams_readable_stream_default_reader(default_reader):
# 1. Perform ! ReadableStreamDefaultReaderErrorReadRequests(reader, e).
streams_readable_stream_default_reader_error_read_requests(default_reader, error_)
# 9. Otherwise,
.streams_readable_stream_byob_reader(_):
# 1. Assert: reader implements ReadableStreamBYOBReader.
# 2. Perform ! ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e).
trap("unported (P4): Web::Streams::readable_stream_byob_reader_error_read_into_requests")
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:942 Web::Streams::readable_stream_fulfill_read_request.
## https://streams.spec.whatwg.org/#readable-stream-fulfill-read-request
pub func streams_readable_stream_fulfill_read_request(stream: StreamsReadableStream*, chunk: JsValue, done: bool):
# 1. Assert: ! ReadableStreamHasDefaultReader(stream) is true.
assert(streams_readable_stream_has_default_reader(stream))
# 2. Let reader be stream.[[reader]].
let reader = streams_readable_stream_default_reader_of(stream)
# 3. Assert: reader.[[readRequests]] is not empty.
assert(not ak.singly_linked_list_is_empty(&reader.m_read_requests))
# 4. Let readRequest be reader.[[readRequests]][0].
# 5. Remove readRequest from reader.[[readRequests]].
let read_request = ak.singly_linked_list_take_first(&reader.m_read_requests)
# 6. If done is true, perform readRequest’s close steps.
if done:
streams_read_request_on_close(read_request)
# 7. Otherwise, perform readRequest’s chunk steps, given chunk.
else:
streams_read_request_on_chunk(read_request, chunk)
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:978 Web::Streams::readable_stream_get_num_read_requests.
## https://streams.spec.whatwg.org/#readable-stream-get-num-read-requests
pub func streams_readable_stream_get_num_read_requests(stream: StreamsReadableStream*) -> usize:
# 1. Assert: ! ReadableStreamHasDefaultReader(stream) is true.
assert(streams_readable_stream_has_default_reader(stream))
# 2. Return stream.[[reader]].[[readRequests]]'s size.
return ak.singly_linked_list_size(&streams_readable_stream_default_reader_of(stream).m_read_requests)
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:988 Web::Streams::readable_stream_has_byob_reader.
## https://streams.spec.whatwg.org/#readable-stream-has-byob-reader
pub func streams_readable_stream_has_byob_reader(stream: StreamsReadableStream*) -> bool:
# 1. Let reader be stream.[[reader]].
# 2. If reader is undefined, return false.
let reader = stream.m_reader else return false
# 3. If reader implements ReadableStreamBYOBReader, return true.
match reader:
.streams_readable_stream_byob_reader(_): return true
_: _ = 0
# 4. Return false.
return false
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1006 Web::Streams::readable_stream_has_default_reader.
## https://streams.spec.whatwg.org/#readable-stream-has-default-reader
pub func streams_readable_stream_has_default_reader(stream: StreamsReadableStream*) -> bool:
# 1. Let reader be stream.[[reader]].
# 2. If reader is undefined, return false.
let reader = stream.m_reader else return false
# 3. If reader implements ReadableStreamDefaultReader, return true.
match reader:
.streams_readable_stream_default_reader(_): return true
_: _ = 0
# 4. Return false.
return false
# mark: Readers =================================================================================
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1024 Web::Streams::readable_stream_reader_generic_cancel.
## https://streams.spec.whatwg.org/#readable-stream-reader-generic-cancel
pub func streams_readable_stream_reader_generic_cancel(reader: StreamsReadableStreamGenericReaderMixin*, reason: JsValue) -> JsPromiseCapability*:
# 1. Let stream be reader.[[stream]]
# 2. Assert: stream is not undefined
let stream = reader.m_stream else trap("VERIFY: the reader has a stream")
# 3. Return ! ReadableStreamCancel(stream, reason)
return streams_readable_stream_cancel_2(stream, reason)
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1037 Web::Streams::readable_stream_reader_generic_initialize.
## https://streams.spec.whatwg.org/#readable-stream-reader-generic-initialize
pub func streams_readable_stream_reader_generic_initialize(reader: StreamsReadableStreamReader, stream: StreamsReadableStream*):
let (mixin, reader_object) = match reader:
.streams_readable_stream_default_reader(default_reader) => (&default_reader.generic_reader, (JsObject*)default_reader)
.streams_readable_stream_byob_reader(_) => trap("unported (P4): Web::Streams::ReadableStreamBYOBReader")
# FIXME: Exactly when we should effectively be using the relevant realm of `this` is to be clarified by the spec.
# For now, we do so as needed by WPT tests. See: https://github.com/whatwg/streams/issues/1213
let realm = html_relevant_realm(reader_object)
# 1. Set reader.[[stream]] to stream.
mixin.m_stream = stream
# 2. Set stream.[[reader]] to reader.
stream.m_reader = reader
# 3. If stream.[[state]] is "readable",
let state = stream.m_state
if state == StreamsReadableStreamState.readable:
# 1. Set reader.[[closedPromise]] to a new promise.
mixin.m_closed_promise = idl_create_promise(realm)
# 4. Otherwise, if stream.[[state]] is "closed",
elif state == StreamsReadableStreamState.closed:
# 1. Set reader.[[closedPromise]] to a promise resolved with undefined.
mixin.m_closed_promise = idl_create_resolved_promise(realm, js_undefined())
# 5. Otherwise,
else:
# 1. Assert: stream.[[state]] is "errored".
assert(state == StreamsReadableStreamState.errored)
# 2. Set reader.[[closedPromise]] to a promise rejected with stream.[[storedError]].
let closed_promise = idl_create_rejected_promise(realm, stream.m_stored_error)
mixin.m_closed_promise = closed_promise
# 3. Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.
idl_mark_promise_as_handled(closed_promise)
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1075 Web::Streams::readable_stream_reader_generic_release.
## https://streams.spec.whatwg.org/#readable-stream-reader-generic-release
pub func streams_readable_stream_reader_generic_release(reader: StreamsReadableStreamGenericReaderMixin*):
# 1. Let stream be reader.[[stream]].
# 2. Assert: stream is not undefined.
let stream = reader.m_stream else trap("VERIFY: the reader has a stream")
# 3. Assert: stream.[[reader]] is reader.
match stream.m_reader else trap("VERIFY: stream.reader() is reader"):
.streams_readable_stream_default_reader(default_reader): assert(&default_reader.generic_reader == reader)
.streams_readable_stream_byob_reader(_): trap("unported (P4): Web::Streams::ReadableStreamBYOBReader")
let realm = streams_readable_stream_realm(stream)
let exception = js_type_error_create(realm, ak.string_from_str("Reader has been released"))
# 4. If stream.[[state]] is "readable", reject reader.[[closedPromise]] with a TypeError exception.
if stream.m_state == StreamsReadableStreamState.readable:
idl_reject_promise(realm, reader.m_closed_promise else trap("VERIFY: the reader has a closed promise"), exception)
# 5. Otherwise, set reader.[[closedPromise]] to a promise rejected with a TypeError exception.
else:
reader.m_closed_promise = idl_create_rejected_promise(realm, exception)
# 6. Set reader.[[closedPromise]].[[PromiseIsHandled]] to true.
idl_mark_promise_as_handled(reader.m_closed_promise else trap("VERIFY: the reader has a closed promise"))
# 7. Perform ! stream.[[controller]].[[ReleaseSteps]]().
match stream.m_controller else trap("VERIFY: the stream has a controller"):
.streams_readable_byte_stream_controller(controller): streams_readable_byte_stream_controller_release_steps(controller)
.streams_readable_stream_default_controller(_): trap("unported (P4): Web::Streams::ReadableStreamDefaultController::release_steps")
# 8. Set stream.[[reader]] to undefined.
stream.m_reader = none
# 9. Set reader.[[stream]] to undefined.
reader.m_stream = none
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1163 Web::Streams::readable_stream_default_reader_error_read_requests.
## https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaultreadererrorreadrequests
pub func streams_readable_stream_default_reader_error_read_requests(reader: StreamsReadableStreamDefaultReader*, error_: JsValue):
# 1. Let readRequests be reader.[[readRequests]].
# 2. Set reader.[[readRequests]] to a new empty list.
var read_requests = reader.m_read_requests
reader.m_read_requests = ak.SinglyLinkedList[StreamsReadRequest*, ak.DefaultSizeCalculationPolicy[StreamsReadRequest*]]()
# 3. For each readRequest of readRequests,
for read_request in ak.singly_linked_list_begin(&read_requests):
# 1. Perform readRequest’s error steps, given e.
streams_read_request_on_error(*read_request, error_)
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1177 Web::Streams::readable_stream_default_reader_read.
## https://streams.spec.whatwg.org/#readable-stream-default-reader-read
pub func streams_readable_stream_default_reader_read_2(reader: StreamsReadableStreamDefaultReader*, read_request: StreamsReadRequest*):
# 1. Let stream be reader.[[stream]].
# 2. Assert: stream is not undefined.
let stream = reader.generic_reader.m_stream else trap("VERIFY: the reader has a stream")
# 3. Set stream.[[disturbed]] to true.
stream.m_disturbed = true
# 4. If stream.[[state]] is "closed", perform readRequest’s close steps.
let state = stream.m_state
if state == StreamsReadableStreamState.closed:
streams_read_request_on_close(read_request)
# 5. Otherwise, if stream.[[state]] is "errored", perform readRequest’s error steps given stream.[[storedError]].
elif state == StreamsReadableStreamState.errored:
streams_read_request_on_error(read_request, stream.m_stored_error)
# 6. Otherwise,
else:
# 1. Assert: stream.[[state]] is "readable".
assert(state == StreamsReadableStreamState.readable)
# 2. Perform ! stream.[[controller]].[[PullSteps]](readRequest).
match stream.m_controller else trap("VERIFY: the stream has a controller"):
.streams_readable_byte_stream_controller(controller): streams_readable_byte_stream_controller_pull_steps(controller, read_request)
.streams_readable_stream_default_controller(_): trap("unported (P4): Web::Streams::ReadableStreamDefaultController::pull_steps")
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1209 Web::Streams::readable_stream_default_reader_release.
## https://streams.spec.whatwg.org/#abstract-opdef-readablestreamdefaultreaderrelease
pub func streams_readable_stream_default_reader_release(reader: StreamsReadableStreamDefaultReader*):
let realm = streams_readable_stream_default_reader_realm(reader)
# 1. Perform ! ReadableStreamReaderGenericRelease(reader).
streams_readable_stream_reader_generic_release(&reader.generic_reader)
# 2. Let e be a new TypeError exception.
let exception = js_type_error_create(realm, ak.string_from_str("Reader has been released"))
# 3. Perform ! ReadableStreamDefaultReaderErrorReadRequests(reader, e).
streams_readable_stream_default_reader_error_read_requests(reader, exception)
## Ported from Libraries/LibWeb/Streams/ReadableStreamOperations.cpp:1244 Web::Streams::set_up_readable_stream_default_reader.
## https://streams.spec.whatwg.org/#set-up-readable-stream-default-reader
pub func streams_set_up_readable_stream_default_reader(reader: StreamsReadableStreamDefaultReader*, stream: StreamsReadableStream*) -> !:
# 1. If ! IsReadableStreamLocked(stream) is true, throw a TypeError exception.
if streams_is_readable_stream_locked(stream):
return try idl_throw_simple(IdlSimpleExceptionType.type_error, .string_view(ak.sv("Cannot create stream reader for a locked stream")))
# 2. Perform ! ReadableStreamReaderGenericInitialize(reader, stream).
streams_readable_stream_reader_generic_initialize(.streams_readable_stream_default_reader(reader), stream)
# 3. Set reader.[[readRequests]] to a new empty list.
ak.singly_linked_list_clear(&reader.m_read_requests)