From c3050a64732dbebd457bf0a4203ced96b341833b Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 10:03:03 +0200
Subject: [PATCH 01/10] stream: initial approach to include strategy options on
 Readable.toWeb()

---
 doc/api/stream.md                   | 3 ++-
 lib/internal/streams/readable.js    | 4 ++--
 lib/internal/webstreams/adapters.js | 7 +++++--
 3 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 41a98aa827df74..386a5a8c7cdf6d 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -2807,7 +2807,7 @@ added:
 
 Returns whether the stream is readable.
 
-### `stream.Readable.toWeb(streamReadable)`
+### `stream.Readable.toWeb(streamReadable[, strategy])`
 
 <!-- YAML
 added: v17.0.0
@@ -2816,6 +2816,7 @@ added: v17.0.0
 > Stability: 1 - Experimental
 
 * `streamReadable` {stream.Readable}
+* `strategy` {queuingstrategies.QueuingStrategy}
 * Returns: {ReadableStream}
 
 ### `stream.Writable.fromWeb(writableStream[, options])`
diff --git a/lib/internal/streams/readable.js b/lib/internal/streams/readable.js
index 4164f7b27d56b2..25e71c9cb601b9 100644
--- a/lib/internal/streams/readable.js
+++ b/lib/internal/streams/readable.js
@@ -1405,8 +1405,8 @@ Readable.fromWeb = function(readableStream, options) {
     options);
 };
 
-Readable.toWeb = function(streamReadable) {
-  return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable);
+Readable.toWeb = function(streamReadable, strategy = null) {
+  return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable, strategy);
 };
 
 Readable.wrap = function(src, options) {
diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index 0fd571bfe11d19..5d806aa2244a33 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -359,10 +359,12 @@ function newStreamWritableFromWritableStream(writableStream, options = kEmptyObj
 }
 
 /**
+ * @typedef {import('./queuingstrategies').QueuingStrategy} QueuingStrategy
  * @param {Readable} streamReadable
+ * @param {QueuingStrategy} [queuingStrategy]
  * @returns {ReadableStream}
  */
-function newReadableStreamFromStreamReadable(streamReadable) {
+function newReadableStreamFromStreamReadable(streamReadable, queuingStrategy = null) {
   // Not using the internal/streams/utils isReadableNodeStream utility
   // here because it will return false if streamReadable is a Duplex
   // whose readable option is false. For a Duplex that is not readable,
@@ -386,7 +388,8 @@ function newReadableStreamFromStreamReadable(streamReadable) {
   // back to a minimal strategy that just specifies the highWaterMark
   // and no size algorithm. Using a ByteLengthQueuingStrategy here
   // is unnecessary.
-  const strategy =
+  const strategy = queuingStrategy ?
+    queuingStrategy :
     objectMode ?
       new CountQueuingStrategy({ highWaterMark }) :
       { highWaterMark };

From b48a89d91cddf6aefd450ec3926fb8589285bb8b Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 10:22:11 +0200
Subject: [PATCH 02/10] stream: extend strategy option using an object to allow
 extensibility

---
 doc/api/stream.md                   |  3 ++-
 lib/internal/streams/readable.js    |  6 ++++--
 lib/internal/webstreams/adapters.js | 10 ++++++++--
 3 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 386a5a8c7cdf6d..ccb70139c541fe 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -2816,7 +2816,8 @@ added: v17.0.0
 > Stability: 1 - Experimental
 
 * `streamReadable` {stream.Readable}
-* `strategy` {queuingstrategies.QueuingStrategy}
+* `options` {Object}
+  * `strategy` {QueuingStrategy}
 * Returns: {ReadableStream}
 
 ### `stream.Writable.fromWeb(writableStream[, options])`
diff --git a/lib/internal/streams/readable.js b/lib/internal/streams/readable.js
index 25e71c9cb601b9..aad4c594501ba6 100644
--- a/lib/internal/streams/readable.js
+++ b/lib/internal/streams/readable.js
@@ -1405,8 +1405,10 @@ Readable.fromWeb = function(readableStream, options) {
     options);
 };
 
-Readable.toWeb = function(streamReadable, strategy = null) {
-  return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable, strategy);
+Readable.toWeb = function(streamReadable, options) {
+  return lazyWebStreams().newReadableStreamFromStreamReadable(
+    streamReadable,
+    options);
 };
 
 Readable.wrap = function(src, options) {
diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index 5d806aa2244a33..8e6adcc5bda1f6 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -361,10 +361,12 @@ function newStreamWritableFromWritableStream(writableStream, options = kEmptyObj
 /**
  * @typedef {import('./queuingstrategies').QueuingStrategy} QueuingStrategy
  * @param {Readable} streamReadable
- * @param {QueuingStrategy} [queuingStrategy]
+ * @param {{
+ *  strategy : QueuingStrategy
+ * }} [options]
  * @returns {ReadableStream}
  */
-function newReadableStreamFromStreamReadable(streamReadable, queuingStrategy = null) {
+function newReadableStreamFromStreamReadable(streamReadable, options = kEmptyObject) {
   // Not using the internal/streams/utils isReadableNodeStream utility
   // here because it will return false if streamReadable is a Duplex
   // whose readable option is false. For a Duplex that is not readable,
@@ -388,6 +390,10 @@ function newReadableStreamFromStreamReadable(streamReadable, queuingStrategy = n
   // back to a minimal strategy that just specifies the highWaterMark
   // and no size algorithm. Using a ByteLengthQueuingStrategy here
   // is unnecessary.
+
+  // If there is an strategy available, use it. Otherwise, fallback to default behavior
+  const queuingStrategy = options?.strategy;
+
   const strategy = queuingStrategy ?
     queuingStrategy :
     objectMode ?

From 9eda83eef373770e8f17944093052bbc393032d7 Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 11:08:21 +0200
Subject: [PATCH 03/10] stream: fix typo on comment and change name of 
 parameter in the documentation file

---
 doc/api/stream.md                   | 2 +-
 lib/internal/webstreams/adapters.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index ccb70139c541fe..2530ef6b552004 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -2807,7 +2807,7 @@ added:
 
 Returns whether the stream is readable.
 
-### `stream.Readable.toWeb(streamReadable[, strategy])`
+### `stream.Readable.toWeb(streamReadable[, options])`
 
 <!-- YAML
 added: v17.0.0
diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index 8e6adcc5bda1f6..8681270919fb0b 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -391,7 +391,7 @@ function newReadableStreamFromStreamReadable(streamReadable, options = kEmptyObj
   // and no size algorithm. Using a ByteLengthQueuingStrategy here
   // is unnecessary.
 
-  // If there is an strategy available, use it. Otherwise, fallback to default behavior
+  // If there is a strategy available, use it. Otherwise, fallback to default behavior
   const queuingStrategy = options?.strategy;
 
   const strategy = queuingStrategy ?

From bcff47add7f19384a18423ee4afe121292a7b79b Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 13:02:50 +0200
Subject: [PATCH 04/10] stream: add unit test for strategy option

---
 doc/api/stream.md                             |  3 +-
 .../test-stream-readable-strategy-option.js   | 48 +++++++++++++++++++
 2 files changed, 50 insertions(+), 1 deletion(-)
 create mode 100644 test/parallel/test-stream-readable-strategy-option.js

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 2530ef6b552004..b492ef6be1d02c 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -2817,7 +2817,8 @@ added: v17.0.0
 
 * `streamReadable` {stream.Readable}
 * `options` {Object}
-  * `strategy` {QueuingStrategy}
+  * `strategy` {Object}
+    * `highWaterMark` {number}
 * Returns: {ReadableStream}
 
 ### `stream.Writable.fromWeb(writableStream[, options])`
diff --git a/test/parallel/test-stream-readable-strategy-option.js b/test/parallel/test-stream-readable-strategy-option.js
new file mode 100644
index 00000000000000..be8ff3aa42f27c
--- /dev/null
+++ b/test/parallel/test-stream-readable-strategy-option.js
@@ -0,0 +1,48 @@
+'use strict';
+const common = require('../common');
+const { Readable } = require('stream');
+const assert = require('assert');
+
+{
+  // Strategy 2
+  const streamData = ['a', 'b', 'c', null];
+
+  // Fulfill a Readable object
+  const readable = new Readable({
+    read: common.mustCall(() => {
+      process.nextTick(() => {
+        readable.push(streamData.shift());
+      });
+    }, streamData.length),
+  });
+
+  // Use helper to convert it to a Web ReadableStream using ByteLength strategy
+  const readableStream = Readable.toWeb(readable, {
+    strategy: new ByteLengthQueuingStrategy({ highWaterMark: 1 }),
+  });
+
+  assert(!readableStream.locked);
+  readableStream.getReader().read().then(common.mustCall());
+}
+
+{
+  // Strategy 2
+  const streamData = ['a', 'b', 'c', null];
+
+  // Fulfill a Readable object
+  const readable = new Readable({
+    read: common.mustCall(() => {
+      process.nextTick(() => {
+        readable.push(streamData.shift());
+      });
+    }, streamData.length),
+  });
+
+  // Use helper to convert it to a Web ReadableStream using Count strategy
+  const readableStream = Readable.toWeb(readable, {
+    strategy: new CountQueuingStrategy({ highWaterMark: 1 }),
+  });
+
+  assert(!readableStream.locked);
+  readableStream.getReader().read().then(common.mustCall());
+}

From dd15dad3eaba6a277585e538f10c1b83f2377b47 Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 13:10:56 +0200
Subject: [PATCH 05/10] stream: added parameter size to calculate size of
 chunks if needed

---
 doc/api/stream.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/api/stream.md b/doc/api/stream.md
index b492ef6be1d02c..c8733268d78c72 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -2819,6 +2819,7 @@ added: v17.0.0
 * `options` {Object}
   * `strategy` {Object}
     * `highWaterMark` {number}
+    * `size` {Function}
 * Returns: {ReadableStream}
 
 ### `stream.Writable.fromWeb(writableStream[, options])`

From f0f87987e9adb964e6a45b76d33b28ac122730d4 Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 13:53:32 +0200
Subject: [PATCH 06/10] stream: add better unit test to check if desireSize is
 being assigned

---
 .../test-stream-readable-strategy-option.js   | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/test/parallel/test-stream-readable-strategy-option.js b/test/parallel/test-stream-readable-strategy-option.js
index be8ff3aa42f27c..c3b037a1f5a9ce 100644
--- a/test/parallel/test-stream-readable-strategy-option.js
+++ b/test/parallel/test-stream-readable-strategy-option.js
@@ -2,6 +2,8 @@
 const common = require('../common');
 const { Readable } = require('stream');
 const assert = require('assert');
+const { strictEqual, strict } = require('assert');
+const { mustCall } = require('../common');
 
 {
   // Strategy 2
@@ -46,3 +48,29 @@ const assert = require('assert');
   assert(!readableStream.locked);
   readableStream.getReader().read().then(common.mustCall());
 }
+
+{
+  const desireSizeExpected = 2;
+
+  const stringStream = new ReadableStream(
+    {
+      start(controller) {
+        // Check if the strategy is being assigned on the init of the ReadableStream
+        strictEqual(controller.desiredSize, desireSizeExpected);
+        controller.enqueue('a');
+        controller.enqueue('b');
+        controller.close();
+      },
+    },
+    new CountQueuingStrategy({ highWaterMark: desireSizeExpected })
+  );
+
+  const reader = stringStream.getReader();
+
+  reader.read().then(common.mustCall());
+  reader.read().then(common.mustCall());
+  reader.read().then(({ value, done }) => {
+    strictEqual(value, undefined);
+    strictEqual(done, true);
+  });
+}

From faf07cc6073dba70d2fa666b64bca8c0079b6643 Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 13:54:11 +0200
Subject: [PATCH 07/10] stream: remove unused imports

---
 test/parallel/test-stream-readable-strategy-option.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/parallel/test-stream-readable-strategy-option.js b/test/parallel/test-stream-readable-strategy-option.js
index c3b037a1f5a9ce..a32e70ef2155ea 100644
--- a/test/parallel/test-stream-readable-strategy-option.js
+++ b/test/parallel/test-stream-readable-strategy-option.js
@@ -2,8 +2,7 @@
 const common = require('../common');
 const { Readable } = require('stream');
 const assert = require('assert');
-const { strictEqual, strict } = require('assert');
-const { mustCall } = require('../common');
+const { strictEqual } = require('assert');
 
 {
   // Strategy 2

From fa44cbf006ec7de948647b54418ea261de3e978e Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 17:55:58 +0200
Subject: [PATCH 08/10] stream: remove nested nernary and replace it with an
 inner function

---
 lib/internal/webstreams/adapters.js | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index 8681270919fb0b..a474fdd50c30fa 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -391,14 +391,15 @@ function newReadableStreamFromStreamReadable(streamReadable, options = kEmptyObj
   // and no size algorithm. Using a ByteLengthQueuingStrategy here
   // is unnecessary.
 
-  // If there is a strategy available, use it. Otherwise, fallback to default behavior
-  const queuingStrategy = options?.strategy;
+  function evaluateStrategyOrFallback(objectMode, strategy) {
+    // Fallback to default behavior
+    if (!strategy)
+      return objectMode ? new CountQueuingStrategy({ highWaterMark }) : { highWaterMark };
+    // Is there is a strategy available, use it
+    return strategy;
+  }
 
-  const strategy = queuingStrategy ?
-    queuingStrategy :
-    objectMode ?
-      new CountQueuingStrategy({ highWaterMark }) :
-      { highWaterMark };
+  const strategy = evaluateStrategyOrFallback(objectMode, options?.strategy);
 
   let controller;
 

From 93d1582853d1bd65b501879e10e6e5494eb86cb1 Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Tue, 21 Jun 2022 18:00:29 +0200
Subject: [PATCH 09/10] stream: use an arrow function instead

---
 lib/internal/webstreams/adapters.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index a474fdd50c30fa..f7f0dd615f8ee5 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -391,15 +391,15 @@ function newReadableStreamFromStreamReadable(streamReadable, options = kEmptyObj
   // and no size algorithm. Using a ByteLengthQueuingStrategy here
   // is unnecessary.
 
-  function evaluateStrategyOrFallback(objectMode, strategy) {
+  const evaluateStrategyOrFallback = (strategy) => {
     // Fallback to default behavior
     if (!strategy)
       return objectMode ? new CountQueuingStrategy({ highWaterMark }) : { highWaterMark };
     // Is there is a strategy available, use it
     return strategy;
-  }
+  };
 
-  const strategy = evaluateStrategyOrFallback(objectMode, options?.strategy);
+  const strategy = evaluateStrategyOrFallback(options?.strategy);
 
   let controller;
 

From 293be9383eb9b573c3371db51a817c8dd1d3538b Mon Sep 17 00:00:00 2001
From: Warkanlock <warkanlock@gmail.com>
Date: Thu, 23 Jun 2022 09:37:13 +0200
Subject: [PATCH 10/10] stream: refactor evaluateStrategyOrFallback method
 inspired by nit suggestions

---
 lib/internal/webstreams/adapters.js | 24 +++++++++++++++---------
 1 file changed, 15 insertions(+), 9 deletions(-)

diff --git a/lib/internal/webstreams/adapters.js b/lib/internal/webstreams/adapters.js
index f7f0dd615f8ee5..402a93342795b2 100644
--- a/lib/internal/webstreams/adapters.js
+++ b/lib/internal/webstreams/adapters.js
@@ -386,17 +386,23 @@ function newReadableStreamFromStreamReadable(streamReadable, options = kEmptyObj
 
   const objectMode = streamReadable.readableObjectMode;
   const highWaterMark = streamReadable.readableHighWaterMark;
-  // When not running in objectMode explicitly, we just fall
-  // back to a minimal strategy that just specifies the highWaterMark
-  // and no size algorithm. Using a ByteLengthQueuingStrategy here
-  // is unnecessary.
 
   const evaluateStrategyOrFallback = (strategy) => {
-    // Fallback to default behavior
-    if (!strategy)
-      return objectMode ? new CountQueuingStrategy({ highWaterMark }) : { highWaterMark };
-    // Is there is a strategy available, use it
-    return strategy;
+    // If there is a strategy available, use it
+    if (strategy)
+      return strategy;
+
+    if (objectMode) {
+      // When running in objectMode explicitly but no strategy, we just fall
+      // back to CountQueuingStrategy
+      return new CountQueuingStrategy({ highWaterMark });
+    }
+
+    // When not running in objectMode explicitly, we just fall
+    // back to a minimal strategy that just specifies the highWaterMark
+    // and no size algorithm. Using a ByteLengthQueuingStrategy here
+    // is unnecessary.
+    return { highWaterMark };
   };
 
   const strategy = evaluateStrategyOrFallback(options?.strategy);