@twilio/mcs-client 0.6.0-rc.2 → 0.6.0-rc.5

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [0.6.0-rc.5](https://github.com/twilio/rtd-sdk-monorepo-js/compare/@twilio/mcs-client@0.6.0-rc.4...@twilio/mcs-client@0.6.0-rc.5) (2022-05-18)
+
+
+### Reverts
+
+* Revert "chore(release): Publish" ([03b27ca](https://github.com/twilio/rtd-sdk-monorepo-js/commit/03b27ca9830bc6aba2d37febebe6e53f7abddb2d))
+
+
+
+## [0.6.0-rc.4](https://github.com/twilio/rtd-sdk-monorepo-js/compare/@twilio/mcs-client@0.6.0-rc.3...@twilio/mcs-client@0.6.0-rc.4) (2022-05-04)
+
+
+### Bug Fixes
+
+* Add cancellable promise export from conversations ([04bd2fc](https://github.com/twilio/rtd-sdk-monorepo-js/commit/04bd2fc10ca1331fbcddf94a186eec351ea922f1))
+* Fix onCancel storing in Cancellable promise ([2dfaccd](https://github.com/twilio/rtd-sdk-monorepo-js/commit/2dfaccd7a984cc3b608bada7cf649473a145fe8b))
+* Fix promise cancelling retrier ([9b30ce2](https://github.com/twilio/rtd-sdk-monorepo-js/commit/9b30ce2750b7447f28e745513f7e1a29e2c48127))
+
+
+
+## [0.6.0-rc.3](https://github.com/twilio/rtd-sdk-monorepo-js/compare/@twilio/mcs-client@0.6.0-rc.2...@twilio/mcs-client@0.6.0-rc.3) (2022-05-02)
+
+**Note:** Version bump only for package @twilio/mcs-client
+
+
+
+
+
 ## [0.6.0-rc.2](https://github.com/twilio/rtd-sdk-monorepo-js/compare/@twilio/mcs-client@0.6.0-rc.1...@twilio/mcs-client@0.6.0-rc.2) (2022-05-02)
 
 

package/builds/browser.js

@@ -28,12 +28,12 @@ var global =
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('core-js/modules/es.promise.js');
-var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
 var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+require('core-js/modules/es.promise.js');
 require('core-js/modules/es.array.iterator.js');
 require('core-js/modules/es.map.js');
 require('core-js/modules/web.dom-collections.iterator.js');
+var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
 require('core-js/modules/web.dom-collections.for-each.js');
 var _regeneratorRuntime = require('@babel/runtime/regenerator');
 require('core-js/modules/es.array.from.js');
@@ -69,11 +69,196 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
 var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
+var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
 var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);
 var log__namespace = /*#__PURE__*/_interopNamespace(log$2);
 
+var rngBrowser = {exports: {}};
+
+// browser this is a little complicated due to unknown quality of Math.random()
+// and inconsistent support for the `crypto` API.  We do the best we can via
+// feature-detection
+// getRandomValues needs to be invoked in a context where "this" is a Crypto
+// implementation. Also, find the complete implementation of crypto on IE11.
+
+var getRandomValues = typeof crypto != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto) || typeof msCrypto != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto);
+
+if (getRandomValues) {
+  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
+  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef
+
+  rngBrowser.exports = function whatwgRNG() {
+    getRandomValues(rnds8);
+    return rnds8;
+  };
+} else {
+  // Math.random()-based (RNG)
+  //
+  // If all else fails, use Math.random().  It's fast, but is of unspecified
+  // quality.
+  var rnds = new Array(16);
+
+  rngBrowser.exports = function mathRNG() {
+    for (var i = 0, r; i < 16; i++) {
+      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
+      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
+    }
+
+    return rnds;
+  };
+}
+
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+var byteToHex = [];
+
+for (var i = 0; i < 256; ++i) {
+  byteToHex[i] = (i + 0x100).toString(16).substr(1);
+}
+
+function bytesToUuid$2(buf, offset) {
+  var i = offset || 0;
+  var bth = byteToHex; // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
+
+  return [bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], '-', bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]], bth[buf[i++]]].join('');
+}
+
+var bytesToUuid_1 = bytesToUuid$2;
+
+var rng$1 = rngBrowser.exports;
+var bytesToUuid$1 = bytesToUuid_1; // **`v1()` - Generate time-based UUID**
+//
+// Inspired by https://github.com/LiosK/UUID.js
+// and http://docs.python.org/library/uuid.html
+
+var _nodeId;
+
+var _clockseq; // Previous uuid creation time
+
+
+var _lastMSecs = 0;
+var _lastNSecs = 0; // See https://github.com/uuidjs/uuid for API details
+
+function v1$1(options, buf, offset) {
+  var i = buf && offset || 0;
+  var b = buf || [];
+  options = options || {};
+  var node = options.node || _nodeId;
+  var clockseq = options.clockseq !== undefined ? options.clockseq : _clockseq; // node and clockseq need to be initialized to random values if they're not
+  // specified.  We do this lazily to minimize issues related to insufficient
+  // system entropy.  See #189
+
+  if (node == null || clockseq == null) {
+    var seedBytes = rng$1();
+
+    if (node == null) {
+      // Per 4.5, create and 48-bit node id, (47 random bits + multicast bit = 1)
+      node = _nodeId = [seedBytes[0] | 0x01, seedBytes[1], seedBytes[2], seedBytes[3], seedBytes[4], seedBytes[5]];
+    }
+
+    if (clockseq == null) {
+      // Per 4.2.2, randomize (14 bit) clockseq
+      clockseq = _clockseq = (seedBytes[6] << 8 | seedBytes[7]) & 0x3fff;
+    }
+  } // UUID timestamps are 100 nano-second units since the Gregorian epoch,
+  // (1582-10-15 00:00).  JSNumbers aren't precise enough for this, so
+  // time is handled internally as 'msecs' (integer milliseconds) and 'nsecs'
+  // (100-nanoseconds offset from msecs) since unix epoch, 1970-01-01 00:00.
+
+
+  var msecs = options.msecs !== undefined ? options.msecs : new Date().getTime(); // Per 4.2.1.2, use count of uuid's generated during the current clock
+  // cycle to simulate higher resolution clock
+
+  var nsecs = options.nsecs !== undefined ? options.nsecs : _lastNSecs + 1; // Time since last uuid creation (in msecs)
+
+  var dt = msecs - _lastMSecs + (nsecs - _lastNSecs) / 10000; // Per 4.2.1.2, Bump clockseq on clock regression
+
+  if (dt < 0 && options.clockseq === undefined) {
+    clockseq = clockseq + 1 & 0x3fff;
+  } // Reset nsecs if clock regresses (new clockseq) or we've moved onto a new
+  // time interval
+
+
+  if ((dt < 0 || msecs > _lastMSecs) && options.nsecs === undefined) {
+    nsecs = 0;
+  } // Per 4.2.1.2 Throw error if too many uuids are requested
+
+
+  if (nsecs >= 10000) {
+    throw new Error('uuid.v1(): Can\'t create more than 10M uuids/sec');
+  }
+
+  _lastMSecs = msecs;
+  _lastNSecs = nsecs;
+  _clockseq = clockseq; // Per 4.1.4 - Convert from unix epoch to Gregorian epoch
+
+  msecs += 12219292800000; // `time_low`
+
+  var tl = ((msecs & 0xfffffff) * 10000 + nsecs) % 0x100000000;
+  b[i++] = tl >>> 24 & 0xff;
+  b[i++] = tl >>> 16 & 0xff;
+  b[i++] = tl >>> 8 & 0xff;
+  b[i++] = tl & 0xff; // `time_mid`
+
+  var tmh = msecs / 0x100000000 * 10000 & 0xfffffff;
+  b[i++] = tmh >>> 8 & 0xff;
+  b[i++] = tmh & 0xff; // `time_high_and_version`
+
+  b[i++] = tmh >>> 24 & 0xf | 0x10; // include version
+
+  b[i++] = tmh >>> 16 & 0xff; // `clock_seq_hi_and_reserved` (Per 4.2.2 - include variant)
+
+  b[i++] = clockseq >>> 8 | 0x80; // `clock_seq_low`
+
+  b[i++] = clockseq & 0xff; // `node`
+
+  for (var n = 0; n < 6; ++n) {
+    b[i + n] = node[n];
+  }
+
+  return buf ? buf : bytesToUuid$1(b);
+}
+
+var v1_1 = v1$1;
+
+var rng = rngBrowser.exports;
+var bytesToUuid = bytesToUuid_1;
+
+function v4$1(options, buf, offset) {
+  var i = buf && offset || 0;
+
+  if (typeof options == 'string') {
+    buf = options === 'binary' ? new Array(16) : null;
+    options = null;
+  }
+
+  options = options || {};
+  var rnds = options.random || (options.rng || rng)(); // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+
+  rnds[6] = rnds[6] & 0x0f | 0x40;
+  rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
+
+  if (buf) {
+    for (var ii = 0; ii < 16; ++ii) {
+      buf[i + ii] = rnds[ii];
+    }
+  }
+
+  return buf || bytesToUuid(rnds);
+}
+
+var v4_1 = v4$1;
+
+var v1 = v1_1;
+var v4 = v4_1;
+var uuid = v4;
+uuid.v1 = v1;
+uuid.v4 = v4;
+var uuid_1 = uuid;
+
 /**
  * Cancellable promise. Extends the functionality of the native Promise to include the cancel method.
  *
@@ -97,6 +282,7 @@ var log__namespace = /*#__PURE__*/_interopNamespace(log$2);
  * cancellableFetchPromise.cancel();
  * ```
  */
+
 class CancellablePromise extends Promise {
   /**
    * Creates a new CancellablePromise.
@@ -106,15 +292,21 @@ class CancellablePromise extends Promise {
    * and an onCancel callback used to define behavior of cancellation.
    */
   constructor(executor) {
-    var outerCancellationFunction;
+    var outerId = uuid_1.v4();
     var outerRejectPromise;
     super((resolve, reject) => {
       outerRejectPromise = reject;
-      return executor(resolve, reject, cancellationFunction => {
-        outerCancellationFunction = cancellationFunction;
+      return executor(value => {
+        CancellablePromise.cancellationMap.delete(outerId);
+        resolve(value);
+      }, reason => {
+        CancellablePromise.cancellationMap.delete(outerId);
+        reject(reason);
+      }, cancellationFunction => {
+        CancellablePromise.cancellationMap.set(outerId, cancellationFunction);
       });
     });
-    this.cancel = outerCancellationFunction;
+    this.id = outerId;
     this.rejectPromise = outerRejectPromise;
   }
   /**
@@ -123,17 +315,21 @@ class CancellablePromise extends Promise {
 
 
   cancel() {
-    if (this.onCancel) {
-      this.onCancel();
-    }
+    var onCancel = CancellablePromise.cancellationMap.get(this.id);
+    onCancel === null || onCancel === void 0 ? void 0 : onCancel();
 
     if (this.rejectPromise) {
+      this.catch(() => void 0);
       this.rejectPromise(new Error("Promise was cancelled"));
     }
+
+    return this;
   }
 
 }
 
+_defineProperty__default["default"](CancellablePromise, "cancellationMap", new Map());
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -589,35 +785,40 @@ class Network {
             switch (_context2.prev = _context2.next) {
               case 0:
                 retrier = new operationRetrier.Retrier(_this.backoffConfig());
-                onCancel(() => {
-                  request.cancel();
-                  retrier.removeAllListeners();
-                  retrier.cancel();
-                });
                 codesToRetryOn = [502, 503, 504];
 
                 if (retryWhenThrottled) {
                   codesToRetryOn.push(429);
                 }
 
+                onCancel(() => {
+                  retrier.cancel();
+                  retrier.removeAllListeners();
+                });
                 retrier.on("attempt", /*#__PURE__*/_asyncToGenerator__default["default"]( /*#__PURE__*/_regeneratorRuntime__default["default"].mark(function _callee() {
-                  var result;
+                  var requestPromise, result;
                   return _regeneratorRuntime__default["default"].wrap(function _callee$(_context) {
                     while (1) {
                       switch (_context.prev = _context.next) {
                         case 0:
                           _context.prev = 0;
-                          _context.next = 3;
-                          return request();
+                          requestPromise = request();
+                          onCancel(() => {
+                            requestPromise.cancel();
+                            retrier.cancel();
+                            retrier.removeAllListeners();
+                          });
+                          _context.next = 5;
+                          return requestPromise;
 
-                        case 3:
+                        case 5:
                           result = _context.sent;
                           retrier.succeeded(result);
-                          _context.next = 10;
+                          _context.next = 12;
                           break;
 
-                        case 7:
-                          _context.prev = 7;
+                        case 9:
+                          _context.prev = 9;
                           _context.t0 = _context["catch"](0);
 
                           if (codesToRetryOn.indexOf(_context.t0.status) > -1) {
@@ -632,12 +833,12 @@ class Network {
                             reject(_context.t0);
                           }
 
-                        case 10:
+                        case 12:
                         case "end":
                           return _context.stop();
                       }
                     }
-                  }, _callee, null, [[0, 7]]);
+                  }, _callee, null, [[0, 9]]);
                 })));
                 retrier.on("succeeded", result => {
                   resolve(result);
@@ -786,7 +987,7 @@ class Network {
 
 }
 
-var version = "0.6.0-rc.2";
+var version = "0.6.0-rc.5";
 
 var _class;
 var log = Logger.scope("");