@walkhi/code-relax 0.1.0-beta.29 → 0.1.0-beta.30

package/node_modules/node-datachannel/src/cpp/peer-connection-wrapper.h

@@ -1,89 +0,0 @@
-#ifndef PEER_CONNECTION_WRAPPER_H
-#define PEER_CONNECTION_WRAPPER_H
-
-#include <string>
-#include <memory>
-#include <unordered_set>
-
-#include <napi.h>
-#include <rtc/rtc.hpp>
-
-#include "thread-safe-callback.h"
-
-class PeerConnectionWrapper : public Napi::ObjectWrap<PeerConnectionWrapper>
-{
-public:
-  static Napi::Object Init(Napi::Env env, Napi::Object exports);
-  PeerConnectionWrapper(const Napi::CallbackInfo &info);
-  ~PeerConnectionWrapper();
-
-  // Functions
-  void close(const Napi::CallbackInfo &info);
-  void setLocalDescription(const Napi::CallbackInfo &info);
-  void setRemoteDescription(const Napi::CallbackInfo &info);
-  Napi::Value localDescription(const Napi::CallbackInfo &info);
-  Napi::Value remoteDescription(const Napi::CallbackInfo &info);
-  void addRemoteCandidate(const Napi::CallbackInfo &info);
-  Napi::Value createDataChannel(const Napi::CallbackInfo &info);
-
-#if RTC_ENABLE_MEDIA == 1
-  Napi::Value addTrack(const Napi::CallbackInfo &info);
-  void onTrack(const Napi::CallbackInfo &info);
-#endif
-
-  Napi::Value hasMedia(const Napi::CallbackInfo &info);
-  Napi::Value state(const Napi::CallbackInfo &info);
-  Napi::Value iceState(const Napi::CallbackInfo &info);
-  Napi::Value signalingState(const Napi::CallbackInfo &info);
-  Napi::Value gatheringState(const Napi::CallbackInfo &info);
-  Napi::Value remoteFingerprint(const Napi::CallbackInfo &info);
-
-  // Callbacks
-  void onLocalDescription(const Napi::CallbackInfo &info);
-  void onLocalCandidate(const Napi::CallbackInfo &info);
-  void onStateChange(const Napi::CallbackInfo &info);
-  void onIceStateChange(const Napi::CallbackInfo &info);
-  void onSignalingStateChange(const Napi::CallbackInfo &info);
-  void onGatheringStateChange(const Napi::CallbackInfo &info);
-  void onDataChannel(const Napi::CallbackInfo &info);
-
-  // Stats
-  Napi::Value bytesSent(const Napi::CallbackInfo &info);
-  Napi::Value bytesReceived(const Napi::CallbackInfo &info);
-  Napi::Value rtt(const Napi::CallbackInfo &info);
-  Napi::Value getSelectedCandidatePair(const Napi::CallbackInfo &info);
-  Napi::Value maxDataChannelId(const Napi::CallbackInfo &info);
-  Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
-
-  // Close all existing Peer Connections
-  static void CloseAll();
-
-  // Reset all Callbacks for existing Peer Connections
-  static void CleanupAll();
-
-private:
-  static Napi::FunctionReference constructor;
-  static std::unordered_set<PeerConnectionWrapper *> instances;
-
-  void doClose();
-  void doCleanup();
-
-  std::string mPeerName;
-  std::unique_ptr<rtc::PeerConnection> mRtcPeerConnPtr = nullptr;
-
-  // Callback Ptrs
-  std::unique_ptr<ThreadSafeCallback> mOnLocalDescriptionCallback = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnLocalCandidateCallback = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnStateChangeCallback = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnIceStateChangeCallback = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnSignalingStateChangeCallback = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnGatheringStateChangeCallback = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnDataChannelCallback = nullptr;
-  std::unique_ptr<ThreadSafeCallback> mOnTrackCallback = nullptr;
-
-  // Helpers
-  std::string candidateTypeToString(const rtc::Candidate::Type &type);
-  std::string candidateTransportTypeToString(const rtc::Candidate::TransportType &transportType);
-};
-
-#endif // PEER_CONNECTION_WRAPPER_H

package/node_modules/node-datachannel/src/cpp/rtc-wrapper.cpp

@@ -1,205 +0,0 @@
-#include "rtc-wrapper.h"
-#include "peer-connection-wrapper.h"
-#include "data-channel-wrapper.h"
-
-#if RTC_ENABLE_MEDIA == 1
-#include "media-track-wrapper.h"
-#endif
-
-#if RTC_ENABLE_WEBSOCKET == 1
-#include "web-socket-wrapper.h"
-#include "web-socket-server-wrapper.h"
-#endif
-
-#include "plog/Log.h"
-
-#include <chrono>
-#include <future>
-
-Napi::Object RtcWrapper::Init(Napi::Env env, Napi::Object exports)
-{
-  Napi::HandleScope scope(env);
-
-  exports.Set("initLogger", Napi::Function::New(env, &RtcWrapper::initLogger));
-  exports.Set("cleanup", Napi::Function::New(env, &RtcWrapper::cleanup));
-  exports.Set("preload", Napi::Function::New(env, &RtcWrapper::preload));
-  exports.Set("setSctpSettings", Napi::Function::New(env, &RtcWrapper::setSctpSettings));
-  exports.Set("getLibraryVersion", Napi::Function::New(env, &RtcWrapper::getLibraryVersion));
-
-  return exports;
-}
-
-void RtcWrapper::preload(const Napi::CallbackInfo &info)
-{
-  PLOG_DEBUG << "preload() called";
-  Napi::Env env = info.Env();
-  try
-  {
-    rtc::Preload();
-  }
-  catch (std::exception &ex)
-  {
-    Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
-  }
-}
-
-void RtcWrapper::initLogger(const Napi::CallbackInfo &info)
-{
-  Napi::Env env = info.Env();
-  int length = info.Length();
-
-  // We expect (String, Object, Function) as param
-  if (length < 1 || !info[0].IsString())
-  {
-    Napi::TypeError::New(env, "LogLevel(String) expected").ThrowAsJavaScriptException();
-    return;
-  }
-
-  std::string logLevelStr = info[0].As<Napi::String>().ToString();
-  rtc::LogLevel logLevel = rtc::LogLevel::None;
-
-  if (logLevelStr == "Verbose")
-    logLevel = rtc::LogLevel::Verbose;
-  if (logLevelStr == "Debug")
-    logLevel = rtc::LogLevel::Debug;
-  if (logLevelStr == "Info")
-    logLevel = rtc::LogLevel::Info;
-  if (logLevelStr == "Warning")
-    logLevel = rtc::LogLevel::Warning;
-  if (logLevelStr == "Error")
-    logLevel = rtc::LogLevel::Error;
-  if (logLevelStr == "Fatal")
-    logLevel = rtc::LogLevel::Fatal;
-
-  try
-  {
-    if (length < 2)
-    {
-      rtc::InitLogger(logLevel);
-    }
-    else
-    {
-      if (!info[1].IsFunction())
-      {
-        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
-        return;
-      }
-      logCallback = std::make_unique<ThreadSafeCallback>(info[1].As<Napi::Function>());
-      rtc::InitLogger(logLevel,
-                      [&](rtc::LogLevel level, std::string message)
-                      {
-        if (logCallback)
-          logCallback->call(
-              [level, message = std::move(message)](Napi::Env env, std::vector<napi_value> &args)
-              {
-            // This will run in main thread and needs to construct the
-            // arguments for the call
-
-            std::string logLevel;
-            if (level == rtc::LogLevel::Verbose)
-              logLevel = "Verbose";
-            if (level == rtc::LogLevel::Debug)
-              logLevel = "Debug";
-            if (level == rtc::LogLevel::Info)
-              logLevel = "Info";
-            if (level == rtc::LogLevel::Warning)
-              logLevel = "Warning";
-            if (level == rtc::LogLevel::Error)
-              logLevel = "Error";
-            if (level == rtc::LogLevel::Fatal)
-              logLevel = "Fatal";
-            args = {Napi::String::New(env, logLevel), Napi::String::New(env, message)};
-          });
-      });
-    }
-  }
-  catch (std::exception &ex)
-  {
-    Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
-    return;
-  }
-}
-
-void RtcWrapper::cleanup(const Napi::CallbackInfo &info)
-{
-  PLOG_DEBUG << "cleanup() called";
-  Napi::Env env = info.Env();
-  try
-  {
-    PeerConnectionWrapper::CloseAll();
-    DataChannelWrapper::CloseAll();
-
-#if RTC_ENABLE_MEDIA == 1
-    TrackWrapper::CloseAll();
-#endif
-
-#if RTC_ENABLE_WEBSOCKET == 1
-    WebSocketWrapper::CloseAll();
-    WebSocketServerWrapper::StopAll();
-#endif
-
-    const auto timeout = std::chrono::seconds(10);
-    if (rtc::Cleanup().wait_for(std::chrono::seconds(timeout)) == std::future_status::timeout)
-      throw std::runtime_error("cleanup timeout (possible deadlock)");
-
-    // Cleanup the instances
-    PeerConnectionWrapper::CleanupAll();
-    DataChannelWrapper::CleanupAll();
-
-#if RTC_ENABLE_MEDIA == 1
-    TrackWrapper::CleanupAll();
-#endif
-
-#if RTC_ENABLE_WEBSOCKET == 1
-    WebSocketWrapper::CleanupAll();
-#endif
-
-    if (logCallback)
-      logCallback.reset();
-  }
-  catch (std::exception &ex)
-  {
-    Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
-    return;
-  }
-}
-
-void RtcWrapper::setSctpSettings(const Napi::CallbackInfo &info)
-{
-  PLOG_DEBUG << "setSctpSettings() called";
-  Napi::Env env = info.Env();
-  int length = info.Length();
-
-  // We expect (Object) as param
-  if (length < 1 || !info[0].IsObject())
-  {
-    Napi::TypeError::New(env, "Configuration (Object) expected").ThrowAsJavaScriptException();
-    return;
-  }
-
-  rtc::SctpSettings settings;
-  Napi::Object config = info[0].As<Napi::Object>();
-
-  if (config.Get("recvBufferSize").IsNumber())
-    settings.recvBufferSize = config.Get("recvBufferSize").As<Napi::Number>().Uint32Value();
-  if (config.Get("sendBufferSize").IsNumber())
-    settings.sendBufferSize = config.Get("sendBufferSize").As<Napi::Number>().Uint32Value();
-  if (config.Get("maxChunksOnQueue").IsNumber())
-    settings.maxChunksOnQueue = config.Get("maxChunksOnQueue").As<Napi::Number>().Uint32Value();
-  if (config.Get("initialCongestionWindow").IsNumber())
-    settings.initialCongestionWindow = config.Get("initialCongestionWindow").As<Napi::Number>().Uint32Value();
-  if (config.Get("congestionControlModule").IsNumber())
-    settings.congestionControlModule = config.Get("congestionControlModule").As<Napi::Number>().Uint32Value();
-  if (config.Get("delayedSackTime").IsNumber())
-    settings.delayedSackTime =
-        std::chrono::milliseconds(config.Get("delayedSackTime").As<Napi::Number>().Uint32Value());
-
-  rtc::SetSctpSettings(settings);
-}
-
-Napi::Value RtcWrapper::getLibraryVersion(const Napi::CallbackInfo &info)
-{
-  PLOG_DEBUG << "getLibraryVersion() called";
-  Napi::Env env = info.Env();
-  return Napi::String::New(info.Env(), RTC_VERSION);
-}

package/node_modules/node-datachannel/src/cpp/rtc-wrapper.h

@@ -1,24 +0,0 @@
-#ifndef RTC_WRAPPER_H
-#define RTC_WRAPPER_H
-
-#include <napi.h>
-
-#include "rtc/rtc.hpp"
-
-#include "thread-safe-callback.h"
-
-class RtcWrapper
-{
-public:
-  static Napi::Object Init(Napi::Env env, Napi::Object exports);
-  static void preload(const Napi::CallbackInfo &info);
-  static void initLogger(const Napi::CallbackInfo &info);
-  static void cleanup(const Napi::CallbackInfo &info);
-  static void setSctpSettings(const Napi::CallbackInfo &info);
-  static Napi::Value getLibraryVersion(const Napi::CallbackInfo &info);
-
-private:
-  static inline std::unique_ptr<ThreadSafeCallback> logCallback = nullptr;
-};
-
-#endif // RTC_WRAPPER_H

package/node_modules/node-datachannel/src/cpp/thread-safe-callback.cpp

@@ -1,57 +0,0 @@
-#include "thread-safe-callback.h"
-
-#include <stdexcept>
-
-const char *ThreadSafeCallback::CancelException::what() const throw() { return "ThreadSafeCallback cancelled"; }
-
-ThreadSafeCallback::ThreadSafeCallback(Napi::Function callback)
-{
-  Napi::Env env = callback.Env();
-
-  if (!callback.IsFunction())
-    throw Napi::Error::New(env, "Callback must be a function");
-
-  tsfn = tsfn_t::New(env, std::move(callback), "ThreadSafeCallback callback",
-                     0, // unlimited queue
-                     1);
-}
-
-ThreadSafeCallback::~ThreadSafeCallback() { tsfn.Abort(); }
-
-void ThreadSafeCallback::call(arg_func_t argFunc, cleanup_func_t cleanupFunc)
-{
-  CallbackData *data = new CallbackData{std::move(argFunc), std::move(cleanupFunc)};
-  if (tsfn.BlockingCall(data) != napi_ok)
-  {
-    delete data;
-    throw std::runtime_error("Failed to call JavaScript callback");
-  }
-}
-
-void ThreadSafeCallback::callbackFunc(Napi::Env env, Napi::Function callback, ContextType *context, CallbackData *data)
-{
-  // if env is gone, it could mean this cb was destroyed. See issue#176
-  if (!data || !env)
-    return;
-
-  arg_vector_t args;
-  arg_func_t argFunc(std::move(data->argFunc));
-  cleanup_func_t cleanup(std::move(data->cleanupFunc));
-  delete data;
-
-  try
-  {
-    argFunc(env, args);
-  }
-  catch (CancelException &)
-  {
-    return;
-  }
-
-  if (callback)
-  {
-    callback.Call(args);
-  }
-
-  cleanup();
-}

package/node_modules/node-datachannel/src/cpp/thread-safe-callback.h

@@ -1,47 +0,0 @@
-#ifndef THREAD_SAFE_CALLBACK_H
-#define THREAD_SAFE_CALLBACK_H
-
-#include <napi.h>
-
-#include <vector>
-#include <functional>
-
-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();
-
-  ThreadSafeCallback(const ThreadSafeCallback &) = delete;
-  ThreadSafeCallback(ThreadSafeCallback &&) = delete;
-
-  ThreadSafeCallback &operator=(const ThreadSafeCallback &) = delete;
-  ThreadSafeCallback &operator=(ThreadSafeCallback &&) = delete;
-
-  void call(
-      arg_func_t argFunc, cleanup_func_t cleanupFunc = []() {});
-
-  class CancelException : public std::exception
-  {
-    const char *what() const throw();
-  };
-
-private:
-  using ContextType = std::nullptr_t;
-  struct CallbackData
-  {
-    arg_func_t argFunc;
-    cleanup_func_t cleanupFunc;
-  };
-
-  static void callbackFunc(Napi::Env env, Napi::Function callback, ContextType *context, CallbackData *data);
-
-  using tsfn_t = Napi::TypedThreadSafeFunction<ContextType, CallbackData, callbackFunc>;
-  tsfn_t tsfn;
-};
-
-#endif // THREAD_SAFE_CALLBACK_H

package/node_modules/node-datachannel/src/cpp/web-socket-server-wrapper.cpp

@@ -1,275 +0,0 @@
-#include "web-socket-server-wrapper.h"
-#include "web-socket-wrapper.h"
-
-#include "plog/Log.h"
-
-Napi::FunctionReference WebSocketServerWrapper::constructor = Napi::FunctionReference();
-std::unordered_set<WebSocketServerWrapper *> WebSocketServerWrapper::instances;
-
-void WebSocketServerWrapper::StopAll()
-{
-  PLOG_DEBUG << "StopAll() called";
-  auto copy(instances);
-  for (auto inst : copy)
-    inst->doStop();
-}
-
-Napi::Object WebSocketServerWrapper::Init(Napi::Env env, Napi::Object exports)
-{
-  Napi::HandleScope scope(env);
-
-  Napi::Function func = DefineClass(env, "WebSocketServer",
-                                    {InstanceMethod("stop", &WebSocketServerWrapper::stop),
-                                     InstanceMethod("port", &WebSocketServerWrapper::port),
-                                     InstanceMethod("onClient", &WebSocketServerWrapper::onClient)});
-
-  // If this is not the first call, we don't want to reassign the constructor (hot-reload problem)
-  if (constructor.IsEmpty())
-  {
-    constructor = Napi::Persistent(func);
-    constructor.SuppressDestruct();
-  }
-
-  exports.Set("WebSocketServer", func);
-  return exports;
-}
-
-WebSocketServerWrapper::WebSocketServerWrapper(const Napi::CallbackInfo &info)
-    : Napi::ObjectWrap<WebSocketServerWrapper>(info)
-{
-  PLOG_DEBUG << "Constructor called";
-  Napi::Env env = info.Env();
-
-  // Create WebSocketServer without config
-  if (info.Length() == 0)
-  {
-    try
-    {
-      PLOG_DEBUG << "Creating a new WebSocketServer without config";
-      mWebSocketServerPtr = std::make_unique<rtc::WebSocketServer>();
-    }
-    catch (std::exception &ex)
-    {
-      Napi::Error::New(env,
-                       std::string("libdatachannel error while creating WebSocketServer without config: ") + ex.what())
-          .ThrowAsJavaScriptException();
-      return;
-    }
-
-    PLOG_DEBUG << "WebSocketServer created without config";
-
-    instances.insert(this);
-    return;
-  }
-
-  // Create WebSocketServer with config
-
-  Napi::Object config = info[0].As<Napi::Object>();
-  rtc::WebSocketServerConfiguration webSocketServerConfig;
-
-  // Port
-  if (config.Has("port"))
-  {
-    if (!config.Get("port").IsNumber())
-    {
-      Napi::TypeError::New(info.Env(), "port must be a number").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.port = config.Get("port").ToNumber().Uint32Value();
-  }
-
-  // Enable TLS
-  if (config.Has("enableTls"))
-  {
-    if (!config.Get("enableTls").IsBoolean())
-    {
-      Napi::TypeError::New(info.Env(), "enableTls must be boolean").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.enableTls = config.Get("enableTls").ToBoolean();
-  }
-
-  // Certificate PEM File
-  if (config.Has("certificatePemFile"))
-  {
-    if (!config.Get("certificatePemFile").IsString())
-    {
-      Napi::TypeError::New(info.Env(), "certificatePemFile must be a string").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.certificatePemFile = config.Get("certificatePemFile").ToString();
-  }
-
-  // Key PEM File
-  if (config.Has("keyPemFile"))
-  {
-    if (!config.Get("keyPemFile").IsString())
-    {
-      Napi::TypeError::New(info.Env(), "keyPemFile must be a string").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.keyPemFile = config.Get("keyPemFile").ToString();
-  }
-
-  // Key PEM Pass
-  if (config.Has("keyPemPass"))
-  {
-    if (!config.Get("keyPemPass").IsString())
-    {
-      Napi::TypeError::New(info.Env(), "keyPemPass must be a string").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.keyPemPass = config.Get("keyPemPass").ToString();
-  }
-
-  // Bind Address
-  if (config.Has("bindAddress"))
-  {
-    if (!config.Get("bindAddress").IsString())
-    {
-      Napi::TypeError::New(info.Env(), "bindAddress must be a string").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.bindAddress = config.Get("bindAddress").ToString();
-  }
-
-  // Connection Timeout
-  if (config.Has("connectionTimeout"))
-  {
-    if (!config.Get("connectionTimeout").IsNumber())
-    {
-      Napi::TypeError::New(info.Env(), "connectionTimeout must be a number").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.connectionTimeout =
-        std::chrono::milliseconds(config.Get("connectionTimeout").ToNumber().Int64Value());
-  }
-
-  // Max Message Size
-  if (config.Has("maxMessageSize"))
-  {
-    if (!config.Get("maxMessageSize").IsNumber())
-    {
-      Napi::TypeError::New(info.Env(), "maxMessageSize must be a number").ThrowAsJavaScriptException();
-      return;
-    }
-    webSocketServerConfig.maxMessageSize = config.Get("maxMessageSize").ToNumber().Int32Value();
-  }
-
-  // Create WebSocketServer with config
-  try
-  {
-    PLOG_DEBUG << "Creating a new WebSocketServer";
-    mWebSocketServerPtr = std::make_unique<rtc::WebSocketServer>(webSocketServerConfig);
-  }
-  catch (std::exception &ex)
-  {
-    Napi::Error::New(env, std::string("libdatachannel error while creating WebSocketServer: ") + ex.what())
-        .ThrowAsJavaScriptException();
-    return;
-  }
-
-  PLOG_DEBUG << "WebSocketServer created";
-  instances.insert(this);
-}
-
-WebSocketServerWrapper::~WebSocketServerWrapper()
-{
-  PLOG_DEBUG << "Destructor called";
-  doStop();
-}
-
-void WebSocketServerWrapper::doStop()
-{
-  PLOG_DEBUG << "doStop() called";
-  if (mWebSocketServerPtr)
-  {
-    PLOG_DEBUG << "Stopping...";
-    try
-    {
-      mWebSocketServerPtr->stop();
-      mWebSocketServerPtr.reset();
-    }
-    catch (std::exception &ex)
-    {
-      std::cerr << std::string("libdatachannel error while closing WebSocketServer: ") + ex.what() << std::endl;
-      return;
-    }
-  }
-
-  mOnClientCallback.reset();
-  instances.erase(this);
-}
-
-void WebSocketServerWrapper::stop(const Napi::CallbackInfo &info)
-{
-  PLOG_DEBUG << "stop() called";
-  doStop();
-}
-
-Napi::Value WebSocketServerWrapper::port(const Napi::CallbackInfo &info)
-{
-  PLOG_DEBUG << "port() called";
-  Napi::Env env = info.Env();
-
-  if (!mWebSocketServerPtr)
-  {
-    return Napi::Number::New(info.Env(), 0);
-  }
-
-  try
-  {
-    return Napi::Number::New(info.Env(), mWebSocketServerPtr->port());
-  }
-  catch (std::exception &ex)
-  {
-    Napi::Error::New(env, std::string("WebSocketServer error: ") + ex.what()).ThrowAsJavaScriptException();
-    return Napi::Number::New(info.Env(), 0);
-  }
-}
-
-void WebSocketServerWrapper::onClient(const Napi::CallbackInfo &info)
-{
-  PLOG_DEBUG << "onClient() called";
-  Napi::Env env = info.Env();
-  int length = info.Length();
-
-  if (!mWebSocketServerPtr)
-  {
-    Napi::Error::New(env, "onClient() called on destroyed WebSocketServer").ThrowAsJavaScriptException();
-    return;
-  }
-
-  if (length < 1 || !info[0].IsFunction())
-  {
-    Napi::TypeError::New(env, "Function expected as onClient callback").ThrowAsJavaScriptException();
-    return;
-  }
-
-  // Callback
-  mOnClientCallback = std::make_unique<ThreadSafeCallback>(info[0].As<Napi::Function>());
-
-  mWebSocketServerPtr->onClient(
-      [&](std::shared_ptr<rtc::WebSocket> ws)
-      {
-    PLOG_DEBUG << "onClient ws received from WebSocketServer";
-    if (mOnClientCallback)
-      mOnClientCallback->call(
-          [this, ws](Napi::Env env, std::vector<napi_value> &args)
-          {
-        PLOG_DEBUG << "mOnClientCallback call(1)";
-        // Check the WebSocketServer is not stopped
-        if (instances.find(this) == instances.end())
-          throw ThreadSafeCallback::CancelException();
-
-        // This will run in main thread and needs to construct the
-        // arguments for the call
-        std::shared_ptr<rtc::WebSocket> webSocket = ws;
-        // First argument is just a placeholder
-        auto instance = WebSocketWrapper::constructor.New(
-            {Napi::Boolean::New(env, false), Napi::External<std::shared_ptr<rtc::WebSocket>>::New(env, &webSocket)});
-        args = {instance};
-        PLOG_DEBUG << "mOnClientCallback call(2)";
-      });
-  });
-}