node-addon-api 3.1.0 → 3.2.0

package/napi-inl.h

@@ -2,9 +2,10 @@
 #define SRC_NAPI_INL_H_
 
 ////////////////////////////////////////////////////////////////////////////////
-// N-API C++ Wrapper Classes
+// Node-API C++ Wrapper Classes
 //
-// Inline header-only implementations for "N-API" ABI-stable C APIs for Node.js.
+// Inline header-only implementations for "Node-API" ABI-stable C APIs for
+// Node.js.
 ////////////////////////////////////////////////////////////////////////////////
 
 // Note: Do not include this file directly! Include "napi.h" instead.
@@ -179,8 +180,9 @@ TemplatedInstanceVoidCallback(napi_env env,
 
 template <typename T, typename Finalizer, typename Hint = void>
 struct FinalizeData {
-  static inline
-  void Wrapper(napi_env env, void* data, void* finalizeHint) noexcept {
+  static inline void Wrapper(napi_env env,
+                             void* data,
+                             void* finalizeHint) NAPI_NOEXCEPT {
     WrapVoidCallback([&] {
       FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
       finalizeData->callback(Env(env), static_cast<T*>(data));
@@ -188,8 +190,9 @@ struct FinalizeData {
     });
   }
 
-  static inline
-  void WrapperWithHint(napi_env env, void* data, void* finalizeHint) noexcept {
+  static inline void WrapperWithHint(napi_env env,
+                                     void* data,
+                                     void* finalizeHint) NAPI_NOEXCEPT {
     WrapVoidCallback([&] {
       FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
       finalizeData->callback(Env(env), static_cast<T*>(data), finalizeData->hint);
@@ -342,12 +345,11 @@ struct AccessorCallbackData {
 ////////////////////////////////////////////////////////////////////////////////
 
 // Register an add-on based on an initializer function.
-#define NODE_API_MODULE(modname, regfunc)                 \
-  napi_value __napi_ ## regfunc(napi_env env,             \
-                                napi_value exports) {     \
-    return Napi::RegisterModule(env, exports, regfunc);   \
-  }                                                       \
-  NAPI_MODULE(modname, __napi_ ## regfunc)
+#define NODE_API_MODULE(modname, regfunc)                                      \
+  static napi_value __napi_##regfunc(napi_env env, napi_value exports) {       \
+    return Napi::RegisterModule(env, exports, regfunc);                        \
+  }                                                                            \
+  NAPI_MODULE(modname, __napi_##regfunc)
 
 // Register an add-on based on a subclass of `Addon<T>` with a custom Node.js
 // module name.
@@ -1234,29 +1236,32 @@ inline Value Object::Get(const std::string& utf8name) const {
 }
 
 template <typename ValueType>
-inline void Object::Set(napi_value key, const ValueType& value) {
+inline bool Object::Set(napi_value key, const ValueType& value) {
   napi_status status =
       napi_set_property(_env, _value, key, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
 }
 
 template <typename ValueType>
-inline void Object::Set(Value key, const ValueType& value) {
+inline bool Object::Set(Value key, const ValueType& value) {
   napi_status status =
       napi_set_property(_env, _value, key, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
 }
 
 template <typename ValueType>
-inline void Object::Set(const char* utf8name, const ValueType& value) {
+inline bool Object::Set(const char* utf8name, const ValueType& value) {
   napi_status status =
       napi_set_named_property(_env, _value, utf8name, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
 }
 
 template <typename ValueType>
-inline void Object::Set(const std::string& utf8name, const ValueType& value) {
-  Set(utf8name.c_str(), value);
+inline bool Object::Set(const std::string& utf8name, const ValueType& value) {
+  return Set(utf8name.c_str(), value);
 }
 
 inline bool Object::Delete(napi_value key) {
@@ -1296,10 +1301,11 @@ inline Value Object::Get(uint32_t index) const {
 }
 
 template <typename ValueType>
-inline void Object::Set(uint32_t index, const ValueType& value) {
+inline bool Object::Set(uint32_t index, const ValueType& value) {
   napi_status status =
       napi_set_element(_env, _value, index, Value::From(_env, value));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
 }
 
 inline bool Object::Delete(uint32_t index) {
@@ -1316,22 +1322,27 @@ inline Array Object::GetPropertyNames() const {
   return Array(_env, result);
 }
 
-inline void Object::DefineProperty(const PropertyDescriptor& property) {
+inline bool Object::DefineProperty(const PropertyDescriptor& property) {
   napi_status status = napi_define_properties(_env, _value, 1,
     reinterpret_cast<const napi_property_descriptor*>(&property));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
 }
 
-inline void Object::DefineProperties(const std::initializer_list<PropertyDescriptor>& properties) {
+inline bool Object::DefineProperties(
+    const std::initializer_list<PropertyDescriptor>& properties) {
   napi_status status = napi_define_properties(_env, _value, properties.size(),
     reinterpret_cast<const napi_property_descriptor*>(properties.begin()));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
 }
 
-inline void Object::DefineProperties(const std::vector<PropertyDescriptor>& properties) {
+inline bool Object::DefineProperties(
+    const std::vector<PropertyDescriptor>& properties) {
   napi_status status = napi_define_properties(_env, _value, properties.size(),
     reinterpret_cast<const napi_property_descriptor*>(properties.data()));
-  NAPI_THROW_IF_FAILED_VOID(_env, status);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
 }
 
 inline bool Object::InstanceOf(const Function& constructor) const {
@@ -1344,7 +1355,8 @@ inline bool Object::InstanceOf(const Function& constructor) const {
 template <typename Finalizer, typename T>
 inline void Object::AddFinalizer(Finalizer finalizeCallback, T* data) {
   details::FinalizeData<T, Finalizer>* finalizeData =
-    new details::FinalizeData<T, Finalizer>({ finalizeCallback, nullptr });
+      new details::FinalizeData<T, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
   napi_status status =
       details::AttachData(_env,
                           *this,
@@ -1362,7 +1374,8 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback,
                                  T* data,
                                  Hint* finalizeHint) {
   details::FinalizeData<T, Finalizer, Hint>* finalizeData =
-    new details::FinalizeData<T, Finalizer, Hint>({ finalizeCallback, finalizeHint });
+      new details::FinalizeData<T, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
   napi_status status =
       details::AttachData(_env,
                           *this,
@@ -1375,6 +1388,20 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback,
   }
 }
 
+#if NAPI_VERSION >= 8
+inline bool Object::Freeze() {
+  napi_status status = napi_object_freeze(_env, _value);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
+}
+
+inline bool Object::Seal() {
+  napi_status status = napi_object_seal(_env, _value);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return true;
+}
+#endif  // NAPI_VERSION >= 8
+
 ////////////////////////////////////////////////////////////////////////////////
 // External class
 ////////////////////////////////////////////////////////////////////////////////
@@ -1394,7 +1421,8 @@ inline External<T> External<T>::New(napi_env env,
                                     Finalizer finalizeCallback) {
   napi_value value;
   details::FinalizeData<T, Finalizer>* finalizeData =
-    new details::FinalizeData<T, Finalizer>({ finalizeCallback, nullptr });
+      new details::FinalizeData<T, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
   napi_status status = napi_create_external(
     env,
     data,
@@ -1416,7 +1444,8 @@ inline External<T> External<T>::New(napi_env env,
                                     Hint* finalizeHint) {
   napi_value value;
   details::FinalizeData<T, Finalizer, Hint>* finalizeData =
-    new details::FinalizeData<T, Finalizer, Hint>({ finalizeCallback, finalizeHint });
+      new details::FinalizeData<T, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
   napi_status status = napi_create_external(
     env,
     data,
@@ -1508,7 +1537,8 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
                                     Finalizer finalizeCallback) {
   napi_value value;
   details::FinalizeData<void, Finalizer>* finalizeData =
-    new details::FinalizeData<void, Finalizer>({ finalizeCallback, nullptr });
+      new details::FinalizeData<void, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
   napi_status status = napi_create_external_arraybuffer(
     env,
     externalData,
@@ -1532,7 +1562,8 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
                                     Hint* finalizeHint) {
   napi_value value;
   details::FinalizeData<void, Finalizer, Hint>* finalizeData =
-    new details::FinalizeData<void, Finalizer, Hint>({ finalizeCallback, finalizeHint });
+      new details::FinalizeData<void, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
   napi_status status = napi_create_external_arraybuffer(
     env,
     externalData,
@@ -1982,8 +2013,8 @@ inline Function Function::New(napi_env env,
                               Callable cb,
                               const char* utf8name,
                               void* data) {
-  typedef decltype(cb(CallbackInfo(nullptr, nullptr))) ReturnType;
-  typedef details::CallbackData<Callable, ReturnType> CbData;
+  using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
+  using CbData = details::CallbackData<Callable, ReturnType>;
   auto callbackData = new CbData({ cb, data });
 
   napi_value value;
@@ -2152,7 +2183,8 @@ inline Buffer<T> Buffer<T>::New(napi_env env,
                                 Finalizer finalizeCallback) {
   napi_value value;
   details::FinalizeData<T, Finalizer>* finalizeData =
-    new details::FinalizeData<T, Finalizer>({ finalizeCallback, nullptr });
+      new details::FinalizeData<T, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
   napi_status status = napi_create_external_buffer(
     env,
     length * sizeof (T),
@@ -2176,7 +2208,8 @@ inline Buffer<T> Buffer<T>::New(napi_env env,
                                 Hint* finalizeHint) {
   napi_value value;
   details::FinalizeData<T, Finalizer, Hint>* finalizeData =
-    new details::FinalizeData<T, Finalizer, Hint>({ finalizeCallback, finalizeHint });
+      new details::FinalizeData<T, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
   napi_status status = napi_create_external_buffer(
     env,
     length * sizeof (T),
@@ -2656,54 +2689,58 @@ inline Napi::Value ObjectReference::Get(const std::string& utf8name) const {
   return scope.Escape(Value().Get(utf8name));
 }
 
-inline void ObjectReference::Set(const char* utf8name, napi_value value) {
+inline bool ObjectReference::Set(const char* utf8name, napi_value value) {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const char* utf8name, Napi::Value value) {
+inline bool ObjectReference::Set(const char* utf8name, Napi::Value value) {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const char* utf8name, const char* utf8value) {
+inline bool ObjectReference::Set(const char* utf8name, const char* utf8value) {
   HandleScope scope(_env);
-  Value().Set(utf8name, utf8value);
+  return Value().Set(utf8name, utf8value);
 }
 
-inline void ObjectReference::Set(const char* utf8name, bool boolValue) {
+inline bool ObjectReference::Set(const char* utf8name, bool boolValue) {
   HandleScope scope(_env);
-  Value().Set(utf8name, boolValue);
+  return Value().Set(utf8name, boolValue);
 }
 
-inline void ObjectReference::Set(const char* utf8name, double numberValue) {
+inline bool ObjectReference::Set(const char* utf8name, double numberValue) {
   HandleScope scope(_env);
-  Value().Set(utf8name, numberValue);
+  return Value().Set(utf8name, numberValue);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, napi_value value) {
+inline bool ObjectReference::Set(const std::string& utf8name,
+                                 napi_value value) {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, Napi::Value value) {
+inline bool ObjectReference::Set(const std::string& utf8name,
+                                 Napi::Value value) {
   HandleScope scope(_env);
-  Value().Set(utf8name, value);
+  return Value().Set(utf8name, value);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, std::string& utf8value) {
+inline bool ObjectReference::Set(const std::string& utf8name,
+                                 std::string& utf8value) {
   HandleScope scope(_env);
-  Value().Set(utf8name, utf8value);
+  return Value().Set(utf8name, utf8value);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, bool boolValue) {
+inline bool ObjectReference::Set(const std::string& utf8name, bool boolValue) {
   HandleScope scope(_env);
-  Value().Set(utf8name, boolValue);
+  return Value().Set(utf8name, boolValue);
 }
 
-inline void ObjectReference::Set(const std::string& utf8name, double numberValue) {
+inline bool ObjectReference::Set(const std::string& utf8name,
+                                 double numberValue) {
   HandleScope scope(_env);
-  Value().Set(utf8name, numberValue);
+  return Value().Set(utf8name, numberValue);
 }
 
 inline Napi::Value ObjectReference::Get(uint32_t index) const {
@@ -2711,34 +2748,34 @@ inline Napi::Value ObjectReference::Get(uint32_t index) const {
   return scope.Escape(Value().Get(index));
 }
 
-inline void ObjectReference::Set(uint32_t index, napi_value value) {
+inline bool ObjectReference::Set(uint32_t index, napi_value value) {
   HandleScope scope(_env);
-  Value().Set(index, value);
+  return Value().Set(index, value);
 }
 
-inline void ObjectReference::Set(uint32_t index, Napi::Value value) {
+inline bool ObjectReference::Set(uint32_t index, Napi::Value value) {
   HandleScope scope(_env);
-  Value().Set(index, value);
+  return Value().Set(index, value);
 }
 
-inline void ObjectReference::Set(uint32_t index, const char* utf8value) {
+inline bool ObjectReference::Set(uint32_t index, const char* utf8value) {
   HandleScope scope(_env);
-  Value().Set(index, utf8value);
+  return Value().Set(index, utf8value);
 }
 
-inline void ObjectReference::Set(uint32_t index, const std::string& utf8value) {
+inline bool ObjectReference::Set(uint32_t index, const std::string& utf8value) {
   HandleScope scope(_env);
-  Value().Set(index, utf8value);
+  return Value().Set(index, utf8value);
 }
 
-inline void ObjectReference::Set(uint32_t index, bool boolValue) {
+inline bool ObjectReference::Set(uint32_t index, bool boolValue) {
   HandleScope scope(_env);
-  Value().Set(index, boolValue);
+  return Value().Set(index, boolValue);
 }
 
-inline void ObjectReference::Set(uint32_t index, double numberValue) {
+inline bool ObjectReference::Set(uint32_t index, double numberValue) {
   HandleScope scope(_env);
-  Value().Set(index, numberValue);
+  return Value().Set(index, numberValue);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -3034,7 +3071,7 @@ PropertyDescriptor::Accessor(Napi::Env env,
                              Getter getter,
                              napi_property_attributes attributes,
                              void* data) {
-  typedef details::CallbackData<Getter, Napi::Value> CbData;
+  using CbData = details::CallbackData<Getter, Napi::Value>;
   auto callbackData = new CbData({ getter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -3072,7 +3109,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(Napi::Env env,
                                                        Getter getter,
                                                        napi_property_attributes attributes,
                                                        void* data) {
-  typedef details::CallbackData<Getter, Napi::Value> CbData;
+  using CbData = details::CallbackData<Getter, Napi::Value>;
   auto callbackData = new CbData({ getter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -3101,7 +3138,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(Napi::Env env,
                                                        Setter setter,
                                                        napi_property_attributes attributes,
                                                        void* data) {
-  typedef details::AccessorCallbackData<Getter, Setter> CbData;
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
   auto callbackData = new CbData({ getter, setter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -3141,7 +3178,7 @@ inline PropertyDescriptor PropertyDescriptor::Accessor(Napi::Env env,
                                                        Setter setter,
                                                        napi_property_attributes attributes,
                                                        void* data) {
-  typedef details::AccessorCallbackData<Getter, Setter> CbData;
+  using CbData = details::AccessorCallbackData<Getter, Setter>;
   auto callbackData = new CbData({ getter, setter, data });
 
   napi_status status = AttachData(env, object, callbackData);
@@ -3261,7 +3298,7 @@ inline void InstanceWrap<T>::AttachPropData(napi_env env,
                                        napi_value value,
                                        const napi_property_descriptor* prop) {
   napi_status status;
-  if (prop->method != nullptr && !(prop->attributes & napi_static)) {
+  if (!(prop->attributes & napi_static)) {
     if (prop->method == T::InstanceVoidMethodCallbackWrapper) {
       status = Napi::details::AttachData(env,
                     value,
@@ -3562,7 +3599,8 @@ inline napi_value InstanceWrap<T>::InstanceSetterCallbackWrapper(
 
 template <typename T>
 template <typename InstanceWrap<T>::InstanceSetterCallback method>
-inline napi_value InstanceWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
+inline napi_value InstanceWrap<T>::WrappedMethod(
+    napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
   return details::WrapCallback([&] {
     const CallbackInfo cbInfo(env, info);
     T* instance = T::Unwrap(cbInfo.This().As<Object>());
@@ -4024,7 +4062,8 @@ inline void ObjectWrap<T>::FinalizeCallback(napi_env env, void* data, void* /*hi
 
 template <typename T>
 template <typename ObjectWrap<T>::StaticSetterCallback method>
-inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
+inline napi_value ObjectWrap<T>::WrappedMethod(
+    napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
   return details::WrapCallback([&] {
     const CallbackInfo cbInfo(env, info);
     method(cbInfo, cbInfo[0]);
@@ -4137,10 +4176,9 @@ inline AsyncContext::AsyncContext(napi_env env, const char* resource_name)
 }
 
 inline AsyncContext::AsyncContext(napi_env env,
-		                  const char* resource_name,
+                                  const char* resource_name,
                                   const Object& resource)
-  : _env(env),
-    _context(nullptr) {
+    : _env(env), _context(nullptr) {
   napi_value resource_id;
   napi_status status = napi_create_string_utf8(
       _env, resource_name, NAPI_AUTO_LENGTH, &resource_id);