diff --git a/node_modules/peerjs/dist/adapter.js b/node_modules/peerjs/dist/adapter.js new file mode 100644 index 0000000..6bfbeb8 --- /dev/null +++ b/node_modules/peerjs/dist/adapter.js @@ -0,0 +1,8 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.webRTCAdapter = void 0; +var webrtc_adapter_1 = __importDefault(require("webrtc-adapter")); +exports.webRTCAdapter = webrtc_adapter_1.default; diff --git a/node_modules/peerjs/dist/api.js b/node_modules/peerjs/dist/api.js new file mode 100644 index 0000000..8c091c2 --- /dev/null +++ b/node_modules/peerjs/dist/api.js @@ -0,0 +1,142 @@ +"use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.API = void 0; +var util_1 = require("./util"); +var logger_1 = __importDefault(require("./logger")); +var API = /** @class */ (function () { + function API(_options) { + this._options = _options; + } + API.prototype._buildUrl = function (method) { + var protocol = this._options.secure ? "https://" : "http://"; + var url = protocol + + this._options.host + + ":" + + this._options.port + + this._options.path + + this._options.key + + "/" + + method; + var queryString = "?ts=" + new Date().getTime() + "" + Math.random(); + url += queryString; + return url; + }; + /** Get a unique ID from the server via XHR and initialize with it. */ + API.prototype.retrieveId = function () { + return __awaiter(this, void 0, void 0, function () { + var url, response, error_1, pathError; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + url = this._buildUrl("id"); + _a.label = 1; + case 1: + _a.trys.push([1, 3, , 4]); + return [4 /*yield*/, fetch(url)]; + case 2: + response = _a.sent(); + if (response.status !== 200) { + throw new Error("Error. Status:" + response.status); + } + return [2 /*return*/, response.text()]; + case 3: + error_1 = _a.sent(); + logger_1.default.error("Error retrieving ID", error_1); + pathError = ""; + if (this._options.path === "/" && + this._options.host !== util_1.util.CLOUD_HOST) { + pathError = + " If you passed in a `path` to your self-hosted PeerServer, " + + "you'll also need to pass in that same path when creating a new " + + "Peer."; + } + throw new Error("Could not get an ID from the server." + pathError); + case 4: return [2 /*return*/]; + } + }); + }); + }; + /** @deprecated */ + API.prototype.listAllPeers = function () { + return __awaiter(this, void 0, void 0, function () { + var url, response, helpfulError, error_2; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + url = this._buildUrl("peers"); + _a.label = 1; + case 1: + _a.trys.push([1, 3, , 4]); + return [4 /*yield*/, fetch(url)]; + case 2: + response = _a.sent(); + if (response.status !== 200) { + if (response.status === 401) { + helpfulError = ""; + if (this._options.host === util_1.util.CLOUD_HOST) { + helpfulError = + "It looks like you're using the cloud server. You can email " + + "team@peerjs.com to enable peer listing for your API key."; + } + else { + helpfulError = + "You need to enable `allow_discovery` on your self-hosted " + + "PeerServer to use this feature."; + } + throw new Error("It doesn't look like you have permission to list peers IDs. " + + helpfulError); + } + throw new Error("Error. Status:" + response.status); + } + return [2 /*return*/, response.json()]; + case 3: + error_2 = _a.sent(); + logger_1.default.error("Error retrieving list peers", error_2); + throw new Error("Could not get list peers from the server." + error_2); + case 4: return [2 /*return*/]; + } + }); + }); + }; + return API; +}()); +exports.API = API; diff --git a/node_modules/peerjs/dist/baseconnection.js b/node_modules/peerjs/dist/baseconnection.js new file mode 100644 index 0000000..0c4e504 --- /dev/null +++ b/node_modules/peerjs/dist/baseconnection.js @@ -0,0 +1,40 @@ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", { value: true }); +exports.BaseConnection = void 0; +var eventemitter3_1 = require("eventemitter3"); +var BaseConnection = /** @class */ (function (_super) { + __extends(BaseConnection, _super); + function BaseConnection(peer, provider, options) { + var _this = _super.call(this) || this; + _this.peer = peer; + _this.provider = provider; + _this.options = options; + _this._open = false; + _this.metadata = options.metadata; + return _this; + } + Object.defineProperty(BaseConnection.prototype, "open", { + get: function () { + return this._open; + }, + enumerable: false, + configurable: true + }); + return BaseConnection; +}(eventemitter3_1.EventEmitter)); +exports.BaseConnection = BaseConnection; diff --git a/node_modules/peerjs/dist/dataconnection.js b/node_modules/peerjs/dist/dataconnection.js new file mode 100644 index 0000000..64262ac --- /dev/null +++ b/node_modules/peerjs/dist/dataconnection.js @@ -0,0 +1,298 @@ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.DataConnection = void 0; +var util_1 = require("./util"); +var logger_1 = __importDefault(require("./logger")); +var negotiator_1 = require("./negotiator"); +var enums_1 = require("./enums"); +var baseconnection_1 = require("./baseconnection"); +var encodingQueue_1 = require("./encodingQueue"); +/** + * Wraps a DataChannel between two Peers. + */ +// @ts-ignore +var DataConnection = /** @class */ (function (_super) { + __extends(DataConnection, _super); + function DataConnection(peerId, provider, options) { + var _this = _super.call(this, peerId, provider, options) || this; + _this.stringify = JSON.stringify; + _this.parse = JSON.parse; + _this._buffer = []; + _this._bufferSize = 0; + _this._buffering = false; + _this._chunkedData = {}; + _this._encodingQueue = new encodingQueue_1.EncodingQueue(); + _this.connectionId = + _this.options.connectionId || DataConnection.ID_PREFIX + util_1.util.randomToken(); + _this.label = _this.options.label || _this.connectionId; + _this.serialization = _this.options.serialization || enums_1.SerializationType.Binary; + _this.reliable = !!_this.options.reliable; + _this._encodingQueue.on('done', function (ab) { + _this._bufferedSend(ab); + }); + _this._encodingQueue.on('error', function () { + logger_1.default.error("DC#" + _this.connectionId + ": Error occured in encoding from blob to arraybuffer, close DC"); + _this.close(); + }); + _this._negotiator = new negotiator_1.Negotiator(_this); + _this._negotiator.startConnection(_this.options._payload || { + originator: true + }); + return _this; + } + Object.defineProperty(DataConnection.prototype, "type", { + get: function () { + return enums_1.ConnectionType.Data; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(DataConnection.prototype, "dataChannel", { + get: function () { + return this._dc; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(DataConnection.prototype, "bufferSize", { + get: function () { return this._bufferSize; }, + enumerable: false, + configurable: true + }); + /** Called by the Negotiator when the DataChannel is ready. */ + DataConnection.prototype.initialize = function (dc) { + this._dc = dc; + this._configureDataChannel(); + }; + DataConnection.prototype._configureDataChannel = function () { + var _this = this; + if (!util_1.util.supports.binaryBlob || util_1.util.supports.reliable) { + this.dataChannel.binaryType = "arraybuffer"; + } + this.dataChannel.onopen = function () { + logger_1.default.log("DC#" + _this.connectionId + " dc connection success"); + _this._open = true; + _this.emit(enums_1.ConnectionEventType.Open); + }; + this.dataChannel.onmessage = function (e) { + logger_1.default.log("DC#" + _this.connectionId + " dc onmessage:", e.data); + _this._handleDataMessage(e); + }; + this.dataChannel.onclose = function () { + logger_1.default.log("DC#" + _this.connectionId + " dc closed for:", _this.peer); + _this.close(); + }; + }; + // Handles a DataChannel message. + DataConnection.prototype._handleDataMessage = function (_a) { + var _this = this; + var data = _a.data; + var datatype = data.constructor; + var isBinarySerialization = this.serialization === enums_1.SerializationType.Binary || + this.serialization === enums_1.SerializationType.BinaryUTF8; + var deserializedData = data; + if (isBinarySerialization) { + if (datatype === Blob) { + // Datatype should never be blob + util_1.util.blobToArrayBuffer(data, function (ab) { + // @ts-ignore + var unpackedData = util_1.util.unpack(ab); + _this.emit(enums_1.ConnectionEventType.Data, unpackedData); + }); + return; + } + else if (datatype === ArrayBuffer) { + deserializedData = util_1.util.unpack(data); + } + else if (datatype === String) { + // String fallback for binary data for browsers that don't support binary yet + var ab = util_1.util.binaryStringToArrayBuffer(data); + deserializedData = util_1.util.unpack(ab); + } + } + else if (this.serialization === enums_1.SerializationType.JSON) { + deserializedData = this.parse(data); + } + // Check if we've chunked--if so, piece things back together. + // We're guaranteed that this isn't 0. + if (deserializedData.__peerData) { + this._handleChunk(deserializedData); + return; + } + _super.prototype.emit.call(this, enums_1.ConnectionEventType.Data, deserializedData); + }; + DataConnection.prototype._handleChunk = function (data) { + var id = data.__peerData; + var chunkInfo = this._chunkedData[id] || { + data: [], + count: 0, + total: data.total + }; + chunkInfo.data[data.n] = data.data; + chunkInfo.count++; + this._chunkedData[id] = chunkInfo; + if (chunkInfo.total === chunkInfo.count) { + // Clean up before making the recursive call to `_handleDataMessage`. + delete this._chunkedData[id]; + // We've received all the chunks--time to construct the complete data. + var data_1 = new Blob(chunkInfo.data); + this._handleDataMessage({ data: data_1 }); + } + }; + /** + * Exposed functionality for users. + */ + /** Allows user to close connection. */ + DataConnection.prototype.close = function () { + this._buffer = []; + this._bufferSize = 0; + this._chunkedData = {}; + if (this._negotiator) { + this._negotiator.cleanup(); + // @ts-ignore + this._negotiator = null; + } + if (this.provider) { + this.provider._removeConnection(this); + // @ts-ignore + this.provider = null; + } + if (this.dataChannel) { + this.dataChannel.onopen = null; + this.dataChannel.onmessage = null; + this.dataChannel.onclose = null; + // @ts-ignore + this._dc = null; + } + if (this._encodingQueue) { + this._encodingQueue.destroy(); + this._encodingQueue.removeAllListeners(); + // @ts-ignore + this._encodingQueue = null; + } + if (!this.open) { + return; + } + this._open = false; + _super.prototype.emit.call(this, enums_1.ConnectionEventType.Close); + }; + /** Allows user to send data. */ + DataConnection.prototype.send = function (data, chunked) { + if (!this.open) { + _super.prototype.emit.call(this, enums_1.ConnectionEventType.Error, new Error("Connection is not open. You should listen for the `open` event before sending messages.")); + return; + } + if (this.serialization === enums_1.SerializationType.JSON) { + this._bufferedSend(this.stringify(data)); + } + else if (this.serialization === enums_1.SerializationType.Binary || + this.serialization === enums_1.SerializationType.BinaryUTF8) { + var blob = util_1.util.pack(data); + if (!chunked && blob.size > util_1.util.chunkedMTU) { + this._sendChunks(blob); + return; + } + if (!util_1.util.supports.binaryBlob) { + // We only do this if we really need to (e.g. blobs are not supported), + // because this conversion is costly. + this._encodingQueue.enque(blob); + } + else { + this._bufferedSend(blob); + } + } + else { + this._bufferedSend(data); + } + }; + DataConnection.prototype._bufferedSend = function (msg) { + if (this._buffering || !this._trySend(msg)) { + this._buffer.push(msg); + this._bufferSize = this._buffer.length; + } + }; + // Returns true if the send succeeds. + DataConnection.prototype._trySend = function (msg) { + var _this = this; + if (!this.open) { + return false; + } + if (this.dataChannel.bufferedAmount > DataConnection.MAX_BUFFERED_AMOUNT) { + this._buffering = true; + setTimeout(function () { + _this._buffering = false; + _this._tryBuffer(); + }, 50); + return false; + } + try { + this.dataChannel.send(msg); + } + catch (e) { + logger_1.default.error("DC#:" + this.connectionId + " Error when sending:", e); + this._buffering = true; + this.close(); + return false; + } + return true; + }; + // Try to send the first message in the buffer. + DataConnection.prototype._tryBuffer = function () { + if (!this.open) { + return; + } + if (this._buffer.length === 0) { + return; + } + var msg = this._buffer[0]; + if (this._trySend(msg)) { + this._buffer.shift(); + this._bufferSize = this._buffer.length; + this._tryBuffer(); + } + }; + DataConnection.prototype._sendChunks = function (blob) { + var blobs = util_1.util.chunk(blob); + logger_1.default.log("DC#" + this.connectionId + " Try to send " + blobs.length + " chunks..."); + for (var _i = 0, blobs_1 = blobs; _i < blobs_1.length; _i++) { + var blob_1 = blobs_1[_i]; + this.send(blob_1, true); + } + }; + DataConnection.prototype.handleMessage = function (message) { + var payload = message.payload; + switch (message.type) { + case enums_1.ServerMessageType.Answer: + this._negotiator.handleSDP(message.type, payload.sdp); + break; + case enums_1.ServerMessageType.Candidate: + this._negotiator.handleCandidate(payload.candidate); + break; + default: + logger_1.default.warn("Unrecognized message type:", message.type, "from peer:", this.peer); + break; + } + }; + DataConnection.ID_PREFIX = "dc_"; + DataConnection.MAX_BUFFERED_AMOUNT = 8 * 1024 * 1024; + return DataConnection; +}(baseconnection_1.BaseConnection)); +exports.DataConnection = DataConnection; diff --git a/node_modules/peerjs/dist/encodingQueue.js b/node_modules/peerjs/dist/encodingQueue.js new file mode 100644 index 0000000..c9ca6b5 --- /dev/null +++ b/node_modules/peerjs/dist/encodingQueue.js @@ -0,0 +1,88 @@ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.EncodingQueue = void 0; +var eventemitter3_1 = require("eventemitter3"); +var logger_1 = __importDefault(require("./logger")); +var EncodingQueue = /** @class */ (function (_super) { + __extends(EncodingQueue, _super); + function EncodingQueue() { + var _this = _super.call(this) || this; + _this.fileReader = new FileReader(); + _this._queue = []; + _this._processing = false; + _this.fileReader.onload = function (evt) { + _this._processing = false; + if (evt.target) { + _this.emit('done', evt.target.result); + } + _this.doNextTask(); + }; + _this.fileReader.onerror = function (evt) { + logger_1.default.error("EncodingQueue error:", evt); + _this._processing = false; + _this.destroy(); + _this.emit('error', evt); + }; + return _this; + } + Object.defineProperty(EncodingQueue.prototype, "queue", { + get: function () { + return this._queue; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(EncodingQueue.prototype, "size", { + get: function () { + return this.queue.length; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(EncodingQueue.prototype, "processing", { + get: function () { + return this._processing; + }, + enumerable: false, + configurable: true + }); + EncodingQueue.prototype.enque = function (blob) { + this.queue.push(blob); + if (this.processing) + return; + this.doNextTask(); + }; + EncodingQueue.prototype.destroy = function () { + this.fileReader.abort(); + this._queue = []; + }; + EncodingQueue.prototype.doNextTask = function () { + if (this.size === 0) + return; + if (this.processing) + return; + this._processing = true; + // @ts-ignore + this.fileReader.readAsArrayBuffer(this.queue.shift()); + }; + return EncodingQueue; +}(eventemitter3_1.EventEmitter)); +exports.EncodingQueue = EncodingQueue; diff --git a/node_modules/peerjs/dist/enums.js b/node_modules/peerjs/dist/enums.js new file mode 100644 index 0000000..9e551a4 --- /dev/null +++ b/node_modules/peerjs/dist/enums.js @@ -0,0 +1,67 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.ServerMessageType = exports.SocketEventType = exports.SerializationType = exports.PeerErrorType = exports.PeerEventType = exports.ConnectionType = exports.ConnectionEventType = void 0; +var ConnectionEventType; +(function (ConnectionEventType) { + ConnectionEventType["Open"] = "open"; + ConnectionEventType["Stream"] = "stream"; + ConnectionEventType["Data"] = "data"; + ConnectionEventType["Close"] = "close"; + ConnectionEventType["Error"] = "error"; + ConnectionEventType["IceStateChanged"] = "iceStateChanged"; +})(ConnectionEventType = exports.ConnectionEventType || (exports.ConnectionEventType = {})); +var ConnectionType; +(function (ConnectionType) { + ConnectionType["Data"] = "data"; + ConnectionType["Media"] = "media"; +})(ConnectionType = exports.ConnectionType || (exports.ConnectionType = {})); +var PeerEventType; +(function (PeerEventType) { + PeerEventType["Open"] = "open"; + PeerEventType["Close"] = "close"; + PeerEventType["Connection"] = "connection"; + PeerEventType["Call"] = "call"; + PeerEventType["Disconnected"] = "disconnected"; + PeerEventType["Error"] = "error"; +})(PeerEventType = exports.PeerEventType || (exports.PeerEventType = {})); +var PeerErrorType; +(function (PeerErrorType) { + PeerErrorType["BrowserIncompatible"] = "browser-incompatible"; + PeerErrorType["Disconnected"] = "disconnected"; + PeerErrorType["InvalidID"] = "invalid-id"; + PeerErrorType["InvalidKey"] = "invalid-key"; + PeerErrorType["Network"] = "network"; + PeerErrorType["PeerUnavailable"] = "peer-unavailable"; + PeerErrorType["SslUnavailable"] = "ssl-unavailable"; + PeerErrorType["ServerError"] = "server-error"; + PeerErrorType["SocketError"] = "socket-error"; + PeerErrorType["SocketClosed"] = "socket-closed"; + PeerErrorType["UnavailableID"] = "unavailable-id"; + PeerErrorType["WebRTC"] = "webrtc"; +})(PeerErrorType = exports.PeerErrorType || (exports.PeerErrorType = {})); +var SerializationType; +(function (SerializationType) { + SerializationType["Binary"] = "binary"; + SerializationType["BinaryUTF8"] = "binary-utf8"; + SerializationType["JSON"] = "json"; +})(SerializationType = exports.SerializationType || (exports.SerializationType = {})); +var SocketEventType; +(function (SocketEventType) { + SocketEventType["Message"] = "message"; + SocketEventType["Disconnected"] = "disconnected"; + SocketEventType["Error"] = "error"; + SocketEventType["Close"] = "close"; +})(SocketEventType = exports.SocketEventType || (exports.SocketEventType = {})); +var ServerMessageType; +(function (ServerMessageType) { + ServerMessageType["Heartbeat"] = "HEARTBEAT"; + ServerMessageType["Candidate"] = "CANDIDATE"; + ServerMessageType["Offer"] = "OFFER"; + ServerMessageType["Answer"] = "ANSWER"; + ServerMessageType["Open"] = "OPEN"; + ServerMessageType["Error"] = "ERROR"; + ServerMessageType["IdTaken"] = "ID-TAKEN"; + ServerMessageType["InvalidKey"] = "INVALID-KEY"; + ServerMessageType["Leave"] = "LEAVE"; + ServerMessageType["Expire"] = "EXPIRE"; // The offer sent to a peer has expired without response. +})(ServerMessageType = exports.ServerMessageType || (exports.ServerMessageType = {})); diff --git a/node_modules/peerjs/dist/exports.js b/node_modules/peerjs/dist/exports.js new file mode 100644 index 0000000..d6e2666 --- /dev/null +++ b/node_modules/peerjs/dist/exports.js @@ -0,0 +1,13 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.peerjs = void 0; +var util_1 = require("./util"); +var peer_1 = require("./peer"); +exports.peerjs = { + Peer: peer_1.Peer, + util: util_1.util +}; +exports.default = peer_1.Peer; +window.peerjs = exports.peerjs; +/** @deprecated Should use peerjs namespace */ +window.Peer = peer_1.Peer; diff --git a/node_modules/peerjs/dist/index.js b/node_modules/peerjs/dist/index.js new file mode 100644 index 0000000..e7d6ac1 --- /dev/null +++ b/node_modules/peerjs/dist/index.js @@ -0,0 +1,27 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +__exportStar(require("./adapter"), exports); +__exportStar(require("./api"), exports); +__exportStar(require("./baseconnection"), exports); +__exportStar(require("./dataconnection"), exports); +__exportStar(require("./encodingQueue"), exports); +__exportStar(require("./enums"), exports); +__exportStar(require("./exports"), exports); +__exportStar(require("./logger"), exports); +__exportStar(require("./mediaconnection"), exports); +__exportStar(require("./negotiator"), exports); +__exportStar(require("./peer"), exports); +__exportStar(require("./servermessage"), exports); +__exportStar(require("./socket"), exports); +__exportStar(require("./supports"), exports); +__exportStar(require("./util"), exports); diff --git a/node_modules/peerjs/dist/logger.js b/node_modules/peerjs/dist/logger.js new file mode 100644 index 0000000..9a5e883 --- /dev/null +++ b/node_modules/peerjs/dist/logger.js @@ -0,0 +1,87 @@ +"use strict"; +var __spreadArray = (this && this.__spreadArray) || function (to, from) { + for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) + to[j] = from[i]; + return to; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.LogLevel = void 0; +var LOG_PREFIX = 'PeerJS: '; +/* +Prints log messages depending on the debug level passed in. Defaults to 0. +0 Prints no logs. +1 Prints only errors. +2 Prints errors and warnings. +3 Prints all logs. +*/ +var LogLevel; +(function (LogLevel) { + LogLevel[LogLevel["Disabled"] = 0] = "Disabled"; + LogLevel[LogLevel["Errors"] = 1] = "Errors"; + LogLevel[LogLevel["Warnings"] = 2] = "Warnings"; + LogLevel[LogLevel["All"] = 3] = "All"; +})(LogLevel = exports.LogLevel || (exports.LogLevel = {})); +var Logger = /** @class */ (function () { + function Logger() { + this._logLevel = LogLevel.Disabled; + } + Object.defineProperty(Logger.prototype, "logLevel", { + get: function () { return this._logLevel; }, + set: function (logLevel) { this._logLevel = logLevel; }, + enumerable: false, + configurable: true + }); + Logger.prototype.log = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + if (this._logLevel >= LogLevel.All) { + this._print.apply(this, __spreadArray([LogLevel.All], args)); + } + }; + Logger.prototype.warn = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + if (this._logLevel >= LogLevel.Warnings) { + this._print.apply(this, __spreadArray([LogLevel.Warnings], args)); + } + }; + Logger.prototype.error = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + if (this._logLevel >= LogLevel.Errors) { + this._print.apply(this, __spreadArray([LogLevel.Errors], args)); + } + }; + Logger.prototype.setLogFunction = function (fn) { + this._print = fn; + }; + Logger.prototype._print = function (logLevel) { + var rest = []; + for (var _i = 1; _i < arguments.length; _i++) { + rest[_i - 1] = arguments[_i]; + } + var copy = __spreadArray([LOG_PREFIX], rest); + for (var i in copy) { + if (copy[i] instanceof Error) { + copy[i] = "(" + copy[i].name + ") " + copy[i].message; + } + } + if (logLevel >= LogLevel.All) { + console.log.apply(console, copy); + } + else if (logLevel >= LogLevel.Warnings) { + console.warn.apply(console, __spreadArray(["WARNING"], copy)); + } + else if (logLevel >= LogLevel.Errors) { + console.error.apply(console, __spreadArray(["ERROR"], copy)); + } + }; + return Logger; +}()); +exports.default = new Logger(); diff --git a/node_modules/peerjs/dist/mediaconnection.js b/node_modules/peerjs/dist/mediaconnection.js new file mode 100644 index 0000000..2318160 --- /dev/null +++ b/node_modules/peerjs/dist/mediaconnection.js @@ -0,0 +1,148 @@ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.MediaConnection = void 0; +var util_1 = require("./util"); +var logger_1 = __importDefault(require("./logger")); +var negotiator_1 = require("./negotiator"); +var enums_1 = require("./enums"); +var baseconnection_1 = require("./baseconnection"); +/** + * Wraps the streaming interface between two Peers. + */ +var MediaConnection = /** @class */ (function (_super) { + __extends(MediaConnection, _super); + function MediaConnection(peerId, provider, options) { + var _this = _super.call(this, peerId, provider, options) || this; + _this._localStream = _this.options._stream; + _this.connectionId = + _this.options.connectionId || + MediaConnection.ID_PREFIX + util_1.util.randomToken(); + _this._negotiator = new negotiator_1.Negotiator(_this); + if (_this._localStream) { + _this._negotiator.startConnection({ + _stream: _this._localStream, + originator: true + }); + } + return _this; + } + Object.defineProperty(MediaConnection.prototype, "type", { + get: function () { + return enums_1.ConnectionType.Media; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(MediaConnection.prototype, "localStream", { + get: function () { return this._localStream; }, + enumerable: false, + configurable: true + }); + Object.defineProperty(MediaConnection.prototype, "remoteStream", { + get: function () { return this._remoteStream; }, + enumerable: false, + configurable: true + }); + // @ts-ignore + MediaConnection.prototype.addStream = function (remoteStream) { + logger_1.default.log("Receiving stream", remoteStream); + this._remoteStream = remoteStream; + _super.prototype.emit.call(this, enums_1.ConnectionEventType.Stream, remoteStream); // Should we call this `open`? + }; + MediaConnection.prototype.handleMessage = function (message) { + var type = message.type; + var payload = message.payload; + switch (message.type) { + case enums_1.ServerMessageType.Answer: + // Forward to negotiator + this._negotiator.handleSDP(type, payload.sdp); + this._open = true; + break; + case enums_1.ServerMessageType.Candidate: + this._negotiator.handleCandidate(payload.candidate); + break; + default: + logger_1.default.warn("Unrecognized message type:" + type + " from peer:" + this.peer); + break; + } + }; + MediaConnection.prototype.answer = function (stream, options) { + if (options === void 0) { options = {}; } + if (this._localStream) { + logger_1.default.warn("Local stream already exists on this MediaConnection. Are you answering a call twice?"); + return; + } + this._localStream = stream; + if (options && options.sdpTransform) { + this.options.sdpTransform = options.sdpTransform; + } + this._negotiator.startConnection(__assign(__assign({}, this.options._payload), { _stream: stream })); + // Retrieve lost messages stored because PeerConnection not set up. + var messages = this.provider._getMessages(this.connectionId); + for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) { + var message = messages_1[_i]; + this.handleMessage(message); + } + this._open = true; + }; + /** + * Exposed functionality for users. + */ + /** Allows user to close connection. */ + MediaConnection.prototype.close = function () { + if (this._negotiator) { + this._negotiator.cleanup(); + // @ts-ignore + this._negotiator = null; + } + // @ts-ignore + this._localStream = null; + // @ts-ignore + this._remoteStream = null; + if (this.provider) { + this.provider._removeConnection(this); + // @ts-ignore + this.provider = null; + } + if (this.options && this.options._stream) { + this.options._stream = null; + } + if (!this.open) { + return; + } + this._open = false; + _super.prototype.emit.call(this, enums_1.ConnectionEventType.Close); + }; + MediaConnection.ID_PREFIX = "mc_"; + return MediaConnection; +}(baseconnection_1.BaseConnection)); +exports.MediaConnection = MediaConnection; diff --git a/node_modules/peerjs/dist/negotiator.js b/node_modules/peerjs/dist/negotiator.js new file mode 100644 index 0000000..afd9687 --- /dev/null +++ b/node_modules/peerjs/dist/negotiator.js @@ -0,0 +1,385 @@ +"use strict"; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (_) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Negotiator = void 0; +var util_1 = require("./util"); +var logger_1 = __importDefault(require("./logger")); +var enums_1 = require("./enums"); +/** + * Manages all negotiations between Peers. + */ +var Negotiator = /** @class */ (function () { + function Negotiator(connection) { + this.connection = connection; + } + /** Returns a PeerConnection object set up correctly (for data, media). */ + Negotiator.prototype.startConnection = function (options) { + var peerConnection = this._startPeerConnection(); + // Set the connection's PC. + this.connection.peerConnection = peerConnection; + if (this.connection.type === enums_1.ConnectionType.Media && options._stream) { + this._addTracksToConnection(options._stream, peerConnection); + } + // What do we need to do now? + if (options.originator) { + if (this.connection.type === enums_1.ConnectionType.Data) { + var dataConnection = this.connection; + var config = { ordered: !!options.reliable }; + var dataChannel = peerConnection.createDataChannel(dataConnection.label, config); + dataConnection.initialize(dataChannel); + } + this._makeOffer(); + } + else { + this.handleSDP("OFFER", options.sdp); + } + }; + /** Start a PC. */ + Negotiator.prototype._startPeerConnection = function () { + logger_1.default.log("Creating RTCPeerConnection."); + var peerConnection = new RTCPeerConnection(this.connection.provider.options.config); + this._setupListeners(peerConnection); + return peerConnection; + }; + /** Set up various WebRTC listeners. */ + Negotiator.prototype._setupListeners = function (peerConnection) { + var _this = this; + var peerId = this.connection.peer; + var connectionId = this.connection.connectionId; + var connectionType = this.connection.type; + var provider = this.connection.provider; + // ICE CANDIDATES. + logger_1.default.log("Listening for ICE candidates."); + peerConnection.onicecandidate = function (evt) { + if (!evt.candidate || !evt.candidate.candidate) + return; + logger_1.default.log("Received ICE candidates for " + peerId + ":", evt.candidate); + provider.socket.send({ + type: enums_1.ServerMessageType.Candidate, + payload: { + candidate: evt.candidate, + type: connectionType, + connectionId: connectionId + }, + dst: peerId + }); + }; + peerConnection.oniceconnectionstatechange = function () { + switch (peerConnection.iceConnectionState) { + case "failed": + logger_1.default.log("iceConnectionState is failed, closing connections to " + + peerId); + _this.connection.emit(enums_1.ConnectionEventType.Error, new Error("Negotiation of connection to " + peerId + " failed.")); + _this.connection.close(); + break; + case "closed": + logger_1.default.log("iceConnectionState is closed, closing connections to " + + peerId); + _this.connection.emit(enums_1.ConnectionEventType.Error, new Error("Connection to " + peerId + " closed.")); + _this.connection.close(); + break; + case "disconnected": + logger_1.default.log("iceConnectionState changed to disconnected on the connection with " + + peerId); + break; + case "completed": + peerConnection.onicecandidate = util_1.util.noop; + break; + } + _this.connection.emit(enums_1.ConnectionEventType.IceStateChanged, peerConnection.iceConnectionState); + }; + // DATACONNECTION. + logger_1.default.log("Listening for data channel"); + // Fired between offer and answer, so options should already be saved + // in the options hash. + peerConnection.ondatachannel = function (evt) { + logger_1.default.log("Received data channel"); + var dataChannel = evt.channel; + var connection = (provider.getConnection(peerId, connectionId)); + connection.initialize(dataChannel); + }; + // MEDIACONNECTION. + logger_1.default.log("Listening for remote stream"); + peerConnection.ontrack = function (evt) { + logger_1.default.log("Received remote stream"); + var stream = evt.streams[0]; + var connection = provider.getConnection(peerId, connectionId); + // @ts-ignore + if (connection.type === enums_1.ConnectionType.Media) { + var mediaConnection = connection; + _this._addStreamToMediaConnection(stream, mediaConnection); + } + }; + }; + Negotiator.prototype.cleanup = function () { + logger_1.default.log("Cleaning up PeerConnection to " + this.connection.peer); + var peerConnection = this.connection.peerConnection; + if (!peerConnection) { + return; + } + // @ts-ignore + this.connection.peerConnection = null; + //unsubscribe from all PeerConnection's events + peerConnection.onicecandidate = peerConnection.oniceconnectionstatechange = peerConnection.ondatachannel = peerConnection.ontrack = function () { }; + var peerConnectionNotClosed = peerConnection.signalingState !== "closed"; + var dataChannelNotClosed = false; + if (this.connection.type === enums_1.ConnectionType.Data) { + var dataConnection = this.connection; + var dataChannel = dataConnection.dataChannel; + if (dataChannel) { + dataChannelNotClosed = !!dataChannel.readyState && dataChannel.readyState !== "closed"; + } + } + if (peerConnectionNotClosed || dataChannelNotClosed) { + peerConnection.close(); + } + }; + Negotiator.prototype._makeOffer = function () { + return __awaiter(this, void 0, void 0, function () { + var peerConnection, provider, offer, payload, dataConnection, err_2, err_1_1; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + peerConnection = this.connection.peerConnection; + provider = this.connection.provider; + _a.label = 1; + case 1: + _a.trys.push([1, 7, , 8]); + return [4 /*yield*/, peerConnection.createOffer(this.connection.options.constraints)]; + case 2: + offer = _a.sent(); + logger_1.default.log("Created offer."); + if (this.connection.options.sdpTransform && typeof this.connection.options.sdpTransform === 'function') { + offer.sdp = this.connection.options.sdpTransform(offer.sdp) || offer.sdp; + } + _a.label = 3; + case 3: + _a.trys.push([3, 5, , 6]); + return [4 /*yield*/, peerConnection.setLocalDescription(offer)]; + case 4: + _a.sent(); + logger_1.default.log("Set localDescription:", offer, "for:" + this.connection.peer); + payload = { + sdp: offer, + type: this.connection.type, + connectionId: this.connection.connectionId, + metadata: this.connection.metadata, + browser: util_1.util.browser + }; + if (this.connection.type === enums_1.ConnectionType.Data) { + dataConnection = this.connection; + payload = __assign(__assign({}, payload), { label: dataConnection.label, reliable: dataConnection.reliable, serialization: dataConnection.serialization }); + } + provider.socket.send({ + type: enums_1.ServerMessageType.Offer, + payload: payload, + dst: this.connection.peer + }); + return [3 /*break*/, 6]; + case 5: + err_2 = _a.sent(); + // TODO: investigate why _makeOffer is being called from the answer + if (err_2 != + "OperationError: Failed to set local offer sdp: Called in wrong state: kHaveRemoteOffer") { + provider.emitError(enums_1.PeerErrorType.WebRTC, err_2); + logger_1.default.log("Failed to setLocalDescription, ", err_2); + } + return [3 /*break*/, 6]; + case 6: return [3 /*break*/, 8]; + case 7: + err_1_1 = _a.sent(); + provider.emitError(enums_1.PeerErrorType.WebRTC, err_1_1); + logger_1.default.log("Failed to createOffer, ", err_1_1); + return [3 /*break*/, 8]; + case 8: return [2 /*return*/]; + } + }); + }); + }; + Negotiator.prototype._makeAnswer = function () { + return __awaiter(this, void 0, void 0, function () { + var peerConnection, provider, answer, err_3, err_1_2; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + peerConnection = this.connection.peerConnection; + provider = this.connection.provider; + _a.label = 1; + case 1: + _a.trys.push([1, 7, , 8]); + return [4 /*yield*/, peerConnection.createAnswer()]; + case 2: + answer = _a.sent(); + logger_1.default.log("Created answer."); + if (this.connection.options.sdpTransform && typeof this.connection.options.sdpTransform === 'function') { + answer.sdp = this.connection.options.sdpTransform(answer.sdp) || answer.sdp; + } + _a.label = 3; + case 3: + _a.trys.push([3, 5, , 6]); + return [4 /*yield*/, peerConnection.setLocalDescription(answer)]; + case 4: + _a.sent(); + logger_1.default.log("Set localDescription:", answer, "for:" + this.connection.peer); + provider.socket.send({ + type: enums_1.ServerMessageType.Answer, + payload: { + sdp: answer, + type: this.connection.type, + connectionId: this.connection.connectionId, + browser: util_1.util.browser + }, + dst: this.connection.peer + }); + return [3 /*break*/, 6]; + case 5: + err_3 = _a.sent(); + provider.emitError(enums_1.PeerErrorType.WebRTC, err_3); + logger_1.default.log("Failed to setLocalDescription, ", err_3); + return [3 /*break*/, 6]; + case 6: return [3 /*break*/, 8]; + case 7: + err_1_2 = _a.sent(); + provider.emitError(enums_1.PeerErrorType.WebRTC, err_1_2); + logger_1.default.log("Failed to create answer, ", err_1_2); + return [3 /*break*/, 8]; + case 8: return [2 /*return*/]; + } + }); + }); + }; + /** Handle an SDP. */ + Negotiator.prototype.handleSDP = function (type, sdp) { + return __awaiter(this, void 0, void 0, function () { + var peerConnection, provider, self, err_4; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + sdp = new RTCSessionDescription(sdp); + peerConnection = this.connection.peerConnection; + provider = this.connection.provider; + logger_1.default.log("Setting remote description", sdp); + self = this; + _a.label = 1; + case 1: + _a.trys.push([1, 5, , 6]); + return [4 /*yield*/, peerConnection.setRemoteDescription(sdp)]; + case 2: + _a.sent(); + logger_1.default.log("Set remoteDescription:" + type + " for:" + this.connection.peer); + if (!(type === "OFFER")) return [3 /*break*/, 4]; + return [4 /*yield*/, self._makeAnswer()]; + case 3: + _a.sent(); + _a.label = 4; + case 4: return [3 /*break*/, 6]; + case 5: + err_4 = _a.sent(); + provider.emitError(enums_1.PeerErrorType.WebRTC, err_4); + logger_1.default.log("Failed to setRemoteDescription, ", err_4); + return [3 /*break*/, 6]; + case 6: return [2 /*return*/]; + } + }); + }); + }; + /** Handle a candidate. */ + Negotiator.prototype.handleCandidate = function (ice) { + return __awaiter(this, void 0, void 0, function () { + var candidate, sdpMLineIndex, sdpMid, peerConnection, provider, err_5; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + logger_1.default.log("handleCandidate:", ice); + candidate = ice.candidate; + sdpMLineIndex = ice.sdpMLineIndex; + sdpMid = ice.sdpMid; + peerConnection = this.connection.peerConnection; + provider = this.connection.provider; + _a.label = 1; + case 1: + _a.trys.push([1, 3, , 4]); + return [4 /*yield*/, peerConnection.addIceCandidate(new RTCIceCandidate({ + sdpMid: sdpMid, + sdpMLineIndex: sdpMLineIndex, + candidate: candidate + }))]; + case 2: + _a.sent(); + logger_1.default.log("Added ICE candidate for:" + this.connection.peer); + return [3 /*break*/, 4]; + case 3: + err_5 = _a.sent(); + provider.emitError(enums_1.PeerErrorType.WebRTC, err_5); + logger_1.default.log("Failed to handleCandidate, ", err_5); + return [3 /*break*/, 4]; + case 4: return [2 /*return*/]; + } + }); + }); + }; + Negotiator.prototype._addTracksToConnection = function (stream, peerConnection) { + logger_1.default.log("add tracks from stream " + stream.id + " to peer connection"); + if (!peerConnection.addTrack) { + return logger_1.default.error("Your browser does't support RTCPeerConnection#addTrack. Ignored."); + } + stream.getTracks().forEach(function (track) { + peerConnection.addTrack(track, stream); + }); + }; + Negotiator.prototype._addStreamToMediaConnection = function (stream, mediaConnection) { + logger_1.default.log("add stream " + stream.id + " to media connection " + mediaConnection.connectionId); + mediaConnection.addStream(stream); + }; + return Negotiator; +}()); +exports.Negotiator = Negotiator; diff --git a/node_modules/peerjs/dist/peer.js b/node_modules/peerjs/dist/peer.js new file mode 100644 index 0000000..8928729 --- /dev/null +++ b/node_modules/peerjs/dist/peer.js @@ -0,0 +1,519 @@ +"use strict"; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Peer = void 0; +var eventemitter3_1 = require("eventemitter3"); +var util_1 = require("./util"); +var logger_1 = __importDefault(require("./logger")); +var socket_1 = require("./socket"); +var mediaconnection_1 = require("./mediaconnection"); +var dataconnection_1 = require("./dataconnection"); +var enums_1 = require("./enums"); +var api_1 = require("./api"); +var PeerOptions = /** @class */ (function () { + function PeerOptions() { + } + return PeerOptions; +}()); +/** + * A peer who can initiate connections with other peers. + */ +var Peer = /** @class */ (function (_super) { + __extends(Peer, _super); + function Peer(id, options) { + var _this = _super.call(this) || this; + _this._id = null; + _this._lastServerId = null; + // States. + _this._destroyed = false; // Connections have been killed + _this._disconnected = false; // Connection to PeerServer killed but P2P connections still active + _this._open = false; // Sockets and such are not yet open. + _this._connections = new Map(); // All connections for this peer. + _this._lostMessages = new Map(); // src => [list of messages] + var userId; + // Deal with overloading + if (id && id.constructor == Object) { + options = id; + } + else if (id) { + userId = id.toString(); + } + // Configurize options + options = __assign({ debug: 0, host: util_1.util.CLOUD_HOST, port: util_1.util.CLOUD_PORT, path: "/", key: Peer.DEFAULT_KEY, token: util_1.util.randomToken(), config: util_1.util.defaultConfig }, options); + _this._options = options; + // Detect relative URL host. + if (_this._options.host === "/") { + _this._options.host = window.location.hostname; + } + // Set path correctly. + if (_this._options.path) { + if (_this._options.path[0] !== "/") { + _this._options.path = "/" + _this._options.path; + } + if (_this._options.path[_this._options.path.length - 1] !== "/") { + _this._options.path += "/"; + } + } + // Set whether we use SSL to same as current host + if (_this._options.secure === undefined && _this._options.host !== util_1.util.CLOUD_HOST) { + _this._options.secure = util_1.util.isSecure(); + } + else if (_this._options.host == util_1.util.CLOUD_HOST) { + _this._options.secure = true; + } + // Set a custom log function if present + if (_this._options.logFunction) { + logger_1.default.setLogFunction(_this._options.logFunction); + } + logger_1.default.logLevel = _this._options.debug || 0; + _this._api = new api_1.API(options); + _this._socket = _this._createServerConnection(); + // Sanity checks + // Ensure WebRTC supported + if (!util_1.util.supports.audioVideo && !util_1.util.supports.data) { + _this._delayedAbort(enums_1.PeerErrorType.BrowserIncompatible, "The current browser does not support WebRTC"); + return _this; + } + // Ensure alphanumeric id + if (!!userId && !util_1.util.validateId(userId)) { + _this._delayedAbort(enums_1.PeerErrorType.InvalidID, "ID \"" + userId + "\" is invalid"); + return _this; + } + if (userId) { + _this._initialize(userId); + } + else { + _this._api.retrieveId() + .then(function (id) { return _this._initialize(id); }) + .catch(function (error) { return _this._abort(enums_1.PeerErrorType.ServerError, error); }); + } + return _this; + } + Object.defineProperty(Peer.prototype, "id", { + get: function () { + return this._id; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(Peer.prototype, "options", { + get: function () { + return this._options; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(Peer.prototype, "open", { + get: function () { + return this._open; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(Peer.prototype, "socket", { + get: function () { + return this._socket; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(Peer.prototype, "connections", { + /** + * @deprecated + * Return type will change from Object to Map + */ + get: function () { + var plainConnections = Object.create(null); + // @ts-ignore + for (var _i = 0, _a = this._connections; _i < _a.length; _i++) { + var _b = _a[_i], k = _b[0], v = _b[1]; + plainConnections[k] = v; + } + return plainConnections; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(Peer.prototype, "destroyed", { + get: function () { + return this._destroyed; + }, + enumerable: false, + configurable: true + }); + Object.defineProperty(Peer.prototype, "disconnected", { + get: function () { + return this._disconnected; + }, + enumerable: false, + configurable: true + }); + Peer.prototype._createServerConnection = function () { + var _this = this; + var socket = new socket_1.Socket(this._options.secure, this._options.host, this._options.port, this._options.path, this._options.key, this._options.pingInterval); + socket.on(enums_1.SocketEventType.Message, function (data) { + _this._handleMessage(data); + }); + socket.on(enums_1.SocketEventType.Error, function (error) { + _this._abort(enums_1.PeerErrorType.SocketError, error); + }); + socket.on(enums_1.SocketEventType.Disconnected, function () { + if (_this.disconnected) { + return; + } + _this.emitError(enums_1.PeerErrorType.Network, "Lost connection to server."); + _this.disconnect(); + }); + socket.on(enums_1.SocketEventType.Close, function () { + if (_this.disconnected) { + return; + } + _this._abort(enums_1.PeerErrorType.SocketClosed, "Underlying socket is already closed."); + }); + return socket; + }; + /** Initialize a connection with the server. */ + Peer.prototype._initialize = function (id) { + this._id = id; + this.socket.start(id, this._options.token); + }; + /** Handles messages from the server. */ + Peer.prototype._handleMessage = function (message) { + var type = message.type; + var payload = message.payload; + var peerId = message.src; + switch (type) { + case enums_1.ServerMessageType.Open: // The connection to the server is open. + this._lastServerId = this.id; + this._open = true; + this.emit(enums_1.PeerEventType.Open, this.id); + break; + case enums_1.ServerMessageType.Error: // Server error. + this._abort(enums_1.PeerErrorType.ServerError, payload.msg); + break; + case enums_1.ServerMessageType.IdTaken: // The selected ID is taken. + this._abort(enums_1.PeerErrorType.UnavailableID, "ID \"" + this.id + "\" is taken"); + break; + case enums_1.ServerMessageType.InvalidKey: // The given API key cannot be found. + this._abort(enums_1.PeerErrorType.InvalidKey, "API KEY \"" + this._options.key + "\" is invalid"); + break; + case enums_1.ServerMessageType.Leave: // Another peer has closed its connection to this peer. + logger_1.default.log("Received leave message from " + peerId); + this._cleanupPeer(peerId); + this._connections.delete(peerId); + break; + case enums_1.ServerMessageType.Expire: // The offer sent to a peer has expired without response. + this.emitError(enums_1.PeerErrorType.PeerUnavailable, "Could not connect to peer " + peerId); + break; + case enums_1.ServerMessageType.Offer: { + // we should consider switching this to CALL/CONNECT, but this is the least breaking option. + var connectionId = payload.connectionId; + var connection = this.getConnection(peerId, connectionId); + if (connection) { + connection.close(); + logger_1.default.warn("Offer received for existing Connection ID:" + connectionId); + } + // Create a new connection. + if (payload.type === enums_1.ConnectionType.Media) { + connection = new mediaconnection_1.MediaConnection(peerId, this, { + connectionId: connectionId, + _payload: payload, + metadata: payload.metadata + }); + this._addConnection(peerId, connection); + this.emit(enums_1.PeerEventType.Call, connection); + } + else if (payload.type === enums_1.ConnectionType.Data) { + connection = new dataconnection_1.DataConnection(peerId, this, { + connectionId: connectionId, + _payload: payload, + metadata: payload.metadata, + label: payload.label, + serialization: payload.serialization, + reliable: payload.reliable + }); + this._addConnection(peerId, connection); + this.emit(enums_1.PeerEventType.Connection, connection); + } + else { + logger_1.default.warn("Received malformed connection type:" + payload.type); + return; + } + // Find messages. + var messages = this._getMessages(connectionId); + for (var _i = 0, messages_1 = messages; _i < messages_1.length; _i++) { + var message_1 = messages_1[_i]; + connection.handleMessage(message_1); + } + break; + } + default: { + if (!payload) { + logger_1.default.warn("You received a malformed message from " + peerId + " of type " + type); + return; + } + var connectionId = payload.connectionId; + var connection = this.getConnection(peerId, connectionId); + if (connection && connection.peerConnection) { + // Pass it on. + connection.handleMessage(message); + } + else if (connectionId) { + // Store for possible later use + this._storeMessage(connectionId, message); + } + else { + logger_1.default.warn("You received an unrecognized message:", message); + } + break; + } + } + }; + /** Stores messages without a set up connection, to be claimed later. */ + Peer.prototype._storeMessage = function (connectionId, message) { + if (!this._lostMessages.has(connectionId)) { + this._lostMessages.set(connectionId, []); + } + // @ts-ignore + this._lostMessages.get(connectionId).push(message); + }; + /** Retrieve messages from lost message store */ + //TODO Change it to private + Peer.prototype._getMessages = function (connectionId) { + var messages = this._lostMessages.get(connectionId); + if (messages) { + this._lostMessages.delete(connectionId); + return messages; + } + return []; + }; + /** + * Returns a DataConnection to the specified peer. See documentation for a + * complete list of options. + */ + Peer.prototype.connect = function (peer, options) { + if (options === void 0) { options = {}; } + if (this.disconnected) { + logger_1.default.warn("You cannot connect to a new Peer because you called " + + ".disconnect() on this Peer and ended your connection with the " + + "server. You can create a new Peer to reconnect, or call reconnect " + + "on this peer if you believe its ID to still be available."); + this.emitError(enums_1.PeerErrorType.Disconnected, "Cannot connect to new Peer after disconnecting from server."); + // @ts-ignore + return; + } + var dataConnection = new dataconnection_1.DataConnection(peer, this, options); + this._addConnection(peer, dataConnection); + return dataConnection; + }; + /** + * Returns a MediaConnection to the specified peer. See documentation for a + * complete list of options. + */ + Peer.prototype.call = function (peer, stream, options) { + if (options === void 0) { options = {}; } + if (this.disconnected) { + logger_1.default.warn("You cannot connect to a new Peer because you called " + + ".disconnect() on this Peer and ended your connection with the " + + "server. You can create a new Peer to reconnect."); + this.emitError(enums_1.PeerErrorType.Disconnected, "Cannot connect to new Peer after disconnecting from server."); + // @ts-ignore + return; + } + if (!stream) { + logger_1.default.error("To call a peer, you must provide a stream from your browser's `getUserMedia`."); + // @ts-ignore + return; + } + options._stream = stream; + var mediaConnection = new mediaconnection_1.MediaConnection(peer, this, options); + this._addConnection(peer, mediaConnection); + return mediaConnection; + }; + /** Add a data/media connection to this peer. */ + Peer.prototype._addConnection = function (peerId, connection) { + logger_1.default.log("add connection " + connection.type + ":" + connection.connectionId + " to peerId:" + peerId); + if (!this._connections.has(peerId)) { + this._connections.set(peerId, []); + } + // @ts-ignore + this._connections.get(peerId).push(connection); + }; + //TODO should be private + Peer.prototype._removeConnection = function (connection) { + var connections = this._connections.get(connection.peer); + if (connections) { + var index = connections.indexOf(connection); + if (index !== -1) { + connections.splice(index, 1); + } + } + //remove from lost messages + this._lostMessages.delete(connection.connectionId); + }; + /** Retrieve a data/media connection for this peer. */ + Peer.prototype.getConnection = function (peerId, connectionId) { + var connections = this._connections.get(peerId); + if (!connections) { + return null; + } + for (var _i = 0, connections_1 = connections; _i < connections_1.length; _i++) { + var connection = connections_1[_i]; + if (connection.connectionId === connectionId) { + return connection; + } + } + return null; + }; + Peer.prototype._delayedAbort = function (type, message) { + var _this = this; + setTimeout(function () { + _this._abort(type, message); + }, 0); + }; + /** + * Emits an error message and destroys the Peer. + * The Peer is not destroyed if it's in a disconnected state, in which case + * it retains its disconnected state and its existing connections. + */ + Peer.prototype._abort = function (type, message) { + logger_1.default.error("Aborting!"); + this.emitError(type, message); + if (!this._lastServerId) { + this.destroy(); + } + else { + this.disconnect(); + } + }; + /** Emits a typed error message. */ + Peer.prototype.emitError = function (type, err) { + logger_1.default.error("Error:", err); + var error; + if (typeof err === "string") { + error = new Error(err); + } + else { + error = err; + } + error.type = type; + this.emit(enums_1.PeerEventType.Error, error); + }; + /** + * Destroys the Peer: closes all active connections as well as the connection + * to the server. + * Warning: The peer can no longer create or accept connections after being + * destroyed. + */ + Peer.prototype.destroy = function () { + if (this.destroyed) { + return; + } + logger_1.default.log("Destroy peer with ID:" + this.id); + this.disconnect(); + this._cleanup(); + this._destroyed = true; + this.emit(enums_1.PeerEventType.Close); + }; + /** Disconnects every connection on this peer. */ + Peer.prototype._cleanup = function () { + // @ts-ignore + for (var _i = 0, _a = this._connections.keys(); _i < _a.length; _i++) { + var peerId = _a[_i]; + this._cleanupPeer(peerId); + this._connections.delete(peerId); + } + this.socket.removeAllListeners(); + }; + /** Closes all connections to this peer. */ + Peer.prototype._cleanupPeer = function (peerId) { + var connections = this._connections.get(peerId); + if (!connections) + return; + for (var _i = 0, connections_2 = connections; _i < connections_2.length; _i++) { + var connection = connections_2[_i]; + connection.close(); + } + }; + /** + * Disconnects the Peer's connection to the PeerServer. Does not close any + * active connections. + * Warning: The peer can no longer create or accept connections after being + * disconnected. It also cannot reconnect to the server. + */ + Peer.prototype.disconnect = function () { + if (this.disconnected) { + return; + } + var currentId = this.id; + logger_1.default.log("Disconnect peer with ID:" + currentId); + this._disconnected = true; + this._open = false; + this.socket.close(); + this._lastServerId = currentId; + this._id = null; + this.emit(enums_1.PeerEventType.Disconnected, currentId); + }; + /** Attempts to reconnect with the same ID. */ + Peer.prototype.reconnect = function () { + if (this.disconnected && !this.destroyed) { + logger_1.default.log("Attempting reconnection to server with ID " + this._lastServerId); + this._disconnected = false; + this._initialize(this._lastServerId); + } + else if (this.destroyed) { + throw new Error("This peer cannot reconnect to the server. It has already been destroyed."); + } + else if (!this.disconnected && !this.open) { + // Do nothing. We're still connecting the first time. + logger_1.default.error("In a hurry? We're still trying to make the initial connection!"); + } + else { + throw new Error("Peer " + this.id + " cannot reconnect because it is not disconnected from the server!"); + } + }; + /** + * Get a list of available peer IDs. If you're running your own server, you'll + * want to set allow_discovery: true in the PeerServer options. If you're using + * the cloud server, email team@peerjs.com to get the functionality enabled for + * your key. + */ + Peer.prototype.listAllPeers = function (cb) { + var _this = this; + if (cb === void 0) { cb = function (_) { }; } + this._api.listAllPeers() + .then(function (peers) { return cb(peers); }) + .catch(function (error) { return _this._abort(enums_1.PeerErrorType.ServerError, error); }); + }; + Peer.DEFAULT_KEY = "peerjs"; + return Peer; +}(eventemitter3_1.EventEmitter)); +exports.Peer = Peer; diff --git a/node_modules/peerjs/dist/peerjs.js b/node_modules/peerjs/dist/peerjs.js deleted file mode 100644 index b902845..0000000 --- a/node_modules/peerjs/dist/peerjs.js +++ /dev/null @@ -1,10318 +0,0 @@ -// modules are defined as an array -// [ module function, map of requires ] -// -// map of requires is short require name -> numeric require -// -// anything defined in a previous bundle is accessed via the -// orig method which is the require for previous bundles -parcelRequire = (function (modules, cache, entry, globalName) { - // Save the require from previous bundle to this closure if any - var previousRequire = typeof parcelRequire === 'function' && parcelRequire; - var nodeRequire = typeof require === 'function' && require; - - function newRequire(name, jumped) { - if (!cache[name]) { - if (!modules[name]) { - // if we cannot find the module within our internal map or - // cache jump to the current global require ie. the last bundle - // that was added to the page. - var currentRequire = typeof parcelRequire === 'function' && parcelRequire; - if (!jumped && currentRequire) { - return currentRequire(name, true); - } - - // If there are other bundles on this page the require from the - // previous one is saved to 'previousRequire'. Repeat this as - // many times as there are bundles until the module is found or - // we exhaust the require chain. - if (previousRequire) { - return previousRequire(name, true); - } - - // Try the node require function if it exists. - if (nodeRequire && typeof name === 'string') { - return nodeRequire(name); - } - - var err = new Error('Cannot find module \'' + name + '\''); - err.code = 'MODULE_NOT_FOUND'; - throw err; - } - - localRequire.resolve = resolve; - localRequire.cache = {}; - - var module = cache[name] = new newRequire.Module(name); - - modules[name][0].call(module.exports, localRequire, module, module.exports, this); - } - - return cache[name].exports; - - function localRequire(x){ - return newRequire(localRequire.resolve(x)); - } - - function resolve(x){ - return modules[name][1][x] || x; - } - } - - function Module(moduleName) { - this.id = moduleName; - this.bundle = newRequire; - this.exports = {}; - } - - newRequire.isParcelRequire = true; - newRequire.Module = Module; - newRequire.modules = modules; - newRequire.cache = cache; - newRequire.parent = previousRequire; - newRequire.register = function (id, exports) { - modules[id] = [function (require, module) { - module.exports = exports; - }, {}]; - }; - - var error; - for (var i = 0; i < entry.length; i++) { - try { - newRequire(entry[i]); - } catch (e) { - // Save first error but execute all entries - if (!error) { - error = e; - } - } - } - - if (entry.length) { - // Expose entry point to Node, AMD or browser globals - // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js - var mainExports = newRequire(entry[entry.length - 1]); - - // CommonJS - if (typeof exports === "object" && typeof module !== "undefined") { - module.exports = mainExports; - - // RequireJS - } else if (typeof define === "function" && define.amd) { - define(function () { - return mainExports; - }); - - //