node-addon-api 8.2.2 → 8.3.1

package/README.md

@@ -19,7 +19,7 @@ and exception handling semantics with low overhead.
 API references are available in the [doc](doc/README.md) directory.
 
 <!-- x-release-please-start-version -->
-## Current version: 8.2.2
+## Current version: 8.3.1
 <!-- x-release-please-end -->
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)

package/napi-inl.h

@@ -79,19 +79,33 @@ inline napi_status AttachData(napi_env env,
 // For use in JS to C++ callback wrappers to catch any Napi::Error exceptions
 // and rethrow them as JavaScript exceptions before returning from the callback.
 template <typename Callable>
-inline napi_value WrapCallback(Callable callback) {
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS_ALL
+inline napi_value WrapCallback(napi_env env, Callable callback) {
+#else
+inline napi_value WrapCallback(napi_env, Callable callback) {
+#endif
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
   try {
     return callback();
   } catch (const Error& e) {
     e.ThrowAsJavaScriptException();
     return nullptr;
   }
-#else   // NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS_ALL
+  catch (const std::exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+    return nullptr;
+  } catch (...) {
+    Napi::Error::New(env, "A native exception was thrown")
+        .ThrowAsJavaScriptException();
+    return nullptr;
+  }
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS_ALL
+#else   // NODE_ADDON_API_CPP_EXCEPTIONS
   // When C++ exceptions are disabled, errors are immediately thrown as JS
   // exceptions, so there is no need to catch and rethrow them here.
   return callback();
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 }
 
 // For use in JS to C++ void callback wrappers to catch any Napi::Error
@@ -99,7 +113,7 @@ inline napi_value WrapCallback(Callable callback) {
 // the callback.
 template <typename Callable>
 inline void WrapVoidCallback(Callable callback) {
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
   try {
     callback();
   } catch (const Error& e) {
@@ -112,10 +126,41 @@ inline void WrapVoidCallback(Callable callback) {
 #endif  // NAPI_CPP_EXCEPTIONS
 }
 
+// For use in JS to C++ void callback wrappers to catch _any_ thrown exception
+// and rethrow them as JavaScript exceptions before returning from the callback,
+// wrapping in an Napi::Error as needed.
+template <typename Callable>
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS_ALL
+inline void WrapVoidCallback(napi_env env, Callable callback) {
+#else
+inline void WrapVoidCallback(napi_env, Callable callback) {
+#endif
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
+  try {
+    callback();
+  } catch (const Error& e) {
+    e.ThrowAsJavaScriptException();
+  }
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS_ALL
+  catch (const std::exception& e) {
+    Napi::Error::New(env, e.what()).ThrowAsJavaScriptException();
+  } catch (...) {
+    Napi::Error::New(env, "A native exception was thrown")
+        .ThrowAsJavaScriptException();
+  }
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS_ALL
+#else
+  // When C++ exceptions are disabled, there is no need to catch and rethrow C++
+  // exceptions. JS errors should be thrown with
+  // `Error::ThrowAsJavaScriptException`.
+  callback();
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
+}
+
 template <typename Callable, typename Return>
 struct CallbackData {
   static inline napi_value Wrapper(napi_env env, napi_callback_info info) {
-    return details::WrapCallback([&] {
+    return details::WrapCallback(env, [&] {
       CallbackInfo callbackInfo(env, info);
       CallbackData* callbackData =
           static_cast<CallbackData*>(callbackInfo.Data());
@@ -131,7 +176,7 @@ struct CallbackData {
 template <typename Callable>
 struct CallbackData<Callable, void> {
   static inline napi_value Wrapper(napi_env env, napi_callback_info info) {
-    return details::WrapCallback([&] {
+    return details::WrapCallback(env, [&] {
       CallbackInfo callbackInfo(env, info);
       CallbackData* callbackData =
           static_cast<CallbackData*>(callbackInfo.Data());
@@ -148,7 +193,7 @@ struct CallbackData<Callable, void> {
 template <void (*Callback)(const CallbackInfo& info)>
 napi_value TemplatedVoidCallback(napi_env env,
                                  napi_callback_info info) NAPI_NOEXCEPT {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo cbInfo(env, info);
     Callback(cbInfo);
     return nullptr;
@@ -158,7 +203,7 @@ napi_value TemplatedVoidCallback(napi_env env,
 template <Napi::Value (*Callback)(const CallbackInfo& info)>
 napi_value TemplatedCallback(napi_env env,
                              napi_callback_info info) NAPI_NOEXCEPT {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo cbInfo(env, info);
     // MSVC requires to copy 'Callback' function pointer to a local variable
     // before invoking it.
@@ -171,7 +216,7 @@ template <typename T,
           Napi::Value (T::*UnwrapCallback)(const CallbackInfo& info)>
 napi_value TemplatedInstanceCallback(napi_env env,
                                      napi_callback_info info) NAPI_NOEXCEPT {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo cbInfo(env, info);
     T* instance = T::Unwrap(cbInfo.This().As<Object>());
     return instance ? (instance->*UnwrapCallback)(cbInfo) : Napi::Value();
@@ -181,7 +226,7 @@ napi_value TemplatedInstanceCallback(napi_env env,
 template <typename T, void (T::*UnwrapCallback)(const CallbackInfo& info)>
 napi_value TemplatedInstanceVoidCallback(napi_env env, napi_callback_info info)
     NAPI_NOEXCEPT {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo cbInfo(env, info);
     T* instance = T::Unwrap(cbInfo.This().As<Object>());
     if (instance) (instance->*UnwrapCallback)(cbInfo);
@@ -264,7 +309,7 @@ struct FinalizeData {
   static inline void WrapperGCWithoutData(napi_env env,
                                           void* /*data*/,
                                           void* finalizeHint) NAPI_NOEXCEPT {
-    WrapVoidCallback([&] {
+    WrapVoidCallback(env, [&] {
       FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
       finalizeData->callback(env);
       delete finalizeData;
@@ -274,7 +319,7 @@ struct FinalizeData {
   static inline void WrapperGC(napi_env env,
                                void* data,
                                void* finalizeHint) NAPI_NOEXCEPT {
-    WrapVoidCallback([&] {
+    WrapVoidCallback(env, [&] {
       FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
       finalizeData->callback(env, static_cast<T*>(data));
       delete finalizeData;
@@ -284,7 +329,7 @@ struct FinalizeData {
   static inline void WrapperGCWithHint(napi_env env,
                                        void* data,
                                        void* finalizeHint) NAPI_NOEXCEPT {
-    WrapVoidCallback([&] {
+    WrapVoidCallback(env, [&] {
       FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
       finalizeData->callback(env, static_cast<T*>(data), finalizeData->hint);
       delete finalizeData;
@@ -351,7 +396,7 @@ struct ThreadSafeFinalize {
 template <typename ContextType, typename DataType, typename CallJs, CallJs call>
 inline typename std::enable_if<call != static_cast<CallJs>(nullptr)>::type
 CallJsWrapper(napi_env env, napi_value jsCallback, void* context, void* data) {
-  details::WrapVoidCallback([&]() {
+  details::WrapVoidCallback(env, [&]() {
     call(env,
          Function(env, jsCallback),
          static_cast<ContextType*>(context),
@@ -365,7 +410,7 @@ CallJsWrapper(napi_env env,
               napi_value jsCallback,
               void* /*context*/,
               void* /*data*/) {
-  details::WrapVoidCallback([&]() {
+  details::WrapVoidCallback(env, [&]() {
     if (jsCallback != nullptr) {
       Function(env, jsCallback).Call(0, nullptr);
     }
@@ -399,7 +444,7 @@ template <typename Getter, typename Setter>
 struct AccessorCallbackData {
   static inline napi_value GetterWrapper(napi_env env,
                                          napi_callback_info info) {
-    return details::WrapCallback([&] {
+    return details::WrapCallback(env, [&] {
       CallbackInfo callbackInfo(env, info);
       AccessorCallbackData* callbackData =
           static_cast<AccessorCallbackData*>(callbackInfo.Data());
@@ -410,7 +455,7 @@ struct AccessorCallbackData {
 
   static inline napi_value SetterWrapper(napi_env env,
                                          napi_callback_info info) {
-    return details::WrapCallback([&] {
+    return details::WrapCallback(env, [&] {
       CallbackInfo callbackInfo(env, info);
       AccessorCallbackData* callbackData =
           static_cast<AccessorCallbackData*>(callbackInfo.Data());
@@ -501,7 +546,7 @@ class HasBasicFinalizer {
 inline napi_value RegisterModule(napi_env env,
                                  napi_value exports,
                                  ModuleRegisterCallback registerCallback) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     return napi_value(
         registerCallback(Napi::Env(env), Napi::Object(env, exports)));
   });
@@ -1808,7 +1853,7 @@ inline void Object::AddFinalizer(Finalizer finalizeCallback,
   }
 }
 
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
 inline Object::const_iterator::const_iterator(const Object* object,
                                               const Type type) {
   _object = object;
@@ -1883,7 +1928,7 @@ Object::iterator::operator*() {
   PropertyLValue<Value> value = (*_object)[key];
   return {key, value};
 }
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 
 #if NAPI_VERSION >= 8
 inline MaybeOrValue<bool> Object::Freeze() const {
@@ -3159,14 +3204,14 @@ inline Error& Error::operator=(const Error& other) {
 
 inline const std::string& Error::Message() const NAPI_NOEXCEPT {
   if (_message.size() == 0 && _env != nullptr) {
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
     try {
       _message = Get("message").As<String>();
     } catch (...) {
       // Catch all errors here, to include e.g. a std::bad_alloc from
       // the std::string::operator=, because this method may not throw.
     }
-#else  // NAPI_CPP_EXCEPTIONS
+#else  // NODE_ADDON_API_CPP_EXCEPTIONS
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
     Napi::Value message_val;
     if (Get("message").UnwrapTo(&message_val)) {
@@ -3175,7 +3220,7 @@ inline const std::string& Error::Message() const NAPI_NOEXCEPT {
 #else
     _message = Get("message").As<String>();
 #endif
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
   }
   return _message;
 }
@@ -3199,7 +3244,7 @@ inline void Error::ThrowAsJavaScriptException() const {
 
       status = napi_throw(_env, Value());
 
-#ifdef NAPI_EXPERIMENTAL
+#if (NAPI_VERSION >= 10)
       napi_status expected_failure_mode = napi_cannot_run_js;
 #else
       napi_status expected_failure_mode = napi_pending_exception;
@@ -3222,24 +3267,24 @@ inline void Error::ThrowAsJavaScriptException() const {
     napi_status status = napi_throw(_env, Value());
 #endif
 
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
     if (status != napi_ok) {
       throw Error::New(_env);
     }
-#else   // NAPI_CPP_EXCEPTIONS
+#else   // NODE_ADDON_API_CPP_EXCEPTIONS
     NAPI_FATAL_IF_FAILED(
         status, "Error::ThrowAsJavaScriptException", "napi_throw");
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
   }
 }
 
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
 
 inline const char* Error::what() const NAPI_NOEXCEPT {
   return Message().c_str();
 }
 
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 
 inline const char* Error::ERROR_WRAP_VALUE() NAPI_NOEXCEPT {
   return "4bda9e7e-4913-4dbc-95de-891cbf66598e-errorVal";
@@ -4508,7 +4553,7 @@ inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceValue(
 template <typename T>
 inline napi_value InstanceWrap<T>::InstanceVoidMethodCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     InstanceVoidMethodCallbackData* callbackData =
         reinterpret_cast<InstanceVoidMethodCallbackData*>(callbackInfo.Data());
@@ -4523,7 +4568,7 @@ inline napi_value InstanceWrap<T>::InstanceVoidMethodCallbackWrapper(
 template <typename T>
 inline napi_value InstanceWrap<T>::InstanceMethodCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     InstanceMethodCallbackData* callbackData =
         reinterpret_cast<InstanceMethodCallbackData*>(callbackInfo.Data());
@@ -4537,7 +4582,7 @@ inline napi_value InstanceWrap<T>::InstanceMethodCallbackWrapper(
 template <typename T>
 inline napi_value InstanceWrap<T>::InstanceGetterCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     InstanceAccessorCallbackData* callbackData =
         reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
@@ -4551,7 +4596,7 @@ inline napi_value InstanceWrap<T>::InstanceGetterCallbackWrapper(
 template <typename T>
 inline napi_value InstanceWrap<T>::InstanceSetterCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     InstanceAccessorCallbackData* callbackData =
         reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
@@ -4567,7 +4612,7 @@ template <typename T>
 template <typename InstanceWrap<T>::InstanceSetterCallback method>
 inline napi_value InstanceWrap<T>::WrappedMethod(
     napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     const CallbackInfo cbInfo(env, info);
     T* instance = T::Unwrap(cbInfo.This().As<Object>());
     if (instance) (instance->*method)(cbInfo, cbInfo[0]);
@@ -4962,13 +5007,13 @@ inline napi_value ObjectWrap<T>::ConstructorCallbackWrapper(
   bool isConstructCall = (new_target != nullptr);
   if (!isConstructCall) {
     return details::WrapCallback(
-        [&] { return T::OnCalledAsFunction(CallbackInfo(env, info)); });
+        env, [&] { return T::OnCalledAsFunction(CallbackInfo(env, info)); });
   }
 
-  napi_value wrapper = details::WrapCallback([&] {
+  napi_value wrapper = details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     T* instance = new T(callbackInfo);
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
     instance->_construction_failed = false;
 #else
     if (callbackInfo.Env().IsExceptionPending()) {
@@ -4979,7 +5024,7 @@ inline napi_value ObjectWrap<T>::ConstructorCallbackWrapper(
     } else {
       instance->_construction_failed = false;
     }
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
     return callbackInfo.This();
   });
 
@@ -4989,7 +5034,7 @@ inline napi_value ObjectWrap<T>::ConstructorCallbackWrapper(
 template <typename T>
 inline napi_value ObjectWrap<T>::StaticVoidMethodCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     StaticVoidMethodCallbackData* callbackData =
         reinterpret_cast<StaticVoidMethodCallbackData*>(callbackInfo.Data());
@@ -5002,7 +5047,7 @@ inline napi_value ObjectWrap<T>::StaticVoidMethodCallbackWrapper(
 template <typename T>
 inline napi_value ObjectWrap<T>::StaticMethodCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     StaticMethodCallbackData* callbackData =
         reinterpret_cast<StaticMethodCallbackData*>(callbackInfo.Data());
@@ -5014,7 +5059,7 @@ inline napi_value ObjectWrap<T>::StaticMethodCallbackWrapper(
 template <typename T>
 inline napi_value ObjectWrap<T>::StaticGetterCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     StaticAccessorCallbackData* callbackData =
         reinterpret_cast<StaticAccessorCallbackData*>(callbackInfo.Data());
@@ -5026,7 +5071,7 @@ inline napi_value ObjectWrap<T>::StaticGetterCallbackWrapper(
 template <typename T>
 inline napi_value ObjectWrap<T>::StaticSetterCallbackWrapper(
     napi_env env, napi_callback_info info) {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     CallbackInfo callbackInfo(env, info);
     StaticAccessorCallbackData* callbackData =
         reinterpret_cast<StaticAccessorCallbackData*>(callbackInfo.Data());
@@ -5101,7 +5146,7 @@ template <typename T>
 template <typename ObjectWrap<T>::StaticSetterCallback method>
 inline napi_value ObjectWrap<T>::WrappedMethod(
     napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
-  return details::WrapCallback([&] {
+  return details::WrapCallback(env, [&] {
     const CallbackInfo cbInfo(env, info);
     // MSVC requires to copy 'method' function pointer to a local variable
     // before invoking it.
@@ -5402,15 +5447,15 @@ inline void AsyncWorker::OnAsyncWorkExecute(napi_env env, void* asyncworker) {
 // must not run any method that would cause JavaScript to run. In practice,
 // this means that almost any use of napi_env will be incorrect.
 inline void AsyncWorker::OnExecute(Napi::Env /*DO_NOT_USE*/) {
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
   try {
     Execute();
   } catch (const std::exception& e) {
     SetError(e.what());
   }
-#else   // NAPI_CPP_EXCEPTIONS
+#else   // NODE_ADDON_API_CPP_EXCEPTIONS
   Execute();
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 }
 
 inline void AsyncWorker::OnAsyncWorkComplete(napi_env env,
@@ -5419,10 +5464,10 @@ inline void AsyncWorker::OnAsyncWorkComplete(napi_env env,
   AsyncWorker* self = static_cast<AsyncWorker*>(asyncworker);
   self->OnWorkComplete(env, status);
 }
-inline void AsyncWorker::OnWorkComplete(Napi::Env /*env*/, napi_status status) {
+inline void AsyncWorker::OnWorkComplete(Napi::Env env, napi_status status) {
   if (status != napi_cancelled) {
     HandleScope scope(_env);
-    details::WrapCallback([&] {
+    details::WrapCallback(env, [&] {
       if (_error.size() == 0) {
         OnOK();
       } else {
@@ -6334,7 +6379,7 @@ inline void ThreadSafeFunction::CallJS(napi_env env,
     return;
   }
 
-  details::WrapVoidCallback([&]() {
+  details::WrapVoidCallback(env, [&]() {
     if (data != nullptr) {
       auto* callbackWrapper = static_cast<CallbackWrapper*>(data);
       (*callbackWrapper)(env, Function(env, jsCallback));

package/napi.h

@@ -37,22 +37,40 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t),
 #define NAPI_WIDE_TEXT(x) u##x
 #endif
 
+// Backwards-compatibility to handle the rename of this macro definition, in
+// case they are used within userland code.
+#ifdef NAPI_CPP_EXCEPTIONS
+#define NODE_ADDON_API_CPP_EXCEPTIONS
+#endif
+#if defined(NODE_ADDON_API_CPP_EXCEPTIONS) && !defined(NAPI_CPP_EXCEPTIONS)
+#define NAPI_CPP_EXCEPTIONS
+#endif
+#ifdef NAPI_DISABLE_CPP_EXCEPTIONS
+#define NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS
+#endif
+#if defined(NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS) &&                          \
+    !defined(NAPI_DISABLE_CPP_EXCEPTIONS)
+#define NAPI_DISABLE_CPP_EXCEPTIONS
+#endif
+
 // If C++ exceptions are not explicitly enabled or disabled, enable them
 // if exceptions were enabled in the compiler settings.
-#if !defined(NAPI_CPP_EXCEPTIONS) && !defined(NAPI_DISABLE_CPP_EXCEPTIONS)
+#if !defined(NODE_ADDON_API_CPP_EXCEPTIONS) &&                                 \
+    !defined(NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS)
 #if defined(_CPPUNWIND) || defined(__EXCEPTIONS)
-#define NAPI_CPP_EXCEPTIONS
+#define NODE_ADDON_API_CPP_EXCEPTIONS
 #else
 #error Exception support not detected. \
-      Define either NAPI_CPP_EXCEPTIONS or NAPI_DISABLE_CPP_EXCEPTIONS.
+      Define either NODE_ADDON_API_CPP_EXCEPTIONS or NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS.
 #endif
 #endif
 
-// If C++ NAPI_CPP_EXCEPTIONS are enabled, NODE_ADDON_API_ENABLE_MAYBE should
-// not be set
-#if defined(NAPI_CPP_EXCEPTIONS) && defined(NODE_ADDON_API_ENABLE_MAYBE)
+// If C++ NODE_ADDON_API_CPP_EXCEPTIONS are enabled, NODE_ADDON_API_ENABLE_MAYBE
+// should not be set
+#if defined(NODE_ADDON_API_CPP_EXCEPTIONS) &&                                  \
+    defined(NODE_ADDON_API_ENABLE_MAYBE)
 #error NODE_ADDON_API_ENABLE_MAYBE should not be set when \
-    NAPI_CPP_EXCEPTIONS is defined.
+    NODE_ADDON_API_CPP_EXCEPTIONS is defined.
 #endif
 
 #ifdef _NOEXCEPT
@@ -61,7 +79,7 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t),
 #define NAPI_NOEXCEPT noexcept
 #endif
 
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
 
 // When C++ exceptions are enabled, Errors are thrown directly. There is no need
 // to return anything after the throw statements. The variadic parameter is an
@@ -78,7 +96,7 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t),
 #define NAPI_THROW_IF_FAILED_VOID(env, status)                                 \
   if ((status) != napi_ok) throw Napi::Error::New(env);
 
-#else  // NAPI_CPP_EXCEPTIONS
+#else  // NODE_ADDON_API_CPP_EXCEPTIONS
 
 // When C++ exceptions are disabled, Errors are thrown as JavaScript exceptions,
 // which are pending until the callback returns to JS.  The variadic parameter
@@ -110,7 +128,7 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t),
     return;                                                                    \
   }
 
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 
 #ifdef NODE_ADDON_API_ENABLE_MAYBE
 #define NAPI_MAYBE_THROW_IF_FAILED(env, status, type)                          \
@@ -1068,7 +1086,7 @@ class Object : public TypeTaggable {
                            T* data,
                            Hint* finalizeHint) const;
 
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
   class const_iterator;
 
   inline const_iterator begin() const;
@@ -1080,7 +1098,7 @@ class Object : public TypeTaggable {
   inline iterator begin();
 
   inline iterator end();
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 
 #if NAPI_VERSION >= 8
   /// This operation can fail in case of Proxy.[[GetPrototypeOf]] calling into
@@ -1132,7 +1150,7 @@ class Array : public Object {
   uint32_t Length() const;
 };
 
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
 class Object::const_iterator {
  private:
   enum class Type { BEGIN, END };
@@ -1179,7 +1197,7 @@ class Object::iterator {
 
   friend class Object;
 };
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 
 /// A JavaScript array buffer value.
 class ArrayBuffer : public Object {
@@ -1811,14 +1829,15 @@ FunctionReference Persistent(Function value);
 ///
 /// ### Handling Errors Without C++ Exceptions
 ///
-/// If C++ exceptions are disabled (by defining `NAPI_DISABLE_CPP_EXCEPTIONS`)
-/// then this class does not extend `std::exception`, and APIs in the `Napi`
-/// namespace do not throw C++ exceptions when they fail. Instead, they raise
-/// _pending_ JavaScript exceptions and return _empty_ `Value`s. Calling code
-/// should check `Value::IsEmpty()` before attempting to use a returned value,
-/// and may use methods on the `Env` class to check for, get, and clear a
-/// pending JavaScript exception. If the pending exception is not cleared, it
-/// will be thrown when the native callback returns to JavaScript.
+/// If C++ exceptions are disabled (by defining
+/// `NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS`) then this class does not extend
+/// `std::exception`, and APIs in the `Napi` namespace do not throw C++
+/// exceptions when they fail. Instead, they raise _pending_ JavaScript
+/// exceptions and return _empty_ `Value`s. Calling code should check
+/// `Value::IsEmpty()` before attempting to use a returned value, and may use
+/// methods on the `Env` class to check for, get, and clear a pending JavaScript
+/// exception. If the pending exception is not cleared, it will be thrown when
+/// the native callback returns to JavaScript.
 ///
 /// #### Example 1B - Throwing a JS exception
 ///
@@ -1853,10 +1872,10 @@ FunctionReference Persistent(Function value);
 /// Since the exception was cleared here, it will not be propagated as a
 /// JavaScript exception after the native callback returns.
 class Error : public ObjectReference
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
     ,
               public std::exception
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 {
  public:
   static Error New(napi_env env);
@@ -1879,9 +1898,9 @@ class Error : public ObjectReference
 
   Object Value() const;
 
-#ifdef NAPI_CPP_EXCEPTIONS
+#ifdef NODE_ADDON_API_CPP_EXCEPTIONS
   const char* what() const NAPI_NOEXCEPT override;
-#endif  // NAPI_CPP_EXCEPTIONS
+#endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 
  protected:
   /// !cond INTERNAL

package/node_addon_api.gyp

@@ -18,6 +18,16 @@
         'includes': ['except.gypi'],
       }
     },
+    {
+      'target_name': 'node_addon_api_except_all',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['except.gypi'],
+        'defines': [ 'NODE_ADDON_API_CPP_EXCEPTIONS_ALL' ]
+      }
+    },
     {
       'target_name': 'node_addon_api_maybe',
       'type': 'none',

package/noexcept.gypi

@@ -1,5 +1,5 @@
 {
-  'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
+  'defines': [ 'NODE_ADDON_API_DISABLE_CPP_EXCEPTIONS' ],
   'cflags': [ '-fno-exceptions' ],
   'cflags_cc': [ '-fno-exceptions' ],
   'conditions': [

package/package.json

@@ -421,16 +421,10 @@
     "benchmark": "^2.1.4",
     "bindings": "^1.5.0",
     "clang-format": "^1.4.0",
-    "eslint": "^7.32.0",
-    "eslint-config-semistandard": "^16.0.0",
-    "eslint-config-standard": "^16.0.3",
-    "eslint-plugin-import": "^2.24.2",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-promise": "^5.1.0",
+    "eslint": "^9.13.0",
     "fs-extra": "^11.1.1",
-    "path": "^0.12.7",
+    "neostandard": "^0.12.0",
     "pre-commit": "^1.2.2",
-    "safe-buffer": "^5.1.1",
     "semver": "^7.6.0"
   },
   "directories": {},
@@ -474,11 +468,11 @@
     "predev:incremental": "node-gyp configure build -C test --debug",
     "dev:incremental": "node test",
     "doc": "doxygen doc/Doxyfile",
-    "lint": "node tools/eslint-format && node tools/clang-format",
-    "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
+    "lint": "eslint && node tools/clang-format",
+    "lint:fix": "eslint --fix && node tools/clang-format --fix"
   },
   "pre-commit": "lint",
-  "version": "8.2.2",
+  "version": "8.3.1",
   "support": true,
   "engines": {
     "node": "^18 || ^20 || >= 21"

package/tools/eslint-format.js

@@ -1,79 +0,0 @@
-#!/usr/bin/env node
-
-const spawn = require('child_process').spawnSync;
-
-const filesToCheck = '*.js';
-const FORMAT_START = process.env.FORMAT_START || 'main';
-const IS_WIN = process.platform === 'win32';
-const ESLINT_PATH = IS_WIN ? 'node_modules\\.bin\\eslint.cmd' : 'node_modules/.bin/eslint';
-
-function main (args) {
-  let fix = false;
-  while (args.length > 0) {
-    switch (args[0]) {
-      case '-f':
-      case '--fix':
-        fix = true;
-        break;
-      default:
-    }
-    args.shift();
-  }
-
-  // Check js files that change on unstaged file
-  const fileUnStaged = spawn(
-    'git',
-    ['diff', '--name-only', '--diff-filter=d', FORMAT_START, filesToCheck],
-    {
-      encoding: 'utf-8'
-    }
-  );
-
-  // Check js files that change on staged file
-  const fileStaged = spawn(
-    'git',
-    ['diff', '--name-only', '--cached', '--diff-filter=d', FORMAT_START, filesToCheck],
-    {
-      encoding: 'utf-8'
-    }
-  );
-
-  const options = [
-    ...fileStaged.stdout.split('\n').filter((f) => f !== ''),
-    ...fileUnStaged.stdout.split('\n').filter((f) => f !== '')
-  ];
-
-  if (fix) {
-    options.push('--fix');
-  }
-
-  const result = spawn(ESLINT_PATH, [...options], {
-    encoding: 'utf-8'
-  });
-
-  if (result.error && result.error.errno === 'ENOENT') {
-    console.error('Eslint not found! Eslint is supposed to be found at ', ESLINT_PATH);
-    return 2;
-  }
-
-  if (result.status === 1) {
-    console.error('Eslint error:', result.stdout);
-    const fixCmd = 'npm run lint:fix';
-    console.error(`ERROR: please run "${fixCmd}" to format changes in your commit
-    Note that when running the command locally, please keep your local
-    main branch and working branch up to date with nodejs/node-addon-api
-    to exclude un-related complains.
-    Or you can run "env FORMAT_START=upstream/main ${fixCmd}".
-    Also fix JS files by yourself if necessary.`);
-    return 1;
-  }
-
-  if (result.stderr) {
-    console.error('Error running eslint:', result.stderr);
-    return 2;
-  }
-}
-
-if (require.main === module) {
-  process.exitCode = main(process.argv.slice(2));
-}