koffi 2.3.4 → 2.3.6-beta.1

package/vendor/node-addon-api/benchmark/property_descriptor.cc

@@ -1,7 +1,7 @@
 #include "napi.h"
 
 static napi_value Getter_Core(napi_env env, napi_callback_info info) {
-  (void) info;
+  (void)info;
   napi_value result;
   napi_status status = napi_create_uint32(env, 42, &result);
   NAPI_THROW_IF_FAILED(env, status, nullptr);
@@ -14,7 +14,7 @@ static napi_value Setter_Core(napi_env env, napi_callback_info info) {
   napi_status status =
       napi_get_cb_info(env, info, &argc, &argv, nullptr, nullptr);
   NAPI_THROW_IF_FAILED(env, status, nullptr);
-  (void) argv;
+  (void)argv;
   return nullptr;
 }
 
@@ -23,22 +23,23 @@ static Napi::Value Getter(const Napi::CallbackInfo& info) {
 }
 
 static void Setter(const Napi::CallbackInfo& info) {
-  (void) info[0];
+  (void)info[0];
 }
 
 #if NAPI_VERSION > 5
 class PropDescBenchmark : public Napi::Addon<PropDescBenchmark> {
  public:
   PropDescBenchmark(Napi::Env, Napi::Object exports) {
-    DefineAddon(exports, {
-      InstanceAccessor("addon",
-                       &PropDescBenchmark::Getter,
-                       &PropDescBenchmark::Setter,
-                       napi_enumerable),
-      InstanceAccessor<&PropDescBenchmark::Getter,
-                       &PropDescBenchmark::Setter>("addon_templated",
-                                                   napi_enumerable),
-    });
+    DefineAddon(exports,
+                {
+                    InstanceAccessor("addon",
+                                     &PropDescBenchmark::Getter,
+                                     &PropDescBenchmark::Setter,
+                                     napi_enumerable),
+                    InstanceAccessor<&PropDescBenchmark::Getter,
+                                     &PropDescBenchmark::Setter>(
+                        "addon_templated", napi_enumerable),
+                });
   }
 
  private:
@@ -47,39 +48,31 @@ class PropDescBenchmark : public Napi::Addon<PropDescBenchmark> {
   }
 
   void Setter(const Napi::CallbackInfo& info, const Napi::Value& val) {
-    (void) info[0];
-    (void) val;
+    (void)info[0];
+    (void)val;
   }
 };
 #endif  // NAPI_VERSION > 5
 
 static Napi::Object Init(Napi::Env env, Napi::Object exports) {
   napi_status status;
-  napi_property_descriptor core_prop = {
-    "core",
-    nullptr,
-    nullptr,
-    Getter_Core,
-    Setter_Core,
-    nullptr,
-    napi_enumerable,
-    nullptr
-  };
+  napi_property_descriptor core_prop = {"core",
+                                        nullptr,
+                                        nullptr,
+                                        Getter_Core,
+                                        Setter_Core,
+                                        nullptr,
+                                        napi_enumerable,
+                                        nullptr};
 
   status = napi_define_properties(env, exports, 1, &core_prop);
   NAPI_THROW_IF_FAILED(env, status, Napi::Object());
 
-  exports.DefineProperty(
-      Napi::PropertyDescriptor::Accessor(env,
-                                         exports,
-                                         "cplusplus",
-                                         Getter,
-                                         Setter,
-                                         napi_enumerable));
+  exports.DefineProperty(Napi::PropertyDescriptor::Accessor(
+      env, exports, "cplusplus", Getter, Setter, napi_enumerable));
 
-  exports.DefineProperty(
-      Napi::PropertyDescriptor::Accessor<Getter, Setter>("templated",
-                                                         napi_enumerable));
+  exports.DefineProperty(Napi::PropertyDescriptor::Accessor<Getter, Setter>(
+      "templated", napi_enumerable));
 
 #if NAPI_VERSION > 5
   PropDescBenchmark::Init(env, exports);

package/vendor/node-addon-api/benchmark/property_descriptor.js

@@ -2,15 +2,15 @@ const path = require('path');
 const Benchmark = require('benchmark');
 const addonName = path.basename(__filename, '.js');
 
-[ addonName, addonName + '_noexcept' ]
+[addonName, addonName + '_noexcept']
   .forEach((addonName) => {
     const rootAddon = require('bindings')({
       bindings: addonName,
       module_root: __dirname
     });
     delete rootAddon.path;
-    const getters = new Benchmark.Suite;
-    const setters = new Benchmark.Suite;
+    const getters = new Benchmark.Suite();
+    const setters = new Benchmark.Suite();
     const maxNameLength = Object.keys(rootAddon)
       .reduce((soFar, value) => Math.max(soFar, value.length), 0);
 
@@ -18,11 +18,12 @@ const addonName = path.basename(__filename, '.js');
 
     Object.keys(rootAddon).forEach((key) => {
       getters.add(`${key} getter`.padStart(maxNameLength + 7), () => {
+        // eslint-disable-next-line no-unused-vars
         const x = rootAddon[key];
       });
       setters.add(`${key} setter`.padStart(maxNameLength + 7), () => {
         rootAddon[key] = 5;
-      })
+      });
     });
 
     getters

package/vendor/node-addon-api/doc/async_operations.md

@@ -19,7 +19,7 @@ asynchronous operations:
 
 - **[`Napi::AsyncWorker`](async_worker.md)**
 
-These class helps manage asynchronous operations through an abstraction
+This class helps manage asynchronous operations through an abstraction
 of the concept of moving data between the **event loop** and **worker threads**.
 
 Also, the above class may not be appropriate for every scenario. When using any

package/vendor/node-addon-api/doc/async_worker_variants.md

@@ -51,8 +51,11 @@ virtual void Napi::AsyncProgressWorker::OnOK();
 
 ### OnProgress
 
-This method is invoked when the computation in the `Napi::AsyncProgressWorker::ExecutionProcess::Send`
-method was called during worker thread execution.
+This method is invoked when the computation in the
+`Napi::AsyncProgressWorker::ExecutionProcess::Send` method was called during
+worker thread execution. This method can also be triggered via a call to
+`Napi::AsyncProgress[Queue]Worker::ExecutionProcess::Signal`, in which case the
+`data` parameter will be `nullptr`.
 
 ```cpp
 virtual void Napi::AsyncProgressWorker::OnProgress(const T* data, size_t count)
@@ -251,6 +254,15 @@ class instead which is documented further down this page.
 void Napi::AsyncProgressWorker::ExecutionProcess::Send(const T* data, size_t count) const;
 ```
 
+### Signal
+
+`Napi::AsyncProgressWorker::ExecutionProcess::Signal` triggers an invocation of
+`Napi::AsyncProgressWorker::OnProgress` with `nullptr` as the `data` parameter.
+
+```cpp
+void Napi::AsyncProgressWorker::ExecutionProcess::Signal();
+```
+
 ## Example
 
 The first step to use the `Napi::AsyncProgressWorker` class is to create a new class that
@@ -415,6 +427,15 @@ with each data item.
 void Napi::AsyncProgressQueueWorker::ExecutionProcess::Send(const T* data, size_t count) const;
 ```
 
+### Signal
+
+`Napi::AsyncProgressQueueWorker::ExecutionProcess::Signal` triggers an invocation of
+`Napi::AsyncProgressQueueWorker::OnProgress` with `nullptr` as the `data` parameter.
+
+```cpp
+void Napi::AsyncProgressQueueWorker::ExecutionProcess::Signal() const;
+```
+
 ## Example
 
 The code below shows an example of the `Napi::AsyncProgressQueueWorker` implementation, but

package/vendor/node-addon-api/doc/cmake-js.md

@@ -47,7 +47,7 @@ add_definitions(-DNAPI_EXPERIMENTAL)
 
 ### node-addon-api
 
-If your Node-API native add-on uses the optional [**node-addon-api**](https://github.com/nodejs/node-addon-api#node-addon-api-module) C++ wrapper, the `CMakeLists.txt` file requires additional configuration information as described on the [CMake.js README file](https://github.com/cmake-js/cmake-js#n-api-and-node-addon-api).
+If your Node-API native add-on uses the optional [**node-addon-api**](https://github.com/nodejs/node-addon-api#node-addon-api-module) C++ wrapper, the `CMakeLists.txt` file requires additional configuration information as described on the [CMake.js README file](https://github.com/cmake-js/cmake-js#node-api-and-node-addon-api).
 
 ## Example
 

package/vendor/node-addon-api/doc/error_handling.md

@@ -26,7 +26,7 @@ The following sections explain the approach for each case:
 <a name="exceptions"></a>
 
 In most cases when an error occurs, the addon should do whatever cleanup is possible
-and then return to JavaScript so that the error can be propagated.  In less frequent
+and then return to JavaScript so that the error can be propagated. In less frequent
 cases the addon may be able to recover from the error, clear the error and then
 continue.
 
@@ -48,8 +48,8 @@ method.
 If a C++ exception of type `Napi::Error` escapes from a Node-API C++ callback, then
 the Node-API wrapper automatically converts and throws it as a JavaScript exception.
 
-On return from a native method, node-addon-api will automatically convert a pending C++
-exception to a JavaScript exception.
+On return from a native method, node-addon-api will automatically convert a pending
+`Napi::Error` C++ exception to a JavaScript exception.
 
 When C++ exceptions are enabled try/catch can be used to catch exceptions thrown
 from calls to JavaScript and then they can either be handled or rethrown before

package/vendor/node-addon-api/doc/external.md

@@ -6,6 +6,13 @@ The `Napi::External` template class implements the ability to create a `Napi::Va
 
 `Napi::External` objects can be created with an optional Finalizer function and optional Hint value. The Finalizer function, if specified, is called when your `Napi::External` object is released by Node's garbage collector. It gives your code the opportunity to free any dynamically created data. If you specify a Hint value, it is passed to your Finalizer function.
 
+Note that `Napi::Value::IsExternal()` will return `true` for any external value.
+It does not differentiate between the templated parameter `T` in
+`Napi::External<T>`. It is up to the addon to ensure an `Napi::External<T>`
+object holds the correct `T` when retrieving the data via
+`Napi::External<T>::Data()`. One method to ensure an object is of a specific
+type is through [type tags](./object.md#TypeTag).
+
 ## Methods
 
 ### New

package/vendor/node-addon-api/doc/handle_scope.md

@@ -61,3 +61,17 @@ Napi::Env Napi::HandleScope::Env() const;
 ```
 
 Returns the `Napi::Env` associated with the `Napi::HandleScope`.
+
+## Example
+
+```cpp
+for (int i = 0; i < LOOP_MAX; i++) {
+  Napi::HandleScope scope(info.Env());
+  std::string name = std::string("inner-scope") + std::to_string(i);
+  Napi::Value newValue = Napi::String::New(info.Env(), name.c_str());
+  // do something with newValue
+};
+```
+
+For more details refer to the section titled [Object lifetime
+management](object_lifetime_management.md).

package/vendor/node-addon-api/doc/hierarchy.md

@@ -81,7 +81,7 @@
 [`Napi::Reference<Napi::Object>`]: ./reference.md
 [`Napi::String`]: ./string.md
 [`Napi::Symbol`]: ./symbol.md
-[`Napi::ThreadSafeFunction`]: ./thread_safe_function.md
+[`Napi::ThreadSafeFunction`]: ./threadsafe_function.md
 [`Napi::TypeError`]: ./type_error.md
 [`Napi::TypedArray`]: ./typed_array.md
 [`Napi::TypedArrayOf`]: ./typed_array_of.md

package/vendor/node-addon-api/doc/object.md

@@ -241,6 +241,33 @@ from being added to it and marking all existing properties as non-configurable.
 Values of present properties can still be changed as long as they are
 writable.
 
+### TypeTag()
+
+```cpp
+void Napi::Object::TypeTag(const napi_type_tag* type_tag) const;
+```
+
+- `[in] type_tag`: The tag with which this object is to be marked.
+
+The `Napi::Object::TypeTag()` method associates the value of the `type_tag`
+pointer with this JavaScript object. `Napi::Object::CheckTypeTag()` can then be
+used to compare the tag that was attached to this object with one owned by the
+addon to ensure that this object has the right type.
+
+### CheckTypeTag()
+
+```cpp
+bool Napi::Object::CheckTypeTag(const napi_type_tag* type_tag) const;
+```
+
+- `[in] type_tag`: The tag with which to compare any tag found on this object.
+
+The `Napi::Object::CheckTypeTag()` method compares the pointer given as
+`type_tag` with any that can be found on this JavaScript object. If no tag is
+found on this object or, if a tag is found but it does not match `type_tag`,
+then the return value is `false`. If a tag is found and it matches `type_tag`,
+then the return value is `true`.
+
 ### operator\[\]()
 
 ```cpp

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

@@ -1,11 +1,11 @@
 const path = require('path');
 
-const include_dir = path.relative('.', __dirname);
+const includeDir = path.relative('.', __dirname);
 
 module.exports = {
   include: `"${__dirname}"`, // deprecated, can be removed as part of 4.0.0
-  include_dir,
-  gyp: path.join(include_dir, 'node_api.gyp:nothing'),
+  include_dir: includeDir,
+  gyp: path.join(includeDir, 'node_api.gyp:nothing'),
   isNodeApiBuiltin: true,
   needsFlag: false
 };

package/vendor/node-addon-api/napi-inl.deprecated.h

@@ -6,187 +6,181 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename Getter>
-inline PropertyDescriptor
-PropertyDescriptor::Accessor(const char* utf8name,
-                             Getter getter,
-                             napi_property_attributes attributes,
-                             void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::CallbackData<Getter, Napi::Value>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, nullptr });
-
-  return PropertyDescriptor({
-    utf8name,
-    nullptr,
-    nullptr,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(const std::string& utf8name,
-                                                       Getter getter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* data) {
   return Accessor(utf8name.c_str(), getter, attributes, data);
 }
 
 template <typename Getter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(napi_value name,
-                                                       Getter getter,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::CallbackData<Getter, Napi::Value>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, nullptr });
-
-  return PropertyDescriptor({
-    nullptr,
-    name,
-    nullptr,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(Name name,
-                                                       Getter getter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name, Getter getter, napi_property_attributes attributes, void* data) {
   napi_value nameValue = name;
   return PropertyDescriptor::Accessor(nameValue, getter, attributes, data);
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(const char* utf8name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const char* utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::AccessorCallbackData<Getter, Setter>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, setter, nullptr });
-
-  return PropertyDescriptor({
-    utf8name,
-    nullptr,
-    nullptr,
-    CbData::GetterWrapper,
-    CbData::SetterWrapper,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(const std::string& utf8name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    const std::string& utf8name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
   return Accessor(utf8name.c_str(), getter, setter, attributes, data);
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(napi_value name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    napi_value name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using CbData = details::AccessorCallbackData<Getter, Setter>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ getter, setter, nullptr });
-
-  return PropertyDescriptor({
-    nullptr,
-    name,
-    nullptr,
-    CbData::GetterWrapper,
-    CbData::SetterWrapper,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({getter, setter, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             nullptr,
+                             CbData::GetterWrapper,
+                             CbData::SetterWrapper,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Getter, typename Setter>
-inline PropertyDescriptor PropertyDescriptor::Accessor(Name name,
-                                                       Getter getter,
-                                                       Setter setter,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Accessor(
+    Name name,
+    Getter getter,
+    Setter setter,
+    napi_property_attributes attributes,
+    void* data) {
   napi_value nameValue = name;
-  return PropertyDescriptor::Accessor(nameValue, getter, setter, attributes, data);
+  return PropertyDescriptor::Accessor(
+      nameValue, getter, setter, attributes, data);
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(const char* utf8name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const char* utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
   using CbData = details::CallbackData<Callable, ReturnType>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ cb, nullptr });
-
-  return PropertyDescriptor({
-    utf8name,
-    nullptr,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({utf8name,
+                             nullptr,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(const std::string& utf8name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    const std::string& utf8name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* data) {
   return Function(utf8name.c_str(), cb, attributes, data);
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(napi_value name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* /*data*/) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    napi_value name,
+    Callable cb,
+    napi_property_attributes attributes,
+    void* /*data*/) {
   using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
   using CbData = details::CallbackData<Callable, ReturnType>;
   // TODO: Delete when the function is destroyed
-  auto callbackData = new CbData({ cb, nullptr });
-
-  return PropertyDescriptor({
-    nullptr,
-    name,
-    CbData::Wrapper,
-    nullptr,
-    nullptr,
-    nullptr,
-    attributes,
-    callbackData
-  });
+  auto callbackData = new CbData({cb, nullptr});
+
+  return PropertyDescriptor({nullptr,
+                             name,
+                             CbData::Wrapper,
+                             nullptr,
+                             nullptr,
+                             nullptr,
+                             attributes,
+                             callbackData});
 }
 
 template <typename Callable>
-inline PropertyDescriptor PropertyDescriptor::Function(Name name,
-                                                       Callable cb,
-                                                       napi_property_attributes attributes,
-                                                       void* data) {
+inline PropertyDescriptor PropertyDescriptor::Function(
+    Name name, Callable cb, napi_property_attributes attributes, void* data) {
   napi_value nameValue = name;
   return PropertyDescriptor::Function(nameValue, cb, attributes, data);
 }
 
-#endif // !SRC_NAPI_INL_DEPRECATED_H_
+#endif  // !SRC_NAPI_INL_DEPRECATED_H_