FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

node_modules/jayson/promise/lib/client/browser/index.d.ts

@@ -0,0 +1,12 @@
+import * as jayson from '../../../..';
+
+type PromiseClientBrowserCallServerFunction = (request:string) => Promise<string>;
+
+declare class PromiseClientBrowser {
+  constructor(callServer:PromiseClientBrowserCallServerFunction, options?:jayson.ClientOptions);
+  request(method:string, params:jayson.RequestParamsLike, id:jayson.JSONRPCIDLike | undefined, shouldCall:false): jayson.JSONRPCRequest;
+  request(method:string, params:jayson.RequestParamsLike, id?:jayson.JSONRPCIDLike): Promise<jayson.JSONRPCResultLike>;
+  request(method: Array<jayson.JSONRPCRequestLike>): Promise<jayson.JSONRPCResultLike>;
+}
+
+export = PromiseClientBrowser;

node_modules/jayson/promise/lib/client/browser/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const ClientBrowser = require('../../../../lib/client/browser/index');
+const promiseUtils = require('../../utils');
+
+/**
+ * Constructor for a Jayson Promise Browser Client that does not depend any node.js core libraries
+ * @class PromiseClientBrowser
+ * @extends ClientBrowser
+ * @return {PromiseClientBrowser}
+ */
+const PromiseClientBrowser = function(callServerPromise, options) {
+  if(!(this instanceof PromiseClientBrowser)) {
+    return new PromiseClientBrowser(callServerPromise, options);
+  }
+
+  const callServer = function (request, callback) {
+    callServerPromise(request).then(res => callback(null, res), err => callback(err));
+  };
+
+  ClientBrowser.call(this, callServer, options);
+  this.request = promiseUtils.wrapClientRequestMethod(this.request.bind(this));
+};
+
+// let's hope this ancient method of inheriting works the way I remember it.
+PromiseClientBrowser.prototype = ClientBrowser.prototype;
+
+module.exports = PromiseClientBrowser;

node_modules/jayson/promise/lib/client/http.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const promisify = require('es6-promisify');
+const jayson = require('../../../');
+const promiseUtils = require('../utils');
+
+/**
+ * Constructor for a Jayson Promise Client Http
+ * @see Client
+ * @class PromiseClientHttp
+ * @extends ClientHttp
+ * @return {PromiseClientHttp}
+ */
+const PromiseClientHttp = function(options) {
+  if(!(this instanceof PromiseClientHttp)) {
+    return new PromiseClientHttp(options);
+  }
+  jayson.Client.http.apply(this, arguments);
+  this.request = promiseUtils.wrapClientRequestMethod(this.request.bind(this));
+};
+require('util').inherits(PromiseClientHttp, jayson.Client.http);
+
+module.exports = PromiseClientHttp;

node_modules/jayson/promise/lib/client/https.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const promisify = require('es6-promisify');
+const jayson = require('../../../');
+const promiseUtils = require('../utils');
+
+/**
+ * Constructor for a Jayson Promise Client Http
+ * @see Client
+ * @class PromiseClientHttps
+ * @extends ClientHttps
+ * @return {PromiseClientHttps}
+ */
+const PromiseClientHttps = function(options) {
+  if(!(this instanceof PromiseClientHttps)) {
+    return new PromiseClientHttps(options);
+  }
+  jayson.Client.https.apply(this, arguments);
+  this.request = promiseUtils.wrapClientRequestMethod(this.request.bind(this));
+};
+require('util').inherits(PromiseClientHttps, jayson.Client.https);
+
+module.exports = PromiseClientHttps;
+

node_modules/jayson/promise/lib/client/index.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const promisify = require('es6-promisify');
+const jayson = require('../../../');
+const promiseUtils = require('../utils');
+
+/**
+ * Constructor for a Jayson Promise Client
+ * @see Client
+ * @class PromiseClient
+ * @extends Client
+ * @return {PromiseClient}
+ */
+const PromiseClient = function(server, options) {
+  if(!(this instanceof PromiseClient)) {
+    return new PromiseClient(server, options);
+  }
+  jayson.Client.apply(this, arguments);
+  this.request = promiseUtils.wrapClientRequestMethod(this.request.bind(this));
+};
+require('util').inherits(PromiseClient, jayson.Client);
+
+/**
+ * @type PromiseClientHttp
+ * @static
+ */
+PromiseClient.http = require('./http');
+
+/**
+ * @type PromiseClientHttps
+ * @static
+ */
+PromiseClient.https = require('./https');
+
+/**
+ * @type PromiseClientTls
+ * @static
+ */
+PromiseClient.tls = require('./tls');
+
+/**
+ * @type PromiseClientTcp
+ * @static
+ */
+PromiseClient.tcp = require('./tcp');
+
+/**
+ * @type PromiseClientWebsocket
+ * @static
+ */
+PromiseClient.websocket = require('./websocket');
+
+module.exports = PromiseClient;

node_modules/jayson/promise/lib/client/tcp.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const promisify = require('es6-promisify');
+const jayson = require('../../../');
+const promiseUtils = require('../utils');
+
+/**
+ * Constructor for a Jayson Promise Client Tcp
+ * @see Client
+ * @class PromiseClientTcp
+ * @extends ClientTcp
+ * @return {PromiseClientTcp}
+ */
+const PromiseClientTcp = function(options) {
+  if(!(this instanceof PromiseClientTcp)) {
+    return new PromiseClientTcp(options);
+  }
+  jayson.Client.tcp.apply(this, arguments);
+  this.request = promiseUtils.wrapClientRequestMethod(this.request.bind(this));
+};
+require('util').inherits(PromiseClientTcp, jayson.Client.tcp);
+
+module.exports = PromiseClientTcp;

node_modules/jayson/promise/lib/client/tls.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const promisify = require('es6-promisify');
+const jayson = require('../../../');
+const promiseUtils = require('../utils');
+
+/**
+ * Constructor for a Jayson Promise Client Tls
+ * @see Client
+ * @class PromiseClientTls
+ * @extends ClientTls
+ * @return {PromiseClientTls}
+ */
+const PromiseClientTls = function(options) {
+  if(!(this instanceof PromiseClientTls)) {
+    return new PromiseClientTls(options);
+  }
+  jayson.Client.tls.apply(this, arguments);
+  this.request = promiseUtils.wrapClientRequestMethod(this.request.bind(this));
+};
+require('util').inherits(PromiseClientTls, jayson.Client.tls);
+
+module.exports = PromiseClientTls;

node_modules/jayson/promise/lib/client/websocket.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const promisify = require('es6-promisify');
+const jayson = require('../../../');
+const promiseUtils = require('../utils');
+
+/**
+ * Constructor for a Jayson Promise Client Websocket
+ * @see Client
+ * @class PromiseClientWebsocket
+ * @extends ClientWebsocket
+ * @return {PromiseClientWebsocket}
+ */
+const PromiseClientWebsocket = function(options) {
+  if(!(this instanceof PromiseClientWebsocket)) {
+    return new PromiseClientWebsocket(options);
+  }
+  jayson.Client.websocket.apply(this, arguments);
+  this.request = promiseUtils.wrapClientRequestMethod(this.request.bind(this));
+};
+require('util').inherits(PromiseClientWebsocket, jayson.Client.websocket);
+
+module.exports = PromiseClientWebsocket;

node_modules/jayson/promise/lib/index.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const Jayson = require('../..');
+
+/**
+ * Namespace available as require('jayson/promise')
+ * @namespace JaysonPromise
+ */
+const JaysonPromise = module.exports;
+
+/**
+ * @static
+ * @type PromiseClient
+ */
+JaysonPromise.Client = JaysonPromise.client = require('./client');
+
+/**
+ * @static
+ * @type Server
+ */
+JaysonPromise.Server = JaysonPromise.server = require('./server');
+
+/**
+ * @static
+ * @type Utils
+ */
+JaysonPromise.Utils = JaysonPromise.utils = Jayson.utils;
+
+/**
+ * @static
+ * @type PromiseMethod
+ */
+JaysonPromise.Method = JaysonPromise.method = require('./method');

node_modules/jayson/promise/lib/method.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const jayson = require('../../');
+
+/**
+ * Constructor for a Jayson Promise Method
+ * @see Method
+ * @class PromiseMethod
+ * @extends Method
+ * @return {PromiseMethod}
+ */
+const PromiseMethod = module.exports = function(handler, options) {
+  if(!(this instanceof PromiseMethod)) {
+    return new PromiseMethod(handler, options);
+  }
+  jayson.Method.apply(this, arguments);
+};
+require('util').inherits(PromiseMethod, jayson.Method);
+
+module.exports = PromiseMethod;
+
+/**
+ * @summary Executes this method in the context of a server
+ * @param {Server} server
+ * @param {Array|Object} requestParams
+ * @param {Object} [context] Optional context object passed to methods
+ * @param {Function} outerCallback
+ * @return {Promise}
+ */
+PromiseMethod.prototype.execute = function(server, requestParams, context, outerCallback) {
+  let wasPromised = false;
+
+  if(typeof(context) === 'function') {
+    outerCallback = context;
+    context = {};
+  }
+
+  const promise = jayson.Method.prototype.execute.call(this, server, requestParams, context, function() {
+    if(wasPromised) {
+      return; // ignore any invocations of the callback if a promise was returned
+    }
+    outerCallback.apply(null, arguments);
+  });
+
+  wasPromised = promise && typeof promise.then === 'function';
+
+  // if the handler returned a promise, call the callback when it resolves
+  if(wasPromised) {
+    return promise.then(
+      function(fulfilled) { outerCallback(null, fulfilled); },
+      function(rejected) { outerCallback(rejected); }
+    );
+  }
+};

node_modules/jayson/promise/lib/server.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const Method = require('./method');
+const jayson = require('../../');
+
+/**
+ * Constructor for a Jayson Promise Server
+ * @see Server
+ * @class PromiseServer
+ * @extends Server
+ * @return {PromiseServer}
+ */
+const PromiseServer = function(methods, options) {
+  if(!(this instanceof PromiseServer)) {
+    return new PromiseServer(methods, options);
+  }
+  options = options || {};
+  options.methodConstructor = options.methodConstructor || Method;
+  jayson.Server.call(this, methods, options);
+};
+require('util').inherits(PromiseServer, jayson.Server);
+
+module.exports = PromiseServer;

node_modules/jayson/promise/lib/utils.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const promisify = require('es6-promisify');
+
+/** * @namespace */
+const PromiseUtils = module.exports;
+
+/**
+ * Wraps the client request method on an instance, making it return a promise in every case except when the fourth argument is explicitly set to false
+ * @param {Function} request The original request method
+ * @return {Function}
+ */
+PromiseUtils.wrapClientRequestMethod = function(request) {
+  const promisified = promisify(request);
+
+  return function(method, params, id, shouldCall) {
+    if(shouldCall === false) {
+      // this should return a raw request for use in batches
+      return request(method, params, id);
+    }
+    return promisified.apply(this, arguments);
+  };
+};