node-addon-api 4.1.0 → 5.0.0

package/napi-inl.h

@@ -14,9 +14,14 @@
 #include <cstring>
 #include <mutex>
 #include <type_traits>
+#include <utility>
 
 namespace Napi {
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+namespace NAPI_CPP_CUSTOM_NAMESPACE {
+#endif
+
 // Helpers to handle functions exposed from C++.
 namespace details {
 
@@ -482,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) {
@@ -492,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(
@@ -530,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));
@@ -541,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) {
@@ -551,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);
@@ -1293,18 +1298,24 @@ 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) const {
+  return PropertyLValue<Value>(*this, index);
+}
+
 inline MaybeOrValue<Value> Object::operator[](const char* utf8name) const {
   return Get(utf8name);
 }
@@ -1387,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);
@@ -1402,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);
@@ -1410,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));
 }
 
@@ -1447,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);
@@ -1466,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);
@@ -1494,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});
@@ -1513,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});
@@ -1529,13 +1542,90 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback,
   }
 }
 
+#ifdef NAPI_CPP_EXCEPTIONS
+inline Object::const_iterator::const_iterator(const Object* object,
+                                              const Type type) {
+  _object = object;
+  _keys = object->GetPropertyNames();
+  _index = type == Type::BEGIN ? 0 : _keys.Length();
+}
+
+inline Object::const_iterator Napi::Object::begin() const {
+  const_iterator it(this, Object::const_iterator::Type::BEGIN);
+  return it;
+}
+
+inline Object::const_iterator Napi::Object::end() const {
+  const_iterator it(this, Object::const_iterator::Type::END);
+  return it;
+}
+
+inline Object::const_iterator& Object::const_iterator::operator++() {
+  ++_index;
+  return *this;
+}
+
+inline bool Object::const_iterator::operator==(
+    const const_iterator& other) const {
+  return _index == other._index;
+}
+
+inline bool Object::const_iterator::operator!=(
+    const const_iterator& other) const {
+  return _index != other._index;
+}
+
+inline const std::pair<Value, Object::PropertyLValue<Value>>
+Object::const_iterator::operator*() const {
+  const Value key = _keys[_index];
+  const PropertyLValue<Value> value = (*_object)[key];
+  return {key, value};
+}
+
+inline Object::iterator::iterator(Object* object, const Type type) {
+  _object = object;
+  _keys = object->GetPropertyNames();
+  _index = type == Type::BEGIN ? 0 : _keys.Length();
+}
+
+inline Object::iterator Napi::Object::begin() {
+  iterator it(this, Object::iterator::Type::BEGIN);
+  return it;
+}
+
+inline Object::iterator Napi::Object::end() {
+  iterator it(this, Object::iterator::Type::END);
+  return it;
+}
+
+inline Object::iterator& Object::iterator::operator++() {
+  ++_index;
+  return *this;
+}
+
+inline bool Object::iterator::operator==(const iterator& other) const {
+  return _index == other._index;
+}
+
+inline bool Object::iterator::operator!=(const iterator& other) const {
+  return _index != other._index;
+}
+
+inline std::pair<Value, Object::PropertyLValue<Value>>
+Object::iterator::operator*() {
+  Value key = _keys[_index];
+  PropertyLValue<Value> value = (*_object)[key];
+  return {key, value};
+}
+#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);
 }
@@ -2044,8 +2134,10 @@ inline TypedArrayOf<T>::TypedArrayOf(napi_env env, napi_value value)
   : TypedArray(env, value), _data(nullptr) {
   napi_status status = napi_ok;
   if (value != nullptr) {
+    void* data = nullptr;
     status = napi_get_typedarray_info(
-      _env, _value, &_type, &_length, reinterpret_cast<void**>(&_data), nullptr, nullptr);
+        _env, _value, &_type, &_length, &data, nullptr, nullptr);
+    _data = static_cast<T*>(data);
   } else {
     _type = TypedArrayTypeForPrimitiveType<T>();
     _length = 0;
@@ -2154,7 +2246,7 @@ inline Function Function::New(napi_env env,
                               void* data) {
   using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
   using CbData = details::CallbackData<Callable, ReturnType>;
-  auto callbackData = new CbData({ cb, data });
+  auto callbackData = new CbData{std::move(cb), data};
 
   napi_value value;
   napi_status status = CreateFunction(env,
@@ -2199,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);
@@ -2214,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 {
@@ -2432,12 +2550,23 @@ inline Error Error::New(napi_env env) {
   napi_status status;
   napi_value error = nullptr;
   bool is_exception_pending;
-  const napi_extended_error_info* info;
+  napi_extended_error_info last_error_info_copy;
 
-  // We must retrieve the last error info before doing anything else, because
-  // doing anything else will replace the last error info.
-  status = napi_get_last_error_info(env, &info);
-  NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_last_error_info");
+  {
+    // We must retrieve the last error info before doing anything else because
+    // doing anything else will replace the last error info.
+    const napi_extended_error_info* last_error_info;
+    status = napi_get_last_error_info(env, &last_error_info);
+    NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_last_error_info");
+
+    // All fields of the `napi_extended_error_info` structure gets reset in
+    // subsequent Node-API function calls on the same `env`. This includes a
+    // call to `napi_is_exception_pending()`. So here it is necessary to make a
+    // copy of the information as the `error_code` field is used later on.
+    memcpy(&last_error_info_copy,
+           last_error_info,
+           sizeof(napi_extended_error_info));
+  }
 
   status = napi_is_exception_pending(env, &is_exception_pending);
   NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_is_exception_pending");
@@ -2448,8 +2577,9 @@ inline Error Error::New(napi_env env) {
     NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_get_and_clear_last_exception");
   }
   else {
-    const char* error_message = info->error_message != nullptr ?
-      info->error_message : "Error in native callback";
+    const char* error_message = last_error_info_copy.error_message != nullptr
+                                    ? last_error_info_copy.error_message
+                                    : "Error in native callback";
 
     napi_value message;
     status = napi_create_string_utf8(
@@ -2459,16 +2589,16 @@ inline Error Error::New(napi_env env) {
       &message);
     NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_string_utf8");
 
-    switch (info->error_code) {
-    case napi_object_expected:
-    case napi_string_expected:
-    case napi_boolean_expected:
-    case napi_number_expected:
-      status = napi_create_type_error(env, nullptr, message, &error);
-      break;
-    default:
-      status = napi_create_error(env, nullptr,  message, &error);
-      break;
+    switch (last_error_info_copy.error_code) {
+      case napi_object_expected:
+      case napi_string_expected:
+      case napi_boolean_expected:
+      case napi_number_expected:
+        status = napi_create_type_error(env, nullptr, message, &error);
+        break;
+      default:
+        status = napi_create_error(env, nullptr, message, &error);
+        break;
     }
     NAPI_FATAL_IF_FAILED(status, "Error::New", "napi_create_error");
   }
@@ -2493,14 +2623,82 @@ inline Error::Error() : ObjectReference() {
 
 inline Error::Error(napi_env env, napi_value value) : ObjectReference(env, nullptr) {
   if (value != nullptr) {
+    // Attempting to create a reference on the error object.
+    // If it's not a Object/Function/Symbol, this call will return an error
+    // status.
     napi_status status = napi_create_reference(env, value, 1, &_ref);
 
+    if (status != napi_ok) {
+      napi_value wrappedErrorObj;
+
+      // Create an error object
+      status = napi_create_object(env, &wrappedErrorObj);
+      NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_create_object");
+
+      // 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
+          nullptr,
+          nullptr,
+          nullptr,
+          nullptr,
+          Value::From(env, value),
+          napi_enumerable,
+          nullptr};
+
+      status = napi_define_properties(env, wrappedErrorObj, 1, &wrapObjFlag);
+      NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_define_properties");
+
+      // Create a reference on the newly wrapped object
+      status = napi_create_reference(env, wrappedErrorObj, 1, &_ref);
+    }
+
     // Avoid infinite recursion in the failure case.
-    // Don't try to construct & throw another Error instance.
     NAPI_FATAL_IF_FAILED(status, "Error::Error", "napi_create_reference");
   }
 }
 
+inline Object Error::Value() const {
+  if (_ref == nullptr) {
+    return Object(_env, nullptr);
+  }
+
+  napi_value refValue;
+  napi_status status = napi_get_reference_value(_env, _ref, &refValue);
+  NAPI_THROW_IF_FAILED(_env, status, Object());
+
+  napi_valuetype type;
+  status = napi_typeof(_env, refValue, &type);
+  NAPI_THROW_IF_FAILED(_env, status, Object());
+
+  // If refValue isn't a symbol, then we proceed to whether the refValue has the
+  // wrapped error flag
+  if (type != napi_symbol) {
+    // We are checking if the object is wrapped
+    bool isWrappedObject = false;
+
+    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()),
+                                 &unwrappedValue);
+      NAPI_THROW_IF_FAILED(_env, status, Object());
+
+      return Object(_env, unwrappedValue);
+    }
+  }
+
+  return Object(_env, refValue);
+}
+
 inline Error::Error(Error&& other) : ObjectReference(std::move(other)) {
 }
 
@@ -2551,6 +2749,7 @@ inline const std::string& Error::Message() const NAPI_NOEXCEPT {
   return _message;
 }
 
+// we created an object on the &_ref
 inline void Error::ThrowAsJavaScriptException() const {
   HandleScope scope(_env);
   if (!IsEmpty()) {
@@ -2605,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,
@@ -2763,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);
@@ -2771,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);
@@ -2897,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);
 }
@@ -2973,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);
 }
@@ -3967,10 +4171,10 @@ inline ObjectWrap<T>::~ObjectWrap() {
 
 template<typename T>
 inline T* ObjectWrap<T>::Unwrap(Object wrapper) {
-  T* unwrapped;
-  napi_status status = napi_unwrap(wrapper.Env(), wrapper, reinterpret_cast<void**>(&unwrapped));
+  void* unwrapped;
+  napi_status status = napi_unwrap(wrapper.Env(), wrapper, &unwrapped);
   NAPI_THROW_IF_FAILED(wrapper.Env(), status, nullptr);
-  return unwrapped;
+  return static_cast<T*>(unwrapped);
 }
 
 template <typename T>
@@ -4284,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*/) {}
 
@@ -4297,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([&] {
@@ -5156,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);
 }
 
@@ -5164,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);
 }
 
@@ -5494,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);
 }
 
@@ -6037,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_