node-datachannel 0.3.1 → 0.3.4

package/src/peer-connection-wrapper.cpp

@@ -63,7 +63,7 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     // We expect (String, Object, Function) as param
     if (length < 2 || !info[0].IsString() || !info[1].IsObject())
     {
-        Napi::TypeError::New(env, "Peer Name (String) & Configuration (Object) expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(env, "Peer Name (String) and Configuration (Object) expected").ThrowAsJavaScriptException();
         return;
     }
 
@@ -182,7 +182,11 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
 
     // Max Message Size
     if (config.Get("maxMessageSize").IsNumber())
-        rtcConfig.maxMessageSize = config.Get("maxMessageSize").As<Napi::Number>().Uint32Value();
+        rtcConfig.maxMessageSize = config.Get("maxMessageSize").As<Napi::Number>().Int32Value();
+
+    // MTU
+    if (config.Get("mtu").IsNumber())
+        rtcConfig.mtu = config.Get("mtu").As<Napi::Number>().Int32Value();
 
     // ICE transport policy
     if (!config.Get("iceTransportPolicy").IsUndefined())
@@ -211,31 +215,10 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while creating peerConnection# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while creating peer connection: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 
-    mRtcPeerConnPtr->onStateChange([&](rtc::PeerConnection::State state) {
-        if (mOnStateChangeCallback)
-            mOnStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
-                // Check the peer connection is not closed
-                if(instances.find(this) == instances.end())
-                    throw ThreadSafeCallback::CancelException();
-
-                if(mDoCloseFlag && state == rtc::PeerConnection::State::Closed)
-                    cleanCbsAndEraseInstance();
-
-                // This will run in main thread and needs to construct the
-                // arguments for the call
-                std::ostringstream stream;
-                stream << state;
-                args = {Napi::String::New(env, stream.str())};
-            });
-        else {
-            if(mDoCloseFlag && state == rtc::PeerConnection::State::Closed)
-                cleanCbsAndEraseInstance();
-         } });
-
     instances.insert(this);
 }
 
@@ -246,26 +229,20 @@ PeerConnectionWrapper::~PeerConnectionWrapper()
 
 void PeerConnectionWrapper::doClose()
 {
-    if (mRtcPeerConnPtr && !mDoCloseFlag)
+    if (mRtcPeerConnPtr)
     {
         try
         {
-            mDoCloseFlag = true;
             mRtcPeerConnPtr->close();
-
-            // Resetting in cleanCbsAndEraseInstance causes a deadlock
             mRtcPeerConnPtr.reset();
         }
         catch (std::exception &ex)
         {
-            std::cout << std::string("libdatachannel error while closing peerConnection# ") + ex.what() << std::endl;
+            std::cerr << std::string("libdatachannel error while closing peer connection: ") + ex.what() << std::endl;
             return;
         }
     }
-}
 
-void PeerConnectionWrapper::cleanCbsAndEraseInstance()
-{
     mOnLocalDescriptionCallback.reset();
     mOnLocalCandidateCallback.reset();
     mOnStateChangeCallback.reset();
@@ -274,8 +251,6 @@ void PeerConnectionWrapper::cleanCbsAndEraseInstance()
     mOnTrackCallback.reset();
 
     instances.erase(this);
-
-    mDoCloseFlag = false;
 }
 
 void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
@@ -286,14 +261,14 @@ void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
 void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    int length = info.Length();
+
     if (!mRtcPeerConnPtr)
     {
-        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        Napi::Error::New(env, "setLocalDescription() called on destroyed peer connection").ThrowAsJavaScriptException();
         return;
     }
 
-    int length = info.Length();
-
     rtc::Description::Type type = rtc::Description::Type::Unspec;
 
     // optional
@@ -322,13 +297,14 @@ void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
 void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    int length = info.Length();
+
     if (!mRtcPeerConnPtr)
     {
-        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        Napi::Error::New(env, "setRemoteDescription() called on destroyed peer connection").ThrowAsJavaScriptException();
         return;
     }
 
-    int length = info.Length();
     if (length < 2 || !info[0].IsString() || !info[1].IsString())
     {
         Napi::TypeError::New(info.Env(), "String,String expected").ThrowAsJavaScriptException();
@@ -345,7 +321,7 @@ void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while adding remote decsription # ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while adding remote description: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 }
@@ -353,7 +329,13 @@ void PeerConnectionWrapper::setRemoteDescription(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::localDescription(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    std::optional<rtc::Description> desc = mRtcPeerConnPtr->localDescription();
+
+    std::optional<rtc::Description> desc = mRtcPeerConnPtr ? mRtcPeerConnPtr->localDescription() : std::nullopt;
+
+    // Return JS null if no description
+    if (!desc.has_value()) {
+        return env.Null();
+    }
 
     Napi::Object obj = Napi::Object::New(env);
     obj.Set("type", desc->typeString());
@@ -364,16 +346,17 @@ Napi::Value PeerConnectionWrapper::localDescription(const Napi::CallbackInfo &in
 void PeerConnectionWrapper::addRemoteCandidate(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+    int length = info.Length();
+
     if (!mRtcPeerConnPtr)
     {
-        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        Napi::Error::New(env, "addRemoteCandidate() called on destroyed peer connection").ThrowAsJavaScriptException();
         return;
     }
 
-    int length = info.Length();
     if (length < 2 || !info[0].IsString() || !info[1].IsString())
     {
-        Napi::TypeError::New(info.Env(), "String,String expected").ThrowAsJavaScriptException();
+        Napi::TypeError::New(info.Env(), "String, String expected").ThrowAsJavaScriptException();
         return;
     }
 
@@ -385,22 +368,22 @@ void PeerConnectionWrapper::addRemoteCandidate(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while adding remote candidate# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while adding remote candidate: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 }
 
 Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &info)
 {
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
     if (!mRtcPeerConnPtr)
     {
-        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        Napi::Error::New(env, "createDataChannel() called on destroyed peer connection").ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 
-    Napi::Env env = info.Env();
-    int length = info.Length();
-
     if (length < 1 || !info[0].IsString())
     {
         Napi::TypeError::New(env, "Data Channel Label expected").ThrowAsJavaScriptException();
@@ -554,7 +537,7 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error while creating datachannel# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while creating datachannel: ") + ex.what()).ThrowAsJavaScriptException();
         return info.Env().Null();
     }
 }
@@ -564,6 +547,12 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onLocalDescription() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -573,9 +562,9 @@ void PeerConnectionWrapper::onLocalDescription(const Napi::CallbackInfo &info)
     // Callback
     mOnLocalDescriptionCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onLocalDescription([&](const rtc::Description &sdp) {
+    mRtcPeerConnPtr->onLocalDescription([&](rtc::Description sdp) {
         if (mOnLocalDescriptionCallback)
-            mOnLocalDescriptionCallback->call([this, sdp](Napi::Env env, std::vector<napi_value> &args) {
+            mOnLocalDescriptionCallback->call([this, sdp = std::move(sdp)](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -593,6 +582,12 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onLocalCandidate() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -602,9 +597,9 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
     // Callback
     mOnLocalCandidateCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onLocalCandidate([&](const rtc::Candidate &candidate) {
+    mRtcPeerConnPtr->onLocalCandidate([&](rtc::Candidate cand) {
         if (mOnLocalCandidateCallback)
-            mOnLocalCandidateCallback->call([this, candidate](Napi::Env env, std::vector<napi_value> &args) {
+            mOnLocalCandidateCallback->call([this, cand = std::move(cand)](Napi::Env env, std::vector<napi_value> &args) {
                  // Check the peer connection is not closed
                 if(instances.find(this) == instances.end())
                     throw ThreadSafeCallback::CancelException();
@@ -612,8 +607,8 @@ void PeerConnectionWrapper::onLocalCandidate(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {
-                    Napi::String::New(env, std::string(candidate)),
-                    Napi::String::New(env, candidate.mid())};
+                    Napi::String::New(env, std::string(cand)),
+                    Napi::String::New(env, cand.mid())};
             }); });
 }
 
@@ -622,6 +617,12 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -631,7 +632,19 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
     // Callback
     mOnStateChangeCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    // onState cb will be called from constructor
+    mRtcPeerConnPtr->onStateChange([&](rtc::PeerConnection::State state) {
+        if (mOnStateChangeCallback)
+            mOnStateChangeCallback->call([this, state](Napi::Env env, std::vector<napi_value> &args) {
+                // Check the peer connection is not closed but still allow a call for State::Closed
+                if(state != rtc::PeerConnection::State::Closed && instances.find(this) == instances.end())
+                    throw ThreadSafeCallback::CancelException();
+
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                std::ostringstream stream;
+                stream << state;
+                args = {Napi::String::New(env, stream.str())};
+            }); });
 }
 
 void PeerConnectionWrapper::onSignalingStateChange(const Napi::CallbackInfo &info)
@@ -639,6 +652,12 @@ void PeerConnectionWrapper::onSignalingStateChange(const Napi::CallbackInfo &inf
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onSignalingStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -668,6 +687,12 @@ void PeerConnectionWrapper::onGatheringStateChange(const Napi::CallbackInfo &inf
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onGatheringStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -697,6 +722,12 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onDataChannel() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -725,6 +756,7 @@ void PeerConnectionWrapper::onDataChannel(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -736,7 +768,7 @@ Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
@@ -744,6 +776,7 @@ Napi::Value PeerConnectionWrapper::bytesSent(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::bytesReceived(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -755,7 +788,7 @@ Napi::Value PeerConnectionWrapper::bytesReceived(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
@@ -763,6 +796,7 @@ Napi::Value PeerConnectionWrapper::bytesReceived(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::rtt(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
         return Napi::Number::New(info.Env(), 0);
@@ -774,7 +808,7 @@ Napi::Value PeerConnectionWrapper::rtt(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), -1);
     }
 }
@@ -782,16 +816,17 @@ Napi::Value PeerConnectionWrapper::rtt(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
+
     if (!mRtcPeerConnPtr)
     {
-        return Napi::Number::New(info.Env(), 0);
+        return env.Null();
     }
 
     try
     {
         rtc::Candidate local, remote;
         if (!mRtcPeerConnPtr->getSelectedCandidatePair(&local, &remote))
-            return info.Env().Null();
+            return env.Null();
 
         Napi::Object retvalue = Napi::Object::New(env);
         Napi::Object localObj = Napi::Object::New(env);
@@ -814,7 +849,7 @@ Napi::Value PeerConnectionWrapper::getSelectedCandidatePair(const Napi::Callback
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), -1);
     }
 }
@@ -862,7 +897,7 @@ Napi::Value PeerConnectionWrapper::addTrack(const Napi::CallbackInfo &info)
 
     if (!mRtcPeerConnPtr)
     {
-        Napi::Error::New(info.Env(), "It seems peer-connection is closed").ThrowAsJavaScriptException();
+        Napi::Error::New(env, "addTrack() called on destroyed peer connection").ThrowAsJavaScriptException();
         return env.Null();
     }
 
@@ -896,7 +931,7 @@ Napi::Value PeerConnectionWrapper::addTrack(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return env.Null();
     }
 }
@@ -906,6 +941,12 @@ void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
     Napi::Env env = info.Env();
     int length = info.Length();
 
+    if (!mRtcPeerConnPtr)
+    {
+        Napi::Error::New(env, "onGatheringStateChange() called on destroyed peer connection").ThrowAsJavaScriptException();
+        return;
+    }
+
     if (length < 1 || !info[0].IsFunction())
     {
         Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
@@ -915,8 +956,7 @@ void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
     // Callback
     mOnTrackCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mRtcPeerConnPtr->onTrack([&](std::shared_ptr<rtc::Track> track)
-                             {
+    mRtcPeerConnPtr->onTrack([&](std::shared_ptr<rtc::Track> track) {
         if (mOnTrackCallback)
             mOnTrackCallback->call([this, track](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the peer connection is not closed
@@ -934,14 +974,14 @@ void PeerConnectionWrapper::onTrack(const Napi::CallbackInfo &info)
 Napi::Value PeerConnectionWrapper::hasMedia(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
-    return Napi::Boolean::New(env, mRtcPeerConnPtr->hasMedia());
+    return Napi::Boolean::New(env, mRtcPeerConnPtr ? mRtcPeerConnPtr->hasMedia() : false);
 }
 
 Napi::Value PeerConnectionWrapper::state(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     std::ostringstream stream;
-    stream << mRtcPeerConnPtr->state();
+    stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->state() : rtc::PeerConnection::State::Closed);
     return Napi::String::New(env, stream.str());
 }
 
@@ -949,7 +989,7 @@ Napi::Value PeerConnectionWrapper::signalingState(const Napi::CallbackInfo &info
 {
     Napi::Env env = info.Env();
     std::ostringstream stream;
-    stream << mRtcPeerConnPtr->signalingState();
+    stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->signalingState() : rtc::PeerConnection::SignalingState::Stable);
     return Napi::String::New(env, stream.str());
 }
 
@@ -957,6 +997,6 @@ Napi::Value PeerConnectionWrapper::gatheringState(const Napi::CallbackInfo &info
 {
     Napi::Env env = info.Env();
     std::ostringstream stream;
-    stream << mRtcPeerConnPtr->gatheringState();
+    stream << (mRtcPeerConnPtr ? mRtcPeerConnPtr->gatheringState() : rtc::PeerConnection::GatheringState::Complete);
     return Napi::String::New(env, stream.str());
 }

package/src/peer-connection-wrapper.h

@@ -55,8 +55,6 @@ private:
   static std::unordered_set<PeerConnectionWrapper *> instances;
 
   void doClose();
-  void cleanCbsAndEraseInstance();
-  bool mDoCloseFlag = false;
 
   std::string mPeerName;
   std::unique_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;

package/test/connectivity.js

@@ -1,6 +1,7 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
 const nodeDataChannel = require('../lib/index');
 
-nodeDataChannel.initLogger("Debug");
+nodeDataChannel.initLogger('Debug');
 nodeDataChannel.preload();
 
 let dc1 = null;
@@ -24,51 +25,51 @@ let dc2 = null;
 // TURN Server Example (TCP)    : turn:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT?transport=tcp
 // TURN Server Example (TLS)    : turns:USERNAME:PASSWORD@TURN_IP_OR_ADDRESS:PORT
 
-let peer1 = new nodeDataChannel.PeerConnection("Peer1", { iceServers: ["stun:stun.l.google.com:19302"] });
+let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stun.l.google.com:19302'] });
 
 // Set Callbacks
 peer1.onStateChange((state) => {
-    console.log("Peer1 State:", state);
+    console.log('Peer1 State:', state);
 });
 peer1.onGatheringStateChange((state) => {
-    console.log("Peer1 GatheringState:", state);
+    console.log('Peer1 GatheringState:', state);
 });
 peer1.onLocalDescription((sdp, type) => {
-    console.log("Peer1 SDP:", sdp, " Type:", type);
+    console.log('Peer1 SDP:', sdp, ' Type:', type);
     peer2.setRemoteDescription(sdp, type);
 });
 peer1.onLocalCandidate((candidate, mid) => {
-    console.log("Peer1 Candidate:", candidate);
+    console.log('Peer1 Candidate:', candidate);
     peer2.addRemoteCandidate(candidate, mid);
 });
 
-let peer2 = new nodeDataChannel.PeerConnection("Peer2", { iceServers: ["stun:stun.l.google.com:19302"] });
+let peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stun.l.google.com:19302'] });
 
 // Set Callbacks
 peer2.onStateChange((state) => {
-    console.log("Peer2 State:", state);
+    console.log('Peer2 State:', state);
 });
 peer2.onGatheringStateChange((state) => {
-    console.log("Peer2 GatheringState:", state);
+    console.log('Peer2 GatheringState:', state);
 });
 peer2.onLocalDescription((sdp, type) => {
-    console.log("Peer2 SDP:", sdp, " Type:", type);
+    console.log('Peer2 SDP:', sdp, ' Type:', type);
     peer1.setRemoteDescription(sdp, type);
 });
 peer2.onLocalCandidate((candidate, mid) => {
-    console.log("Peer2 Candidate:", candidate);
+    console.log('Peer2 Candidate:', candidate);
     peer1.addRemoteCandidate(candidate, mid);
 });
 peer2.onDataChannel((dc) => {
-    console.log("Peer2 Got DataChannel: ", dc.getLabel());
+    console.log('Peer2 Got DataChannel: ', dc.getLabel());
     dc2 = dc;
     dc2.onMessage((msg) => {
         console.log('Peer2 Received Msg:', msg);
     });
-    dc2.sendMessage("Hello From Peer2");
+    dc2.sendMessage('Hello From Peer2');
     dc2.onClosed(() => {
         console.log('dc2 closed');
-     });
+    });
 });
 
 // DataChannel Options
@@ -80,16 +81,16 @@ peer2.onDataChannel((dc) => {
 //     maxPacketLifeTime?: number;
 //     maxRetransmits?: number;
 // }
-dc1 = peer1.createDataChannel("test");
+dc1 = peer1.createDataChannel('test');
 dc1.onOpen(() => {
-    dc1.sendMessage("Hello from Peer1");
+    dc1.sendMessage('Hello from Peer1');
     // Binary message: Use sendMessageBinary(Buffer)
 });
 dc1.onMessage((msg) => {
     console.log('Peer1 Received Msg:', msg);
 });
 dc1.onClosed(() => {
-   console.log('dc1 closed');
+    console.log('dc1 closed');
 });
 
 setTimeout(() => {