diff --git a/api-reports/2_12.txt b/api-reports/2_12.txt index c2887d6c2..bcf31dc83 100644 --- a/api-reports/2_12.txt +++ b/api-reports/2_12.txt @@ -15625,6 +15625,8 @@ PushSubscriptionJSON[JT] val expirationTime: java.lang.Double PushSubscriptionJSON[JT] val keys: js.Dictionary[String] PushSubscriptionOptions[JT] var applicationServerKey: js.UndefOr[Uint8Array] PushSubscriptionOptions[JT] var userVisibleOnly: js.UndefOr[Boolean] +QueuingStrategy[JT] var highWaterMark: Int +QueuingStrategy[JT] var size: js.Function1[T, Int] RTCBundlePolicy[JT] RTCBundlePolicy[SO] val balanced: RTCBundlePolicy RTCBundlePolicy[SO] val `max-bundle` = "max-bundle".asInstanceOf[RTCBundlePolicy] @@ -15851,14 +15853,24 @@ ReadableStream[JT] def locked: Boolean ReadableStream[JT] def pipeThrough[U](pair: Any, options: Any?): ReadableStream[U] ReadableStream[JT] def pipeTo(dest: WriteableStream[T], options: Any?): Unit ReadableStream[JT] def tee(): js.Array[_ <: ReadableStream[T]] +ReadableStream[SO] def apply[T](underlyingSource: js.UndefOr[ReadableStreamUnderlyingSource[T]]?, queuingStrategy: js.UndefOr[QueuingStrategy[T]]?): ReadableStream[T] ReadableStreamController[JC] def close(): Unit ReadableStreamController[JC] def desiredSize: Int -ReadableStreamController[JC] def enqueue(chunk: Chunk[T]): js.UndefOr[Int] +ReadableStreamController[JC] def enqueue(): Unit +ReadableStreamController[JC] def enqueue(chunk: T): Unit ReadableStreamController[JC] def error(e: Any): Unit -ReadableStreamReader[JC] def cancel(reason: Any): js.Promise[Any] +ReadableStreamReader[JC] def cancel(): js.Promise[Unit] +ReadableStreamReader[JC] def cancel(reason: Any): js.Promise[Unit] ReadableStreamReader[JC] def closed: js.Promise[ReadableStreamReader[T]] ReadableStreamReader[JC] def read(): js.Promise[Chunk[T]] ReadableStreamReader[JC] def releaseLock(): Unit +ReadableStreamType[JT] +ReadableStreamType[SO] val bytes: ReadableStreamType +ReadableStreamUnderlyingSource[JT] var autoAllocateChunkSize: js.UndefOr[Int] +ReadableStreamUnderlyingSource[JT] var cancel: js.UndefOr[js.Function1[js.Any, js.UndefOr[js.Promise[Unit]]]] +ReadableStreamUnderlyingSource[JT] var pull: js.UndefOr[js.Function1[ReadableStreamController[T], js.UndefOr[js.Promise[Unit]]]] +ReadableStreamUnderlyingSource[JT] var start: js.UndefOr[js.Function1[ReadableStreamController[T], js.UndefOr[js.Promise[Unit]]]] +ReadableStreamUnderlyingSource[JT] var `type`: js.UndefOr[ReadableStreamType] ReferrerPolicy[JT] ReferrerPolicy[SO] val empty: ReferrerPolicy ReferrerPolicy[SO] val `no-referrer` = "no-referrer".asInstanceOf[ReferrerPolicy] @@ -25958,7 +25970,7 @@ intl/NumberFormatOptions[JT] var useGrouping: js.UndefOr[Boolean] intl/NumberFormatOptions[SO] def apply(localeMatcher: js.UndefOr[String]?, style: js.UndefOr[String]?, currency: js.UndefOr[String]?, currencyDisplay: js.UndefOr[String]?, useGrouping: js.UndefOr[Boolean]?, minimumIntegerDigits: js.UndefOr[Double]?, minimumFractionDigits: js.UndefOr[Double]?, maximumFractionDigits: js.UndefOr[Double]?, minimumSignificantDigits: js.UndefOr[Double]?, maximumSignificantDigits: js.UndefOr[Double]?): NumberFormatOptions (@deprecated in 2.0.0) package[SO] type AlgorithmIdentifier = Algorithm | String package[SO] type BigInteger = js.typedarray.Uint8Array -package[SO] type BodyInit = Blob | BufferSource | FormData | String +package[SO] type BodyInit = Blob | BufferSource | FormData | String | ReadableStream[Uint8Array] package[SO] type BufferSource = ArrayBufferView | ArrayBuffer package[SO] type ByteString = String package[SO] type ClientRect = DOMRect (@deprecated in 2.0.0) diff --git a/api-reports/2_13.txt b/api-reports/2_13.txt index c2887d6c2..bcf31dc83 100644 --- a/api-reports/2_13.txt +++ b/api-reports/2_13.txt @@ -15625,6 +15625,8 @@ PushSubscriptionJSON[JT] val expirationTime: java.lang.Double PushSubscriptionJSON[JT] val keys: js.Dictionary[String] PushSubscriptionOptions[JT] var applicationServerKey: js.UndefOr[Uint8Array] PushSubscriptionOptions[JT] var userVisibleOnly: js.UndefOr[Boolean] +QueuingStrategy[JT] var highWaterMark: Int +QueuingStrategy[JT] var size: js.Function1[T, Int] RTCBundlePolicy[JT] RTCBundlePolicy[SO] val balanced: RTCBundlePolicy RTCBundlePolicy[SO] val `max-bundle` = "max-bundle".asInstanceOf[RTCBundlePolicy] @@ -15851,14 +15853,24 @@ ReadableStream[JT] def locked: Boolean ReadableStream[JT] def pipeThrough[U](pair: Any, options: Any?): ReadableStream[U] ReadableStream[JT] def pipeTo(dest: WriteableStream[T], options: Any?): Unit ReadableStream[JT] def tee(): js.Array[_ <: ReadableStream[T]] +ReadableStream[SO] def apply[T](underlyingSource: js.UndefOr[ReadableStreamUnderlyingSource[T]]?, queuingStrategy: js.UndefOr[QueuingStrategy[T]]?): ReadableStream[T] ReadableStreamController[JC] def close(): Unit ReadableStreamController[JC] def desiredSize: Int -ReadableStreamController[JC] def enqueue(chunk: Chunk[T]): js.UndefOr[Int] +ReadableStreamController[JC] def enqueue(): Unit +ReadableStreamController[JC] def enqueue(chunk: T): Unit ReadableStreamController[JC] def error(e: Any): Unit -ReadableStreamReader[JC] def cancel(reason: Any): js.Promise[Any] +ReadableStreamReader[JC] def cancel(): js.Promise[Unit] +ReadableStreamReader[JC] def cancel(reason: Any): js.Promise[Unit] ReadableStreamReader[JC] def closed: js.Promise[ReadableStreamReader[T]] ReadableStreamReader[JC] def read(): js.Promise[Chunk[T]] ReadableStreamReader[JC] def releaseLock(): Unit +ReadableStreamType[JT] +ReadableStreamType[SO] val bytes: ReadableStreamType +ReadableStreamUnderlyingSource[JT] var autoAllocateChunkSize: js.UndefOr[Int] +ReadableStreamUnderlyingSource[JT] var cancel: js.UndefOr[js.Function1[js.Any, js.UndefOr[js.Promise[Unit]]]] +ReadableStreamUnderlyingSource[JT] var pull: js.UndefOr[js.Function1[ReadableStreamController[T], js.UndefOr[js.Promise[Unit]]]] +ReadableStreamUnderlyingSource[JT] var start: js.UndefOr[js.Function1[ReadableStreamController[T], js.UndefOr[js.Promise[Unit]]]] +ReadableStreamUnderlyingSource[JT] var `type`: js.UndefOr[ReadableStreamType] ReferrerPolicy[JT] ReferrerPolicy[SO] val empty: ReferrerPolicy ReferrerPolicy[SO] val `no-referrer` = "no-referrer".asInstanceOf[ReferrerPolicy] @@ -25958,7 +25970,7 @@ intl/NumberFormatOptions[JT] var useGrouping: js.UndefOr[Boolean] intl/NumberFormatOptions[SO] def apply(localeMatcher: js.UndefOr[String]?, style: js.UndefOr[String]?, currency: js.UndefOr[String]?, currencyDisplay: js.UndefOr[String]?, useGrouping: js.UndefOr[Boolean]?, minimumIntegerDigits: js.UndefOr[Double]?, minimumFractionDigits: js.UndefOr[Double]?, maximumFractionDigits: js.UndefOr[Double]?, minimumSignificantDigits: js.UndefOr[Double]?, maximumSignificantDigits: js.UndefOr[Double]?): NumberFormatOptions (@deprecated in 2.0.0) package[SO] type AlgorithmIdentifier = Algorithm | String package[SO] type BigInteger = js.typedarray.Uint8Array -package[SO] type BodyInit = Blob | BufferSource | FormData | String +package[SO] type BodyInit = Blob | BufferSource | FormData | String | ReadableStream[Uint8Array] package[SO] type BufferSource = ArrayBufferView | ArrayBuffer package[SO] type ByteString = String package[SO] type ClientRect = DOMRect (@deprecated in 2.0.0) diff --git a/dom/src/main/scala-2/org/scalajs/dom/ReadableStreamType.scala b/dom/src/main/scala-2/org/scalajs/dom/ReadableStreamType.scala new file mode 100644 index 000000000..0f622a271 --- /dev/null +++ b/dom/src/main/scala-2/org/scalajs/dom/ReadableStreamType.scala @@ -0,0 +1,11 @@ +package org.scalajs.dom + +import scala.scalajs.js + +/** [[https://streams.spec.whatwg.org/#enumdef-readablestreamtype ReadableStreamType enum]] */ +@js.native +sealed trait ReadableStreamType extends js.Any + +object ReadableStreamType { + val bytes: ReadableStreamType = "bytes".asInstanceOf[ReadableStreamType] +} \ No newline at end of file diff --git a/dom/src/main/scala-3/org/scalajs/dom/ReadableStreamType.scala b/dom/src/main/scala-3/org/scalajs/dom/ReadableStreamType.scala new file mode 100644 index 000000000..c19fb3d14 --- /dev/null +++ b/dom/src/main/scala-3/org/scalajs/dom/ReadableStreamType.scala @@ -0,0 +1,7 @@ +package org.scalajs.dom + +opaque type ReadableStreamType <: String = String + +object ReadableStreamType { + val bytes: ReadableStreamType = "bytes" +} diff --git a/dom/src/main/scala/org/scalajs/dom/QueuingStrategy.scala b/dom/src/main/scala/org/scalajs/dom/QueuingStrategy.scala new file mode 100644 index 000000000..bf5e8845a --- /dev/null +++ b/dom/src/main/scala/org/scalajs/dom/QueuingStrategy.scala @@ -0,0 +1,23 @@ +package org.scalajs.dom + +import scala.scalajs.js + +/** See [[https://streams.spec.whatwg.org/#qs-api ¶7.1. The queuing strategy API]] + * + * @tparam T + * Type of the Chunks returned by the Stream + */ +trait QueuingStrategy[T] extends js.Object { + + /** A non-negative number indicating the high water mark of the stream using this queuing strategy. */ + var highWaterMark: Int + + /** (non-byte streams only) + * + * The result is used to determine backpressure, manifesting via the appropriate desiredSize property. For readable + * streams, it also governs when the underlying source's [[ReadableStreamUnderlyingSource.pull]] method is called. + * + * A function that computes and returns the finite non-negative size of the given chunk value. + */ + var size: js.Function1[T, Int] +} diff --git a/dom/src/main/scala/org/scalajs/dom/ReadableStream.scala b/dom/src/main/scala/org/scalajs/dom/ReadableStream.scala index df6ffeb54..cc6cd9973 100644 --- a/dom/src/main/scala/org/scalajs/dom/ReadableStream.scala +++ b/dom/src/main/scala/org/scalajs/dom/ReadableStream.scala @@ -92,3 +92,18 @@ trait ReadableStream[+T] extends js.Object { */ def tee(): js.Array[_ <: ReadableStream[T]] = js.native // TODO js.Tuple2[ReadableStream[T], ReadableStream[T]] } + +object ReadableStream { + + def apply[T]( + underlyingSource: js.UndefOr[ReadableStreamUnderlyingSource[T]] = js.undefined, + queuingStrategy: js.UndefOr[QueuingStrategy[T]] = js.undefined + ): ReadableStream[T] = { + js.Dynamic + .newInstance(js.Dynamic.global.ReadableStream)( + underlyingSource.asInstanceOf[js.Any], + queuingStrategy.asInstanceOf[js.Any] + ) + .asInstanceOf[ReadableStream[T]] + } +} diff --git a/dom/src/main/scala/org/scalajs/dom/ReadableStreamController.scala b/dom/src/main/scala/org/scalajs/dom/ReadableStreamController.scala index 55e7106d5..ee40db34b 100644 --- a/dom/src/main/scala/org/scalajs/dom/ReadableStreamController.scala +++ b/dom/src/main/scala/org/scalajs/dom/ReadableStreamController.scala @@ -1,7 +1,7 @@ package org.scalajs.dom import scala.scalajs.js -import scala.scalajs.js.annotation._ +import scala.scalajs.js.annotation.JSGlobal /** [[https://streams.spec.whatwg.org/#rs-controller-class ¶3.3 Class ReadableStreamController]] of whatwg spec * @@ -15,7 +15,7 @@ import scala.scalajs.js.annotation._ */ @js.native @JSGlobal -class ReadableStreamController[-T](stream: ReadableStream[T] = null) extends js.Object { +class ReadableStreamController[-T] private[this] () extends js.Object { /** The desiredSize getter returns the desired size to fill the controlled stream’s internal queue. It can be * negative, if the queue is over-full. An underlying source should use this information to determine when and how to @@ -39,7 +39,8 @@ class ReadableStreamController[-T](stream: ReadableStream[T] = null) extends js. * @return * seems like its an undefOr[Int] of the size */ - def enqueue(chunk: Chunk[T]): js.UndefOr[Int] = js.native + def enqueue(chunk: T): Unit = js.native + def enqueue(): Unit = js.native /** The error method will error the readable stream, making all future interactions with it fail with the given error * e. diff --git a/dom/src/main/scala/org/scalajs/dom/ReadableStreamReader.scala b/dom/src/main/scala/org/scalajs/dom/ReadableStreamReader.scala index adf996e55..1953b2688 100644 --- a/dom/src/main/scala/org/scalajs/dom/ReadableStreamReader.scala +++ b/dom/src/main/scala/org/scalajs/dom/ReadableStreamReader.scala @@ -30,11 +30,9 @@ class ReadableStreamReader[+T](stream: ReadableStream[T]) extends js.Object { * * If the reader is active, the cancel method behaves the same as that for the associated stream. When done, it * automatically releases the lock. - * - * //todo determine type of reason */ - // not actually sure what the return type is here - def cancel(reason: Any): js.Promise[Any] = js.native + def cancel(reason: Any): js.Promise[Unit] = js.native + def cancel(): js.Promise[Unit] = js.native /** See [[https://streams.spec.whatwg.org/#reader-read 3.4.4.3. read()]] of whatwg Stream spec. * diff --git a/dom/src/main/scala/org/scalajs/dom/ReadableStreamUnderlyingSource.scala b/dom/src/main/scala/org/scalajs/dom/ReadableStreamUnderlyingSource.scala new file mode 100644 index 000000000..0d7712bc4 --- /dev/null +++ b/dom/src/main/scala/org/scalajs/dom/ReadableStreamUnderlyingSource.scala @@ -0,0 +1,57 @@ +package org.scalajs.dom + +import scala.scalajs.js + +/** See [[https://streams.spec.whatwg.org/#underlying-source-api ¶4.2.3. The underlying source API]] of whatwg streams + * spec. + * + * @tparam T + * Type of the Chunks returned by the Stream + */ +trait ReadableStreamUnderlyingSource[T] extends js.Object { + + /** A function that is called immediately during creation of the ReadableStream. + * + * If this setup process is asynchronous, it can return a promise to signal success or failure; a rejected promise + * will error the stream. Any thrown exceptions will be re-thrown by the [[ReadableStream]] constructor. + */ + var start: js.UndefOr[js.Function1[ReadableStreamController[T], js.UndefOr[js.Promise[Unit]]]] = js.undefined + + /** A function that is called whenever the stream’s internal queue of chunks becomes not full, i.e. whenever the + * queue’s desired size becomes positive. Generally, it will be called repeatedly until the queue reaches its high + * water mark (i.e. until the desired size becomes non-positive). + * + * This function will not be called until [[start]] successfully completes. Additionally, it will only be called + * repeatedly if it enqueues at least one chunk or fulfills a BYOB request; a no-op [[pull]] implementation will not + * be continually called. + * + * If the function returns a promise, then it will not be called again until that promise fulfills. (If the promise + * rejects, the stream will become errored.) This is mainly used in the case of pull sources, where the promise + * returned represents the process of acquiring a new chunk. Throwing an exception is treated the same as returning a + * rejected promise. + */ + var pull: js.UndefOr[js.Function1[ReadableStreamController[T], js.UndefOr[js.Promise[Unit]]]] = js.undefined + + /** A function that is called whenever the consumer cancels the stream, via [[ReadableStream.cancel]] or + * [[ReadableStreamReader.cancel():scala\.scalajs\.js\.Promise[Unit]*]]. It takes as its argument the same value as + * was passed to those methods by the consumer. If the shutdown process is asynchronous, it can return a promise to + * signal success or failure; the result will be communicated via the return value of the [[cancel]] method that was + * called. Additionally, a rejected promise will error the stream, instead of letting it close. Throwing an exception + * is treated the same as returning a rejected promise. + */ + var cancel: js.UndefOr[js.Function1[js.Any, js.UndefOr[js.Promise[Unit]]]] = js.undefined + + /** Can be set to "bytes" to signal that the constructed [[ReadableStream]] is a readable byte stream. + * + * Setting any value other than "bytes" or undefined will cause the ReadableStream() constructor to throw an + * exception. + */ + var `type`: js.UndefOr[ReadableStreamType] = js.undefined + + /** (byte streams only) + * + * Can be set to a positive integer to cause the implementation to automatically allocate buffers for the underlying + * source code to write into. + */ + var autoAllocateChunkSize: js.UndefOr[Int] = js.undefined +} diff --git a/dom/src/main/scala/org/scalajs/dom/package.scala b/dom/src/main/scala/org/scalajs/dom/package.scala index 6ed863024..caeea520b 100644 --- a/dom/src/main/scala/org/scalajs/dom/package.scala +++ b/dom/src/main/scala/org/scalajs/dom/package.scala @@ -2,7 +2,7 @@ package org.scalajs import scala.scalajs.js import scala.scalajs.js.annotation._ -import scala.scalajs.js.typedarray.{ArrayBuffer, ArrayBufferView} +import scala.scalajs.js.typedarray.{ArrayBuffer, ArrayBufferView, Uint8Array} import scala.scalajs.js.| package object dom { @@ -32,7 +32,7 @@ package object dom { /** defined at [[https://fetch.spec.whatwg.org/#body-mixin ¶6.2 Body mixin]] in whatwg Fetch spec */ type BodyInit = - Blob | BufferSource | FormData | String // todo: add URLSearchParams + Blob | BufferSource | FormData | String | ReadableStream[Uint8Array] // todo: add URLSearchParams /** WebIDL sequence is js.Array[T] | JSIterable[T]. However @mseddon knows at least Blink's IDL compiler treats * these as simply js.Array[T] for now. We keep this type as a reminder to check in more detail diff --git a/tests-chrome/src/test/scala/org/scalajs/dom/tests/chrome/ChromeTests.scala b/tests-chrome/src/test/scala/org/scalajs/dom/tests/chrome/ChromeTests.scala index 9a4e5e267..b91a6cff8 100644 --- a/tests-chrome/src/test/scala/org/scalajs/dom/tests/chrome/ChromeTests.scala +++ b/tests-chrome/src/test/scala/org/scalajs/dom/tests/chrome/ChromeTests.scala @@ -3,4 +3,4 @@ package org.scalajs.dom.tests.chrome import org.scalajs.dom.tests.shared._ import org.scalajs.dom.tests.webworker._ -class ChromeTests extends SharedTests with WebWorkerTests \ No newline at end of file +class ChromeTests extends SharedTests with WebWorkerTests with BrowserTests \ No newline at end of file diff --git a/tests-firefox/src/test/scala/org/scalajs/dom/tests/firefox/FirefoxTests.scala b/tests-firefox/src/test/scala/org/scalajs/dom/tests/firefox/FirefoxTests.scala index 1a8735389..d877f8b79 100644 --- a/tests-firefox/src/test/scala/org/scalajs/dom/tests/firefox/FirefoxTests.scala +++ b/tests-firefox/src/test/scala/org/scalajs/dom/tests/firefox/FirefoxTests.scala @@ -3,4 +3,4 @@ package org.scalajs.dom.tests.firefox import org.scalajs.dom.tests.shared._ import org.scalajs.dom.tests.webworker._ -class FirefoxTests extends SharedTests with WebWorkerTests \ No newline at end of file +class FirefoxTests extends SharedTests with WebWorkerTests with BrowserTests \ No newline at end of file diff --git a/tests-shared/src/main/scala/org/scalajs/dom/tests/shared/BrowserTests.scala b/tests-shared/src/main/scala/org/scalajs/dom/tests/shared/BrowserTests.scala new file mode 100644 index 000000000..10d8c26a8 --- /dev/null +++ b/tests-shared/src/main/scala/org/scalajs/dom/tests/shared/BrowserTests.scala @@ -0,0 +1,131 @@ +package org.scalajs.dom.tests.shared + +import org.junit.Assert.assertEquals +import org.junit.Test +import org.scalajs.dom.QueuingStrategy +import org.scalajs.dom.ReadableStream +import org.scalajs.dom.ReadableStreamController +import org.scalajs.dom.ReadableStreamReader +import org.scalajs.dom.ReadableStreamUnderlyingSource +import org.scalajs.dom.tests.shared.AsyncTesting.AsyncResult +import org.scalajs.dom.tests.shared.AsyncTesting._ +import org.scalajs.dom.tests.shared.AsyncTesting.async + +import scala.concurrent.Future +import scala.concurrent.Promise +import scala.scalajs.js +import scala.scalajs.js.Thenable.Implicits._ +import scala.util.Try + +trait BrowserTests { + + def read[T](reader: ReadableStreamReader[T])(values: Seq[T]): Future[Seq[T]] = { + reader + .read() + .flatMap { chunk => + if (chunk.done) { + Future.successful(values) + } else { + read(reader)(values :+ chunk.value) + } + } + } + + @Test + final def ReadableStreamConstructionAndConsumptionTest: AsyncResult = async { + case class Tuna(color: String) + + val expectedTunas = Seq( + Tuna("blue"), + Tuna("red") + ) + + val stream = ReadableStream[Tuna]( + new ReadableStreamUnderlyingSource[Tuna] { + start = js.defined({ (controller: ReadableStreamController[Tuna]) => + controller.enqueue(Tuna("blue")) + controller.enqueue(Tuna("red")) + controller.close(): js.UndefOr[js.Promise[Unit]] + }): js.UndefOr[js.Function1[ReadableStreamController[Tuna], js.UndefOr[js.Promise[Unit]]]] + } + ) + + read(stream.getReader())(Seq.empty) + .map { receivedTunas => + assertEquals(receivedTunas, expectedTunas) + } + } + + @Test + final def ReadableStreamQueueingStrategyTest: AsyncResult = async { + val expectedStrings = Seq( + "short one", + "definitely a longer one" + ) + + val stream = ReadableStream[String]( + new ReadableStreamUnderlyingSource[String] { + start = js.defined({ (controller: ReadableStreamController[String]) => + controller.enqueue("short one") + controller.enqueue("definitely a longer one") + controller.close(): js.UndefOr[js.Promise[Unit]] + }): js.UndefOr[js.Function1[ReadableStreamController[String], js.UndefOr[js.Promise[Unit]]]] + }, + new QueuingStrategy[String] { + var highWaterMark = 1 + var size: js.Function1[String, Int] = { (chunk: String) => + chunk.length + } + } + ) + + read(stream.getReader())(Seq.empty) + .map { receivedStrings => + assertEquals(receivedStrings, expectedStrings) + } + } + + @Test + final def ReadableStreamReaderCancelUnitTest: AsyncResult = async { + val reasonPromise = Promise[Unit]() + val stream = ReadableStream[Unit]( + new ReadableStreamUnderlyingSource[Unit] { + cancel = js.defined({ (reason: Any) => + reasonPromise.tryComplete(Try(reason.asInstanceOf[Unit])) + (): js.UndefOr[js.Promise[Unit]] + }): js.UndefOr[js.Function1[Any, js.UndefOr[js.Promise[Unit]]]] + } + ) + + for { + _ <- stream + .getReader() + .cancel() + .map(assertEquals((), _)) + _ <- reasonPromise.future.map(assertEquals((), _)) + } yield () + } + + @Test + final def ReadableStreamReaderCancelPromiseTest: AsyncResult = async { + val expectedReason = "probably a good one" + + val reasonPromise = Promise[String]() + val stream = ReadableStream[Unit]( + new ReadableStreamUnderlyingSource[Unit] { + cancel = js.defined({ (reason: Any) => + reasonPromise.tryComplete(Try(reason.asInstanceOf[String])) + (): js.UndefOr[js.Promise[Unit]] + }): js.UndefOr[js.Function1[Any, js.UndefOr[js.Promise[Unit]]]] + } + ) + + for { + _ <- stream + .getReader() + .cancel(expectedReason) + .map(assertEquals((), _)) + _ <- reasonPromise.future.map(assertEquals(expectedReason, _)) + } yield () + } +}