koffi 0.9.30 → 0.9.33

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

@@ -140,6 +140,18 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t), "Size mismatch between char16
 ////////////////////////////////////////////////////////////////////////////////
 namespace Napi {
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+// NAPI_CPP_CUSTOM_NAMESPACE can be #define'd per-addon to avoid symbol
+// conflicts between different instances of node-addon-api
+
+// First dummy definition of the namespace to make sure that Napi::(name) still
+// refers to the right things inside this file.
+namespace NAPI_CPP_CUSTOM_NAMESPACE {}
+using namespace NAPI_CPP_CUSTOM_NAMESPACE;
+
+namespace NAPI_CPP_CUSTOM_NAMESPACE {
+#endif
+
   // Forward declarations
   class Env;
   class Value;
@@ -286,11 +298,11 @@ namespace Napi {
     Value Null() const;
 
     bool IsExceptionPending() const;
-    Error GetAndClearPendingException();
+    Error GetAndClearPendingException() const;
 
-    MaybeOrValue<Value> RunScript(const char* utf8script);
-    MaybeOrValue<Value> RunScript(const std::string& utf8script);
-    MaybeOrValue<Value> RunScript(String script);
+    MaybeOrValue<Value> RunScript(const char* utf8script) const;
+    MaybeOrValue<Value> RunScript(const std::string& utf8script) const;
+    MaybeOrValue<Value> RunScript(String script) const;
 
 #if NAPI_VERSION > 2
     template <typename Hook>
@@ -301,19 +313,20 @@ namespace Napi {
 #endif  // NAPI_VERSION > 2
 
 #if NAPI_VERSION > 5
-    template <typename T> T* GetInstanceData();
+    template <typename T>
+    T* GetInstanceData() const;
 
     template <typename T> using Finalizer = void (*)(Env, T*);
     template <typename T, Finalizer<T> fini = Env::DefaultFini<T>>
-    void SetInstanceData(T* data);
+    void SetInstanceData(T* data) const;
 
     template <typename DataType, typename HintType>
     using FinalizerWithHint = void (*)(Env, DataType*, HintType*);
     template <typename DataType,
               typename HintType,
               FinalizerWithHint<DataType, HintType> fini =
-                Env::DefaultFiniWithHint<DataType, HintType>>
-    void SetInstanceData(DataType* data, HintType* hint);
+                  Env::DefaultFiniWithHint<DataType, HintType>>
+    void SetInstanceData(DataType* data, HintType* hint) const;
 #endif  // NAPI_VERSION > 5
 
   private:
@@ -727,22 +740,18 @@ namespace Napi {
            napi_value value);  ///< Wraps a Node-API value primitive.
 
     /// Gets or sets a named property.
-    PropertyLValue<std::string> operator [](
-      const char* utf8name ///< UTF-8 encoded null-terminated property name
+    PropertyLValue<std::string> operator[](
+        const char* utf8name  ///< UTF-8 encoded null-terminated property name
     );
 
     /// Gets or sets a named property.
-    PropertyLValue<std::string> operator [](
-      const std::string& utf8name ///< UTF-8 encoded property name
+    PropertyLValue<std::string> operator[](
+        const std::string& utf8name  ///< UTF-8 encoded property name
     );
 
     /// Gets or sets an indexed property or array element.
-    PropertyLValue<uint32_t> operator [](
-      uint32_t index /// Property / element index
-    );
-
-    /// Gets or sets an indexed property or array element.
-    PropertyLValue<Value> operator[](Value index  /// Property / element index
+    PropertyLValue<uint32_t> operator[](
+        uint32_t index  /// Property / element index
     );
 
     /// Gets or sets an indexed property or array element.
@@ -822,44 +831,44 @@ namespace Napi {
     template <typename ValueType>
     MaybeOrValue<bool> Set(napi_value key,         ///< Property key primitive
                            const ValueType& value  ///< Property value primitive
-    );
+    ) const;
 
     /// Sets a property.
     template <typename ValueType>
     MaybeOrValue<bool> Set(Value key,              ///< Property key
                            const ValueType& value  ///< Property value
-    );
+    ) const;
 
     /// Sets a named property.
     template <typename ValueType>
     MaybeOrValue<bool> Set(
         const char* utf8name,  ///< UTF-8 encoded null-terminated property name
-        const ValueType& value);
+        const ValueType& value) const;
 
     /// Sets a named property.
     template <typename ValueType>
     MaybeOrValue<bool> Set(
         const std::string& utf8name,  ///< UTF-8 encoded property name
         const ValueType& value        ///< Property value primitive
-    );
+    ) const;
 
     /// Delete property.
     MaybeOrValue<bool> Delete(napi_value key  ///< Property key primitive
-    );
+    ) const;
 
     /// Delete property.
     MaybeOrValue<bool> Delete(Value key  ///< Property key
-    );
+    ) const;
 
     /// Delete property.
     MaybeOrValue<bool> Delete(
         const char* utf8name  ///< UTF-8 encoded null-terminated property name
-    );
+    ) const;
 
     /// Delete property.
     MaybeOrValue<bool> Delete(
         const std::string& utf8name  ///< UTF-8 encoded property name
-    );
+    ) const;
 
     /// Checks whether an indexed property is present.
     MaybeOrValue<bool> Has(uint32_t index  ///< Property / element index
@@ -873,11 +882,11 @@ namespace Napi {
     template <typename ValueType>
     MaybeOrValue<bool> Set(uint32_t index,         ///< Property / element index
                            const ValueType& value  ///< Property value primitive
-    );
+    ) const;
 
     /// Deletes an indexed property or array element.
     MaybeOrValue<bool> Delete(uint32_t index  ///< Property / element index
-    );
+    ) const;
 
     /// This operation can fail in case of Proxy.[[OwnPropertyKeys]] and
     /// Proxy.[[GetOwnProperty]] calling into JavaScript. See:
@@ -895,7 +904,7 @@ namespace Napi {
     MaybeOrValue<bool> DefineProperty(
         const PropertyDescriptor&
             property  ///< Descriptor for the property to be defined
-    );
+    ) const;
 
     /// Defines properties on the object.
     ///
@@ -905,7 +914,7 @@ namespace Napi {
     MaybeOrValue<bool> DefineProperties(
         const std::initializer_list<PropertyDescriptor>& properties
         ///< List of descriptors for the properties to be defined
-    );
+    ) const;
 
     /// Defines properties on the object.
     ///
@@ -915,7 +924,7 @@ namespace Napi {
     MaybeOrValue<bool> DefineProperties(
         const std::vector<PropertyDescriptor>& properties
         ///< Vector of descriptors for the properties to be defined
-    );
+    ) const;
 
     /// Checks if an object is an instance created by a constructor function.
     ///
@@ -930,12 +939,12 @@ namespace Napi {
     ) const;
 
     template <typename Finalizer, typename T>
-    inline void AddFinalizer(Finalizer finalizeCallback, T* data);
+    inline void AddFinalizer(Finalizer finalizeCallback, T* data) const;
 
     template <typename Finalizer, typename T, typename Hint>
     inline void AddFinalizer(Finalizer finalizeCallback,
                              T* data,
-                             Hint* finalizeHint);
+                             Hint* finalizeHint) const;
 
 #ifdef NAPI_CPP_EXCEPTIONS
     class const_iterator;
@@ -956,12 +965,12 @@ namespace Napi {
     /// JavaScript.
     /// See
     /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof
-    MaybeOrValue<bool> Freeze();
+    MaybeOrValue<bool> Freeze() const;
     /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into
     /// JavaScript.
     /// See
     /// https://tc39.es/ecma262/#sec-proxy-object-internal-methods-and-internal-slots-getprototypeof
-    MaybeOrValue<bool> Seal();
+    MaybeOrValue<bool> Seal() const;
 #endif  // NAPI_VERSION >= 8
   };
 
@@ -1350,11 +1359,14 @@ namespace Napi {
    MaybeOrValue<Value> Call(
        const std::initializer_list<napi_value>& args) const;
    MaybeOrValue<Value> Call(const std::vector<napi_value>& args) const;
+   MaybeOrValue<Value> Call(const std::vector<Value>& args) const;
    MaybeOrValue<Value> Call(size_t argc, const napi_value* args) const;
    MaybeOrValue<Value> Call(
        napi_value recv, const std::initializer_list<napi_value>& args) const;
    MaybeOrValue<Value> Call(napi_value recv,
                             const std::vector<napi_value>& args) const;
+   MaybeOrValue<Value> Call(napi_value recv,
+                            const std::vector<Value>& args) const;
    MaybeOrValue<Value> Call(napi_value recv,
                             size_t argc,
                             const napi_value* args) const;
@@ -1462,8 +1474,8 @@ namespace Napi {
     // within a HandleScope so that the value handle gets cleaned up efficiently.
     T Value() const;
 
-    uint32_t Ref();
-    uint32_t Unref();
+    uint32_t Ref() const;
+    uint32_t Unref() const;
     void Reset();
     void Reset(const T& value, uint32_t refcount = 0);
 
@@ -1500,24 +1512,27 @@ namespace Napi {
 
     MaybeOrValue<Napi::Value> Get(const char* utf8name) const;
     MaybeOrValue<Napi::Value> Get(const std::string& utf8name) const;
-    MaybeOrValue<bool> Set(const char* utf8name, napi_value value);
-    MaybeOrValue<bool> Set(const char* utf8name, Napi::Value value);
-    MaybeOrValue<bool> Set(const char* utf8name, const char* utf8value);
-    MaybeOrValue<bool> Set(const char* utf8name, bool boolValue);
-    MaybeOrValue<bool> Set(const char* utf8name, double numberValue);
-    MaybeOrValue<bool> Set(const std::string& utf8name, napi_value value);
-    MaybeOrValue<bool> Set(const std::string& utf8name, Napi::Value value);
-    MaybeOrValue<bool> Set(const std::string& utf8name, std::string& utf8value);
-    MaybeOrValue<bool> Set(const std::string& utf8name, bool boolValue);
-    MaybeOrValue<bool> Set(const std::string& utf8name, double numberValue);
+    MaybeOrValue<bool> Set(const char* utf8name, napi_value value) const;
+    MaybeOrValue<bool> Set(const char* utf8name, Napi::Value value) const;
+    MaybeOrValue<bool> Set(const char* utf8name, const char* utf8value) const;
+    MaybeOrValue<bool> Set(const char* utf8name, bool boolValue) const;
+    MaybeOrValue<bool> Set(const char* utf8name, double numberValue) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name, napi_value value) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name,
+                           Napi::Value value) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name,
+                           std::string& utf8value) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name, bool boolValue) const;
+    MaybeOrValue<bool> Set(const std::string& utf8name,
+                           double numberValue) const;
 
     MaybeOrValue<Napi::Value> Get(uint32_t index) const;
-    MaybeOrValue<bool> Set(uint32_t index, const napi_value value);
-    MaybeOrValue<bool> Set(uint32_t index, const Napi::Value value);
-    MaybeOrValue<bool> Set(uint32_t index, const char* utf8value);
-    MaybeOrValue<bool> Set(uint32_t index, const std::string& utf8value);
-    MaybeOrValue<bool> Set(uint32_t index, bool boolValue);
-    MaybeOrValue<bool> Set(uint32_t index, double numberValue);
+    MaybeOrValue<bool> Set(uint32_t index, const napi_value value) const;
+    MaybeOrValue<bool> Set(uint32_t index, const Napi::Value value) const;
+    MaybeOrValue<bool> Set(uint32_t index, const char* utf8value) const;
+    MaybeOrValue<bool> Set(uint32_t index, const std::string& utf8value) const;
+    MaybeOrValue<bool> Set(uint32_t index, bool boolValue) const;
+    MaybeOrValue<bool> Set(uint32_t index, double numberValue) const;
 
    protected:
     ObjectReference(const ObjectReference&);
@@ -1720,8 +1735,7 @@ namespace Napi {
    /// !endcond
 
   private:
-   const char* ERROR_WRAP_VALUE =
-       "4bda9e7e-4913-4dbc-95de-891cbf66598e-errorVal";
+   static inline const char* ERROR_WRAP_VALUE() NAPI_NOEXCEPT;
    mutable std::string _message;
   };
 
@@ -2199,6 +2213,8 @@ namespace Napi {
     static PropertyDescriptor StaticValue(Symbol name,
                                           Napi::Value value,
                                           napi_property_attributes attributes = napi_default);
+    static Napi::Value OnCalledAsFunction(
+        const Napi::CallbackInfo& callbackInfo);
     virtual void Finalize(Napi::Env env);
 
   private:
@@ -2553,10 +2569,10 @@ namespace Napi {
     napi_status Acquire() const;
 
     // This API may be called from any thread.
-    napi_status Release();
+    napi_status Release() const;
 
     // This API may be called from any thread.
-    napi_status Abort();
+    napi_status Abort() const;
 
     struct ConvertibleContext
     {
@@ -2752,10 +2768,10 @@ namespace Napi {
     napi_status Acquire() const;
 
     // This API may be called from any thread.
-    napi_status Release();
+    napi_status Release() const;
 
     // This API may be called from any thread.
-    napi_status Abort();
+    napi_status Abort() const;
 
     // This API may be called from any thread.
     ContextType* GetContext() const;
@@ -2975,6 +2991,10 @@ namespace Napi {
   };
 #endif  // NAPI_VERSION > 5
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+  }  // namespace NAPI_CPP_CUSTOM_NAMESPACE
+#endif
+
 } // namespace Napi
 
 // Inline implementations of all the above class methods are included here.

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

@@ -95,14 +95,18 @@
       "name": "Doni Rubiagatra",
       "url": "https://github.com/rubiagatra"
     },
-    {
-      "name": "Ferdinand Holzer",
-      "url": "https://github.com/fholzer"
-    },
     {
       "name": "Eric Bickle",
       "url": "https://github.com/ebickle"
     },
+    {
+      "name": "extremeheat",
+      "url": "https://github.com/extremeheat"
+    },
+    {
+      "name": "Ferdinand Holzer",
+      "url": "https://github.com/fholzer"
+    },
     {
       "name": "Gabriel Schulhof",
       "url": "https://github.com/gabrielschulhof"
@@ -267,6 +271,10 @@
       "name": "Philipp Renoth",
       "url": "https://github.com/DaAitch"
     },
+    {
+      "name": "rgerd",
+      "url": "https://github.com/rgerd"
+    },
     {
       "name": "Rolf Timmermans",
       "url": "https://github.com/rolftimmermans"
@@ -319,11 +327,19 @@
       "name": "Vlad Velmisov",
       "url": "https://github.com/Velmisov"
     },
+    {
+      "name": "Vladimir Morozov",
+      "url": "https://github.com/vmoroz"
+
+    },
     {
       "name": "WenheLI",
       "url": "https://github.com/WenheLI"
     },
-
+    {
+      "name": "Xuguang Mei",
+      "url": "https://github.com/meixg"
+    },
     {
       "name": "Yohei Kishimoto",
       "url": "https://github.com/morokosi"
@@ -394,6 +410,6 @@
     "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
   },
   "pre-commit": "lint",
-  "version": "4.3.0",
+  "version": "5.0.0",
   "support": true
 }

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

@@ -12,10 +12,25 @@ static void MakeCallback(const CallbackInfo& info) {
       Object::New(info.Env()), std::initializer_list<napi_value>{}, context);
 }
 
+static void MakeCallbackNoResource(const CallbackInfo& info) {
+  Function callback = info[0].As<Function>();
+  AsyncContext context(info.Env(), "async_context_no_res_test");
+  callback.MakeCallback(
+      Object::New(info.Env()), std::initializer_list<napi_value>{}, context);
+}
+
+static Boolean AssertAsyncContextReturnCorrectEnv(const CallbackInfo& info) {
+  AsyncContext context(info.Env(), "empty_context_test");
+  return Boolean::New(info.Env(), context.Env() == info.Env());
+}
 }  // end anonymous namespace
 
 Object InitAsyncContext(Env env) {
   Object exports = Object::New(env);
   exports["makeCallback"] = Function::New(env, MakeCallback);
+  exports["makeCallbackNoResource"] =
+      Function::New(env, MakeCallbackNoResource);
+  exports["asyncCxtReturnCorrectEnv"] =
+      Function::New(env, AssertAsyncContextReturnCorrectEnv);
   return exports;
 }

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

@@ -5,12 +5,12 @@ const common = require('./common');
 
 // we only check async hooks on 8.x an higher were
 // they are closer to working properly
-const nodeVersion = process.versions.node.split('.')[0]
-let async_hooks = undefined;
-function checkAsyncHooks() {
+const nodeVersion = process.versions.node.split('.')[0];
+let asyncHooks;
+function checkAsyncHooks () {
   if (nodeVersion >= 8) {
-    if (async_hooks == undefined) {
-      async_hooks = require('async_hooks');
+    if (asyncHooks === undefined) {
+      asyncHooks = require('async_hooks');
     }
     return true;
   }
@@ -19,7 +19,7 @@ function checkAsyncHooks() {
 
 module.exports = common.runTest(test);
 
-function installAsyncHooksForTest() {
+function installAsyncHooksForTest (resName) {
   return new Promise((resolve, reject) => {
     let id;
     const events = [];
@@ -27,60 +27,96 @@ function installAsyncHooksForTest() {
      * TODO(legendecas): investigate why resolving & disabling hooks in
      * destroy callback causing crash with case 'callbackscope.js'.
      */
-    let hook;
     let destroyed = false;
-    const interval = setInterval(() => {
-      if (destroyed) {
-        hook.disable();
-        clearInterval(interval);
-        resolve(events);
-      }
-    }, 10);
-
-    hook = async_hooks.createHook({
-      init(asyncId, type, triggerAsyncId, resource) {
-        if (id === undefined && type === 'async_context_test') {
+    const hook = asyncHooks.createHook({
+      init (asyncId, type, triggerAsyncId, resource) {
+        if (id === undefined && type === resName) {
           id = asyncId;
           events.push({ eventName: 'init', type, triggerAsyncId, resource });
         }
       },
-      before(asyncId) {
+      before (asyncId) {
         if (asyncId === id) {
           events.push({ eventName: 'before' });
         }
       },
-      after(asyncId) {
+      after (asyncId) {
         if (asyncId === id) {
           events.push({ eventName: 'after' });
         }
       },
-      destroy(asyncId) {
+      destroy (asyncId) {
         if (asyncId === id) {
           events.push({ eventName: 'destroy' });
           destroyed = true;
         }
       }
     }).enable();
+
+    const interval = setInterval(() => {
+      if (destroyed) {
+        hook.disable();
+        clearInterval(interval);
+        resolve(events);
+      }
+    }, 10);
   });
 }
 
-function test(binding) {
-  if (!checkAsyncHooks()) {
-    return;
-  }
-
-  const hooks = installAsyncHooksForTest();
-  const triggerAsyncId = async_hooks.executionAsyncId();
-  binding.asynccontext.makeCallback(common.mustCall(), { foo: 'foo' });
-  return hooks.then(actual => {
+async function makeCallbackWithResource (binding) {
+  const hooks = installAsyncHooksForTest('async_context_test');
+  const triggerAsyncId = asyncHooks.executionAsyncId();
+  await new Promise((resolve, reject) => {
+    binding.asynccontext.makeCallback(common.mustCall(), { foo: 'foo' });
+    hooks.then(actual => {
       assert.deepStrictEqual(actual, [
-        { eventName: 'init',
+        {
+          eventName: 'init',
           type: 'async_context_test',
           triggerAsyncId: triggerAsyncId,
-          resource: { foo: 'foo' } },
+          resource: { foo: 'foo' }
+        },
+        { eventName: 'before' },
+        { eventName: 'after' },
+        { eventName: 'destroy' }
+      ]);
+    }).catch(common.mustNotCall());
+    resolve();
+  });
+}
+
+async function makeCallbackWithoutResource (binding) {
+  const hooks = installAsyncHooksForTest('async_context_no_res_test');
+  const triggerAsyncId = asyncHooks.executionAsyncId();
+  await new Promise((resolve, reject) => {
+    binding.asynccontext.makeCallbackNoResource(common.mustCall());
+    hooks.then(actual => {
+      assert.deepStrictEqual(actual, [
+        {
+          eventName: 'init',
+          type: 'async_context_no_res_test',
+          triggerAsyncId: triggerAsyncId,
+          resource: { }
+        },
         { eventName: 'before' },
         { eventName: 'after' },
         { eventName: 'destroy' }
       ]);
-  }).catch(common.mustNotCall());
+    }).catch(common.mustNotCall());
+    resolve();
+  });
+}
+
+function assertAsyncContextReturnsCorrectEnv (binding) {
+  assert.strictEqual(binding.asynccontext.asyncCxtReturnCorrectEnv(), true);
+}
+
+async function test (binding) {
+  if (!checkAsyncHooks()) {
+    return;
+  }
+
+  await makeCallbackWithResource(binding);
+  await makeCallbackWithoutResource(binding);
+  assertAsyncContextReturnsCorrectEnv(binding);
 }

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

@@ -65,6 +65,7 @@ Object InitTypedArray(Env env);
 Object InitGlobalObject(Env env);
 Object InitObjectWrap(Env env);
 Object InitObjectWrapConstructorException(Env env);
+Object InitObjectWrapFunction(Env env);
 Object InitObjectWrapRemoveWrap(Env env);
 Object InitObjectWrapMultipleInheritance(Env env);
 Object InitObjectReference(Env env);
@@ -152,6 +153,7 @@ Object Init(Env env, Object exports) {
   exports.Set("objectwrap", InitObjectWrap(env));
   exports.Set("objectwrapConstructorException",
       InitObjectWrapConstructorException(env));
+  exports.Set("objectwrap_function", InitObjectWrapFunction(env));
   exports.Set("objectwrap_removewrap", InitObjectWrapRemoveWrap(env));
   exports.Set("objectwrap_multiple_inheritance", InitObjectWrapMultipleInheritance(env));
   exports.Set("objectreference", InitObjectReference(env));

package/vendor/node-addon-api/test/binding.gyp

@@ -66,6 +66,7 @@
         'typedarray.cc',
         'objectwrap.cc',
         'objectwrap_constructor_exception.cc',
+        'objectwrap_function.cc',
         'objectwrap_removewrap.cc',
         'objectwrap_multiple_inheritance.cc',
         'object_reference.cc',
@@ -113,5 +114,11 @@
       'sources': ['>@(build_sources_swallowexcept)'],
       'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
     },
+    {
+      'target_name': 'binding_custom_namespace',
+      'includes': ['../noexcept.gypi'],
+      'sources': ['>@(build_sources)'],
+      'defines': ['NAPI_CPP_CUSTOM_NAMESPACE=cstm']
+    },
   ],
 }