update eslint-plugin-promise

eslint.config.js

@@ -413,6 +413,8 @@ const base = {
   // promise:
   // avoid calling `cb()` inside of a `then()` or `catch()`
   'promise/no-callback-in-promise': ERROR,
+  // disallow creating new promises with paths that resolve multiple times (no-multiple-resolved)
+  'promise/no-multiple-resolved': ERROR,
   // avoid nested `then()` or `catch()` statements
   'promise/no-nesting': ERROR,
   // avoid calling new on a `Promise` static method
@@ -424,7 +426,10 @@ const base = {
   // avoid wrapping values in `Promise.resolve` or `Promise.reject` when not needed
   'promise/no-return-wrap': ERROR,
   // enforce consistent param names when creating new promises
-  'promise/param-names': ERROR,
+  'promise/param-names': [ERROR, {
+    resolvePattern: '^resolve',
+    rejectPattern: '^reject',
+  }],
   // ensures the proper number of arguments are passed to `Promise` functions
   'promise/valid-params': ERROR,
 

package.json

@@ -48,7 +48,7 @@
     "eslint-plugin-import": "^2.26.0",
     "eslint-plugin-jsonc": "^2.4.0",
     "eslint-plugin-n": "^15.3.0",
-    "eslint-plugin-promise": "^6.0.1",
+    "eslint-plugin-promise": "^6.1.0",
     "eslint-plugin-qunit": "^7.3.1",
     "eslint-plugin-regexp": "^1.9.0",
     "eslint-plugin-sonarjs": "~0.16.0",

tests/pure/es.promise.all-settled.js

@@ -26,6 +26,7 @@ QUnit.test('Promise.allSettled, resolved', assert => {
 QUnit.test('Promise.allSettled, rejected', assert => {
   assert.expect(1);
   const async = assert.async();
+  // eslint-disable-next-line promise/valid-params -- required for testing
   Promise.allSettled().catch(() => {
     assert.required('rejected as expected');
     async();

tests/pure/es.promise.any.js

@@ -37,6 +37,7 @@ QUnit.test('Promise.any, rejected #1', assert => {
 QUnit.test('Promise.any, rejected #2', assert => {
   assert.expect(1);
   const async = assert.async();
+  // eslint-disable-next-line promise/valid-params -- required for testing
   Promise.any().catch(() => {
     assert.required('rejected as expected');
     async();

tests/pure/esnext.async-iterator.drop.js

@@ -22,7 +22,8 @@ QUnit.test('AsyncIterator#drop', assert => {
     return drop.call(createIterator([1, 2, 3]), 0).toArray();
   }).then(it => {
     assert.arrayEqual(it, [1, 2, 3], 'zero');
-  }).then(() => async());
+    async();
+  });
 
   assert.throws(() => drop.call(undefined, 1), TypeError);
   assert.throws(() => drop.call(null, 1), TypeError);

tests/pure/esnext.async-iterator.take.js

@@ -22,7 +22,8 @@ QUnit.test('AsyncIterator#take', assert => {
     return take.call(createIterator([1, 2, 3]), 0).toArray();
   }).then(it => {
     assert.arrayEqual(it, [], 'zero');
-  }).then(() => async());
+    async();
+  });
 
   assert.throws(() => take.call(undefined, 1), TypeError);
   assert.throws(() => take.call(null, 1), TypeError);

tests/pure/esnext.iterator.to-async.js

@@ -21,8 +21,7 @@ QUnit.test('Iterator#toAsync', assert => {
 
   Iterator.from([1, 2, 3]).toAsync().map(it => Promise.resolve(it)).toArray().then(it => {
     assert.arrayEqual(it, [1, 2, 3]);
-  }).then(() => {
-    return Iterator.from(new Set([1, 2, 3])).toAsync().map(it => Promise.resolve(it)).toArray();
+    return Iterator.from(new Set([1, 2, 3])).toAsync().map(el => Promise.resolve(el)).toArray();
   }).then(it => {
     assert.arrayEqual(it, [1, 2, 3]);
     async();

tests/pure/web.set-immediate.js

@@ -8,6 +8,7 @@ QUnit.test('setImmediate / clearImmediate', assert => {
   assert.expect(6);
   assert.isFunction(setImmediate, 'setImmediate is function');
   assert.isFunction(clearImmediate, 'clearImmediate is function');
+
   timeLimitedPromise(1e3, res => {
     setImmediate(() => {
       called = true;
@@ -18,7 +19,9 @@ QUnit.test('setImmediate / clearImmediate', assert => {
   }).catch(() => {
     assert.avoid('setImmediate works');
   }).then(assert.async());
+
   assert.false(called, 'setImmediate is async');
+
   timeLimitedPromise(1e3, res => {
     setImmediate((a, b) => {
       res(a + b);
@@ -28,6 +31,7 @@ QUnit.test('setImmediate / clearImmediate', assert => {
   }).catch(() => {
     assert.avoid('setImmediate works with additional args');
   }).then(assert.async());
+
   timeLimitedPromise(50, res => {
     clearImmediate(setImmediate(res));
   }).then(() => {

tests/tests/es.promise.all-settled.js

@@ -26,6 +26,7 @@ QUnit.test('Promise.allSettled, resolved', assert => {
 QUnit.test('Promise.allSettled, rejected', assert => {
   assert.expect(1);
   const async = assert.async();
+  // eslint-disable-next-line promise/valid-params -- required for testing
   Promise.allSettled().catch(() => {
     assert.required('rejected as expected');
     async();

tests/tests/es.promise.any.js

@@ -36,6 +36,7 @@ QUnit.test('Promise.any, rejected #1', assert => {
 QUnit.test('Promise.any, rejected #2', assert => {
   assert.expect(1);
   const async = assert.async();
+  // eslint-disable-next-line promise/valid-params -- required for testing
   Promise.any().catch(() => {
     assert.required('rejected as expected');
     async();

tests/tests/esnext.async-iterator.drop.js

@@ -22,7 +22,8 @@ QUnit.test('AsyncIterator#drop', assert => {
     return drop.call(createIterator([1, 2, 3]), 0).toArray();
   }).then(it => {
     assert.arrayEqual(it, [1, 2, 3], 'zero');
-  }).then(() => async());
+    async();
+  });
 
   assert.throws(() => drop.call(undefined, 1), TypeError);
   assert.throws(() => drop.call(null, 1), TypeError);

tests/tests/esnext.async-iterator.take.js

@@ -22,7 +22,8 @@ QUnit.test('AsyncIterator#take', assert => {
     return take.call(createIterator([1, 2, 3]), 0).toArray();
   }).then(it => {
     assert.arrayEqual(it, [], 'zero');
-  }).then(() => async());
+    async();
+  });
 
   assert.throws(() => take.call(undefined, 1), TypeError);
   assert.throws(() => take.call(null, 1), TypeError);

tests/tests/esnext.iterator.to-async.js

@@ -19,8 +19,7 @@ QUnit.test('Iterator#toAsync', assert => {
 
   [1, 2, 3].values().toAsync().map(it => Promise.resolve(it)).toArray().then(it => {
     assert.arrayEqual(it, [1, 2, 3]);
-  }).then(() => {
-    return new Set([1, 2, 3]).values().toAsync().map(it => Promise.resolve(it)).toArray();
+    return new Set([1, 2, 3]).values().toAsync().map(el => Promise.resolve(el)).toArray();
   }).then(it => {
     assert.arrayEqual(it, [1, 2, 3]);
     async();

tests/tests/web.set-immediate.js

@@ -7,6 +7,7 @@ QUnit.test('setImmediate / clearImmediate', assert => {
   assert.isFunction(clearImmediate, 'clearImmediate is function');
   assert.name(setImmediate, 'setImmediate');
   assert.name(clearImmediate, 'clearImmediate');
+
   timeLimitedPromise(1e3, resolve => {
     setImmediate(() => {
       called = true;
@@ -17,7 +18,9 @@ QUnit.test('setImmediate / clearImmediate', assert => {
   }).catch(() => {
     assert.avoid('setImmediate works');
   }).then(assert.async());
+
   assert.false(called, 'setImmediate is async');
+
   timeLimitedPromise(1e3, resolve => {
     setImmediate((a, b) => {
       resolve(a + b);
@@ -27,6 +30,7 @@ QUnit.test('setImmediate / clearImmediate', assert => {
   }).catch(() => {
     assert.avoid('setImmediate works with additional args');
   }).then(assert.async());
+
   timeLimitedPromise(50, resolve => {
     clearImmediate(setImmediate(resolve));
   }).then(() => {

tests/tests/web.url-search-params.js

@@ -857,8 +857,10 @@ QUnit.test('URLSearchParams#@@toStringTag', assert => {
 
 if (typeof Request == 'function') {
   QUnit.test('URLSearchParams with Request', assert => {
+    const async = assert.async();
     new Request('http://zloirock.ru', { body: new URLSearchParams({ foo: 'baz' }), method: 'POST' }).text().then(text => {
       assert.same(text, 'foo=baz');
-    }).then(assert.async());
+      async();
+    });
   });
 }