@woosh/meep-engine 2.106.1 → 2.108.0

package/src/engine/network/DataChannel.js

@@ -1,6 +1,4 @@
-/**
- * Created by Alex on 06/05/2015.
- */
+
 const DataChannel = function (channel, extras) {
     if (channel) this.automatic = true;
     this.channel = channel || location.href.replace(/\/|:|#|%|\.|\[|\]/g, '');
@@ -268,359 +266,361 @@ const DataChannel = function (channel, extras) {
     }
 };
 
-function DataConnector(root, config) {
-    const self = {};
-    const that = this;
-
-    self.userToken = root.userid = root.userid || uniqueToken();
-    self.sockets = [];
-    self.socketObjects = {};
-
-    let channels = '--';
-    let isbroadcaster;
-    let isGetNewRoom = true,
-        RTCDataChannels = [];
-
-    function newPrivateSocket(_config) {
-        const socketConfig = {
-            channel: _config.channel,
-            onmessage: socketResponse,
-            onopen: function () {
-                if (isofferer && !peer) initPeer();
-
-                _config.socketIndex = socket.index = self.sockets.length;
-                self.socketObjects[socketConfig.channel] = socket;
-                self.sockets[_config.socketIndex] = socket;
-            }
-        };
+class DataConnector {
+    constructor(root, config) {
+        const self = {};
+        const that = this;
+
+        self.userToken = root.userid = root.userid || uniqueToken();
+        self.sockets = [];
+        self.socketObjects = {};
+
+        let channels = '--';
+        let isbroadcaster;
+        let isGetNewRoom = true,
+            RTCDataChannels = [];
+
+        function newPrivateSocket(_config) {
+            const socketConfig = {
+                channel: _config.channel,
+                onmessage: socketResponse,
+                onopen: function () {
+                    if (isofferer && !peer) initPeer();
+
+                    _config.socketIndex = socket.index = self.sockets.length;
+                    self.socketObjects[socketConfig.channel] = socket;
+                    self.sockets[_config.socketIndex] = socket;
+                }
+            };
 
-        socketConfig.callback = function (_socket) {
-            socket = _socket;
-            socketConfig.onopen();
-        };
+            socketConfig.callback = function (_socket) {
+                socket = _socket;
+                socketConfig.onopen();
+            };
 
-        let socket = root.openSignalingChannel(socketConfig),
-            isofferer = _config.isofferer;
-        let gotstream;
-        const inner = {};
-        let peer;
+            let socket = root.openSignalingChannel(socketConfig),
+                isofferer = _config.isofferer;
+            let gotstream;
+            const inner = {};
+            let peer;
+
+            const peerConfig = {
+                onICE: function (candidate) {
+                    socket && socket.send({
+                        userToken: self.userToken,
+                        candidate: {
+                            sdpMLineIndex: candidate.sdpMLineIndex,
+                            candidate: JSON.stringify(candidate.candidate)
+                        }
+                    });
+                },
+                onopen: onChannelOpened,
+                onmessage: function (event) {
+                    config.onmessage(event.data, _config.userid);
+                },
+                onclose: config.onclose,
+                onerror: root.onerror,
+                preferSCTP: root.preferSCTP
+            };
 
-        const peerConfig = {
-            onICE: function (candidate) {
-                socket && socket.send({
-                    userToken: self.userToken,
-                    candidate: {
-                        sdpMLineIndex: candidate.sdpMLineIndex,
-                        candidate: JSON.stringify(candidate.candidate)
-                    }
-                });
-            },
-            onopen: onChannelOpened,
-            onmessage: function (event) {
-                config.onmessage(event.data, _config.userid);
-            },
-            onclose: config.onclose,
-            onerror: root.onerror,
-            preferSCTP: root.preferSCTP
-        };
+            function initPeer(offerSDP) {
+                if (root.direction === 'one-to-one' && window.isFirstConnectionOpened) return;
 
-        function initPeer(offerSDP) {
-            if (root.direction === 'one-to-one' && window.isFirstConnectionOpened) return;
+                if (!offerSDP) peerConfig.onOfferSDP = sendsdp;
+                else {
+                    peerConfig.offerSDP = offerSDP;
+                    peerConfig.onAnswerSDP = sendsdp;
+                }
 
-            if (!offerSDP) peerConfig.onOfferSDP = sendsdp;
-            else {
-                peerConfig.offerSDP = offerSDP;
-                peerConfig.onAnswerSDP = sendsdp;
+                peer = RTCPeerConnection(peerConfig);
             }
 
-            peer = RTCPeerConnection(peerConfig);
-        }
+            function onChannelOpened(channel) {
+                channel.peer = peer.peer;
+                RTCDataChannels.push(channel);
 
-        function onChannelOpened(channel) {
-            channel.peer = peer.peer;
-            RTCDataChannels.push(channel);
+                config.onopen(_config.userid, channel);
 
-            config.onopen(_config.userid, channel);
+                if (root.direction === 'many-to-many' && isbroadcaster && channels.split('--').length > 3) {
+                    defaultSocket && defaultSocket.send({
+                        newParticipant: socket.channel,
+                        userToken: self.userToken
+                    });
+                }
 
-            if (root.direction === 'many-to-many' && isbroadcaster && channels.split('--').length > 3) {
-                defaultSocket && defaultSocket.send({
-                    newParticipant: socket.channel,
-                    userToken: self.userToken
-                });
+                window.isFirstConnectionOpened = gotstream = true;
             }
 
-            window.isFirstConnectionOpened = gotstream = true;
-        }
+            function sendsdp(sdp) {
+                sdp = JSON.stringify(sdp);
+                const part = parseInt(sdp.length / 3);
 
-        function sendsdp(sdp) {
-            sdp = JSON.stringify(sdp);
-            const part = parseInt(sdp.length / 3);
+                const firstPart = sdp.slice(0, part);
+                let secondPart = sdp.slice(part, sdp.length - 1),
+                    thirdPart = '';
 
-            const firstPart = sdp.slice(0, part);
-            let secondPart = sdp.slice(part, sdp.length - 1),
-                thirdPart = '';
+                if (sdp.length > part + part) {
+                    secondPart = sdp.slice(part, part + part);
+                    thirdPart = sdp.slice(part + part, sdp.length);
+                }
 
-            if (sdp.length > part + part) {
-                secondPart = sdp.slice(part, part + part);
-                thirdPart = sdp.slice(part + part, sdp.length);
-            }
+                socket.send({
+                    userToken: self.userToken,
+                    firstPart: firstPart
+                });
 
-            socket.send({
-                userToken: self.userToken,
-                firstPart: firstPart
-            });
+                socket.send({
+                    userToken: self.userToken,
+                    secondPart: secondPart
+                });
 
-            socket.send({
-                userToken: self.userToken,
-                secondPart: secondPart
-            });
+                socket.send({
+                    userToken: self.userToken,
+                    thirdPart: thirdPart
+                });
+            }
 
-            socket.send({
-                userToken: self.userToken,
-                thirdPart: thirdPart
-            });
-        }
+            function socketResponse(response) {
+                if (response.userToken == self.userToken) return;
 
-        function socketResponse(response) {
-            if (response.userToken == self.userToken) return;
+                if (response.firstPart || response.secondPart || response.thirdPart) {
+                    if (response.firstPart) {
+                        // sdp sender's user id passed over "onopen" method
+                        _config.userid = response.userToken;
 
-            if (response.firstPart || response.secondPart || response.thirdPart) {
-                if (response.firstPart) {
-                    // sdp sender's user id passed over "onopen" method
-                    _config.userid = response.userToken;
+                        inner.firstPart = response.firstPart;
+                        if (inner.secondPart && inner.thirdPart) selfInvoker();
+                    }
+                    if (response.secondPart) {
+                        inner.secondPart = response.secondPart;
+                        if (inner.firstPart && inner.thirdPart) selfInvoker();
+                    }
 
-                    inner.firstPart = response.firstPart;
-                    if (inner.secondPart && inner.thirdPart) selfInvoker();
-                }
-                if (response.secondPart) {
-                    inner.secondPart = response.secondPart;
-                    if (inner.firstPart && inner.thirdPart) selfInvoker();
+                    if (response.thirdPart) {
+                        inner.thirdPart = response.thirdPart;
+                        if (inner.firstPart && inner.secondPart) selfInvoker();
+                    }
                 }
 
-                if (response.thirdPart) {
-                    inner.thirdPart = response.thirdPart;
-                    if (inner.firstPart && inner.secondPart) selfInvoker();
-                }
-            }
+                if (response.candidate && !gotstream) {
+                    peer && peer.addICE({
+                        sdpMLineIndex: response.candidate.sdpMLineIndex,
+                        candidate: JSON.parse(response.candidate.candidate)
+                    });
 
-            if (response.candidate && !gotstream) {
-                peer && peer.addICE({
-                    sdpMLineIndex: response.candidate.sdpMLineIndex,
-                    candidate: JSON.parse(response.candidate.candidate)
-                });
+                    console.debug('ice candidate', response.candidate.candidate);
+                }
 
-                console.debug('ice candidate', response.candidate.candidate);
-            }
+                if (response.left) {
+                    if (peer && peer.peer) {
+                        peer.peer.close();
+                        peer.peer = null;
+                    }
 
-            if (response.left) {
-                if (peer && peer.peer) {
-                    peer.peer.close();
-                    peer.peer = null;
-                }
+                    if (response.closeEntireSession) leaveChannels();
+                    else if (socket) {
+                        socket.send({
+                            left: true,
+                            userToken: self.userToken
+                        });
+                        socket = null;
+                    }
 
-                if (response.closeEntireSession) leaveChannels();
-                else if (socket) {
-                    socket.send({
-                        left: true,
-                        userToken: self.userToken
-                    });
-                    socket = null;
+                    root.onleave(response.userToken);
                 }
 
-                root.onleave(response.userToken);
+                if (response.playRoleOfBroadcaster)
+                    setTimeout(function () {
+                        self.roomToken = response.roomToken;
+                        root.open(self.roomToken);
+                        self.sockets = swap(self.sockets);
+                    }, 600);
             }
 
-            if (response.playRoleOfBroadcaster)
-                setTimeout(function () {
-                    self.roomToken = response.roomToken;
-                    root.open(self.roomToken);
-                    self.sockets = swap(self.sockets);
-                }, 600);
-        }
+            let invokedOnce = false;
 
-        let invokedOnce = false;
+            function selfInvoker() {
+                if (invokedOnce) return;
 
-        function selfInvoker() {
-            if (invokedOnce) return;
+                invokedOnce = true;
+                inner.sdp = JSON.parse(inner.firstPart + inner.secondPart + inner.thirdPart);
 
-            invokedOnce = true;
-            inner.sdp = JSON.parse(inner.firstPart + inner.secondPart + inner.thirdPart);
+                if (isofferer) peer.addAnswerSDP(inner.sdp);
+                else initPeer(inner.sdp);
 
-            if (isofferer) peer.addAnswerSDP(inner.sdp);
-            else initPeer(inner.sdp);
-
-            console.debug('sdp', inner.sdp.sdp);
+                console.debug('sdp', inner.sdp.sdp);
+            }
         }
-    }
 
-    function onNewParticipant(channel) {
-        if (!channel || channels.indexOf(channel) != -1 || channel == self.userToken) return;
-        channels += channel + '--';
+        function onNewParticipant(channel) {
+            if (!channel || channels.indexOf(channel) != -1 || channel == self.userToken) return;
+            channels += channel + '--';
 
-        const new_channel = uniqueToken();
+            const new_channel = uniqueToken();
 
-        newPrivateSocket({
-            channel: new_channel,
-            closeSocket: true
-        });
+            newPrivateSocket({
+                channel: new_channel,
+                closeSocket: true
+            });
 
-        defaultSocket && defaultSocket.send({
-            participant: true,
-            userToken: self.userToken,
-            joinUser: channel,
-            channel: new_channel
-        });
-    }
+            defaultSocket && defaultSocket.send({
+                participant: true,
+                userToken: self.userToken,
+                joinUser: channel,
+                channel: new_channel
+            });
+        }
 
-    function uniqueToken() {
-        return Math.round(Math.random() * 60535) + 5000000;
-    }
+        function uniqueToken() {
+            return Math.round(Math.random() * 60535) + 5000000;
+        }
 
-    function leaveChannels(channel) {
-        const alert = {
-            left: true,
-            userToken: self.userToken
-        };
+        function leaveChannels(channel) {
+            const alert = {
+                left: true,
+                userToken: self.userToken
+            };
 
-        // if room initiator is leaving the room; close the entire session
-        if (isbroadcaster) {
-            if (root.autoCloseEntireSession) alert.closeEntireSession = true;
-            else
-                self.sockets[0].send({
-                    playRoleOfBroadcaster: true,
-                    userToken: self.userToken,
-                    roomToken: self.roomToken
-                });
-        }
+            // if room initiator is leaving the room; close the entire session
+            if (isbroadcaster) {
+                if (root.autoCloseEntireSession) alert.closeEntireSession = true;
+                else
+                    self.sockets[0].send({
+                        playRoleOfBroadcaster: true,
+                        userToken: self.userToken,
+                        roomToken: self.roomToken
+                    });
+            }
 
-        if (!channel) {
-            // closing all sockets
-            const sockets = self.sockets,
-                length = sockets.length;
+            if (!channel) {
+                // closing all sockets
+                const sockets = self.sockets,
+                    length = sockets.length;
 
-            for (let i = 0; i < length; i++) {
-                const socket = sockets[i];
-                if (socket) {
-                    socket.send(alert);
+                for (let i = 0; i < length; i++) {
+                    const socket = sockets[i];
+                    if (socket) {
+                        socket.send(alert);
 
-                    if (self.socketObjects[socket.channel])
-                        delete self.socketObjects[socket.channel];
+                        if (self.socketObjects[socket.channel])
+                            delete self.socketObjects[socket.channel];
 
-                    delete sockets[i];
+                        delete sockets[i];
+                    }
                 }
-            }
 
-            that.left = true;
-        }
+                that.left = true;
+            }
 
-        // eject a specific user!
-        if (channel) {
-            socket = self.socketObjects[channel];
-            if (socket) {
-                socket.send(alert);
+            // eject a specific user!
+            if (channel) {
+                socket = self.socketObjects[channel];
+                if (socket) {
+                    socket.send(alert);
 
-                if (self.sockets[socket.index])
-                    delete self.sockets[socket.index];
+                    if (self.sockets[socket.index])
+                        delete self.sockets[socket.index];
 
-                delete self.socketObjects[channel];
+                    delete self.socketObjects[channel];
+                }
             }
+            self.sockets = swap(self.sockets);
         }
-        self.sockets = swap(self.sockets);
-    }
 
-    window.addEventListener('beforeunload', function () {
-        leaveChannels();
-    }, false);
-
-    window.addEventListener('keydown', function (e) {
-        if (e.keyCode == 116)
+        window.addEventListener('beforeunload', function () {
             leaveChannels();
-    }, false);
+        }, false);
 
-    let defaultSocket = root.openSignalingChannel({
-        onmessage: function (response) {
-            if (response.userToken == self.userToken) return;
-            if (isGetNewRoom && response.roomToken && response.broadcaster) config.ondatachannel(response);
+        window.addEventListener('keydown', function (e) {
+            if (e.keyCode == 116)
+                leaveChannels();
+        }, false);
 
-            if (response.newParticipant) onNewParticipant(response.newParticipant);
+        let defaultSocket = root.openSignalingChannel({
+            onmessage: function (response) {
+                if (response.userToken == self.userToken) return;
+                if (isGetNewRoom && response.roomToken && response.broadcaster) config.ondatachannel(response);
 
-            if (response.userToken && response.joinUser == self.userToken && response.participant && channels.indexOf(response.userToken) == -1) {
-                channels += response.userToken + '--';
+                if (response.newParticipant) onNewParticipant(response.newParticipant);
 
-                console.debug('Data connection is being opened between you and', response.userToken || response.channel);
-                newPrivateSocket({
-                    isofferer: true,
-                    channel: response.channel || response.userToken,
-                    closeSocket: true
-                });
+                if (response.userToken && response.joinUser == self.userToken && response.participant && channels.indexOf(response.userToken) == -1) {
+                    channels += response.userToken + '--';
+
+                    console.debug('Data connection is being opened between you and', response.userToken || response.channel);
+                    newPrivateSocket({
+                        isofferer: true,
+                        channel: response.channel || response.userToken,
+                        closeSocket: true
+                    });
+                }
+            },
+            callback: function (socket) {
+                defaultSocket = socket;
             }
-        },
-        callback: function (socket) {
-            defaultSocket = socket;
-        }
-    });
+        });
 
-    return {
-        createRoom: function (roomToken) {
-            self.roomToken = roomToken || uniqueToken();
+        return {
+            createRoom: function (roomToken) {
+                self.roomToken = roomToken || uniqueToken();
 
-            isbroadcaster = true;
-            isGetNewRoom = false;
+                isbroadcaster = true;
+                isGetNewRoom = false;
 
-            (function transmit() {
-                defaultSocket && defaultSocket.send({
-                    roomToken: self.roomToken,
-                    broadcaster: self.userToken
-                });
+                (function transmit() {
+                    defaultSocket && defaultSocket.send({
+                        roomToken: self.roomToken,
+                        broadcaster: self.userToken
+                    });
 
-                if (!root.transmitRoomOnce && !that.leaving) {
-                    if (root.direction === 'one-to-one') {
-                        if (!window.isFirstConnectionOpened) setTimeout(transmit, 3000);
-                    } else setTimeout(transmit, 3000);
-                }
-            })();
-        },
-        joinRoom: function (_config) {
-            self.roomToken = _config.roomToken;
-            isGetNewRoom = false;
+                    if (!root.transmitRoomOnce && !that.leaving) {
+                        if (root.direction === 'one-to-one') {
+                            if (!window.isFirstConnectionOpened) setTimeout(transmit, 3000);
+                        } else setTimeout(transmit, 3000);
+                    }
+                })();
+            },
+            joinRoom: function (_config) {
+                self.roomToken = _config.roomToken;
+                isGetNewRoom = false;
 
-            newPrivateSocket({
-                channel: self.userToken
-            });
+                newPrivateSocket({
+                    channel: self.userToken
+                });
 
-            defaultSocket.send({
-                participant: true,
-                userToken: self.userToken,
-                joinUser: _config.joinUser
-            });
-        },
-        send: function (message, _channel) {
-            const _channels = RTCDataChannels;
-            let data, length = _channels.length;
-            if (!length) return;
+                defaultSocket.send({
+                    participant: true,
+                    userToken: self.userToken,
+                    joinUser: _config.joinUser
+                });
+            },
+            send: function (message, _channel) {
+                const _channels = RTCDataChannels;
+                let data, length = _channels.length;
+                if (!length) return;
 
-            data = JSON.stringify(message);
+                data = JSON.stringify(message);
 
-            if (_channel) {
-                if (_channel.readyState == 'open') {
-                    _channel.send(data);
-                }
-            } else
-                for (let i = 0; i < length; i++) {
-                    if (_channels[i].readyState == 'open') {
-                        _channels[i].send(data);
+                if (_channel) {
+                    if (_channel.readyState == 'open') {
+                        _channel.send(data);
+                    }
+                } else
+                    for (let i = 0; i < length; i++) {
+                        if (_channels[i].readyState == 'open') {
+                            _channels[i].send(data);
+                        }
                     }
+            },
+            leave: function (userid, autoCloseEntireSession) {
+                if (autoCloseEntireSession) root.autoCloseEntireSession = true;
+                leaveChannels(userid);
+                if (!userid) {
+                    self.joinedARoom = isbroadcaster = false;
+                    isGetNewRoom = true;
                 }
-        },
-        leave: function (userid, autoCloseEntireSession) {
-            if (autoCloseEntireSession) root.autoCloseEntireSession = true;
-            leaveChannels(userid);
-            if (!userid) {
-                self.joinedARoom = isbroadcaster = false;
-                isGetNewRoom = true;
             }
-        }
-    };
+        };
+    }
 }
 
 function SocketConnector(_channel, config) {

package/src/engine/network/xhr.d.ts

@@ -1,6 +1,3 @@
 export default xhr;
-/**
- * Created by Alex on 26/04/2015.
- */
 declare function xhr(path: any, success: any, error: any): void;
 //# sourceMappingURL=xhr.d.ts.map