Added Promise.any polyfill + tests (#152)

* Added Promise.any polyfill + tests

* Moved Promise.any into a separate module, added it to index.js & polyfill.js

Author: spanic

dist/polyfill.js

@@ -74,6 +74,48 @@ function allSettled(arr) {
   });
 }
 
+/**
+ * @constructor
+ */
+function AggregateError(errors, message) {
+  this.name = 'AggregateError', this.errors = errors;
+  this.message = message || '';
+}
+AggregateError.prototype = Error.prototype;
+
+function any(arr) {
+  var P = this;
+  return new P(function(resolve, reject) {
+    if (!(arr && typeof arr.length !== 'undefined')) {
+      return reject(new TypeError('Promise.any accepts an array'));
+    }
+
+    var args = Array.prototype.slice.call(arr);
+    if (args.length === 0) return reject();
+
+    var rejectionReasons = [];
+    for (var i = 0; i < args.length; i++) {
+      try {
+        P.resolve(args[i])
+          .then(resolve)
+          .catch(function(error) {
+            rejectionReasons.push(error);
+            if (rejectionReasons.length === args.length) {
+              reject(
+                new AggregateError(
+                  rejectionReasons,
+                  'All promises were rejected'
+                )
+              );
+            }
+          });
+      } catch (ex) {
+        reject(ex);
+      }
+    }
+  });
+}
+
 // Store setTimeout reference so promise-polyfill will be unaffected by
 // other code modifying setTimeout (like sinon.useFakeTimers())
 var setTimeoutFunc = setTimeout;
@@ -277,6 +319,8 @@ Promise.all = function(arr) {
   });
 };
 
+Promise.any = any;
+
 Promise.allSettled = allSettled;
 
 Promise.resolve = function(value) {
@@ -355,6 +399,9 @@ if (typeof globalNS['Promise'] !== 'function') {
   if (!globalNS.Promise.allSettled) {
     globalNS.Promise.allSettled = allSettled;
   }
+  if (!globalNS.Promise.any) {
+    globalNS.Promise.any = any;
+  }
 }
 
 })));

dist/polyfill.min.js

@@ -0,0 +1,43 @@
+/**
+ * @constructor
+ */
+function AggregateError(errors, message) {
+  (this.name = 'AggregateError'), (this.errors = errors);
+  this.message = message || '';
+}
+AggregateError.prototype = Error.prototype;
+
+function any(arr) {
+  var P = this;
+  return new P(function(resolve, reject) {
+    if (!(arr && typeof arr.length !== 'undefined')) {
+      return reject(new TypeError('Promise.any accepts an array'));
+    }
+
+    var args = Array.prototype.slice.call(arr);
+    if (args.length === 0) return reject();
+
+    var rejectionReasons = [];
+    for (var i = 0; i < args.length; i++) {
+      try {
+        P.resolve(args[i])
+          .then(resolve)
+          .catch(function(error) {
+            rejectionReasons.push(error);
+            if (rejectionReasons.length === args.length) {
+              reject(
+                new AggregateError(
+                  rejectionReasons,
+                  'All promises were rejected'
+                )
+              );
+            }
+          });
+      } catch (ex) {
+        reject(ex);
+      }
+    }
+  });
+}
+
+export default any;

src/any.js

@@ -1,5 +1,6 @@
 import promiseFinally from './finally';
 import allSettled from './allSettled';
+import any from './any';
 
 // Store setTimeout reference so promise-polyfill will be unaffected by
 // other code modifying setTimeout (like sinon.useFakeTimers())
@@ -204,6 +205,8 @@ Promise.all = function(arr) {
   });
 };
 
+Promise.any = any;
+
 Promise.allSettled = allSettled;
 
 Promise.resolve = function(value) {

src/index.js

@@ -1,6 +1,7 @@
 import Promise from './index';
 import promiseFinally from './finally';
 import allSettled from './allSettled';
+import any from './any';
 
 /** @suppress {undefinedVars} */
 var globalNS = (function() {
@@ -28,8 +29,11 @@ if (typeof globalNS['Promise'] !== 'function') {
 } else {
   if (!globalNS.Promise.prototype['finally']) {
     globalNS.Promise.prototype['finally'] = promiseFinally;
-  } 
+  }
   if (!globalNS.Promise.allSettled) {
     globalNS.Promise.allSettled = allSettled;
   }
+  if (!globalNS.Promise.any) {
+    globalNS.Promise.any = any;
+  }
 }

src/polyfill.js

@@ -395,6 +395,149 @@ describe('Promise', function() {
     });
   });
 
+  describe('Promise.any', function() {
+    it('throws on implicit undefined', function() {
+      return Promise.any().then(
+        function() {
+          assert.fail();
+        },
+        function(error) {
+          assert.ok(error instanceof Error);
+        }
+      );
+    });
+    it('throws on explicit undefined', function() {
+      return Promise.all(undefined).then(
+        function() {
+          assert.fail();
+        },
+        function(error) {
+          assert.ok(error instanceof Error);
+        }
+      );
+    });
+    it('throws on null', function() {
+      return Promise.all(null).then(
+        function() {
+          assert.fail();
+        },
+        function(error) {
+          assert.ok(error instanceof Error);
+        }
+      );
+    });
+    it('works on array with a single resolved promise', function() {
+      return Promise.any([Promise.resolve()]).then(
+        function() {
+          assert.ok(true);
+        },
+        function() {
+          assert.fail();
+        }
+      );
+    });
+    it('works on array with multiple resolved promises', function() {
+      return Promise.any([
+        Promise.resolve('first'),
+        Promise.resolve('second')
+      ]).then(
+        function(value) {
+          assert.equal(value, 'first');
+        },
+        function() {
+          assert.fail();
+        }
+      );
+    });
+    it('works on array with at least one resolved promise', function() {
+      return Promise.any([
+        Promise.reject(),
+        Promise.resolve('second'),
+        Promise.reject(),
+        Promise.resolve('fourth')
+      ]).then(
+        function(value) {
+          assert.equal(value, 'second');
+        },
+        function() {
+          assert.fail();
+        }
+      );
+    });
+    it('works on array with a single rejected promise', function() {
+      return Promise.any([Promise.reject('error')]).then(
+        function() {
+          assert.fail();
+        },
+        function(aggregateError) {
+          assert.ok(aggregateError instanceof Error);
+          assert.equal(aggregateError.name, 'AggregateError');
+          assert.equal(aggregateError.errors.length, 1);
+          assert.equal(aggregateError.errors[0], 'error');
+        }
+      );
+    });
+    it('works on array with multiple rejected promises', function() {
+      return Promise.any([
+        Promise.reject('first'),
+        Promise.reject('second')
+      ]).then(
+        function() {
+          assert.fail();
+        },
+        function(aggregateError) {
+          assert.ok(aggregateError instanceof Error);
+          assert.equal(aggregateError.name, 'AggregateError');
+          assert.equal(aggregateError.errors.length, 2);
+          assert.equal(aggregateError.errors[0], 'first');
+          assert.equal(aggregateError.errors[1], 'second');
+        }
+      );
+    });
+    it('works on array without promises', function() {
+      return Promise.any([1, 'value', {}]).then(
+        function(value) {
+          assert.equal(value, 1);
+        },
+        function() {
+          assert.fail();
+        }
+      );
+    });
+    it('works on array with asynchronously resolved promises', function(done) {
+      Promise.any([
+        new Promise(function(resolve) {
+          setTimeout(function() {
+            return resolve('first (slow)');
+          }, 100);
+        }),
+        new Promise(function(resolve) {
+          setTimeout(function() {
+            return resolve('second (fast)');
+          }, 50);
+        })
+      ]).then(
+        function(value) {
+          assert.equal(value, 'second (fast)');
+          done();
+        },
+        function() {
+          assert.fail();
+        }
+      );
+    });
+    it('works on empty array', function() {
+      return Promise.any([]).then(
+        function() {
+          assert.fail();
+        },
+        function() {
+          assert.ok(true);
+        }
+      );
+    });
+  });
+
   describe('Promise.allSettled', function() {
     it('throws on implicit undefined', function() {
       return Promise.allSettled().then(