node-addon-api 4.3.0 → 5.0.0

package/README.md

@@ -10,7 +10,7 @@ git branch -u origin/main main
 ```
 
 # **node-addon-api module**
-This module contains **header-only C++ wrapper classes** which simplify
+This module contains  **header-only C++ wrapper classes** which simplify
 the use of the C based [Node-API](https://nodejs.org/dist/latest/docs/api/n-api.html)
 provided by Node.js when using C++. It provides a C++ object model
 and exception handling semantics with low overhead.
@@ -70,7 +70,7 @@ and node-addon-api.
 - **[Contributors](#contributors)**
 - **[License](#license)**
 
-## **Current version: 4.3.0**
+## **Current version: 5.0.0**
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
 
@@ -83,7 +83,7 @@ This allows addons built with it to run with Node.js versions which support the
 **However** the node-addon-api support model is to support only the active LTS Node.js versions. This means that
 every year there will be a new major which drops support for the Node.js LTS version which has gone out of service.
 
-The oldest Node.js version supported by the current version of node-addon-api is Node.js 12.x.
+The oldest Node.js version supported by the current version of node-addon-api is Node.js 14.x.
 
 ## Setup
   - [Installation and usage](doc/setup.md)

package/napi-inl.h

@@ -18,6 +18,10 @@
 
 namespace Napi {
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+namespace NAPI_CPP_CUSTOM_NAMESPACE {
+#endif
+
 // Helpers to handle functions exposed from C++.
 namespace details {
 
@@ -483,7 +487,7 @@ inline bool Env::IsExceptionPending() const {
   return result;
 }
 
-inline Error Env::GetAndClearPendingException() {
+inline Error Env::GetAndClearPendingException() const {
   napi_value value;
   napi_status status = napi_get_and_clear_last_exception(_env, &value);
   if (status != napi_ok) {
@@ -493,16 +497,16 @@ inline Error Env::GetAndClearPendingException() {
   return Error(_env, value);
 }
 
-inline MaybeOrValue<Value> Env::RunScript(const char* utf8script) {
+inline MaybeOrValue<Value> Env::RunScript(const char* utf8script) const {
   String script = String::New(_env, utf8script);
   return RunScript(script);
 }
 
-inline MaybeOrValue<Value> Env::RunScript(const std::string& utf8script) {
+inline MaybeOrValue<Value> Env::RunScript(const std::string& utf8script) const {
   return RunScript(utf8script.c_str());
 }
 
-inline MaybeOrValue<Value> Env::RunScript(String script) {
+inline MaybeOrValue<Value> Env::RunScript(String script) const {
   napi_value result;
   napi_status status = napi_run_script(_env, script, &result);
   NAPI_RETURN_OR_THROW_IF_FAILED(
@@ -531,7 +535,7 @@ void Env::CleanupHook<Hook, Arg>::WrapperWithArg(void* data) NAPI_NOEXCEPT {
 
 #if NAPI_VERSION > 5
 template <typename T, Env::Finalizer<T> fini>
-inline void Env::SetInstanceData(T* data) {
+inline void Env::SetInstanceData(T* data) const {
   napi_status status =
     napi_set_instance_data(_env, data, [](napi_env env, void* data, void*) {
       fini(env, static_cast<T*>(data));
@@ -542,7 +546,7 @@ inline void Env::SetInstanceData(T* data) {
 template <typename DataType,
           typename HintType,
           Napi::Env::FinalizerWithHint<DataType, HintType> fini>
-inline void Env::SetInstanceData(DataType* data, HintType* hint) {
+inline void Env::SetInstanceData(DataType* data, HintType* hint) const {
   napi_status status =
     napi_set_instance_data(_env, data,
       [](napi_env env, void* data, void* hint) {
@@ -552,7 +556,7 @@ inline void Env::SetInstanceData(DataType* data, HintType* hint) {
 }
 
 template <typename T>
-inline T* Env::GetInstanceData() {
+inline T* Env::GetInstanceData() const {
   void* data = nullptr;
 
   napi_status status = napi_get_instance_data(_env, &data);
@@ -1294,22 +1298,20 @@ inline Object::Object() : Value() {
 inline Object::Object(napi_env env, napi_value value) : Value(env, value) {
 }
 
-inline Object::PropertyLValue<std::string> Object::operator [](const char* utf8name) {
+inline Object::PropertyLValue<std::string> Object::operator[](
+    const char* utf8name) {
   return PropertyLValue<std::string>(*this, utf8name);
 }
 
-inline Object::PropertyLValue<std::string> Object::operator [](const std::string& utf8name) {
+inline Object::PropertyLValue<std::string> Object::operator[](
+    const std::string& utf8name) {
   return PropertyLValue<std::string>(*this, utf8name);
 }
 
-inline Object::PropertyLValue<uint32_t> Object::operator [](uint32_t index) {
+inline Object::PropertyLValue<uint32_t> Object::operator[](uint32_t index) {
   return PropertyLValue<uint32_t>(*this, index);
 }
 
-inline Object::PropertyLValue<Value> Object::operator[](Value index) {
-  return PropertyLValue<Value>(*this, index);
-}
-
 inline Object::PropertyLValue<Value> Object::operator[](Value index) const {
   return PropertyLValue<Value>(*this, index);
 }
@@ -1396,14 +1398,15 @@ inline MaybeOrValue<Value> Object::Get(const std::string& utf8name) const {
 }
 
 template <typename ValueType>
-inline MaybeOrValue<bool> Object::Set(napi_value key, const ValueType& value) {
+inline MaybeOrValue<bool> Object::Set(napi_value key,
+                                      const ValueType& value) const {
   napi_status status =
       napi_set_property(_env, _value, key, Value::From(_env, value));
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
 template <typename ValueType>
-inline MaybeOrValue<bool> Object::Set(Value key, const ValueType& value) {
+inline MaybeOrValue<bool> Object::Set(Value key, const ValueType& value) const {
   napi_status status =
       napi_set_property(_env, _value, key, Value::From(_env, value));
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
@@ -1411,7 +1414,7 @@ inline MaybeOrValue<bool> Object::Set(Value key, const ValueType& value) {
 
 template <typename ValueType>
 inline MaybeOrValue<bool> Object::Set(const char* utf8name,
-                                      const ValueType& value) {
+                                      const ValueType& value) const {
   napi_status status =
       napi_set_named_property(_env, _value, utf8name, Value::From(_env, value));
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
@@ -1419,27 +1422,27 @@ inline MaybeOrValue<bool> Object::Set(const char* utf8name,
 
 template <typename ValueType>
 inline MaybeOrValue<bool> Object::Set(const std::string& utf8name,
-                                      const ValueType& value) {
+                                      const ValueType& value) const {
   return Set(utf8name.c_str(), value);
 }
 
-inline MaybeOrValue<bool> Object::Delete(napi_value key) {
+inline MaybeOrValue<bool> Object::Delete(napi_value key) const {
   bool result;
   napi_status status = napi_delete_property(_env, _value, key, &result);
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline MaybeOrValue<bool> Object::Delete(Value key) {
+inline MaybeOrValue<bool> Object::Delete(Value key) const {
   bool result;
   napi_status status = napi_delete_property(_env, _value, key, &result);
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
 }
 
-inline MaybeOrValue<bool> Object::Delete(const char* utf8name) {
+inline MaybeOrValue<bool> Object::Delete(const char* utf8name) const {
   return Delete(String::New(_env, utf8name));
 }
 
-inline MaybeOrValue<bool> Object::Delete(const std::string& utf8name) {
+inline MaybeOrValue<bool> Object::Delete(const std::string& utf8name) const {
   return Delete(String::New(_env, utf8name));
 }
 
@@ -1456,13 +1459,14 @@ inline MaybeOrValue<Value> Object::Get(uint32_t index) const {
 }
 
 template <typename ValueType>
-inline MaybeOrValue<bool> Object::Set(uint32_t index, const ValueType& value) {
+inline MaybeOrValue<bool> Object::Set(uint32_t index,
+                                      const ValueType& value) const {
   napi_status status =
       napi_set_element(_env, _value, index, Value::From(_env, value));
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
-inline MaybeOrValue<bool> Object::Delete(uint32_t index) {
+inline MaybeOrValue<bool> Object::Delete(uint32_t index) const {
   bool result;
   napi_status status = napi_delete_element(_env, _value, index, &result);
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, result, bool);
@@ -1475,21 +1479,21 @@ inline MaybeOrValue<Array> Object::GetPropertyNames() const {
 }
 
 inline MaybeOrValue<bool> Object::DefineProperty(
-    const PropertyDescriptor& property) {
+    const PropertyDescriptor& property) const {
   napi_status status = napi_define_properties(_env, _value, 1,
     reinterpret_cast<const napi_property_descriptor*>(&property));
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
 inline MaybeOrValue<bool> Object::DefineProperties(
-    const std::initializer_list<PropertyDescriptor>& properties) {
+    const std::initializer_list<PropertyDescriptor>& properties) const {
   napi_status status = napi_define_properties(_env, _value, properties.size(),
     reinterpret_cast<const napi_property_descriptor*>(properties.begin()));
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
 inline MaybeOrValue<bool> Object::DefineProperties(
-    const std::vector<PropertyDescriptor>& properties) {
+    const std::vector<PropertyDescriptor>& properties) const {
   napi_status status = napi_define_properties(_env, _value, properties.size(),
     reinterpret_cast<const napi_property_descriptor*>(properties.data()));
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
@@ -1503,7 +1507,7 @@ inline MaybeOrValue<bool> Object::InstanceOf(
 }
 
 template <typename Finalizer, typename T>
-inline void Object::AddFinalizer(Finalizer finalizeCallback, T* data) {
+inline void Object::AddFinalizer(Finalizer finalizeCallback, T* data) const {
   details::FinalizeData<T, Finalizer>* finalizeData =
       new details::FinalizeData<T, Finalizer>(
           {std::move(finalizeCallback), nullptr});
@@ -1522,7 +1526,7 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback, T* data) {
 template <typename Finalizer, typename T, typename Hint>
 inline void Object::AddFinalizer(Finalizer finalizeCallback,
                                  T* data,
-                                 Hint* finalizeHint) {
+                                 Hint* finalizeHint) const {
   details::FinalizeData<T, Finalizer, Hint>* finalizeData =
       new details::FinalizeData<T, Finalizer, Hint>(
           {std::move(finalizeCallback), finalizeHint});
@@ -1616,12 +1620,12 @@ Object::iterator::operator*() {
 #endif  // NAPI_CPP_EXCEPTIONS
 
 #if NAPI_VERSION >= 8
-inline MaybeOrValue<bool> Object::Freeze() {
+inline MaybeOrValue<bool> Object::Freeze() const {
   napi_status status = napi_object_freeze(_env, _value);
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
 
-inline MaybeOrValue<bool> Object::Seal() {
+inline MaybeOrValue<bool> Object::Seal() const {
   napi_status status = napi_object_seal(_env, _value);
   NAPI_RETURN_OR_THROW_IF_FAILED(_env, status, status == napi_ok, bool);
 }
@@ -2287,6 +2291,11 @@ inline MaybeOrValue<Value> Function::Call(
   return Call(Env().Undefined(), args);
 }
 
+inline MaybeOrValue<Value> Function::Call(
+    const std::vector<Value>& args) const {
+  return Call(Env().Undefined(), args);
+}
+
 inline MaybeOrValue<Value> Function::Call(size_t argc,
                                           const napi_value* args) const {
   return Call(Env().Undefined(), argc, args);
@@ -2302,6 +2311,27 @@ inline MaybeOrValue<Value> Function::Call(
   return Call(recv, args.size(), args.data());
 }
 
+inline MaybeOrValue<Value> Function::Call(
+    napi_value recv, const std::vector<Value>& args) const {
+  const size_t argc = args.size();
+  const size_t stackArgsCount = 6;
+  napi_value stackArgs[stackArgsCount];
+  std::vector<napi_value> heapArgs;
+  napi_value* argv;
+  if (argc <= stackArgsCount) {
+    argv = stackArgs;
+  } else {
+    heapArgs.resize(argc);
+    argv = heapArgs.data();
+  }
+
+  for (size_t index = 0; index < argc; index++) {
+    argv[index] = static_cast<napi_value>(args[index]);
+  }
+
+  return Call(recv, argc, argv);
+}
+
 inline MaybeOrValue<Value> Function::Call(napi_value recv,
                                           size_t argc,
                                           const napi_value* args) const {
@@ -2607,8 +2637,8 @@ inline Error::Error(napi_env env, napi_value value) : ObjectReference(env, nullp
 
       // property flag that we attach to show the error object is wrapped
       napi_property_descriptor wrapObjFlag = {
-          ERROR_WRAP_VALUE,  // Unique GUID identifier since Symbol isn't a
-                             // viable option
+          ERROR_WRAP_VALUE(),  // Unique GUID identifier since Symbol isn't a
+                               // viable option
           nullptr,
           nullptr,
           nullptr,
@@ -2648,15 +2678,17 @@ inline Object Error::Value() const {
     // We are checking if the object is wrapped
     bool isWrappedObject = false;
 
-    status = napi_has_property(
-        _env, refValue, String::From(_env, ERROR_WRAP_VALUE), &isWrappedObject);
+    status = napi_has_property(_env,
+                               refValue,
+                               String::From(_env, ERROR_WRAP_VALUE()),
+                               &isWrappedObject);
 
     // Don't care about status
     if (isWrappedObject) {
       napi_value unwrappedValue;
       status = napi_get_property(_env,
                                  refValue,
-                                 String::From(_env, ERROR_WRAP_VALUE),
+                                 String::From(_env, ERROR_WRAP_VALUE()),
                                  &unwrappedValue);
       NAPI_THROW_IF_FAILED(_env, status, Object());
 
@@ -2772,6 +2804,10 @@ inline const char* Error::what() const NAPI_NOEXCEPT {
 
 #endif // NAPI_CPP_EXCEPTIONS
 
+inline const char* Error::ERROR_WRAP_VALUE() NAPI_NOEXCEPT {
+  return "4bda9e7e-4913-4dbc-95de-891cbf66598e-errorVal";
+}
+
 template <typename TError>
 inline TError Error::New(napi_env env,
                          const char* message,
@@ -2930,7 +2966,7 @@ inline T Reference<T>::Value() const {
 }
 
 template <typename T>
-inline uint32_t Reference<T>::Ref() {
+inline uint32_t Reference<T>::Ref() const {
   uint32_t result;
   napi_status status = napi_reference_ref(_env, _ref, &result);
   NAPI_THROW_IF_FAILED(_env, status, 0);
@@ -2938,7 +2974,7 @@ inline uint32_t Reference<T>::Ref() {
 }
 
 template <typename T>
-inline uint32_t Reference<T>::Unref() {
+inline uint32_t Reference<T>::Unref() const {
   uint32_t result;
   napi_status status = napi_reference_unref(_env, _ref, &result);
   NAPI_THROW_IF_FAILED(_env, status, 0);
@@ -3064,61 +3100,61 @@ inline MaybeOrValue<Napi::Value> ObjectReference::Get(
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
-                                               napi_value value) {
+                                               napi_value value) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
-                                               Napi::Value value) {
+                                               Napi::Value value) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
-                                               const char* utf8value) {
+                                               const char* utf8value) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, utf8value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
-                                               bool boolValue) {
+                                               bool boolValue) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, boolValue);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const char* utf8name,
-                                               double numberValue) {
+                                               double numberValue) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, numberValue);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
-                                               napi_value value) {
+                                               napi_value value) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
-                                               Napi::Value value) {
+                                               Napi::Value value) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
-                                               std::string& utf8value) {
+                                               std::string& utf8value) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, utf8value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
-                                               bool boolValue) {
+                                               bool boolValue) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, boolValue);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(const std::string& utf8name,
-                                               double numberValue) {
+                                               double numberValue) const {
   HandleScope scope(_env);
   return Value().Set(utf8name, numberValue);
 }
@@ -3140,36 +3176,37 @@ inline MaybeOrValue<Napi::Value> ObjectReference::Get(uint32_t index) const {
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
-                                               napi_value value) {
+                                               napi_value value) const {
   HandleScope scope(_env);
   return Value().Set(index, value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
-                                               Napi::Value value) {
+                                               Napi::Value value) const {
   HandleScope scope(_env);
   return Value().Set(index, value);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
-                                               const char* utf8value) {
+                                               const char* utf8value) const {
   HandleScope scope(_env);
   return Value().Set(index, utf8value);
 }
 
-inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
-                                               const std::string& utf8value) {
+inline MaybeOrValue<bool> ObjectReference::Set(
+    uint32_t index, const std::string& utf8value) const {
   HandleScope scope(_env);
   return Value().Set(index, utf8value);
 }
 
-inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index, bool boolValue) {
+inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
+                                               bool boolValue) const {
   HandleScope scope(_env);
   return Value().Set(index, boolValue);
 }
 
 inline MaybeOrValue<bool> ObjectReference::Set(uint32_t index,
-                                               double numberValue) {
+                                               double numberValue) const {
   HandleScope scope(_env);
   return Value().Set(index, numberValue);
 }
@@ -4451,6 +4488,15 @@ inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticValue(Symbol name,
   return desc;
 }
 
+template <typename T>
+inline Value ObjectWrap<T>::OnCalledAsFunction(
+    const Napi::CallbackInfo& callbackInfo) {
+  NAPI_THROW(
+      TypeError::New(callbackInfo.Env(),
+                     "Class constructors cannot be invoked without 'new'"),
+      Napi::Value());
+}
+
 template <typename T>
 inline void ObjectWrap<T>::Finalize(Napi::Env /*env*/) {}
 
@@ -4464,8 +4510,8 @@ inline napi_value ObjectWrap<T>::ConstructorCallbackWrapper(
 
   bool isConstructCall = (new_target != nullptr);
   if (!isConstructCall) {
-    napi_throw_type_error(env, nullptr, "Class constructors cannot be invoked without 'new'");
-    return nullptr;
+    return details::WrapCallback(
+        [&] { return T::OnCalledAsFunction(CallbackInfo(env, info)); });
   }
 
   napi_value wrapper = details::WrapCallback([&] {
@@ -5323,7 +5369,7 @@ template <typename ContextType,
           typename DataType,
           void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
 inline napi_status
-TypedThreadSafeFunction<ContextType, DataType, CallJs>::Release() {
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::Release() const {
   return napi_release_threadsafe_function(_tsfn, napi_tsfn_release);
 }
 
@@ -5331,7 +5377,7 @@ template <typename ContextType,
           typename DataType,
           void (*CallJs)(Napi::Env, Napi::Function, ContextType*, DataType*)>
 inline napi_status
-TypedThreadSafeFunction<ContextType, DataType, CallJs>::Abort() {
+TypedThreadSafeFunction<ContextType, DataType, CallJs>::Abort() const {
   return napi_release_threadsafe_function(_tsfn, napi_tsfn_abort);
 }
 
@@ -5661,11 +5707,11 @@ inline napi_status ThreadSafeFunction::Acquire() const {
   return napi_acquire_threadsafe_function(_tsfn);
 }
 
-inline napi_status ThreadSafeFunction::Release() {
+inline napi_status ThreadSafeFunction::Release() const {
   return napi_release_threadsafe_function(_tsfn, napi_tsfn_release);
 }
 
-inline napi_status ThreadSafeFunction::Abort() {
+inline napi_status ThreadSafeFunction::Abort() const {
   return napi_release_threadsafe_function(_tsfn, napi_tsfn_abort);
 }
 
@@ -6204,6 +6250,10 @@ bool Env::CleanupHook<Hook, Arg>::IsEmpty() const {
 }
 #endif  // NAPI_VERSION > 2
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+}  // namespace NAPI_CPP_CUSTOM_NAMESPACE
+#endif
+
 } // namespace Napi
 
 #endif // SRC_NAPI_INL_H_

package/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/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/tools/clang-format.js

@@ -20,7 +20,10 @@ function main (args) {
   }
 
   const clangFormatPath = path.dirname(require.resolve('clang-format'));
-  const options = ['--binary=node_modules/.bin/clang-format', '--style=file'];
+  const binary = process.platform === 'win32'
+    ? 'node_modules\\.bin\\clang-format.cmd'
+    : 'node_modules/.bin/clang-format';
+  const options = ['--binary=' + binary, '--style=file'];
   if (fix) {
     options.push(FORMAT_START);
   } else {