cdk-common 2.0.299 → 2.0.300

package/node_modules/promise/setimmediate/core.js

@@ -58,16 +58,16 @@ function Promise(fn) {
   if (typeof fn !== 'function') {
     throw new TypeError('Promise constructor\'s argument is not a function');
   }
-  this._1 = 0;
-  this._2 = 0;
-  this._3 = null;
-  this._4 = null;
+  this._x = 0;
+  this._y = 0;
+  this._z = null;
+  this._A = null;
   if (fn === noop) return;
   doResolve(fn, this);
 }
-Promise._5 = null;
-Promise._6 = null;
-Promise._7 = noop;
+Promise._B = null;
+Promise._C = null;
+Promise._D = noop;
 
 Promise.prototype.then = function(onFulfilled, onRejected) {
   if (this.constructor !== Promise) {
@@ -86,24 +86,24 @@ function safeThen(self, onFulfilled, onRejected) {
   });
 }
 function handle(self, deferred) {
-  while (self._2 === 3) {
-    self = self._3;
+  while (self._y === 3) {
+    self = self._z;
   }
-  if (Promise._5) {
-    Promise._5(self);
+  if (Promise._B) {
+    Promise._B(self);
   }
-  if (self._2 === 0) {
-    if (self._1 === 0) {
-      self._1 = 1;
-      self._4 = deferred;
+  if (self._y === 0) {
+    if (self._x === 0) {
+      self._x = 1;
+      self._A = deferred;
       return;
     }
-    if (self._1 === 1) {
-      self._1 = 2;
-      self._4 = [self._4, deferred];
+    if (self._x === 1) {
+      self._x = 2;
+      self._A = [self._A, deferred];
       return;
     }
-    self._4.push(deferred);
+    self._A.push(deferred);
     return;
   }
   handleResolved(self, deferred);
@@ -111,16 +111,16 @@ function handle(self, deferred) {
 
 function handleResolved(self, deferred) {
   setImmediate(function() {
-    var cb = self._2 === 1 ? deferred.onFulfilled : deferred.onRejected;
+    var cb = self._y === 1 ? deferred.onFulfilled : deferred.onRejected;
     if (cb === null) {
-      if (self._2 === 1) {
-        resolve(deferred.promise, self._3);
+      if (self._y === 1) {
+        resolve(deferred.promise, self._z);
       } else {
-        reject(deferred.promise, self._3);
+        reject(deferred.promise, self._z);
       }
       return;
     }
-    var ret = tryCallOne(cb, self._3);
+    var ret = tryCallOne(cb, self._z);
     if (ret === IS_ERROR) {
       reject(deferred.promise, LAST_ERROR);
     } else {
@@ -148,8 +148,8 @@ function resolve(self, newValue) {
       then === self.then &&
       newValue instanceof Promise
     ) {
-      self._2 = 3;
-      self._3 = newValue;
+      self._y = 3;
+      self._z = newValue;
       finale(self);
       return;
     } else if (typeof then === 'function') {
@@ -157,29 +157,29 @@ function resolve(self, newValue) {
       return;
     }
   }
-  self._2 = 1;
-  self._3 = newValue;
+  self._y = 1;
+  self._z = newValue;
   finale(self);
 }
 
 function reject(self, newValue) {
-  self._2 = 2;
-  self._3 = newValue;
-  if (Promise._6) {
-    Promise._6(self, newValue);
+  self._y = 2;
+  self._z = newValue;
+  if (Promise._C) {
+    Promise._C(self, newValue);
   }
   finale(self);
 }
 function finale(self) {
-  if (self._1 === 1) {
-    handle(self, self._4);
-    self._4 = null;
+  if (self._x === 1) {
+    handle(self, self._A);
+    self._A = null;
   }
-  if (self._1 === 2) {
-    for (var i = 0; i < self._4.length; i++) {
-      handle(self, self._4[i]);
+  if (self._x === 2) {
+    for (var i = 0; i < self._A.length; i++) {
+      handle(self, self._A[i]);
     }
-    self._4 = null;
+    self._A = null;
   }
 }
 

package/node_modules/promise/setimmediate/es6-extensions.js

@@ -16,9 +16,9 @@ var ZERO = valuePromise(0);
 var EMPTYSTRING = valuePromise('');
 
 function valuePromise(value) {
-  var p = new Promise(Promise._7);
-  p._2 = 1;
-  p._3 = value;
+  var p = new Promise(Promise._D);
+  p._y = 1;
+  p._z = value;
   return p;
 }
 Promise.resolve = function (value) {
@@ -67,11 +67,11 @@ Promise.all = function (arr) {
     function res(i, val) {
       if (val && (typeof val === 'object' || typeof val === 'function')) {
         if (val instanceof Promise && val.then === Promise.prototype.then) {
-          while (val._2 === 3) {
-            val = val._3;
+          while (val._y === 3) {
+            val = val._z;
           }
-          if (val._2 === 1) return res(i, val._3);
-          if (val._2 === 2) reject(val._3);
+          if (val._y === 1) return res(i, val._z);
+          if (val._y === 2) reject(val._z);
           val.then(function (val) {
             res(i, val);
           }, reject);
@@ -140,3 +140,47 @@ Promise.race = function (values) {
 Promise.prototype['catch'] = function (onRejected) {
   return this.then(null, onRejected);
 };
+
+function getAggregateError(errors){
+  if(typeof AggregateError === 'function'){
+    return new AggregateError(errors,'All promises were rejected');
+  }
+
+  var error = new Error('All promises were rejected');
+
+  error.name = 'AggregateError';
+  error.errors = errors;
+
+  return error;
+}
+
+Promise.any = function promiseAny(values) {
+  return new Promise(function(resolve, reject) {
+    var promises = iterableToArray(values);
+    var hasResolved = false;
+    var rejectionReasons = [];
+
+    function resolveOnce(value) {
+      if (!hasResolved) {
+        hasResolved = true;
+        resolve(value);
+      }
+    }
+
+    function rejectionCheck(reason) {
+      rejectionReasons.push(reason);
+
+      if (rejectionReasons.length === promises.length) {
+        reject(getAggregateError(rejectionReasons));
+      }
+    }
+
+    if(promises.length === 0){
+      reject(getAggregateError(rejectionReasons));
+    } else {
+      promises.forEach(function(value){
+        Promise.resolve(value).then(resolveOnce, rejectionCheck);
+      });
+    }
+  });
+};

package/node_modules/promise/setimmediate/rejection-tracking.js

@@ -12,8 +12,8 @@ var enabled = false;
 exports.disable = disable;
 function disable() {
   enabled = false;
-  Promise._5 = null;
-  Promise._6 = null;
+  Promise._B = null;
+  Promise._C = null;
 }
 
 exports.enable = enable;
@@ -24,27 +24,27 @@ function enable(options) {
   var id = 0;
   var displayId = 0;
   var rejections = {};
-  Promise._5 = function (promise) {
+  Promise._B = function (promise) {
     if (
-      promise._2 === 2 && // IS REJECTED
-      rejections[promise._8]
+      promise._y === 2 && // IS REJECTED
+      rejections[promise._E]
     ) {
-      if (rejections[promise._8].logged) {
-        onHandled(promise._8);
+      if (rejections[promise._E].logged) {
+        onHandled(promise._E);
       } else {
-        clearTimeout(rejections[promise._8].timeout);
+        clearTimeout(rejections[promise._E].timeout);
       }
-      delete rejections[promise._8];
+      delete rejections[promise._E];
     }
   };
-  Promise._6 = function (promise, err) {
-    if (promise._1 === 0) { // not yet handled
-      promise._8 = id++;
-      rejections[promise._8] = {
+  Promise._C = function (promise, err) {
+    if (promise._x === 0) { // not yet handled
+      promise._E = id++;
+      rejections[promise._E] = {
         displayId: null,
         error: err,
         timeout: setTimeout(
-          onUnhandled.bind(null, promise._8),
+          onUnhandled.bind(null, promise._E),
           // For reference errors and type errors, this almost always
           // means the programmer made a mistake, so log them after just
           // 100ms

package/node_modules/promise/setimmediate/synchronous.js

@@ -17,38 +17,38 @@ Promise.enableSynchronous = function () {
   };
 
   Promise.prototype.getValue = function () {
-    if (this._2 === 3) {
-      return this._3.getValue();
+    if (this._y === 3) {
+      return this._z.getValue();
     }
 
     if (!this.isFulfilled()) {
       throw new Error('Cannot get a value of an unfulfilled promise.');
     }
 
-    return this._3;
+    return this._z;
   };
 
   Promise.prototype.getReason = function () {
-    if (this._2 === 3) {
-      return this._3.getReason();
+    if (this._y === 3) {
+      return this._z.getReason();
     }
 
     if (!this.isRejected()) {
       throw new Error('Cannot get a rejection reason of a non-rejected promise.');
     }
 
-    return this._3;
+    return this._z;
   };
 
   Promise.prototype.getState = function () {
-    if (this._2 === 3) {
-      return this._3.getState();
+    if (this._y === 3) {
+      return this._z.getState();
     }
-    if (this._2 === -1 || this._2 === -2) {
+    if (this._y === -1 || this._y === -2) {
       return 0;
     }
 
-    return this._2;
+    return this._y;
   };
 };
 

package/node_modules/promise/src/es6-extensions.js

@@ -140,3 +140,47 @@ Promise.race = function (values) {
 Promise.prototype['catch'] = function (onRejected) {
   return this.then(null, onRejected);
 };
+
+function getAggregateError(errors){
+  if(typeof AggregateError === 'function'){
+    return new AggregateError(errors,'All promises were rejected');
+  }
+
+  var error = new Error('All promises were rejected');
+
+  error.name = 'AggregateError';
+  error.errors = errors;
+
+  return error;
+}
+
+Promise.any = function promiseAny(values) {
+  return new Promise(function(resolve, reject) {
+    var promises = iterableToArray(values);
+    var hasResolved = false;
+    var rejectionReasons = [];
+
+    function resolveOnce(value) {
+      if (!hasResolved) {
+        hasResolved = true;
+        resolve(value);
+      }
+    }
+
+    function rejectionCheck(reason) {
+      rejectionReasons.push(reason);
+
+      if (rejectionReasons.length === promises.length) {
+        reject(getAggregateError(rejectionReasons));
+      }
+    }
+
+    if(promises.length === 0){
+      reject(getAggregateError(rejectionReasons));
+    } else {
+      promises.forEach(function(value){
+        Promise.resolve(value).then(resolveOnce, rejectionCheck);
+      });
+    }
+  });
+};

package/package.json

@@ -55,7 +55,7 @@
     "jsii-pacmak": "^1.70.0",
     "json-schema": "^0.4.0",
     "npm-check-updates": "^16",
-    "projen": "0.64.0",
+    "projen": "0.65.0",
     "standard-version": "^9",
     "ts-jest": "^27",
     "typescript": "3.9.10"
@@ -83,7 +83,7 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "2.0.299",
+  "version": "2.0.300",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",