node-datachannel 0.7.0 → 0.9.0

package/.github/workflows/npm-publish-manual.yml

@@ -13,7 +13,7 @@ jobs:
       - name: Set up Node.js
         uses: actions/setup-node@v1
         with:
-          node-version: 16.x
+          node-version: 20.x
           registry-url: "https://registry.npmjs.org"
       - name: Publish
         run: |

package/CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.15)
 cmake_policy(SET CMP0091 NEW)
 cmake_policy(SET CMP0042 NEW)
 
-project(node_datachannel VERSION 0.7.0)
+project(node_datachannel VERSION 0.9.0)
 
 # -Dnapi_build_version=8
 add_definitions(-DNAPI_VERSION=8)
@@ -29,7 +29,7 @@ include(FetchContent)
 FetchContent_Declare(
     libdatachannel
     GIT_REPOSITORY https://github.com/paullouisageneau/libdatachannel.git
-    GIT_TAG "v0.20.2"
+    GIT_TAG "v0.21.0"
 )
 
 option(NO_MEDIA "Disable media transport support in libdatachannel" OFF)

package/examples/electron-demo/package.json

@@ -34,7 +34,7 @@
     },
     "dependencies": {
         "electron-squirrel-startup": "^1.0.0",
-        "node-datachannel": "^0.5.2"
+        "node-datachannel": "^0.8.0"
     },
     "cmake-js": {
         "runtime": "electron",

package/lib/index.d.cts

@@ -0,0 +1,314 @@
+import * as stream from 'stream';
+
+export as namespace NodeDataChannel;
+
+// Enum in d.ts is tricky
+export type LogLevel = 'Verbose' | 'Debug' | 'Info' | 'Warning' | 'Error' | 'Fatal';
+
+// SCTP Settings
+export interface SctpSettings {
+    recvBufferSize?: number;
+    sendBufferSize?: number;
+    maxChunksOnQueue?: number;
+    initialCongestionWindow?: number;
+    congestionControlModule?: number;
+    delayedSackTime?: number;
+}
+
+// Functions
+export function preload(): void;
+export function initLogger(level: LogLevel, callback?: (level: LogLevel, message: string) => void): void;
+export function cleanup(): void;
+export function setSctpSettings(settings: SctpSettings): void;
+
+// Proxy Server
+export type ProxyServerType = 'Socks5' | 'Http';
+export interface ProxyServer {
+    type: ProxyServerType;
+    ip: string;
+    port: number;
+    username?: string;
+    password?: string;
+}
+
+export const enum RelayType {
+    TurnUdp = 'TurnUdp',
+    TurnTcp = 'TurnTcp',
+    TurnTls = 'TurnTls',
+}
+
+export interface IceServer {
+    hostname: string;
+    port: number;
+    username?: string;
+    password?: string;
+    relayType?: RelayType;
+}
+
+export type TransportPolicy = 'all' | 'relay';
+
+export interface RtcConfig {
+    iceServers: (string | IceServer)[];
+    proxyServer?: ProxyServer;
+    bindAddress?: string;
+    enableIceTcp?: boolean;
+    enableIceUdpMux?: boolean;
+    disableAutoNegotiation?: boolean;
+    forceMediaTransport?: boolean;
+    portRangeBegin?: number;
+    portRangeEnd?: number;
+    maxMessageSize?: number;
+    mtu?: number;
+    iceTransportPolicy?: TransportPolicy;
+}
+
+// Lowercase to match the description type string from libdatachannel
+export const enum DescriptionType {
+    Unspec = 'unspec',
+    Offer = 'offer',
+    Answer = 'answer',
+    Pranswer = 'pranswer',
+    Rollback = 'rollback',
+}
+
+export const enum ReliabilityType {
+    Reliable = 0,
+    Rexmit = 1,
+    Timed = 2,
+}
+
+export interface DataChannelInitConfig {
+    protocol?: string;
+    negotiated?: boolean;
+    id?: number;
+    ordered?: boolean;
+    maxPacketLifeTime?: number;
+    maxRetransmits?: number;
+
+    // Deprecated, use ordered, maxPacketLifeTime, and maxRetransmits
+    reliability?: {
+        type?: ReliabilityType;
+        unordered?: boolean;
+        rexmit?: number;
+    };
+}
+
+export interface SelectedCandidateInfo {
+    address: string;
+    port: number;
+    type: string;
+    transportType: string;
+    candidate: string;
+    mid: string;
+    priority: number;
+}
+
+// Must be same as rtc enum class Direction
+export const enum Direction {
+    SendOnly = 'SendOnly',
+    RecvOnly = 'RecvOnly',
+    SendRecv = 'SendRecv',
+    Inactive = 'Inactive',
+    Unknown = 'Unknown',
+}
+
+export class RtcpReceivingSession {
+    requestBitrate(bitRate: number): void;
+    requestKeyframe(): boolean;
+}
+
+export class Audio {
+    constructor(mid: string, dir: Direction);
+    addAudioCodec(payloadType: number, codec: string, profile?: string): void;
+    addOpusCodec(payloadType: number, profile?: string): string;
+
+    direction(): Direction;
+    generateSdp(eol: string, addr: string, port: number): string;
+    mid(): string;
+    setDirection(dir: Direction): void;
+    description(): string;
+    removeFormat(fmt: string): void;
+    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    removeSSRC(ssrc: number): void;
+    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    hasSSRC(ssrc: number): boolean;
+    getSSRCs(): number[];
+    getCNameForSsrc(ssrc: number): string;
+    setBitrate(bitRate: number): void;
+    getBitrate(): number;
+    hasPayloadType(payloadType: number): boolean;
+    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+    addRTPMap(): void;
+    parseSdpLine(line: string): void;
+}
+
+export class Video {
+    constructor(mid: string, dir: Direction);
+    addVideoCodec(payloadType: number, codec: string, profile?: string): void;
+    addH264Codec(payloadType: number, profile?: string): void;
+    addVP8Codec(payloadType: number): void;
+    addVP9Codec(payloadType: number): void;
+
+    direction(): Direction;
+    generateSdp(eol: string, addr: string, port: number): string;
+    mid(): string;
+    setDirection(dir: Direction): void;
+    description(): string;
+    removeFormat(fmt: string): void;
+    addSSRC(ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    removeSSRC(ssrc: number): void;
+    replaceSSRC(oldSsrc: number, ssrc: number, name?: string, msid?: string, trackID?: string): void;
+    hasSSRC(ssrc: number): boolean;
+    getSSRCs(): number[];
+    getCNameForSsrc(ssrc: number): string;
+    setBitrate(bitRate: number): void;
+    getBitrate(): number;
+    hasPayloadType(payloadType: number): boolean;
+    addRTXCodec(payloadType: number, originalPayloadType: number, clockRate: number): void;
+    addRTPMap(): void;
+    parseSdpLine(line: string): void;
+}
+
+export class Track {
+    direction(): Direction;
+    mid(): string;
+    type(): string;
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Buffer): boolean;
+    isOpen(): boolean;
+    isClosed(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    requestBitrate(bitRate: number): boolean;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    requestKeyframe(): boolean;
+    setMediaHandler(handler: RtcpReceivingSession): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onMessage(cb: (msg: Buffer) => void): void;
+}
+
+export interface Channel {
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+export class DataChannel implements Channel {
+    getLabel(): string;
+    getId(): number;
+    getProtocol(): string;
+
+    // Channel implementation
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+
+export interface WebSocketConfiguration {
+    disableTlsVerification?: boolean; // default = false, if true, don't verify the TLS certificate
+    proxyServer?: ProxyServer; // only non-authenticated http supported for now
+    protocols?: string[];
+    connectionTimeout?: number; // miliseconds, zero to disable
+    pingInterval?: number; // millisecondrs, zero to disable
+    maxOutstandingPings?: number;
+    caCertificatePemFile?: string;
+    certificatePemFile?: string;
+    keyPemFile?: string;
+    keyPemPass?: string;
+    maxMessageSize: number;
+}
+export class WebSocket implements Channel {
+    constructor(config?: WebSocketConfiguration);
+    open(url: string): void;
+    forceClose(): void;
+    remoteAddress(): string | undefined;
+    path(): string | undefined;
+
+    // Channel implementation
+    close(): void;
+    sendMessage(msg: string): boolean;
+    sendMessageBinary(buffer: Uint8Array): boolean;
+    isOpen(): boolean;
+    bufferedAmount(): number;
+    maxMessageSize(): number;
+    setBufferedAmountLowThreshold(newSize: number): void;
+    onOpen(cb: () => void): void;
+    onClosed(cb: () => void): void;
+    onError(cb: (err: string) => void): void;
+    onBufferedAmountLow(cb: () => void): void;
+    onMessage(cb: (msg: string | Buffer) => void): void;
+}
+
+export interface WebSocketServerConfiguration {
+    port?: number; // default 8080
+    enableTls?: boolean; // default = false;
+    certificatePemFile?: string;
+    keyPemFile?: string;
+    keyPemPass?: string;
+    bindAddress?: string;
+    connectionTimeout?: number; // milliseconds
+    maxMessageSize?: number;
+}
+
+export class WebSocketServer {
+    constructor(config?: WebSocketServerConfiguration);
+    port(): number;
+    stop(): void;
+    onClient(cb: (ws: WebSocket) => void): void;
+}
+
+export class PeerConnection {
+    constructor(peerName: string, config: RtcConfig);
+    close(): void;
+    setLocalDescription(type?: DescriptionType): void;
+    setRemoteDescription(sdp: string, type: DescriptionType): void;
+    localDescription(): { type: string; sdp: string } | null;
+    remoteDescription(): { type: string; sdp: string } | null;
+    addRemoteCandidate(candidate: string, mid: string): void;
+    createDataChannel(label: string, config?: DataChannelInitConfig): DataChannel;
+    addTrack(media: Video | Audio): Track;
+    hasMedia(): boolean;
+    state(): RTCPeerConnectionState;
+    iceState(): RTCIceConnectionState;
+    signalingState(): RTCSignalingState;
+    gatheringState(): RTCIceGatheringState;
+    onLocalDescription(cb: (sdp: string, type: DescriptionType) => void): void;
+    onLocalCandidate(cb: (candidate: string, mid: string) => void): void;
+    onStateChange(cb: (state: string) => void): void;
+    onIceStateChange(cb: (state: string) => void): void;
+    onSignalingStateChange(cb: (state: string) => void): void;
+    onGatheringStateChange(cb: (state: string) => void): void;
+    onDataChannel(cb: (dc: DataChannel) => void): void;
+    onTrack(cb: (track: Track) => void): void;
+    bytesSent(): number;
+    bytesReceived(): number;
+    rtt(): number;
+    getSelectedCandidatePair(): { local: SelectedCandidateInfo; remote: SelectedCandidateInfo } | null;
+    maxDataChannelId(): number;
+    maxMessageSize(): number;
+}
+
+export class DataChannelStream extends stream.Duplex {
+    constructor(rawChannel: DataChannel, options?: Omit<stream.DuplexOptions, 'objectMode'>);
+    get label(): string;
+}

package/lib/index.d.ts

@@ -180,6 +180,7 @@ export class Track {
     isClosed(): boolean;
     bufferedAmount(): number;
     maxMessageSize(): number;
+    requestBitrate(bitRate: number): boolean;
     setBufferedAmountLowThreshold(newSize: number): void;
     requestKeyframe(): boolean;
     setMediaHandler(handler: RtcpReceivingSession): void;
@@ -238,6 +239,10 @@ export interface WebSocketConfiguration {
 }
 export class WebSocket implements Channel {
     constructor(config?: WebSocketConfiguration);
+    open(url: string): void;
+    forceClose(): void;
+    remoteAddress(): string | undefined;
+    path(): string | undefined;
 
     // Channel implementation
     close(): void;

package/package.json

@@ -1,19 +1,30 @@
 {
     "name": "node-datachannel",
-    "version": "0.7.0",
+    "version": "0.9.0",
     "description": "libdatachannel node bindings",
     "type": "module",
     "exports": {
         ".": {
-            "import": "./lib/index.js",
-            "require": "./lib/index.cjs"
+            "import": {
+                "default": "./lib/index.js",
+                "types": "./lib/index.d.ts"
+            },
+            "require": {
+                "default": "./lib/index.cjs",
+                "types": "./lib/index.d.cts"
+            }
         },
         "./polyfill": {
-            "import": "./polyfill/index.js",
-            "require": "./polyfill/polyfill.cjs"
+            "import": {
+                "default": "./polyfill/index.js",
+                "types": "./polyfill/index.d.ts"
+            },
+            "require": {
+                "default": "./polyfill/index.cjs",
+                "types": "./polyfill/index.d.cts"
+            }
         }
     },
-    "typings": "lib/index.d.ts",
     "engines": {
         "node": ">=16.0.0"
     },
@@ -34,7 +45,7 @@
         "test": "NODE_OPTIONS=--experimental-vm-modules jest",
         "wpt-test": "node test/wpt.js",
         "test-types": "tsc",
-        "prepublishOnly": "rollup lib/index.js --file lib/index.cjs --format cjs && rollup polyfill/index.js --file polyfill/polyfill.cjs --format cjs"
+        "prepublishOnly": "cp lib/index.d.ts lib/index.d.cts && cp polyfill/index.d.ts polyfill/index.d.cts && rollup lib/index.js --file lib/index.cjs --format cjs && rollup polyfill/index.js --file polyfill/index.cjs --format cjs"
     },
     "binary": {
         "napi_versions": [
@@ -88,4 +99,4 @@
         "prebuild-install": "^7.0.1",
         "rollup": "^4.14.1"
     }
-}
+}

package/polyfill/{polyfill.cjs → index.cjs}

@@ -547,7 +547,7 @@ class DataChannelStream extends stream.Duplex {
 }
 
 // createRequire is native in node version >= 12
-const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('polyfill.cjs', document.baseURI).href)));
+const require$1 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
 
 const nodeDataChannel = require$1('../build/Release/node_datachannel.node');
 

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

@@ -58,6 +58,10 @@ DataChannelWrapper::DataChannelWrapper(const Napi::CallbackInfo &info) : Napi::O
     PLOG_DEBUG << "Constructor called";
     mDataChannelPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::DataChannel>>>().Data());
     PLOG_DEBUG << "Data Channel created";
+
+    // Closed callback must be set to trigger cleanup
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
+
     instances.insert(this);
 }
 

package/src/media-audio-wrapper.cpp

@@ -390,9 +390,8 @@ void AudioWrapper::setBitrate(const Napi::CallbackInfo &info)
         return;
     }
 
-    int bitRate = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
-
-    mAudioPtr->setBitrate(bitRate);
+    unsigned int bitrate = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+    mAudioPtr->setBitrate(bitrate);
 }
 
 Napi::Value AudioWrapper::getBitrate(const Napi::CallbackInfo &info)
@@ -428,9 +427,9 @@ void AudioWrapper::addRTXCodec(const Napi::CallbackInfo &info)
         return;
     }
 
-    unsigned int payloadType = static_cast<unsigned int>(info[0].As<Napi::Number>().ToNumber());
-    unsigned int originalPayloadType = static_cast<unsigned int>(info[1].As<Napi::Number>().ToNumber());
-    unsigned int clockRate = static_cast<unsigned int>(info[2].As<Napi::Number>().ToNumber());
+    int payloadType = static_cast<int32_t>(info[0].As<Napi::Number>().ToNumber());
+    int originalPayloadType = static_cast<int32_t>(info[1].As<Napi::Number>().ToNumber());
+    unsigned int clockRate = static_cast<uint32_t>(info[2].As<Napi::Number>().ToNumber());
 
     mAudioPtr->addRtxCodec(payloadType, originalPayloadType, clockRate);
 }

package/src/media-rtcpreceivingsession-wrapper.cpp

@@ -51,13 +51,12 @@ void RtcpReceivingSessionWrapper::requestBitrate(const Napi::CallbackInfo &info)
         return;
     }
 
-    unsigned int bitRate = static_cast<unsigned int>(info[0].As<Napi::Number>().ToNumber());
-
-    mSessionPtr->requestBitrate(bitRate);
+    unsigned int bitrate = static_cast<uint32_t>(info[0].As<Napi::Number>().ToNumber());
+    mSessionPtr->requestBitrate(bitrate);
 }
 
 Napi::Value RtcpReceivingSessionWrapper::requestKeyframe(const Napi::CallbackInfo &info)
 {
     Napi::Env env = info.Env();
     return Napi::Boolean::New(env, mSessionPtr->requestKeyframe());
-}
+}

package/src/media-track-wrapper.cpp

@@ -39,6 +39,7 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
             InstanceMethod("isOpen", &TrackWrapper::isOpen),
             InstanceMethod("isClosed", &TrackWrapper::isClosed),
             InstanceMethod("maxMessageSize", &TrackWrapper::maxMessageSize),
+            InstanceMethod("requestBitrate", &TrackWrapper::requestBitrate),
             InstanceMethod("requestKeyframe", &TrackWrapper::requestKeyframe),
             InstanceMethod("setMediaHandler", &TrackWrapper::setMediaHandler),
             InstanceMethod("onOpen", &TrackWrapper::onOpen),
@@ -56,7 +57,12 @@ Napi::Object TrackWrapper::Init(Napi::Env env, Napi::Object exports)
 
 TrackWrapper::TrackWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<TrackWrapper>(info)
 {
+    PLOG_DEBUG << "Constructor called";
     mTrackPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::Track>>>().Data());
+    PLOG_DEBUG << "Track created";
+
+    // Closed callback must be set to trigger cleanup
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
 
     instances.insert(this);
 }
@@ -237,6 +243,27 @@ Napi::Value TrackWrapper::maxMessageSize(const Napi::CallbackInfo &info)
     }
 }
 
+Napi::Value TrackWrapper::requestBitrate(const Napi::CallbackInfo &info)
+{
+    if (!mTrackPtr)
+    {
+        Napi::Error::New(info.Env(), "requestBitrate() called on destroyed track").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsNumber())
+    {
+        Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    unsigned int bitrate = static_cast<uint32_t>(info[0].As<Napi::Number>());
+    return Napi::Boolean::New(env, mTrackPtr->requestBitrate(bitrate));
+}
+
 Napi::Value TrackWrapper::requestKeyframe(const Napi::CallbackInfo &info)
 {
     if (!mTrackPtr)

package/src/media-track-wrapper.h

@@ -30,6 +30,7 @@ public:
   Napi::Value isOpen(const Napi::CallbackInfo &info);
   Napi::Value isClosed(const Napi::CallbackInfo &info);
   Napi::Value maxMessageSize(const Napi::CallbackInfo &info);
+  Napi::Value requestBitrate(const Napi::CallbackInfo &info);
   Napi::Value requestKeyframe(const Napi::CallbackInfo &info);
   void setMediaHandler(const Napi::CallbackInfo &info);
 

package/src/media-video-wrapper.cpp

@@ -423,14 +423,12 @@ void VideoWrapper::setBitrate(const Napi::CallbackInfo &info)
         return;
     }
 
-    int bitRate = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
-
-    mVideoPtr->setBitrate(bitRate);
+    unsigned int bitrate = info[0].As<Napi::Number>().ToNumber().Uint32Value();
+    mVideoPtr->setBitrate(bitrate);
 }
 
 Napi::Value VideoWrapper::getBitrate(const Napi::CallbackInfo &info)
 {
-
     return Napi::Number::New(info.Env(), mVideoPtr->bitrate());
 }
 
@@ -445,7 +443,7 @@ Napi::Value VideoWrapper::hasPayloadType(const Napi::CallbackInfo &info)
         return env.Null();
     }
 
-    int payloadType = static_cast<int>(info[0].As<Napi::Number>().ToNumber());
+    int payloadType = static_cast<int32_t>(info[0].As<Napi::Number>().ToNumber());
 
     return Napi::Boolean::New(env, mVideoPtr->hasPayloadType(payloadType));
 }
@@ -461,9 +459,9 @@ void VideoWrapper::addRTXCodec(const Napi::CallbackInfo &info)
         return;
     }
 
-    unsigned int payloadType = static_cast<unsigned int>(info[0].As<Napi::Number>().ToNumber());
-    unsigned int originalPayloadType = static_cast<unsigned int>(info[1].As<Napi::Number>().ToNumber());
-    unsigned int clockRate = static_cast<unsigned int>(info[2].As<Napi::Number>().ToNumber());
+    int payloadType = static_cast<int32_t>(info[0].As<Napi::Number>().ToNumber());
+    int originalPayloadType = static_cast<int32_t>(info[1].As<Napi::Number>().ToNumber());
+    unsigned int clockRate = static_cast<uint32_t>(info[2].As<Napi::Number>().ToNumber());
 
     mVideoPtr->addRtxCodec(payloadType, originalPayloadType, clockRate);
 }

package/src/peer-connection-wrapper.cpp

@@ -237,7 +237,7 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
     // Create peer-connection
     try
     {
-        PLOG_DEBUG << "Creating a new peer";
+        PLOG_DEBUG << "Creating a new Peer Connection";
         mRtcPeerConnPtr = std::make_unique<rtc::PeerConnection>(rtcConfig);
     }
     catch (std::exception &ex)
@@ -246,6 +246,11 @@ PeerConnectionWrapper::PeerConnectionWrapper(const Napi::CallbackInfo &info) : N
         return;
     }
 
+    PLOG_DEBUG << "Peer Connection created";
+
+    // State change callback must be set to trigger cleanup on close
+    mOnStateChangeCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
+
     instances.insert(this);
 }
 
@@ -552,10 +557,10 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
                 switch (reliability.Get("type").As<Napi::Number>().Uint32Value())
                 {
                 case 1:
-                    init.reliability.rexmit = static_cast<int>(reliability.Get("rexmit").As<Napi::Number>().ToNumber());
+                    init.reliability.rexmit = int(reliability.Get("rexmit").As<Napi::Number>().ToNumber().Uint32Value());
                     break;
                 case 2:
-                    init.reliability.rexmit = std::chrono::milliseconds(reliability.Get("rexmit").As<Napi::Number>().Uint32Value());
+                    init.reliability.rexmit = std::chrono::milliseconds(reliability.Get("rexmit").As<Napi::Number>().Int32Value());
                     break;
                 }
             }
@@ -572,25 +577,31 @@ Napi::Value PeerConnectionWrapper::createDataChannel(const Napi::CallbackInfo &i
             init.reliability.unordered = !initConfig.Get("ordered").As<Napi::Boolean>();
         }
 
-        if (initConfig.Get("maxPacketLifeTime").IsNumber() && initConfig.Get("maxRetransmits").IsNumber())
+
+        if (!initConfig.Get("maxPacketLifeTime").IsUndefined() && !initConfig.Get("maxPacketLifeTime").IsNull() &&
+            !initConfig.Get("maxRetransmits").IsUndefined() && !initConfig.Get("maxRetransmits").IsNull())
         {
             Napi::TypeError::New(env, "Wrong DataChannel Init Config, maxPacketLifeTime and maxRetransmits are exclusive").ThrowAsJavaScriptException();
             return info.Env().Null();
         }
 
-        if (initConfig.Get("maxPacketLifeTime").IsNumber())
+        if (!initConfig.Get("maxPacketLifeTime").IsUndefined() && !initConfig.Get("maxPacketLifeTime").IsNull())
         {
-            init.reliability.type = rtc::Reliability::Type::Timed;
-            init.reliability.rexmit = std::chrono::milliseconds(initConfig.Get("maxPacketLifeTime").As<Napi::Number>().Uint32Value());
-        }
-        else if (initConfig.Get("maxRetransmits").IsNumber())
-        {
-            init.reliability.type = rtc::Reliability::Type::Rexmit;
-            init.reliability.rexmit = int(initConfig.Get("maxRetransmits").As<Napi::Number>().Uint32Value());
+            if (!initConfig.Get("maxPacketLifeTime").IsNumber())
+            {
+                Napi::TypeError::New(env, "Wrong DataChannel Init Config (maxPacketLifeTime)").ThrowAsJavaScriptException();
+                return info.Env().Null();
+            }
+            init.reliability.maxPacketLifeTime = std::chrono::milliseconds(initConfig.Get("maxPacketLifeTime").As<Napi::Number>().Uint32Value());
         }
-        else
+        else if (!initConfig.Get("maxRetransmits").IsUndefined() && !initConfig.Get("maxRetransmits").IsNull())
         {
-            init.reliability.type = rtc::Reliability::Type::Reliable;
+            if (!initConfig.Get("maxRetransmits").IsNumber())
+            {
+                Napi::TypeError::New(env, "Wrong DataChannel Init Config (maxRetransmits)").ThrowAsJavaScriptException();
+                return info.Env().Null();
+            }
+            init.reliability.maxRetransmits = int(initConfig.Get("maxRetransmits").As<Napi::Number>().Int32Value());
         }
     }
 

package/src/thread-safe-callback.cpp

@@ -9,16 +9,16 @@ const char *ThreadSafeCallback::CancelException::what() const throw()
 
 ThreadSafeCallback::ThreadSafeCallback(Napi::Function callback)
 {
-    if (!callback.IsFunction())
-        throw Napi::Error::New(callback.Env(), "Callback must be a function");
-
     Napi::Env env = callback.Env();
 
-    receiver = Napi::Persistent(static_cast<Napi::Value>(Napi::Object::New(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, 1, &receiver);
+                       0, // unlimited queue
+                       1);
 }
 
 ThreadSafeCallback::~ThreadSafeCallback()
@@ -38,10 +38,10 @@ void ThreadSafeCallback::call(arg_func_t argFunc, cleanup_func_t cleanupFunc)
 
 void ThreadSafeCallback::callbackFunc(Napi::Env env,
                                       Napi::Function callback,
-                                      Napi::Reference<Napi::Value> *context,
+                                      ContextType *context,
                                       CallbackData *data)
 {
-    // if env is gone this could mean cb fn has changed. See issue#176
+    // if env is gone, it could mean this cb was destroyed. See issue#176
     if (!data || !env)
         return;
 
@@ -59,9 +59,10 @@ void ThreadSafeCallback::callbackFunc(Napi::Env env,
         return;
     }
 
-    if (env && callback)
+    if (callback)
     {
-        callback.Call(context->Value(), args);
-        cleanup();
+        callback.Call(args);
     }
+
+    cleanup();
 }

package/src/thread-safe-callback.h

@@ -30,6 +30,7 @@ public:
     };
 
 private:
+    using ContextType = std::nullptr_t;
     struct CallbackData
     {
         arg_func_t argFunc;
@@ -38,12 +39,10 @@ private:
 
     static void callbackFunc(Napi::Env env,
                              Napi::Function callback,
-                             Napi::Reference<Napi::Value> *context,
+                             ContextType *context,
                              CallbackData *data);
 
-    using tsfn_t = Napi::TypedThreadSafeFunction<Napi::Reference<Napi::Value>, CallbackData, callbackFunc>;
-
-    Napi::Reference<Napi::Value> receiver;
+    using tsfn_t = Napi::TypedThreadSafeFunction<ContextType, CallbackData, callbackFunc>;
     tsfn_t tsfn;
 };
 

package/src/web-socket-wrapper.cpp

@@ -31,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),
@@ -42,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);
@@ -235,6 +238,10 @@ WebSocketWrapper::WebSocketWrapper(const Napi::CallbackInfo &info) : Napi::Objec
     }
 
     PLOG_DEBUG << "WebSocket created";
+
+    // Closed callback must set to trigger cleanup
+    mOnClosedCallback = std::make_unique<ThreadSafeCallback>(Napi::Function::New(info.Env(), [](const Napi::CallbackInfo&){}));
+
     instances.insert(this);
 }
 
@@ -257,7 +264,31 @@ 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();
+    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;
         }
     }
@@ -297,7 +328,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;
     }
 }
@@ -308,6 +339,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";
@@ -333,7 +370,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);
     }
 }
@@ -363,7 +400,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);
     }
 }
@@ -384,7 +421,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);
     }
 }
@@ -405,7 +442,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);
     }
 }
@@ -426,11 +463,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";
@@ -455,7 +550,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;
     }
 }

package/src/web-socket-wrapper.h

@@ -23,12 +23,15 @@ public:
   // Functions
   void open(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);
@@ -47,6 +50,7 @@ private:
   static std::unordered_set<WebSocketWrapper *> instances;
 
   void doClose();
+  void doForceClose();
   void doCleanup();
 
   std::shared_ptr<rtc::WebSocket> mWebSocketPtr = nullptr;

package/test/websockets.js

@@ -6,7 +6,9 @@ nodeDataChannel.preload();
 const webSocketServer = new nodeDataChannel.WebSocketServer({ bindAddress: '127.0.0.1', port: 1987 });
 
 webSocketServer.onClient((serverSocket) => {
-    console.log('webSocketServer.onClient()');
+    console.log(
+        'webSocketServer.onClient() remoteAddress: ' + serverSocket.remoteAddress() + ', path: ' + serverSocket.path(),
+    );
 
     serverSocket.onOpen(() => {
         console.log('serverSocket.onOpen()');
@@ -32,7 +34,7 @@ clientSocket.onOpen(() => {
 
 clientSocket.onMessage((message) => {
     console.log('clientSocket.onMessage():', message);
-    clientSocket.close();
+    clientSocket.forceClose();
     webSocketServer.stop();
 });