From 448c2080cedfc10ad178d0ed8b82ed05025d30d1 Mon Sep 17 00:00:00 2001
From: atlowChemi <chemi@testim.io>
Date: Wed, 24 May 2023 11:27:29 +0300
Subject: [PATCH] stream: remove asIndexedPairs

---
 doc/api/stream.md                             | 31 -----------
 lib/internal/streams/operators.js             | 21 --------
 test/parallel/test-stream-asIndexedPairs.mjs  | 53 -------------------
 ...-stream-iterator-helpers-test262-tests.mjs | 20 -------
 4 files changed, 125 deletions(-)
 delete mode 100644 test/parallel/test-stream-asIndexedPairs.mjs

diff --git a/doc/api/stream.md b/doc/api/stream.md
index 8de6b17dc9c674..46cbf7965aebc1 100644
--- a/doc/api/stream.md
+++ b/doc/api/stream.md
@@ -2447,37 +2447,6 @@ import { Readable } from 'node:stream';
 await Readable.from([1, 2, 3, 4]).take(2).toArray(); // [1, 2]
 ```
 
-##### `readable.asIndexedPairs([options])`
-
-<!-- YAML
-added:
-  - v17.5.0
-  - v16.15.0
-changes:
-  - version: v20.3.0
-    pr-url: https://github.com/nodejs/node/pull/48102
-    description: Using the `asIndexedPairs` method emits a runtime warning that
-                  it will be removed in a future version.
--->
-
-> Stability: 1 - Experimental
-
-* `options` {Object}
-  * `signal` {AbortSignal} allows destroying the stream if the signal is
-    aborted.
-* Returns: {Readable} a stream of indexed pairs.
-
-This method returns a new stream with chunks of the underlying stream paired
-with a counter in the form `[index, chunk]`. The first index value is 0 and it
-increases by 1 for each chunk produced.
-
-```mjs
-import { Readable } from 'node:stream';
-
-const pairs = await Readable.from(['a', 'b', 'c']).asIndexedPairs().toArray();
-console.log(pairs); // [[0, 'a'], [1, 'b'], [2, 'c']]
-```
-
 ##### `readable.reduce(fn[, initial[, options]])`
 
 <!-- YAML
diff --git a/lib/internal/streams/operators.js b/lib/internal/streams/operators.js
index 96e2a95476813d..13cbce1005ece1 100644
--- a/lib/internal/streams/operators.js
+++ b/lib/internal/streams/operators.js
@@ -23,7 +23,6 @@ const {
   addAbortSignalNoValidate,
 } = require('internal/streams/add-abort-signal');
 const { isWritable, isNodeStream } = require('internal/streams/utils');
-const { deprecate } = require('internal/util');
 
 const {
   ArrayPrototypePush,
@@ -199,25 +198,6 @@ function map(fn, options) {
   }.call(this);
 }
 
-function asIndexedPairs(options = undefined) {
-  if (options != null) {
-    validateObject(options, 'options');
-  }
-  if (options?.signal != null) {
-    validateAbortSignal(options.signal, 'options.signal');
-  }
-
-  return async function* asIndexedPairs() {
-    let index = 0;
-    for await (const val of this) {
-      if (options?.signal?.aborted) {
-        throw new AbortError({ cause: options.signal.reason });
-      }
-      yield [index++, val];
-    }
-  }.call(this);
-}
-
 async function some(fn, options = undefined) {
   for await (const unused of filter.call(this, fn, options)) {
     return true;
@@ -421,7 +401,6 @@ function take(number, options = undefined) {
 }
 
 module.exports.streamReturningOperators = {
-  asIndexedPairs: deprecate(asIndexedPairs, 'readable.asIndexedPairs will be removed in a future version.'),
   drop,
   filter,
   flatMap,
diff --git a/test/parallel/test-stream-asIndexedPairs.mjs b/test/parallel/test-stream-asIndexedPairs.mjs
deleted file mode 100644
index 6f577caefd28dc..00000000000000
--- a/test/parallel/test-stream-asIndexedPairs.mjs
+++ /dev/null
@@ -1,53 +0,0 @@
-import '../common/index.mjs';
-import { Readable } from 'stream';
-import { deepStrictEqual, rejects, throws } from 'assert';
-
-{
-  // asIndexedPairs with a synchronous stream
-  const pairs = await Readable.from([1, 2, 3]).asIndexedPairs().toArray();
-  deepStrictEqual(pairs, [[0, 1], [1, 2], [2, 3]]);
-  const empty = await Readable.from([]).asIndexedPairs().toArray();
-  deepStrictEqual(empty, []);
-}
-
-{
-  // asIndexedPairs works an asynchronous streams
-  const asyncFrom = (...args) => Readable.from(...args).map(async (x) => x);
-  const pairs = await asyncFrom([1, 2, 3]).asIndexedPairs().toArray();
-  deepStrictEqual(pairs, [[0, 1], [1, 2], [2, 3]]);
-  const empty = await asyncFrom([]).asIndexedPairs().toArray();
-  deepStrictEqual(empty, []);
-}
-
-{
-  // Does not enumerate an infinite stream
-  const infinite = () => Readable.from(async function* () {
-    while (true) yield 1;
-  }());
-  const pairs = await infinite().asIndexedPairs().take(3).toArray();
-  deepStrictEqual(pairs, [[0, 1], [1, 1], [2, 1]]);
-  const empty = await infinite().asIndexedPairs().take(0).toArray();
-  deepStrictEqual(empty, []);
-}
-
-{
-  // AbortSignal
-  await rejects(async () => {
-    const ac = new AbortController();
-    const { signal } = ac;
-    const p = Readable.from([1, 2, 3]).asIndexedPairs({ signal }).toArray();
-    ac.abort();
-    await p;
-  }, { name: 'AbortError' });
-
-  await rejects(async () => {
-    const signal = AbortSignal.abort();
-    await Readable.from([1, 2, 3]).asIndexedPairs({ signal }).toArray();
-  }, /AbortError/);
-}
-
-{
-  // Error cases
-  throws(() => Readable.from([1]).asIndexedPairs(1), /ERR_INVALID_ARG_TYPE/);
-  throws(() => Readable.from([1]).asIndexedPairs({ signal: true }), /ERR_INVALID_ARG_TYPE/);
-}
diff --git a/test/parallel/test-stream-iterator-helpers-test262-tests.mjs b/test/parallel/test-stream-iterator-helpers-test262-tests.mjs
index 2f4f30e14c4cfe..59bcfdc565defb 100644
--- a/test/parallel/test-stream-iterator-helpers-test262-tests.mjs
+++ b/test/parallel/test-stream-iterator-helpers-test262-tests.mjs
@@ -48,26 +48,6 @@ import assert from 'assert';
 
 // Note all the tests that check AsyncIterator's prototype itself and things
 // that happen before stream conversion were not ported.
-{
-  // asIndexedPairs/is-function
-  assert.strictEqual(typeof Readable.prototype.asIndexedPairs, 'function');
-  // asIndexedPairs/indexed-pairs.js
-  const iterator = Readable.from([0, 1]);
-  const indexedPairs = iterator.asIndexedPairs();
-
-  for await (const [i, v] of indexedPairs) {
-    assert.strictEqual(i, v);
-  }
-  // asIndexedPairs/length.js
-  assert.strictEqual(Readable.prototype.asIndexedPairs.length, 0);
-  const descriptor = Object.getOwnPropertyDescriptor(
-    Readable.prototype,
-    'asIndexedPairs'
-  );
-  assert.strictEqual(descriptor.enumerable, false);
-  assert.strictEqual(descriptor.configurable, true);
-  assert.strictEqual(descriptor.writable, true);
-}
 {
   // drop/length
   assert.strictEqual(Readable.prototype.drop.length, 1);