LibWeb: Add TransformStream scaffolding

This adds the scaffolding of TransformStream so we can start
implementing the necessary abstract operations for it.

Userland/Libraries/LibWeb/CMakeLists.txt

@@ -514,6 +514,7 @@ set(SOURCES
     Streams/ReadableStreamDefaultReader.cpp
     Streams/ReadableStreamGenericReader.cpp
     Streams/Transformer.cpp
+    Streams/TransformStream.cpp
     Streams/UnderlyingSink.cpp
     Streams/UnderlyingSource.cpp
     Streams/WritableStream.cpp

Userland/Libraries/LibWeb/Forward.h

@@ -556,6 +556,8 @@ class ReadableStreamDefaultController;
 class ReadableStreamDefaultReader;
 class ReadableStreamGenericReaderMixin;
 class ReadRequest;
+class TransformStream;
+class TransformStreamDefaultController;
 class WritableStream;
 class WritableStreamDefaultController;
 class WritableStreamDefaultWriter;

Userland/Libraries/LibWeb/Streams/TransformStream.cpp

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023, Kenneth Myhra <kennethmyhra@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include <LibWeb/Bindings/Intrinsics.h>
+#include <LibWeb/Streams/AbstractOperations.h>
+#include <LibWeb/Streams/TransformStream.h>
+#include <LibWeb/Streams/Transformer.h>
+#include <LibWeb/Streams/WritableStream.h>
+#include <LibWeb/WebIDL/ExceptionOr.h>
+
+namespace Web::Streams {
+
+// https://streams.spec.whatwg.org/#ts-construct
+WebIDL::ExceptionOr<JS::NonnullGCPtr<TransformStream>> TransformStream::construct_impl(JS::Realm& realm, Optional<JS::Handle<JS::Object>> transformer_object, QueuingStrategy const& writable_strategy, QueuingStrategy const& readable_strategy)
+{
+    (void)transformer_object;
+    (void)writable_strategy;
+    (void)readable_strategy;
+
+    return MUST_OR_THROW_OOM(realm.heap().allocate<TransformStream>(realm, realm));
+}
+
+TransformStream::TransformStream(JS::Realm& realm)
+    : Bindings::PlatformObject(realm)
+{
+}
+
+TransformStream::~TransformStream() = default;
+
+JS::ThrowCompletionOr<void> TransformStream::initialize(JS::Realm& realm)
+{
+    MUST_OR_THROW_OOM(Base::initialize(realm));
+    set_prototype(&Bindings::ensure_web_prototype<Bindings::TransformStreamPrototype>(realm, "TransformStream"));
+
+    return {};
+}
+
+void TransformStream::visit_edges(Cell::Visitor& visitor)
+{
+    Base::visit_edges(visitor);
+    visitor.visit(m_backpressure_change_promise);
+    visitor.visit(m_controller);
+    visitor.visit(m_readable);
+    visitor.visit(m_writable);
+}
+
+}

Userland/Libraries/LibWeb/Streams/TransformStream.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2023, Kenneth Myhra <kennethmyhra@serenityos.org>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#pragma once
+
+#include <LibJS/Forward.h>
+#include <LibWeb/Bindings/PlatformObject.h>
+#include <LibWeb/Forward.h>
+#include <LibWeb/Streams/QueuingStrategy.h>
+#include <LibWeb/WebIDL/Promise.h>
+
+namespace Web::Streams {
+
+class TransformStream final : public Bindings::PlatformObject {
+    WEB_PLATFORM_OBJECT(TransformStream, Bindings::PlatformObject);
+
+public:
+    virtual ~TransformStream() override;
+
+    static WebIDL::ExceptionOr<JS::NonnullGCPtr<TransformStream>> construct_impl(JS::Realm&, Optional<JS::Handle<JS::Object>> transformer_object = {}, QueuingStrategy const& writable_strategy = {}, QueuingStrategy const& readable_strategy = {});
+
+    // https://streams.spec.whatwg.org/#ts-readable
+    JS::NonnullGCPtr<ReadableStream> readable() { return *m_readable; }
+    void set_readable(ReadableStream& readable) { m_readable = readable; }
+
+    // https://streams.spec.whatwg.org/#ts-writable
+    JS::NonnullGCPtr<WritableStream> writable() { return *m_writable; }
+    void set_writable(WritableStream& writable) { m_writable = writable; }
+
+    Optional<bool> backpressure() const { return m_backpressure; }
+    void set_backpressure(Optional<bool> value) { m_backpressure = move(value); }
+
+    JS::GCPtr<WebIDL::Promise> backpressure_change_promise() const { return m_backpressure_change_promise; }
+    void set_backpressure_change_promise(JS::GCPtr<WebIDL::Promise> value) { m_backpressure_change_promise = value; }
+
+    JS::GCPtr<TransformStreamDefaultController> controller() const { return m_controller; }
+    void set_controller(JS::GCPtr<TransformStreamDefaultController> value) { m_controller = value; }
+
+private:
+    explicit TransformStream(JS::Realm& realm);
+
+    virtual JS::ThrowCompletionOr<void> initialize(JS::Realm&) override;
+
+    virtual void visit_edges(Cell::Visitor&) override;
+
+    // https://streams.spec.whatwg.org/#transformstream-backpressure
+    // Whether there was backpressure on [[readable]] the last time it was observed
+    Optional<bool> m_backpressure { false };
+
+    // https://streams.spec.whatwg.org/#transformstream-backpressurechangepromise
+    // A promise which is fulfilled and replaced every time the value of [[backpressure]] changes
+    JS::GCPtr<WebIDL::Promise> m_backpressure_change_promise;
+
+    // https://streams.spec.whatwg.org/#transformstream-controller
+    // A TransformStreamDefaultController created with the ability to control [[readable]] and [[writable]]
+    JS::GCPtr<TransformStreamDefaultController> m_controller;
+
+    // https://streams.spec.whatwg.org/#transformstream-detached
+    // A boolean flag set to true when the stream is transferred
+    bool m_detached { false };
+
+    // https://streams.spec.whatwg.org/#transformstream-readable
+    // The ReadableStream instance controlled by this object
+    JS::GCPtr<ReadableStream> m_readable;
+
+    // https://streams.spec.whatwg.org/#transformstream-writable
+    // The WritableStream instance controlled by this object
+    JS::GCPtr<WritableStream> m_writable;
+};
+
+}

Userland/Libraries/LibWeb/Streams/TransformStream.idl

@@ -0,0 +1,12 @@
+#import <Streams/QueuingStrategy.idl>
+#import <Streams/ReadableStream.idl>
+#import <Streams/WritableStream.idl>
+
+// https://streams.spec.whatwg.org/#transformstream
+[Exposed=*, Transferable]
+interface TransformStream {
+    constructor(optional object transformer, optional QueuingStrategy writableStrategy = {}, optional QueuingStrategy readableStrategy = {});
+
+    readonly attribute ReadableStream readable;
+    readonly attribute WritableStream writable;
+};

Userland/Libraries/LibWeb/idl_files.cmake

@@ -196,6 +196,7 @@ libweb_js_bindings(Streams/ReadableStreamBYOBReader)
 libweb_js_bindings(Streams/ReadableStreamBYOBRequest)
 libweb_js_bindings(Streams/ReadableStreamDefaultController)
 libweb_js_bindings(Streams/ReadableStreamDefaultReader)
+libweb_js_bindings(Streams/TransformStream)
 libweb_js_bindings(Streams/WritableStream)
 libweb_js_bindings(Streams/WritableStreamDefaultWriter)
 libweb_js_bindings(SVG/SVGAnimatedLength)