node-datachannel 0.1.8

package/node_modules/wide-align/package.json

@@ -0,0 +1,69 @@
+{
+  "_args": [
+    [
+      "wide-align@1.1.3",
+      "/home/runner/work/node-datachannel/node-datachannel"
+    ]
+  ],
+  "_from": "wide-align@1.1.3",
+  "_id": "wide-align@1.1.3",
+  "_inBundle": false,
+  "_integrity": "sha512-QGkOQc8XL6Bt5PwnsExKBPuMKBxnGxWWW3fU55Xt4feHozMUhdUMaBCk290qpm/wG5u/RSKzwdAC4i51YigihA==",
+  "_location": "/wide-align",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "wide-align@1.1.3",
+    "name": "wide-align",
+    "escapedName": "wide-align",
+    "rawSpec": "1.1.3",
+    "saveSpec": null,
+    "fetchSpec": "1.1.3"
+  },
+  "_requiredBy": [
+    "/npmlog/gauge"
+  ],
+  "_resolved": "https://registry.npmjs.org/wide-align/-/wide-align-1.1.3.tgz",
+  "_spec": "1.1.3",
+  "_where": "/home/runner/work/node-datachannel/node-datachannel",
+  "author": {
+    "name": "Rebecca Turner",
+    "email": "me@re-becca.org",
+    "url": "http://re-becca.org/"
+  },
+  "bugs": {
+    "url": "https://github.com/iarna/wide-align/issues"
+  },
+  "dependencies": {
+    "string-width": "^1.0.2 || 2"
+  },
+  "description": "A wide-character aware text alignment function for use on the console or with fixed width fonts.",
+  "devDependencies": {
+    "tap": "10 || 11 || 12"
+  },
+  "files": [
+    "align.js"
+  ],
+  "homepage": "https://github.com/iarna/wide-align#readme",
+  "keywords": [
+    "wide",
+    "double",
+    "unicode",
+    "cjkv",
+    "pad",
+    "align"
+  ],
+  "license": "ISC",
+  "main": "align.js",
+  "name": "wide-align",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iarna/wide-align.git"
+  },
+  "scripts": {
+    "test": "tap --coverage test/*.js",
+    "version": "perl -pi -e 's/^(  \"version\": $ENV{npm_config_node_version}\").*?\",/$1abc\",/' package-lock.json ; git add package-lock.json"
+  },
+  "version": "1.1.3"
+}

package/node_modules/wrappy/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+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/wrappy/README.md

@@ -0,0 +1,36 @@
+# wrappy
+
+Callback wrapping utility
+
+## USAGE
+
+```javascript
+var wrappy = require("wrappy")
+
+// var wrapper = wrappy(wrapperFunction)
+
+// make sure a cb is called only once
+// See also: http://npm.im/once for this specific use case
+var once = wrappy(function (cb) {
+  var called = false
+  return function () {
+    if (called) return
+    called = true
+    return cb.apply(this, arguments)
+  }
+})
+
+function printBoo () {
+  console.log('boo')
+}
+// has some rando property
+printBoo.iAmBooPrinter = true
+
+var onlyPrintOnce = once(printBoo)
+
+onlyPrintOnce() // prints 'boo'
+onlyPrintOnce() // does nothing
+
+// random property is retained!
+assert.equal(onlyPrintOnce.iAmBooPrinter, true)
+```

package/node_modules/wrappy/package.json

@@ -0,0 +1,62 @@
+{
+  "_args": [
+    [
+      "wrappy@1.0.2",
+      "/home/runner/work/node-datachannel/node-datachannel"
+    ]
+  ],
+  "_from": "wrappy@1.0.2",
+  "_id": "wrappy@1.0.2",
+  "_inBundle": false,
+  "_integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=",
+  "_location": "/wrappy",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "wrappy@1.0.2",
+    "name": "wrappy",
+    "escapedName": "wrappy",
+    "rawSpec": "1.0.2",
+    "saveSpec": null,
+    "fetchSpec": "1.0.2"
+  },
+  "_requiredBy": [
+    "/inflight",
+    "/once"
+  ],
+  "_resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
+  "_spec": "1.0.2",
+  "_where": "/home/runner/work/node-datachannel/node-datachannel",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "bugs": {
+    "url": "https://github.com/npm/wrappy/issues"
+  },
+  "dependencies": {},
+  "description": "Callback wrapping utility",
+  "devDependencies": {
+    "tap": "^2.3.1"
+  },
+  "directories": {
+    "test": "test"
+  },
+  "files": [
+    "wrappy.js"
+  ],
+  "homepage": "https://github.com/npm/wrappy",
+  "license": "ISC",
+  "main": "wrappy.js",
+  "name": "wrappy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/npm/wrappy.git"
+  },
+  "scripts": {
+    "test": "tap --coverage test/*.js"
+  },
+  "version": "1.0.2"
+}

package/node_modules/wrappy/wrappy.js

@@ -0,0 +1,33 @@
+// Returns a wrapper function that returns a wrapped callback
+// The wrapper function should do some stuff, and return a
+// presumably different callback function.
+// This makes sure that own properties are retained, so that
+// decorations and such are not lost along the way.
+module.exports = wrappy
+function wrappy (fn, cb) {
+  if (fn && cb) return wrappy(fn)(cb)
+
+  if (typeof fn !== 'function')
+    throw new TypeError('need wrapper function')
+
+  Object.keys(fn).forEach(function (k) {
+    wrapper[k] = fn[k]
+  })
+
+  return wrapper
+
+  function wrapper() {
+    var args = new Array(arguments.length)
+    for (var i = 0; i < args.length; i++) {
+      args[i] = arguments[i]
+    }
+    var ret = fn.apply(this, args)
+    var cb = args[args.length-1]
+    if (typeof ret === 'function' && ret !== cb) {
+      Object.keys(cb).forEach(function (k) {
+        ret[k] = cb[k]
+      })
+    }
+    return ret
+  }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "node-datachannel",
+  "version": "0.1.8",
+  "description": "libdatachannel node bindings",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "directories": {
+    "lib": "lib",
+    "test": "test"
+  },
+  "_from": "node-datachannel@latest",
+  "scripts": {
+    "install": "prebuild-install || (npm install --ignore-scripts && npm run _prebuild)",
+    "install-nice": "npm run clean && cmake-js build --CDUSE_NICE=1",
+    "build": "cmake-js build",
+    "_prebuild": "prebuild --backend cmake-js",
+    "clean": "cmake-js clean",
+    "test": "jest --forceExit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/murat-dogan/node-datachannel.git"
+  },
+  "keywords": [
+    "libdatachannel"
+  ],
+  "author": "Murat Doğan",
+  "license": "GPL-2.0-or-later",
+  "gypfile": true,
+  "bugs": {
+    "url": "https://github.com/murat-dogan/node-datachannel/issues"
+  },
+  "homepage": "https://github.com/murat-dogan/node-datachannel#readme",
+  "devDependencies": {
+    "cmake-js": "^6.1.0",
+    "jest": "^27.0.6",
+    "nan": "^2.14.2",
+    "napi-thread-safe-callback": "0.0.6",
+    "node-addon-api": "^3.1.0",
+    "prebuild": "^10.0.1"
+  },
+  "bundledDependencies": [
+    "prebuild-install"
+  ],
+  "dependencies": {
+    "prebuild-install": "^5.3.6"
+  }
+}

package/src/data-channel-wrapper.cpp

@@ -0,0 +1,401 @@
+#include "data-channel-wrapper.h"
+
+Napi::FunctionReference DataChannelWrapper::constructor;
+
+Napi::Object DataChannelWrapper::Init(Napi::Env env, Napi::Object exports)
+{
+    Napi::HandleScope scope(env);
+
+    Napi::Function func = DefineClass(
+        env,
+        "DataChannel",
+        {InstanceMethod("close", &DataChannelWrapper::close),
+         InstanceMethod("getLabel", &DataChannelWrapper::getLabel),
+         InstanceMethod("sendMessage", &DataChannelWrapper::sendMessage),
+         InstanceMethod("sendMessageBinary", &DataChannelWrapper::sendMessageBinary),
+         InstanceMethod("isOpen", &DataChannelWrapper::isOpen),
+         InstanceMethod("availableAmount", &DataChannelWrapper::availableAmount),
+         InstanceMethod("bufferedAmount", &DataChannelWrapper::bufferedAmount),
+         InstanceMethod("maxMessageSize", &DataChannelWrapper::maxMessageSize),
+         InstanceMethod("setBufferedAmountLowThreshold", &DataChannelWrapper::setBufferedAmountLowThreshold),
+         InstanceMethod("onOpen", &DataChannelWrapper::onOpen),
+         InstanceMethod("onClosed", &DataChannelWrapper::onClosed),
+         InstanceMethod("onError", &DataChannelWrapper::onError),
+         InstanceMethod("onAvailable", &DataChannelWrapper::onAvailable),
+         InstanceMethod("onBufferedAmountLow", &DataChannelWrapper::onBufferedAmountLow),
+         InstanceMethod("onMessage", &DataChannelWrapper::onMessage)});
+
+    constructor = Napi::Persistent(func);
+    constructor.SuppressDestruct();
+
+    exports.Set("DataChannel", func);
+    return exports;
+}
+
+DataChannelWrapper::DataChannelWrapper(const Napi::CallbackInfo &info) : Napi::ObjectWrap<DataChannelWrapper>(info)
+{
+    mDataChannelPtr = *(info[0].As<Napi::External<std::shared_ptr<rtc::DataChannel>>>().Data());
+}
+
+DataChannelWrapper::~DataChannelWrapper()
+{
+    if (mDataChannelPtr)
+    {
+        try
+        {
+            mDataChannelPtr->close();
+            mDataChannelPtr.reset();
+        }
+        catch (std::exception &ex)
+        {
+            std::cout << std::string("libdatachannel error while closing dataChannel# ") + ex.what() << std::endl;
+            return;
+        }
+    }
+}
+
+void DataChannelWrapper::close(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(env, "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        return;
+    }
+
+    try
+    {
+        mDataChannelPtr->close();
+        mDataChannelPtr.reset();
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error while closing dataChannel# ") + ex.what()).ThrowAsJavaScriptException();
+        return;
+    }
+}
+
+Napi::Value DataChannelWrapper::getLabel(const Napi::CallbackInfo &info)
+{
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    return Napi::String::New(info.Env(), mDataChannelPtr->label());
+}
+
+Napi::Value DataChannelWrapper::sendMessage(const Napi::CallbackInfo &info)
+{
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    // Allow call with NULL
+    if (length < 1 || (!info[0].IsString() && !info[0].IsNull()))
+    {
+        Napi::TypeError::New(env, "String or Null expected").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    try
+    {
+        return Napi::Boolean::New(info.Env(), mDataChannelPtr->send(info[0].As<Napi::String>().ToString()));
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error while sending dataChannel msg# ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Boolean::New(info.Env(), false);
+    }
+}
+
+Napi::Value DataChannelWrapper::sendMessageBinary(const Napi::CallbackInfo &info)
+{
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsBuffer())
+    {
+        Napi::TypeError::New(env, "Buffer expected").ThrowAsJavaScriptException();
+        return info.Env().Null();
+    }
+
+    try
+    {
+        Napi::Uint8Array buffer = info[0].As<Napi::Uint8Array>();
+        return Napi::Boolean::New(info.Env(), mDataChannelPtr->send((std::byte *)buffer.Data(), buffer.ByteLength()));
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error while sending dataChannel msg# ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Boolean::New(info.Env(), false);
+    }
+}
+
+Napi::Value DataChannelWrapper::isOpen(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!mDataChannelPtr)
+    {
+        return Napi::Boolean::New(info.Env(), false);
+    }
+
+    try
+    {
+        return Napi::Boolean::New(info.Env(), mDataChannelPtr->isOpen());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Boolean::New(info.Env(), false);
+    }
+}
+
+Napi::Value DataChannelWrapper::availableAmount(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!mDataChannelPtr)
+    {
+        return Napi::Number::New(info.Env(), 0);
+    }
+
+    try
+    {
+        return Napi::Number::New(info.Env(), mDataChannelPtr->availableAmount());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Number::New(info.Env(), 0);
+    }
+}
+
+Napi::Value DataChannelWrapper::bufferedAmount(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!mDataChannelPtr)
+    {
+        return Napi::Number::New(info.Env(), 0);
+    }
+
+    try
+    {
+        return Napi::Number::New(info.Env(), mDataChannelPtr->bufferedAmount());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Number::New(info.Env(), 0);
+    }
+}
+
+Napi::Value DataChannelWrapper::maxMessageSize(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    if (!mDataChannelPtr)
+    {
+        return Napi::Number::New(info.Env(), 0);
+    }
+
+    try
+    {
+        return Napi::Number::New(info.Env(), mDataChannelPtr->maxMessageSize());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return Napi::Number::New(info.Env(), 0);
+    }
+}
+
+void DataChannelWrapper::setBufferedAmountLowThreshold(const Napi::CallbackInfo &info)
+{
+    if (!mDataChannelPtr)
+    {
+        Napi::Error::New(info.Env(), "It seems data-channel is destroyed!").ThrowAsJavaScriptException();
+        return;
+    }
+
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsNumber())
+    {
+        Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    try
+    {
+        mDataChannelPtr->setBufferedAmountLowThreshold(info[0].ToNumber().Uint32Value());
+    }
+    catch (std::exception &ex)
+    {
+        Napi::Error::New(env, std::string("libdatachannel error# ") + ex.what()).ThrowAsJavaScriptException();
+        return;
+    }
+}
+
+void DataChannelWrapper::onOpen(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnOpenCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mDataChannelPtr->onOpen([&]() {
+        if (mOnOpenCallback)
+            mOnOpenCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                args = {};
+            });
+    });
+}
+
+void DataChannelWrapper::onClosed(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnClosedCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mDataChannelPtr->onClosed([&]() {
+        if (mOnClosedCallback)
+            mOnClosedCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                args = {};
+            });
+    });
+}
+
+void DataChannelWrapper::onError(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnErrorCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mDataChannelPtr->onError([&](const std::string &error) {
+        if (mOnErrorCallback)
+            mOnErrorCallback->call([error](Napi::Env env, std::vector<napi_value> &args) {
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                args = {Napi::String::New(env, error)};
+            });
+    });
+}
+
+void DataChannelWrapper::onAvailable(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnAvailableCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mDataChannelPtr->onAvailable([&]() {
+        if (mOnAvailableCallback)
+            mOnAvailableCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                args = {};
+            });
+    });
+}
+
+void DataChannelWrapper::onBufferedAmountLow(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnBufferedAmountLowCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mDataChannelPtr->onBufferedAmountLow([&]() {
+        if (mOnBufferedAmountLowCallback)
+            mOnBufferedAmountLowCallback->call([](Napi::Env env, std::vector<napi_value> &args) {
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                args = {};
+            });
+    });
+}
+
+void DataChannelWrapper::onMessage(const Napi::CallbackInfo &info)
+{
+    Napi::Env env = info.Env();
+    int length = info.Length();
+
+    if (length < 1 || !info[0].IsFunction())
+    {
+        Napi::TypeError::New(env, "Function expected").ThrowAsJavaScriptException();
+        return;
+    }
+
+    // Callback
+    mOnMessageCallback = std::make_shared<ThreadSafeCallback>(info[0].As<Napi::Function>());
+
+    mDataChannelPtr->onMessage([&](const std::variant<rtc::binary, std::string> &message) {
+        if (mOnMessageCallback)
+            mOnMessageCallback->call([message](Napi::Env env, std::vector<napi_value> &args) {
+                // This will run in main thread and needs to construct the
+                // arguments for the call
+                Napi::Object payload = Napi::Object::New(env);
+                if (std::holds_alternative<std::string>(message))
+                {
+                    args = {Napi::String::New(env, std::get<std::string>(message))};
+                }
+                else
+                {
+                    args = {Napi::Buffer<std::byte>::Copy(env, std::get<rtc::binary>(message).data(), std::get<rtc::binary>(message).size())};
+                }
+            });
+    });
+}