node-datachannel 0.6.0 → 0.8.0

package/polyfill/index.d.cts

@@ -0,0 +1,37 @@
+import RTCCertificate from './RTCCertificate.js';
+import RTCDataChannel from './RTCDataChannel.js';
+import RTCDtlsTransport from './RTCDtlsTransport.js';
+import RTCIceCandidate from './RTCIceCandidate.js';
+import RTCIceTransport from './RTCIceTransport.js';
+import RTCPeerConnection from './RTCPeerConnection.js';
+import RTCSctpTransport from './RTCSctpTransport.js';
+import RTCSessionDescription from './RTCSessionDescription.js';
+import { RTCDataChannelEvent, RTCPeerConnectionIceEvent } from './Events.js';
+
+export {
+    RTCCertificate,
+    RTCDataChannel,
+    RTCDtlsTransport,
+    RTCIceCandidate,
+    RTCIceTransport,
+    RTCPeerConnection,
+    RTCSctpTransport,
+    RTCSessionDescription,
+    RTCDataChannelEvent,
+    RTCPeerConnectionIceEvent,
+};
+
+declare const _default: {
+    RTCCertificate: typeof RTCCertificate;
+    RTCDataChannel: typeof RTCDataChannel;
+    RTCDtlsTransport: typeof RTCDtlsTransport;
+    RTCIceCandidate: typeof RTCIceCandidate;
+    RTCIceTransport: typeof RTCIceTransport;
+    RTCPeerConnection: typeof RTCPeerConnection;
+    RTCSctpTransport: typeof RTCSctpTransport;
+    RTCSessionDescription: typeof RTCSessionDescription;
+    RTCDataChannelEvent: typeof RTCDataChannelEvent;
+    RTCPeerConnectionIceEvent: typeof RTCPeerConnectionIceEvent;
+};
+
+export default _default;

package/src/data-channel-wrapper.cpp

@@ -13,6 +13,14 @@ void DataChannelWrapper::CloseAll()
         inst->doClose();
 }
 
+void DataChannelWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -78,11 +86,15 @@ void DataChannelWrapper::doClose()
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnBufferedAmountLowCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void DataChannelWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -350,6 +362,8 @@ void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 

package/src/data-channel-wrapper.h

@@ -42,10 +42,14 @@ public:
   // Close all existing DataChannels
   static void CloseAll();
 
+  // Reset all Callbacks for existing DataChannels
+  static void CleanupAll();
+
 private:
-  static std::unordered_set<DataChannelWrapper*> instances;
+  static std::unordered_set<DataChannelWrapper *> instances;
 
   void doClose();
+  void doCleanup();
 
   std::string mLabel;
   std::shared_ptr<rtc::DataChannel> mDataChannelPtr = nullptr;

package/src/media-track-wrapper.cpp

@@ -2,6 +2,8 @@
 #include "media-direction.h"
 #include "media-rtcpreceivingsession-wrapper.h"
 
+#include "plog/Log.h"
+
 Napi::FunctionReference TrackWrapper::constructor;
 std::unordered_set<TrackWrapper *> TrackWrapper::instances;
 
@@ -12,6 +14,14 @@ void TrackWrapper::CloseAll()
         inst->doClose();
 }
 
+void TrackWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -73,10 +83,14 @@ void TrackWrapper::doClose()
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void TrackWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -276,7 +290,8 @@ void TrackWrapper::onOpen(const Napi::CallbackInfo &info)
     // Callback
     mOnOpenCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onOpen([&]() {
+    mTrackPtr->onOpen([&]()
+                      {
         if (mOnOpenCallback)
             mOnOpenCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed
@@ -309,7 +324,8 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
     // Callback
     mOnClosedCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onClosed([&]() {
+    mTrackPtr->onClosed([&]()
+                        {
         if (mOnClosedCallback)
             mOnClosedCallback->call([this](Napi::Env env, std::vector<napi_value> &args) {
                 // Do not check if the data channel has been closed here
@@ -317,6 +333,8 @@ void TrackWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 
@@ -340,7 +358,8 @@ void TrackWrapper::onError(const Napi::CallbackInfo &info)
     // Callback
     mOnErrorCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onError([&](const std::string &error) {
+    mTrackPtr->onError([&](const std::string &error)
+                       {
         if (mOnErrorCallback)
             mOnErrorCallback->call([this, error](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed
@@ -373,7 +392,8 @@ void TrackWrapper::onMessage(const Napi::CallbackInfo &info)
     // Callback
     mOnMessageCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
 
-    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message) {
+    mTrackPtr->onMessage([&](std::variant<rtc::binary, std::string> message)
+                         {
         if (mOnMessageCallback)
             mOnMessageCallback->call([this, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args) {
                 // Check the track is not closed

package/src/media-track-wrapper.h

@@ -39,21 +39,25 @@ public:
   void onError(const Napi::CallbackInfo &info);
   void onMessage(const Napi::CallbackInfo &info);
 
-  // Close all existing track
+  // Close all existing tracks
   static void CloseAll();
 
+  // Reset all Callbacks for existing tracks
+  static void CleanupAll();
+
 private:
   static std::unordered_set<TrackWrapper *> instances;
 
   void doClose();
+  void doCleanup();
 
   std::shared_ptr<rtc::Track> mTrackPtr = nullptr;
 
-    // Callback Ptrs
+  // Callback Ptrs
   std::unique_ptr<ThreadSafeCallback> mOnOpenCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnClosedCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnErrorCallback = nullptr;
   std::unique_ptr<ThreadSafeCallback> mOnMessageCallback = nullptr;
 };
 
-#endif // MEDIA_TRACK_WRAPPER_H
+#endif // MEDIA_TRACK_WRAPPER_H

package/src/peer-connection-wrapper.cpp

@@ -20,12 +20,12 @@ void PeerConnectionWrapper::CloseAll()
         inst->doClose();
 }
 
-void PeerConnectionWrapper::ResetCallbacksAll()
+void PeerConnectionWrapper::CleanupAll()
 {
-    PLOG_DEBUG << "ResetCallbacksAll() called";
+    PLOG_DEBUG << "CleanupAll() called";
     auto copy(instances);
     for (auto inst : copy)
-        inst->doResetCallbacks();
+        inst->doCleanup();
 }
 
 Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
@@ -37,7 +37,6 @@ Napi::Object PeerConnectionWrapper::Init(Napi::Env env, Napi::Object exports)
         "PeerConnection",
         {
             InstanceMethod("close", &PeerConnectionWrapper::close),
-            InstanceMethod("destroy", &PeerConnectionWrapper::destroy),
             InstanceMethod("setLocalDescription", &PeerConnectionWrapper::setLocalDescription),
             InstanceMethod("setRemoteDescription", &PeerConnectionWrapper::setRemoteDescription),
             InstanceMethod("localDescription", &PeerConnectionWrapper::localDescription),
@@ -253,7 +252,8 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
 PeerConnectionWrapper::~PeerConnectionWrapper()
 {
     PLOG_DEBUG << "Destructor called";
-    doDestroy();
+    doCleanup();
+    doClose();
 }
 
 void PeerConnectionWrapper::doClose()
@@ -273,40 +273,27 @@ void PeerConnectionWrapper::doClose()
             return;
         }
     }
-}
-
-void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
-{
-    PLOG_DEBUG << "close() called";
-    doClose();
-}
-
-void PeerConnectionWrapper::doDestroy()
-{
-    PLOG_DEBUG << "doDestroy() called";
-    doClose();
-    doResetCallbacks();
-}
 
-void PeerConnectionWrapper::doResetCallbacks()
-{
-    PLOG_DEBUG << "doResetCallbacks() called";
     mOnLocalDescriptionCallback.reset();
     mOnLocalCandidateCallback.reset();
-    mOnStateChangeCallback.reset();
     mOnIceStateChangeCallback.reset();
     mOnSignalingStateChangeCallback.reset();
     mOnGatheringStateChangeCallback.reset();
     mOnDataChannelCallback.reset();
     mOnTrackCallback.reset();
+}
 
-    instances.erase(this);
+void PeerConnectionWrapper::close(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "close() called";
+    doClose();
 }
 
-void PeerConnectionWrapper::destroy(const Napi::CallbackInfo &info)
+void PeerConnectionWrapper::doCleanup()
 {
-    PLOG_DEBUG << "destroy() called";
-    doDestroy();
+    PLOG_DEBUG << "doCleanup() called";
+    mOnStateChangeCallback.reset();
+    instances.erase(this);
 }
 
 void PeerConnectionWrapper::setLocalDescription(const Napi::CallbackInfo &info)
@@ -738,6 +725,13 @@ void PeerConnectionWrapper::onStateChange(const Napi::CallbackInfo &info)
                 stream << state;
                 args = {Napi::String::New(env, stream.str())};
                 PLOG_DEBUG << "mOnStateChangeCallback call(2)";
+            },[this,state](){
+                PLOG_DEBUG << "mOnStateChangeCallback cleanup";
+                // Special case for closed state, we need to reset all callbacks
+                if(state == rtc::PeerConnection::State::Closed)
+                {
+                    doCleanup();
+                }
             }); });
 }
 

package/src/peer-connection-wrapper.h

@@ -19,8 +19,6 @@ public:
   PeerConnectionWrapper(const Napi::CallbackInfo &info);
   ~PeerConnectionWrapper();
 
-  void destroy(const Napi::CallbackInfo &info);
-
   // Functions
   void close(const Napi::CallbackInfo &info);
   void setLocalDescription(const Napi::CallbackInfo &info);
@@ -58,15 +56,14 @@ public:
   static void CloseAll();
 
   // Reset all Callbacks for existing Peer Connections
-  static void ResetCallbacksAll();
+  static void CleanupAll();
 
 private:
   static Napi::FunctionReference constructor;
   static std::unordered_set<PeerConnectionWrapper *> instances;
 
   void doClose();
-  void doDestroy();
-  void doResetCallbacks();
+  void doCleanup();
 
   std::string mPeerName;
   std::unique_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;

package/src/rtc-wrapper.cpp

@@ -125,8 +125,11 @@ void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
         if (rtc::Cleanup().wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout)
             throw std::runtime_error("cleanup timeout (possible deadlock)");
 
-        // Clear Callbacks
-        PeerConnectionWrapper::ResetCallbacksAll();
+        // Cleanup the instances
+        PeerConnectionWrapper::CleanupAll();
+        DataChannelWrapper::CleanupAll();
+        TrackWrapper::CleanupAll();
+        WebSocketWrapper::CleanupAll();
 
         if (logCallback)
             logCallback.reset();

package/src/thread-safe-callback.cpp

@@ -26,9 +26,9 @@ ThreadSafeCallback::~ThreadSafeCallback()
     tsfn.Abort();
 }
 
-void ThreadSafeCallback::call(arg_func_t argFunc)
+void ThreadSafeCallback::call(arg_func_t argFunc, cleanup_func_t cleanupFunc)
 {
-    CallbackData *data = new CallbackData{std::move(argFunc)};
+    CallbackData *data = new CallbackData{std::move(argFunc), std::move(cleanupFunc)};
     if (tsfn.BlockingCall(data) != napi_ok)
     {
         delete data;
@@ -47,6 +47,7 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
 
     arg_vector_t args;
     arg_func_t argFunc(std::move(data->argFunc));
+    cleanup_func_t cleanup(std::move(data->cleanupFunc));
     delete data;
 
     try
@@ -59,5 +60,8 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
     }
 
     if (env && callback)
+    {
         callback.Call(context->Value(), args);
+        cleanup();
+    }
 }

package/src/thread-safe-callback.h

@@ -11,6 +11,7 @@ class ThreadSafeCallback
 public:
     using arg_vector_t = std::vector<napi_value>;
     using arg_func_t = std::function<void(napi_env, arg_vector_t &)>;
+    using cleanup_func_t = std::function<void()>;
 
     ThreadSafeCallback(Napi::Function callback);
     ~ThreadSafeCallback();
@@ -21,7 +22,7 @@ public:
     ThreadSafeCallback &operator=(const ThreadSafeCallback &) = delete;
     ThreadSafeCallback &operator=(ThreadSafeCallback &&) = delete;
 
-    void call(arg_func_t argFunc);
+    void call(arg_func_t argFunc, cleanup_func_t cleanupFunc = []() {});
 
     class CancelException : public std::exception
     {
@@ -32,6 +33,7 @@ private:
     struct CallbackData
     {
         arg_func_t argFunc;
+        cleanup_func_t cleanupFunc;
     };
 
     static void callbackFunc(Napi::Env env,

package/src/web-socket-wrapper.cpp

@@ -13,6 +13,14 @@ void WebSocketWrapper::CloseAll()
         inst->doClose();
 }
 
+void WebSocketWrapper::CleanupAll()
+{
+    PLOG_DEBUG << "CleanupAll() called";
+    auto copy(instances);
+    for (auto inst : copy)
+        inst->doCleanup();
+}
+
 Napi::Object WebSocketWrapper::Init(Napi::Env env, Napi::Object exports)
 {
     Napi::HandleScope scope(env);
@@ -23,6 +31,7 @@ Napi::Object WebSocketWrapper::Init(Napi::Env env, Napi::Object exports)
         {
             InstanceMethod("open", &WebSocketWrapper::open),
             InstanceMethod("close", &WebSocketWrapper::close),
+            InstanceMethod("forceClose", &WebSocketWrapper::forceClose),
             InstanceMethod("sendMessage", &WebSocketWrapper::sendMessage),
             InstanceMethod("sendMessageBinary", &WebSocketWrapper::sendMessageBinary),
             InstanceMethod("isOpen", &WebSocketWrapper::isOpen),
@@ -34,6 +43,8 @@ Napi::Object WebSocketWrapper::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod("onError", &WebSocketWrapper::onError),
             InstanceMethod("onBufferedAmountLow", &WebSocketWrapper::onBufferedAmountLow),
             InstanceMethod("onMessage", &WebSocketWrapper::onMessage),
+            InstanceMethod("remoteAddress", &WebSocketWrapper::remoteAddress),
+            InstanceMethod("path", &WebSocketWrapper::path),
         });
 
     constructor = Napi::Persistent(func);
@@ -249,17 +260,45 @@ void WebSocketWrapper::doClose()
         }
         catch (std::exception &ex)
         {
-            std::cerr << std::string("libWebSocket error while closing WebSocket: ") + ex.what() << std::endl;
+            std::cerr << std::string("libdatachannel error while closing WebSocket: ") + ex.what() << std::endl;
             return;
         }
     }
 
     mOnOpenCallback.reset();
-    mOnClosedCallback.reset();
     mOnErrorCallback.reset();
     mOnBufferedAmountLowCallback.reset();
     mOnMessageCallback.reset();
+}
 
+void WebSocketWrapper::doForceClose()
+{
+    PLOG_DEBUG << "doForceClose() called";
+    if (mWebSocketPtr)
+    {
+        PLOG_DEBUG << "Force closing...";
+        try
+        {
+            mWebSocketPtr->forceClose();
+            mWebSocketPtr.reset();
+        }
+        catch (std::exception &ex)
+        {
+            std::cerr << std::string("libdatachannel error while force closing WebSocket: ") + ex.what() << std::endl;
+            return;
+        }
+    }
+
+    mOnOpenCallback.reset();
+    mOnErrorCallback.reset();
+    mOnBufferedAmountLowCallback.reset();
+    mOnMessageCallback.reset();
+}
+
+void WebSocketWrapper::doCleanup()
+{
+    PLOG_DEBUG << "doCleanup() called";
+    mOnClosedCallback.reset();
     instances.erase(this);
 }
 
@@ -285,7 +324,7 @@ void WebSocketWrapper::open(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libWebSocket error while opening WebSocket: ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while opening WebSocket: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 }
@@ -296,6 +335,12 @@ void WebSocketWrapper::close(const Napi::CallbackInfo &info)
     doClose();
 }
 
+void WebSocketWrapper::forceClose(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "forceClose() called";
+    doForceClose();
+}
+
 Napi::Value WebSocketWrapper::sendMessage(const Napi::CallbackInfo &info)
 {
     PLOG_DEBUG << "sendMessage() called";
@@ -321,7 +366,7 @@ Napi::Value WebSocketWrapper::sendMessage(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libWebSocket error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -351,7 +396,7 @@ Napi::Value WebSocketWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libWebSocket error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error while sending data channel message: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -372,7 +417,7 @@ Napi::Value WebSocketWrapper::isOpen(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libWebSocket error: ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Boolean::New(info.Env(), false);
     }
 }
@@ -393,7 +438,7 @@ Napi::Value WebSocketWrapper::bufferedAmount(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libWebSocket error: ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
@@ -414,11 +459,69 @@ Napi::Value WebSocketWrapper::maxMessageSize(const Napi::CallbackInfo &info)
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libWebSocket error: ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return Napi::Number::New(info.Env(), 0);
     }
 }
 
+Napi::Value WebSocketWrapper::remoteAddress(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "remoteAddress() called";
+    Napi::Env env = info.Env();
+
+    if (!mWebSocketPtr)
+    {
+        return env.Undefined(); 
+    }
+
+    try
+    {
+        auto address = mWebSocketPtr->remoteAddress();
+        if (address.has_value())
+        {
+            return Napi::String::New(info.Env(), address.value());
+        }
+        else
+        {
+            return env.Undefined();
+        }
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+}
+
+Napi::Value WebSocketWrapper::path(const Napi::CallbackInfo &info)
+{
+    PLOG_DEBUG << "path() called";
+    Napi::Env env = info.Env();
+
+    if (!mWebSocketPtr)
+    {
+        return env.Undefined(); 
+    }
+
+    try
+    {
+        auto path = mWebSocketPtr->path();
+        if (path.has_value())
+        {
+            return Napi::String::New(info.Env(), path.value());
+        }
+        else
+        {
+            return env.Undefined();
+        }
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
+        return env.Undefined();
+    }
+}
+
 void WebSocketWrapper::setBufferedAmountLowThreshold(const Napi::CallbackInfo &info)
 {
     PLOG_DEBUG << "setBufferedAmountLowThreshold() called";
@@ -443,7 +546,7 @@ void WebSocketWrapper::setBufferedAmountLowThreshold(const Napi::CallbackInfo &i
     }
     catch (std::exception &ex)
     {
-        Napi::Error::New(env, std::string("libWebSocket error: ") + ex.what()).ThrowAsJavaScriptException();
+        Napi::Error::New(env, std::string("libdatachannel error: ") + ex.what()).ThrowAsJavaScriptException();
         return;
     }
 }
@@ -488,8 +591,7 @@ void WebSocketWrapper::onOpen(const Napi::CallbackInfo &info)
                     // This will run in main thread and needs to construct the
                     // arguments for the call
                     args = {};
-                    PLOG_DEBUG << "mOnOpenCallback call(2)"; });
-                          });
+                    PLOG_DEBUG << "mOnOpenCallback call(2)"; }); });
 }
 
 void WebSocketWrapper::onClosed(const Napi::CallbackInfo &info)
@@ -524,6 +626,8 @@ void WebSocketWrapper::onClosed(const Napi::CallbackInfo &info)
                 // This will run in main thread and needs to construct the
                 // arguments for the call
                 args = {};
+            },[this]{
+                doCleanup();
             }); });
 }
 

package/src/web-socket-wrapper.h

@@ -22,13 +22,16 @@ public:
 
   // Functions
   void open(const Napi::CallbackInfo &info);
-  void close(const Napi::CallbackInfo &info); 
+  void close(const Napi::CallbackInfo &info);
+  void forceClose(const Napi::CallbackInfo &info);
   Napi::Value sendMessage(const Napi::CallbackInfo &info);
   Napi::Value sendMessageBinary(const Napi::CallbackInfo &info);
   Napi::Value isOpen(const Napi::CallbackInfo &info);
   Napi::Value bufferedAmount(const Napi::CallbackInfo &info);
   Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
   void setBufferedAmountLowThreshold(const Napi::CallbackInfo &info);
+  Napi::Value remoteAddress(const Napi::CallbackInfo &info);
+  Napi::Value path(const Napi::CallbackInfo &info);
 
   // Callbacks
   void onOpen(const Napi::CallbackInfo &info);
@@ -40,10 +43,15 @@ public:
   // Close all existing WebSockets
   static void CloseAll();
 
+  // Reset all Callbacks for existing WebSockets
+  static void CleanupAll();
+
 private:
-  static std::unordered_set<WebSocketWrapper*> instances;
+  static std::unordered_set<WebSocketWrapper *> instances;
 
   void doClose();
+  void doForceClose();
+  void doCleanup();
 
   std::shared_ptr<rtc::WebSocket> mWebSocketPtr = nullptr;