koffi 2.3.4 → 2.3.6-beta.1

package/vendor/node-addon-api/package.json

@@ -15,6 +15,10 @@
       "name": "Alexander Floh",
       "url": "https://github.com/alexanderfloh"
     },
+    {
+      "name": "Ammar Faizi",
+      "url": "https://github.com/ammarfaizi2"
+    },
     {
       "name": "András Timár, Dr",
       "url": "https://github.com/timarandras"
@@ -71,6 +75,10 @@
       "name": "Daniel Bevenius",
       "url": "https://github.com/danbev"
     },
+    {
+      "name": "Dante Calderón",
+      "url": "https://github.com/dantehemerson"
+    },
     {
       "name": "Darshan Sen",
       "url": "https://github.com/RaisinTen"
@@ -103,6 +111,10 @@
       "name": "extremeheat",
       "url": "https://github.com/extremeheat"
     },
+    {
+      "name": "Feng Yu",
+      "url": "https://github.com/F3n67u"
+    },
     {
       "name": "Ferdinand Holzer",
       "url": "https://github.com/fholzer"
@@ -147,6 +159,10 @@
       "name": "Jason Ginchereau",
       "url": "https://github.com/jasongin"
     },
+    {
+      "name": "Jenny",
+      "url": "https://github.com/egg-bread"
+    },
     {
       "name": "Jeroen Janssen",
       "url": "https://github.com/japj"
@@ -167,6 +183,10 @@
       "name": "joshgarde",
       "url": "https://github.com/joshgarde"
     },
+    {
+      "name": "Julian Mesa",
+      "url": "https://github.com/julianmesa-gitkraken"
+    },
     {
       "name": "Kasumi Hanazuki",
       "url": "https://github.com/hanazuki"
@@ -199,6 +219,10 @@
       "name": "Kyle Farnung",
       "url": "https://github.com/kfarnung"
     },
+    {
+      "name": "Kyle Kovacs",
+      "url": "https://github.com/nullromo"
+    },
     {
       "name": "legendecas",
       "url": "https://github.com/legendecas"
@@ -267,6 +291,10 @@
       "name": "pacop",
       "url": "https://github.com/pacop"
     },
+    {
+      "name": "Peter Šándor",
+      "url": "https://github.com/petersandor"
+    },
     {
       "name": "Philipp Renoth",
       "url": "https://github.com/DaAitch"
@@ -275,6 +303,10 @@
       "name": "rgerd",
       "url": "https://github.com/rgerd"
     },
+    {
+      "name": "Richard Lau",
+      "url": "https://github.com/richardlau"
+    },
     {
       "name": "Rolf Timmermans",
       "url": "https://github.com/rolftimmermans"
@@ -287,6 +319,10 @@
       "name": "Ryuichi Okumura",
       "url": "https://github.com/okuryu"
     },
+    {
+      "name": "Saint Gabriel",
+      "url": "https://github.com/chineduG"
+    },
     {
       "name": "Sampson Gao",
       "url": "https://github.com/sampsongao"
@@ -351,6 +387,10 @@
     {
       "name": "Ziqiu Zhao",
       "url": "https://github.com/ZzqiZQute"
+    },
+    {
+      "name": "Feng Yu",
+      "url": "https://github.com/F3n67u"
     }
   ],
   "description": "Node.js API (Node-API)",
@@ -401,6 +441,7 @@
     "benchmark": "node benchmark",
     "pretest": "node-gyp rebuild -C test",
     "test": "node test",
+    "test:debug": "node-gyp rebuild -C test --debug && NODE_API_BUILD_CONFIG=Debug node ./test/index.js",
     "predev": "node-gyp rebuild -C test --debug",
     "dev": "node test",
     "predev:incremental": "node-gyp configure build -C test --debug",
@@ -410,6 +451,6 @@
     "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
   },
   "pre-commit": "lint",
-  "version": "5.0.0",
+  "version": "6.0.0",
   "support": true
 }

package/vendor/node-addon-api/test/addon.cc

@@ -7,12 +7,14 @@ namespace {
 class TestAddon : public Napi::Addon<TestAddon> {
  public:
   inline TestAddon(Napi::Env env, Napi::Object exports) {
-    DefineAddon(exports, {
-      InstanceMethod("increment", &TestAddon::Increment),
-      InstanceValue("subObject", DefineProperties(Napi::Object::New(env), {
-        InstanceMethod("decrement", &TestAddon::Decrement)
-      }))
-    });
+    DefineAddon(
+        exports,
+        {InstanceMethod("increment", &TestAddon::Increment),
+         InstanceValue(
+             "subObject",
+             DefineProperties(
+                 Napi::Object::New(env),
+                 {InstanceMethod("decrement", &TestAddon::Decrement)}))});
   }
 
  private:

package/vendor/node-addon-api/test/addon_build/index.js

@@ -4,28 +4,28 @@ const { promisify } = require('util');
 const exec = promisify(require('child_process').exec);
 const { copy, remove } = require('fs-extra');
 const path = require('path');
-const assert = require('assert')
+const assert = require('assert');
 
 const ADDONS_FOLDER = path.join(__dirname, 'addons');
 
 const addons = [
   'echo addon',
   'echo-addon'
-]
+];
 
-async function beforeAll(addons) {
-  console.log('   >Preparing native addons to build')
+async function beforeAll (addons) {
+  console.log('   >Preparing native addons to build');
   for (const addon of addons) {
     await remove(path.join(ADDONS_FOLDER, addon));
     await copy(path.join(__dirname, 'tpl'), path.join(ADDONS_FOLDER, addon));
   }
 }
 
-async function test(addon) {
+async function test (addon) {
   console.log(`   >Building addon: '${addon}'`);
-  const { stderr, stdout } = await exec('npm install', {
+  await exec('npm install', {
     cwd: path.join(ADDONS_FOLDER, addon)
-  })
+  });
   console.log(`   >Running test for: '${addon}'`);
   // Disabled the checks on stderr and stdout because of this issue on npm:
   // Stop using process.umask(): https://github.com/npm/cli/issues/1103
@@ -41,9 +41,9 @@ async function test(addon) {
   assert.strictEqual(binding.noexcept.echo(103), 103);
 }
 
-module.exports = (async function() {
+module.exports = (async function () {
   await beforeAll(addons);
   for (const addon of addons) {
     await test(addon);
   }
-})()
+})();

package/vendor/node-addon-api/test/addon_build/tpl/addon.cc

@@ -3,7 +3,8 @@
 Napi::Value Echo(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
   if (info.Length() != 1) {
-    Napi::TypeError::New(env, "Wrong number of arguments. One argument expected.")
+    Napi::TypeError::New(env,
+                         "Wrong number of arguments. One argument expected.")
         .ThrowAsJavaScriptException();
   }
   return info[0].As<Napi::Value>();

package/vendor/node-addon-api/test/addon_build/tpl/index.js

@@ -1,9 +1,9 @@
-'use strict'
+'use strict';
 
-const except = require('bindings')('addon')
-const noexcept = require('bindings')('addon_noexcept')
+const except = require('bindings')('addon');
+const noexcept = require('bindings')('addon_noexcept');
 
 module.exports = {
   except,
   noexcept
-}
+};

package/vendor/node-addon-api/test/addon_data.cc

@@ -17,11 +17,10 @@ class Addon {
  public:
   class VerboseIndicator : public Napi::ObjectWrap<VerboseIndicator> {
    public:
-    VerboseIndicator(const Napi::CallbackInfo& info):
-        Napi::ObjectWrap<VerboseIndicator>(info) {
-      info.This().As<Napi::Object>()["verbose"] =
-          Napi::Boolean::New(info.Env(),
-                             info.Env().GetInstanceData<Addon>()->verbose);
+    VerboseIndicator(const Napi::CallbackInfo& info)
+        : Napi::ObjectWrap<VerboseIndicator>(info) {
+      info.This().As<Napi::Object>()["verbose"] = Napi::Boolean::New(
+          info.Env(), info.Env().GetInstanceData<Addon>()->verbose);
     }
 
     Napi::Value Getter(const Napi::CallbackInfo& info) {
@@ -34,11 +33,11 @@ class Addon {
     }
 
     static Napi::FunctionReference Init(Napi::Env env) {
-      return Napi::Persistent(DefineClass(env, "VerboseIndicator", {
-        InstanceAccessor<
-                         &VerboseIndicator::Getter,
-                         &VerboseIndicator::Setter>("verbose")
-      }));
+      return Napi::Persistent(DefineClass(
+          env,
+          "VerboseIndicator",
+          {InstanceAccessor<&VerboseIndicator::Getter,
+                            &VerboseIndicator::Setter>("verbose")}));
     }
   };
 
@@ -51,7 +50,7 @@ class Addon {
     info.Env().GetInstanceData<Addon>()->verbose = info[0].As<Napi::Boolean>();
   }
 
-  Addon(Napi::Env env): VerboseIndicator(VerboseIndicator::Init(env)) {}
+  Addon(Napi::Env env) : VerboseIndicator(VerboseIndicator::Init(env)) {}
   ~Addon() {
     if (verbose) {
       fprintf(stderr, "addon_data: Addon::~Addon\n");
@@ -60,7 +59,7 @@ class Addon {
 
   static void DeleteAddon(Napi::Env, Addon* addon, uint32_t* hint) {
     delete addon;
-    fprintf(stderr, "hint: %d\n", *hint);
+    fprintf(stderr, "hint: %u\n", *hint);
     delete hint;
   }
 
@@ -76,7 +75,7 @@ class Addon {
                                                         new uint32_t(hint));
     Napi::Object result = Napi::Object::New(env);
     result.DefineProperties({
-      Napi::PropertyDescriptor::Accessor<Getter, Setter>("verbose"),
+        Napi::PropertyDescriptor::Accessor<Getter, Setter>("verbose"),
     });
 
     return result;

package/vendor/node-addon-api/test/array_buffer.js

@@ -5,7 +5,7 @@ const testUtil = require('./testUtil');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   return testUtil.runGCTests([
     'Internal ArrayBuffer',
     () => {
@@ -58,12 +58,13 @@ function test(binding) {
     'ArrayBuffer updates data pointer and length when detached',
     () => {
       // Detach the ArrayBuffer in JavaScript.
+      // eslint-disable-next-line no-undef
       const mem = new WebAssembly.Memory({ initial: 1 });
       binding.arraybuffer.checkDetachUpdatesData(mem.buffer, () => mem.grow(1));
 
       // Let C++ detach the ArrayBuffer.
       const extBuffer = binding.arraybuffer.createExternalBuffer();
       binding.arraybuffer.checkDetachUpdatesData(extBuffer);
-    },
+    }
   ]);
 }

package/vendor/node-addon-api/test/async_progress_queue_worker.cc

@@ -41,6 +41,8 @@ class TestWorker : public AsyncProgressQueueWorker<ProgressData> {
 
     if (_times < 0) {
       SetError("test error");
+    } else {
+      progress.Signal();
     }
     ProgressData data{0};
     for (int32_t idx = 0; idx < _times; idx++) {
@@ -49,11 +51,18 @@ class TestWorker : public AsyncProgressQueueWorker<ProgressData> {
     }
   }
 
-  void OnProgress(const ProgressData* data, size_t /* count */) override {
+  void OnProgress(const ProgressData* data, size_t count) override {
     Napi::Env env = Env();
+    _test_case_count++;
     if (!_js_progress_cb.IsEmpty()) {
-      Number progress = Number::New(env, data->progress);
-      _js_progress_cb.Call(Receiver().Value(), {progress});
+      if (_test_case_count == 1) {
+        if (count != 0) {
+          SetError("expect 0 count of data on 1st call");
+        }
+      } else {
+        Number progress = Number::New(env, data->progress);
+        _js_progress_cb.Call(Receiver().Value(), {progress});
+      }
     }
   }
 
@@ -68,6 +77,7 @@ class TestWorker : public AsyncProgressQueueWorker<ProgressData> {
   }
 
   int32_t _times;
+  size_t _test_case_count = 0;
   FunctionReference _js_progress_cb;
 };
 

package/vendor/node-addon-api/test/async_progress_queue_worker.js

@@ -1,16 +1,16 @@
 'use strict';
 
-const common = require('./common')
+const common = require('./common');
 const assert = require('assert');
 
 module.exports = common.runTest(test);
 
-async function test({ asyncprogressqueueworker }) {
+async function test ({ asyncprogressqueueworker }) {
   await success(asyncprogressqueueworker);
   await fail(asyncprogressqueueworker);
 }
 
-function success(binding) {
+function success (binding) {
   return new Promise((resolve, reject) => {
     const expected = [0, 1, 2, 3];
     const actual = [];
@@ -32,11 +32,11 @@ function success(binding) {
   });
 }
 
-function fail(binding) {
+function fail (binding) {
   return new Promise((resolve, reject) => {
     const worker = binding.createWork(-1,
       common.mustCall((err) => {
-        assert.throws(() => { throw err }, /test error/);
+        assert.throws(() => { throw err; }, /test error/);
         resolve();
       }),
       common.mustNotCall()

package/vendor/node-addon-api/test/async_progress_worker.cc

@@ -78,10 +78,17 @@ class MalignWorker : public AsyncProgressWorker<ProgressData> {
 
  protected:
   void Execute(const ExecutionProgress& progress) override {
-    std::unique_lock<std::mutex> lock(_cvm);
-    // Testing a nullptr send is acceptable.
-    progress.Send(nullptr, 0);
-    _cv.wait(lock);
+    {
+      std::unique_lock<std::mutex> lock(_cvm);
+      // Testing a nullptr send is acceptable.
+      progress.Send(nullptr, 0);
+      _cv.wait(lock, [this] { return _test_case_count == 1; });
+    }
+    {
+      std::unique_lock<std::mutex> lock(_cvm);
+      progress.Signal();
+      _cv.wait(lock, [this] { return _test_case_count == 2; });
+    }
     // Testing busy looping on send doesn't trigger unexpected empty data
     // OnProgress call.
     for (size_t i = 0; i < 1000000; i++) {
@@ -92,16 +99,21 @@ class MalignWorker : public AsyncProgressWorker<ProgressData> {
 
   void OnProgress(const ProgressData* /* data */, size_t count) override {
     Napi::Env env = Env();
-    _test_case_count++;
+    {
+      std::lock_guard<std::mutex> lock(_cvm);
+      _test_case_count++;
+    }
     bool error = false;
     Napi::String reason = Napi::String::New(env, "No error");
-    if (_test_case_count == 1 && count != 0) {
+    if (_test_case_count <= 2 && count != 0) {
       error = true;
-      reason = Napi::String::New(env, "expect 0 count of data on 1st call");
+      reason =
+          Napi::String::New(env, "expect 0 count of data on 1st and 2nd call");
     }
-    if (_test_case_count > 1 && count != 1) {
+    if (_test_case_count > 2 && count != 1) {
       error = true;
-      reason = Napi::String::New(env, "expect 1 count of data on non-1st call");
+      reason = Napi::String::New(
+          env, "expect 1 count of data on non-1st and non-2nd call");
     }
     _progress.MakeCallback(Receiver().Value(),
                            {Napi::Boolean::New(env, error), reason});
@@ -122,12 +134,56 @@ class MalignWorker : public AsyncProgressWorker<ProgressData> {
   std::mutex _cvm;
   FunctionReference _progress;
 };
+
+// Calling a Signal after a SendProgress should not clear progress data
+class SignalAfterProgressTestWorker : public AsyncProgressWorker<ProgressData> {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    Function cb = info[0].As<Function>();
+    Function progress = info[1].As<Function>();
+
+    SignalAfterProgressTestWorker* worker = new SignalAfterProgressTestWorker(
+        cb, progress, "TestResource", Object::New(info.Env()));
+    worker->Queue();
+  }
+
+ protected:
+  void Execute(const ExecutionProgress& progress) override {
+    ProgressData data{0};
+    progress.Send(&data, 1);
+    progress.Signal();
+  }
+
+  void OnProgress(const ProgressData* /* data */, size_t count) override {
+    Napi::Env env = Env();
+    bool error = false;
+    Napi::String reason = Napi::String::New(env, "No error");
+    if (count != 1) {
+      error = true;
+      reason = Napi::String::New(env, "expect 1 count of data");
+    }
+    _progress.MakeCallback(Receiver().Value(),
+                           {Napi::Boolean::New(env, error), reason});
+  }
+
+ private:
+  SignalAfterProgressTestWorker(Function cb,
+                                Function progress,
+                                const char* resource_name,
+                                const Object& resource)
+      : AsyncProgressWorker(cb, resource_name, resource) {
+    _progress.Reset(progress, 1);
+  }
+  FunctionReference _progress;
+};
 }  // namespace
 
 Object InitAsyncProgressWorker(Env env) {
   Object exports = Object::New(env);
   exports["doWork"] = Function::New(env, TestWorker::DoWork);
   exports["doMalignTest"] = Function::New(env, MalignWorker::DoWork);
+  exports["doSignalAfterProgressTest"] =
+      Function::New(env, SignalAfterProgressTestWorker::DoWork);
   return exports;
 }
 

package/vendor/node-addon-api/test/async_progress_worker.js

@@ -1,17 +1,18 @@
 'use strict';
 
-const common = require('./common')
+const common = require('./common');
 const assert = require('assert');
 
 module.exports = common.runTest(test);
 
-async function test({ asyncprogressworker }) {
+async function test ({ asyncprogressworker }) {
   await success(asyncprogressworker);
   await fail(asyncprogressworker);
-  await malignTest(asyncprogressworker);
+  await signalTest(asyncprogressworker.doMalignTest);
+  await signalTest(asyncprogressworker.doSignalAfterProgressTest);
 }
 
-function success(binding) {
+function success (binding) {
   return new Promise((resolve, reject) => {
     const expected = [0, 1, 2, 3];
     const actual = [];
@@ -32,11 +33,11 @@ function success(binding) {
   });
 }
 
-function fail(binding) {
+function fail (binding) {
   return new Promise((resolve) => {
     binding.doWork(-1,
       common.mustCall((err) => {
-        assert.throws(() => { throw err }, /test error/)
+        assert.throws(() => { throw err; }, /test error/);
         resolve();
       }),
       common.mustNotCall()
@@ -44,9 +45,9 @@ function fail(binding) {
   });
 }
 
-function malignTest(binding) {
+function signalTest (bindingFunction) {
   return new Promise((resolve, reject) => {
-    binding.doMalignTest(
+    bindingFunction(
       common.mustCall((err) => {
         if (err) {
           return reject(err);
@@ -54,7 +55,11 @@ function malignTest(binding) {
         resolve();
       }),
       common.mustCallAtLeast((error, reason) => {
-        assert(!error, reason);
+        try {
+          assert(!error, reason);
+        } catch (e) {
+          reject(e);
+        }
       }, 1)
     );
   });