node-datachannel 0.4.2 → 0.5.0-dev

package/src/thread-safe-callback.h

@@ -1,12 +1,6 @@
 #ifndef THREAD_SAFE_CALLBACK_H
 #define THREAD_SAFE_CALLBACK_H
 
-#ifdef LEGACY_NAPI_THREAD_SAFE_CALLBACK
-
-#include "napi-thread-safe-callback.hpp"
-
-#else
-
 #include <napi.h>
 
 #include <vector>
@@ -24,14 +18,14 @@ public:
     ThreadSafeCallback(const ThreadSafeCallback &) = delete;
     ThreadSafeCallback(ThreadSafeCallback &&) = delete;
 
-    ThreadSafeCallback& operator=(const ThreadSafeCallback &) = delete;
-    ThreadSafeCallback& operator=(ThreadSafeCallback &&) = delete;
+    ThreadSafeCallback &operator=(const ThreadSafeCallback &) = delete;
+    ThreadSafeCallback &operator=(ThreadSafeCallback &&) = delete;
 
     void call(arg_func_t argFunc);
 
     class CancelException : public std::exception
     {
-        const char* what() const throw();
+        const char *what() const throw();
     };
 
 private:
@@ -51,7 +45,4 @@ private:
     tsfn_t tsfn;
 };
 
-#endif // LEGACY_NAPI_THREAD_SAFE_CALLBACK
-
 #endif // THREAD_SAFE_CALLBACK_H
-

package/test/connectivity.js

@@ -1,5 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const nodeDataChannel = require('../lib/index');
+import nodeDataChannel from '../lib/index.js';
 
 nodeDataChannel.initLogger('Debug');
 nodeDataChannel.preload();
@@ -32,6 +31,9 @@ let peer1 = new nodeDataChannel.PeerConnection('Peer1', { iceServers: ['stun:stu
 peer1.onStateChange((state) => {
     console.log('Peer1 State:', state);
 });
+peer1.onIceStateChange((state) => {
+    console.log('Peer1 IceState:', state);
+});
 peer1.onGatheringStateChange((state) => {
     console.log('Peer1 GatheringState:', state);
 });
@@ -50,6 +52,9 @@ let peer2 = new nodeDataChannel.PeerConnection('Peer2', { iceServers: ['stun:stu
 peer2.onStateChange((state) => {
     console.log('Peer2 State:', state);
 });
+peer2.onIceStateChange((state) => {
+    console.log('Peer2 IceState:', state);
+});
 peer2.onGatheringStateChange((state) => {
     console.log('Peer2 GatheringState:', state);
 });
@@ -95,8 +100,8 @@ dc1.onClosed(() => {
 });
 
 setTimeout(() => {
-    dc1.close();
-    dc2.close();
+    if (dc1) dc1.close();
+    if (dc2) dc2.close();
     peer1.close();
     peer2.close();
     nodeDataChannel.cleanup();

package/test/polyfill-connectivity.js

@@ -0,0 +1,89 @@
+import polyfill from '../polyfill/index.js';
+import nodeDataChannel from '../lib/index.js';
+
+nodeDataChannel.initLogger('Info');
+
+let dc1 = null;
+let dc2 = null;
+
+let peer1 = new polyfill.RTCPeerConnection({
+    peerIdentity: 'peer1',
+    iceServers: [{ urls: ['stun:stun.l.google.com:19302'] }],
+});
+
+// Set Callbacks
+peer1.onconnectionstatechange = () => {
+    console.log('Peer1 State:', peer1.connectionState);
+};
+peer1.oniceconnectionstatechange = () => {
+    console.log('Peer1 IceState:', peer1.iceConnectionState);
+};
+peer1.onicegatheringstatechange = () => {
+    console.log('Peer1 GatheringState:', peer1.iceGatheringState);
+};
+peer1.onicecandidate = (e) => {
+    console.log('Peer1 Candidate:', e.candidate.candidate);
+    peer2.addIceCandidate(e.candidate);
+};
+
+let peer2 = new polyfill.RTCPeerConnection({
+    peerIdentity: 'peer2',
+    iceServers: [{ urls: ['stun:stun.l.google.com:19302'] }],
+});
+
+// Set Callbacks
+peer2.onconnectionstatechange = () => {
+    console.log('Peer2 State:', peer2.connectionState);
+};
+peer2.oniceconnectionstatechange = () => {
+    console.log('Peer2 IceState:', peer2.iceConnectionState);
+};
+peer2.onicegatheringstatechange = () => {
+    console.log('Peer2 GatheringState:', peer2.iceGatheringState);
+};
+peer2.onicecandidate = (e) => {
+    console.log('Peer2 Candidate:', e.candidate.candidate);
+    peer1.addIceCandidate(e.candidate);
+};
+peer2.ondatachannel = (dce) => {
+    console.log('Peer2 Got DataChannel: ', dce.channel.label);
+    dc2 = dce.channel;
+    dc2.onmessage = (msg) => {
+        console.log('Peer2 Received Msg:', msg.data.toString());
+    };
+    dc2.send('Hello From Peer2');
+    dc2.onclose = () => {
+        console.log('dc2 closed');
+    };
+};
+
+dc1 = peer1.createDataChannel('test');
+dc1.onopen = () => {
+    dc1.send('Hello from Peer1');
+};
+dc1.onmessage = (msg) => {
+    console.log('Peer1 Received Msg:', msg.data.toString());
+};
+dc1.onclose = () => {
+    console.log('dc1 closed');
+};
+
+peer1
+    .createOffer({})
+    .then((desc) => {
+        peer2.setRemoteDescription(desc);
+    })
+    .catch((err) => console.error(err));
+
+peer2
+    .createAnswer({})
+    .then((answerDesc) => {
+        peer1.setRemoteDescription(answerDesc);
+    })
+    .catch((err) => console.error("Couldn't create answer", err));
+
+setTimeout(() => {
+    peer1.close();
+    peer2.close();
+    nodeDataChannel.cleanup();
+}, 5 * 1000);

package/test/test.js

@@ -1,5 +1,5 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const nodeDataChannel = require('../lib/index');
+import { jest } from '@jest/globals';
+import nodeDataChannel, { DataChannelStream } from '../lib/index.js';
 
 describe('Module Definition', () => {
     test('Module Defined', () => {
@@ -154,7 +154,7 @@ describe('DataChannel streams', () => {
         let clientPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
         let echoPeer = new nodeDataChannel.PeerConnection('Client', { iceServers: [] });
 
-        const echoStream = new nodeDataChannel.DataChannelStream(echoPeer.createDataChannel('echo-channel'));
+        const echoStream = new DataChannelStream(echoPeer.createDataChannel('echo-channel'));
         echoStream.pipe(echoStream); // Echo all received data back to the client
 
         await waitForGathering(echoPeer);

package/test/wpt.js

@@ -0,0 +1,50 @@
+// RUn WPT manually before calling this script
+// Example: ./wpt serve
+// Example: node test/wpt.js
+
+import { JSDOM } from 'jsdom';
+import nodeDataChannel from '../lib/index.js';
+
+const WPT_SERVER_URL = 'http://web-platform.test:8000';
+const WPT_TEST_PATH_LIST = ['/webrtc/RTCPeerConnection-addIceCandidate.html', '/webrtc/RTCDataChannel-send.html'];
+
+// call runTest for each test path
+for (let i = 0; i < WPT_TEST_PATH_LIST.length; i++) {
+    let result = await runTest(`${WPT_SERVER_URL}${WPT_TEST_PATH_LIST[i]}`);
+    console.log(result);
+
+    // sleep for 1 second
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+}
+
+function runTest(filePath) {
+    // return new promise
+    return new Promise((resolve, reject) => {
+        JSDOM.fromURL(filePath, {
+            runScripts: 'dangerously',
+            resources: 'usable',
+        }).then((dom) => {
+            const { window } = dom;
+
+            // Assign the data channel polyfill to the window object
+            Object.assign(window, nodeDataChannel);
+
+            const returnObject = [];
+            window.addEventListener('load', () => {
+                window.add_result_callback((test) => {
+                    // Meaning of status
+                    // 0: PASS (test passed)
+                    // 1: FAIL (test failed)
+                    // 2: TIMEOUT (test timed out)
+                    // 3: PRECONDITION_FAILED (test skipped)
+                    returnObject.push({ name: test.name, message: test.message, status: test.status });
+                });
+
+                window.add_completion_callback(() => {
+                    window.close();
+                    return resolve(returnObject);
+                });
+            });
+        });
+    });
+}

package/.github/workflows/build-linux-arm64-test.yml

@@ -1,36 +0,0 @@
-name: Build - Linux-Arm64
-
-on:
-  workflow_dispatch:
-
-env:
-  ACTIONS_ALLOW_UNSECURE_COMMANDS: true
-
-jobs:
-  build-linux-arm64:
-    runs-on: ubuntu-20.04
-
-    strategy:
-      matrix:
-        node-version: [12.x, 13.x, 14.x, 15.x, 16.x, 17.x, 18.x, 19.x]
-    steps:
-      - uses: actions/checkout@v2
-      - name: Prepare Cross Compile
-        run: |
-          sudo apt update
-          sudo apt install -y g++-aarch64-linux-gnu gcc-aarch64-linux-gnu
-          mkdir sysroot && cd sysroot
-          wget https://commondatastorage.googleapis.com/chrome-linux-sysroot/toolchain/953c2471bc7e71a788309f6c2d2003e8b703305d/debian_sid_arm64_sysroot.tar.xz        
-          tar xf debian_sid_arm64_sysroot.tar.xz
-          echo "ARM64_SYSROOT=$(pwd)" >> $GITHUB_ENV
-          ls -l
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v1
-        with:
-          node-version: ${{ matrix.node-version }}
-      - name: Build & Upload
-        run: |
-          npm install --ignore-scripts
-          node_modules/.bin/prebuild --backend cmake-js --arch arm64 --upload -u ${{ secrets.GITHUB_TOKEN }} -- --CDCMAKE_TOOLCHAIN_FILE:FILEPATH=./cmake/toolchain/arm64.cmake
-        env:
-          CI: true

package/examples/README.md

@@ -1,21 +0,0 @@
-# Examples
-
-# client-server
- * You can use client-server example project to test WebRTC Data Channels with WebSocket signaling.
- * It uses same logic of [libdatachannel/examples/client](https://github.com/paullouisageneau/libdatachannel/tree/master/examples) project.
- * Contains an equivalent implementation for a node.js signaling server
-
-## How to Use?
-* Prepare Project
-  * cd examples/client-server
-  * npm i
-* Start ws signaling server;
-  * node signaling-server.js
-* Start answerer (On a new Console);
-  * node client.js
-  * Note local ID
-* Start Offerer (On a new Console);
-  * node client.js
-  * Enter answerer ID
-
-  > You can also use [libdatachannel/examples/client](https://github.com/paullouisageneau/libdatachannel/tree/master/examples) project's client & signaling server

package/node_modules/ansi-regex/index.js

@@ -1,4 +0,0 @@
-'use strict';
-module.exports = function () {
-	return /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;
-};

package/node_modules/ansi-regex/package.json

@@ -1,111 +0,0 @@
-{
-  "_args": [
-    [
-      "ansi-regex@2.1.1",
-      "/home/runner/work/node-datachannel/node-datachannel"
-    ]
-  ],
-  "_from": "ansi-regex@2.1.1",
-  "_id": "ansi-regex@2.1.1",
-  "_inBundle": false,
-  "_integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=",
-  "_location": "/ansi-regex",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "ansi-regex@2.1.1",
-    "name": "ansi-regex",
-    "escapedName": "ansi-regex",
-    "rawSpec": "2.1.1",
-    "saveSpec": null,
-    "fetchSpec": "2.1.1"
-  },
-  "_requiredBy": [
-    "/strip-ansi"
-  ],
-  "_resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz",
-  "_spec": "2.1.1",
-  "_where": "/home/runner/work/node-datachannel/node-datachannel",
-  "author": {
-    "name": "Sindre Sorhus",
-    "email": "sindresorhus@gmail.com",
-    "url": "sindresorhus.com"
-  },
-  "bugs": {
-    "url": "https://github.com/chalk/ansi-regex/issues"
-  },
-  "description": "Regular expression for matching ANSI escape codes",
-  "devDependencies": {
-    "ava": "0.17.0",
-    "xo": "0.16.0"
-  },
-  "engines": {
-    "node": ">=0.10.0"
-  },
-  "files": [
-    "index.js"
-  ],
-  "homepage": "https://github.com/chalk/ansi-regex#readme",
-  "keywords": [
-    "ansi",
-    "styles",
-    "color",
-    "colour",
-    "colors",
-    "terminal",
-    "console",
-    "cli",
-    "string",
-    "tty",
-    "escape",
-    "formatting",
-    "rgb",
-    "256",
-    "shell",
-    "xterm",
-    "command-line",
-    "text",
-    "regex",
-    "regexp",
-    "re",
-    "match",
-    "test",
-    "find",
-    "pattern"
-  ],
-  "license": "MIT",
-  "maintainers": [
-    {
-      "name": "Sindre Sorhus",
-      "email": "sindresorhus@gmail.com",
-      "url": "sindresorhus.com"
-    },
-    {
-      "name": "Joshua Appelman",
-      "email": "jappelman@xebia.com",
-      "url": "jbnicolai.com"
-    },
-    {
-      "name": "JD Ballard",
-      "email": "i.am.qix@gmail.com",
-      "url": "github.com/qix-"
-    }
-  ],
-  "name": "ansi-regex",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/chalk/ansi-regex.git"
-  },
-  "scripts": {
-    "test": "xo && ava --verbose",
-    "view-supported": "node fixtures/view-codes.js"
-  },
-  "version": "2.1.1",
-  "xo": {
-    "rules": {
-      "guard-for-in": 0,
-      "no-loop-func": 0
-    }
-  }
-}

package/node_modules/ansi-regex/readme.md

@@ -1,39 +0,0 @@
-# ansi-regex [![Build Status](https://travis-ci.org/chalk/ansi-regex.svg?branch=master)](https://travis-ci.org/chalk/ansi-regex)
-
-> Regular expression for matching [ANSI escape codes](http://en.wikipedia.org/wiki/ANSI_escape_code)
-
-
-## Install
-
-```
-$ npm install --save ansi-regex
-```
-
-
-## Usage
-
-```js
-const ansiRegex = require('ansi-regex');
-
-ansiRegex().test('\u001b[4mcake\u001b[0m');
-//=> true
-
-ansiRegex().test('cake');
-//=> false
-
-'\u001b[4mcake\u001b[0m'.match(ansiRegex());
-//=> ['\u001b[4m', '\u001b[0m']
-```
-
-## FAQ
-
-### Why do you test for codes not in the ECMA 48 standard?
-
-Some of the codes we run as a test are codes that we acquired finding various lists of non-standard or manufacturer specific codes. If I recall correctly, we test for both standard and non-standard codes, as most of them follow the same or similar format and can be safely matched in strings without the risk of removing actual string content. There are a few non-standard control codes that do not follow the traditional format (i.e. they end in numbers) thus forcing us to exclude them from the test because we cannot reliably match them.
-
-On the historical side, those ECMA standards were established in the early 90's whereas the VT100, for example, was designed in the mid/late 70's. At that point in time, control codes were still pretty ungoverned and engineers used them for a multitude of things, namely to activate hardware ports that may have been proprietary. Somewhere else you see a similar 'anarchy' of codes is in the x86 architecture for processors; there are a ton of "interrupts" that can mean different things on certain brands of processors, most of which have been phased out.
-
-
-## License
-
-MIT © [Sindre Sorhus](http://sindresorhus.com)

package/node_modules/aproba/LICENSE

@@ -1,14 +0,0 @@
-Copyright (c) 2015, Rebecca Turner <me@re-becca.org>
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-

package/node_modules/aproba/README.md

@@ -1,94 +0,0 @@
-aproba
-======
-
-A ridiculously light-weight function argument validator
-
-```
-var validate = require("aproba")
-
-function myfunc(a, b, c) {
-  // `a` must be a string, `b` a number, `c` a function
-  validate('SNF', arguments) // [a,b,c] is also valid
-}
-
-myfunc('test', 23, function () {}) // ok
-myfunc(123, 23, function () {}) // type error
-myfunc('test', 23) // missing arg error
-myfunc('test', 23, function () {}, true) // too many args error
-
-```
-
-Valid types are:
-
-| type | description
-| :--: | :----------
-| *    | matches any type
-| A    | `Array.isArray` OR an `arguments` object
-| S    | typeof == string
-| N    | typeof == number
-| F    | typeof == function
-| O    | typeof == object and not type A and not type E
-| B    | typeof == boolean
-| E    | `instanceof Error` OR `null` **(special: see below)**
-| Z    | == `null`
-
-Validation failures throw one of three exception types, distinguished by a
-`code` property of `EMISSINGARG`, `EINVALIDTYPE` or `ETOOMANYARGS`.
-
-If you pass in an invalid type then it will throw with a code of
-`EUNKNOWNTYPE`.
-
-If an **error** argument is found and is not null then the remaining
-arguments are optional.  That is, if you say `ESO` then that's like using a
-non-magical `E` in: `E|ESO|ZSO`.
-
-### But I have optional arguments?!
-
-You can provide more than one signature by separating them with pipes `|`.
-If any signature matches the arguments then they'll be considered valid.
-
-So for example, say you wanted to write a signature for
-`fs.createWriteStream`.  The docs for it describe it thusly:
-
-```
-fs.createWriteStream(path[, options])
-```
-
-This would be a signature of `SO|S`.  That is, a string and and object, or
-just a string.
-
-Now, if you read the full `fs` docs, you'll see that actually path can ALSO
-be a buffer.  And options can be a string, that is:
-```
-path <String> | <Buffer>
-options <String> | <Object>
-```
-
-To reproduce this you have to fully enumerate all of the possible
-combinations and that implies a signature of `SO|SS|OO|OS|S|O`.  The
-awkwardness is a feature: It reminds you of the complexity you're adding to
-your API when you do this sort of thing.
-
-
-### Browser support
-
-This has no dependencies and should work in browsers, though you'll have
-noisier stack traces.
-
-### Why this exists
-
-I wanted a very simple argument validator. It needed to do two things:
-
-1. Be more concise and easier to use than assertions
-
-2. Not encourage an infinite bikeshed of DSLs
-
-This is why types are specified by a single character and there's no such
-thing as an optional argument. 
-
-This is not intended to validate user data. This is specifically about
-asserting the interface of your functions.
-
-If you need greater validation, I encourage you to write them by hand or
-look elsewhere.
-

package/node_modules/aproba/index.js

@@ -1,105 +0,0 @@
-'use strict'
-
-function isArguments (thingy) {
-  return thingy != null && typeof thingy === 'object' && thingy.hasOwnProperty('callee')
-}
-
-var types = {
-  '*': {label: 'any', check: function () { return true }},
-  A: {label: 'array', check: function (thingy) { return Array.isArray(thingy) || isArguments(thingy) }},
-  S: {label: 'string', check: function (thingy) { return typeof thingy === 'string' }},
-  N: {label: 'number', check: function (thingy) { return typeof thingy === 'number' }},
-  F: {label: 'function', check: function (thingy) { return typeof thingy === 'function' }},
-  O: {label: 'object', check: function (thingy) { return typeof thingy === 'object' && thingy != null && !types.A.check(thingy) && !types.E.check(thingy) }},
-  B: {label: 'boolean', check: function (thingy) { return typeof thingy === 'boolean' }},
-  E: {label: 'error', check: function (thingy) { return thingy instanceof Error }},
-  Z: {label: 'null', check: function (thingy) { return thingy == null }}
-}
-
-function addSchema (schema, arity) {
-  var group = arity[schema.length] = arity[schema.length] || []
-  if (group.indexOf(schema) === -1) group.push(schema)
-}
-
-var validate = module.exports = function (rawSchemas, args) {
-  if (arguments.length !== 2) throw wrongNumberOfArgs(['SA'], arguments.length)
-  if (!rawSchemas) throw missingRequiredArg(0, 'rawSchemas')
-  if (!args) throw missingRequiredArg(1, 'args')
-  if (!types.S.check(rawSchemas)) throw invalidType(0, ['string'], rawSchemas)
-  if (!types.A.check(args)) throw invalidType(1, ['array'], args)
-  var schemas = rawSchemas.split('|')
-  var arity = {}
-
-  schemas.forEach(function (schema) {
-    for (var ii = 0; ii < schema.length; ++ii) {
-      var type = schema[ii]
-      if (!types[type]) throw unknownType(ii, type)
-    }
-    if (/E.*E/.test(schema)) throw moreThanOneError(schema)
-    addSchema(schema, arity)
-    if (/E/.test(schema)) {
-      addSchema(schema.replace(/E.*$/, 'E'), arity)
-      addSchema(schema.replace(/E/, 'Z'), arity)
-      if (schema.length === 1) addSchema('', arity)
-    }
-  })
-  var matching = arity[args.length]
-  if (!matching) {
-    throw wrongNumberOfArgs(Object.keys(arity), args.length)
-  }
-  for (var ii = 0; ii < args.length; ++ii) {
-    var newMatching = matching.filter(function (schema) {
-      var type = schema[ii]
-      var typeCheck = types[type].check
-      return typeCheck(args[ii])
-    })
-    if (!newMatching.length) {
-      var labels = matching.map(function (schema) {
-        return types[schema[ii]].label
-      }).filter(function (schema) { return schema != null })
-      throw invalidType(ii, labels, args[ii])
-    }
-    matching = newMatching
-  }
-}
-
-function missingRequiredArg (num) {
-  return newException('EMISSINGARG', 'Missing required argument #' + (num + 1))
-}
-
-function unknownType (num, type) {
-  return newException('EUNKNOWNTYPE', 'Unknown type ' + type + ' in argument #' + (num + 1))
-}
-
-function invalidType (num, expectedTypes, value) {
-  var valueType
-  Object.keys(types).forEach(function (typeCode) {
-    if (types[typeCode].check(value)) valueType = types[typeCode].label
-  })
-  return newException('EINVALIDTYPE', 'Argument #' + (num + 1) + ': Expected ' +
-    englishList(expectedTypes) + ' but got ' + valueType)
-}
-
-function englishList (list) {
-  return list.join(', ').replace(/, ([^,]+)$/, ' or $1')
-}
-
-function wrongNumberOfArgs (expected, got) {
-  var english = englishList(expected)
-  var args = expected.every(function (ex) { return ex.length === 1 })
-    ? 'argument'
-    : 'arguments'
-  return newException('EWRONGARGCOUNT', 'Expected ' + english + ' ' + args + ' but got ' + got)
-}
-
-function moreThanOneError (schema) {
-  return newException('ETOOMANYERRORTYPES',
-    'Only one error type per argument signature is allowed, more than one found in "' + schema + '"')
-}
-
-function newException (code, msg) {
-  var e = new Error(msg)
-  e.code = code
-  if (Error.captureStackTrace) Error.captureStackTrace(e, validate)
-  return e
-}