node-addon-api 8.4.0 → 8.6.0

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.4.0
+## Current version: 8.6.0
 <!-- x-release-please-end -->
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)

package/common.gypi

@@ -5,7 +5,7 @@
   },
   'conditions': [
     ['NAPI_VERSION!=""', { 'defines': ['NAPI_VERSION=<@(NAPI_VERSION)'] } ],
-    ['NAPI_VERSION==2147483647', { 'defines': ['NAPI_EXPERIMENTAL'] } ],
+    ['NAPI_VERSION==2147483647', { 'defines': ['NAPI_EXPERIMENTAL', 'NODE_API_EXPERIMENTAL_NO_WARNING'] } ],
     ['disable_deprecated=="true"', {
       'defines': ['NODE_ADDON_API_DISABLE_DEPRECATED']
     }],

package/napi-inl.h

@@ -21,6 +21,12 @@
 #include <type_traits>
 #include <utility>
 
+#if defined(__clang__) || defined(__GNUC__)
+#define NAPI_NO_SANITIZE_VPTR __attribute__((no_sanitize("vptr")))
+#else
+#define NAPI_NO_SANITIZE_VPTR
+#endif
+
 namespace Napi {
 
 #ifdef NAPI_CPP_CUSTOM_NAMESPACE
@@ -934,6 +940,19 @@ inline bool Value::IsExternal() const {
   return Type() == napi_external;
 }
 
+#ifdef NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER
+inline bool Value::IsSharedArrayBuffer() const {
+  if (IsEmpty()) {
+    return false;
+  }
+
+  bool result;
+  napi_status status = node_api_is_sharedarraybuffer(_env, _value, &result);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return result;
+}
+#endif
+
 template <typename T>
 inline T Value::As() const {
 #ifdef NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS
@@ -2068,6 +2087,55 @@ inline uint32_t Array::Length() const {
   return result;
 }
 
+#ifdef NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER
+////////////////////////////////////////////////////////////////////////////////
+// SharedArrayBuffer class
+////////////////////////////////////////////////////////////////////////////////
+
+inline SharedArrayBuffer::SharedArrayBuffer() : Object() {}
+
+inline SharedArrayBuffer::SharedArrayBuffer(napi_env env, napi_value value)
+    : Object(env, value) {}
+
+inline void SharedArrayBuffer::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "SharedArrayBuffer::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = node_api_is_sharedarraybuffer(env, value, &result);
+  NAPI_CHECK(status == napi_ok,
+             "SharedArrayBuffer::CheckCast",
+             "node_api_is_sharedarraybuffer failed");
+  NAPI_CHECK(
+      result, "SharedArrayBuffer::CheckCast", "value is not sharedarraybuffer");
+}
+
+inline SharedArrayBuffer SharedArrayBuffer::New(napi_env env,
+                                                size_t byteLength) {
+  napi_value value;
+  void* data;
+  napi_status status =
+      node_api_create_sharedarraybuffer(env, byteLength, &data, &value);
+  NAPI_THROW_IF_FAILED(env, status, SharedArrayBuffer());
+
+  return SharedArrayBuffer(env, value);
+}
+
+inline void* SharedArrayBuffer::Data() {
+  void* data;
+  napi_status status = napi_get_arraybuffer_info(_env, _value, &data, nullptr);
+  NAPI_THROW_IF_FAILED(_env, status, nullptr);
+  return data;
+}
+
+inline size_t SharedArrayBuffer::ByteLength() {
+  size_t length;
+  napi_status status =
+      napi_get_arraybuffer_info(_env, _value, nullptr, &length);
+  NAPI_THROW_IF_FAILED(_env, status, 0);
+  return length;
+}
+#endif  // NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER
+
 ////////////////////////////////////////////////////////////////////////////////
 // ArrayBuffer class
 ////////////////////////////////////////////////////////////////////////////////
@@ -2811,8 +2879,95 @@ inline void Promise::CheckCast(napi_env env, napi_value value) {
   NAPI_CHECK(result, "Promise::CheckCast", "value is not promise");
 }
 
+inline Promise::Promise() : Object() {}
+
 inline Promise::Promise(napi_env env, napi_value value) : Object(env, value) {}
 
+inline MaybeOrValue<Promise> Promise::Then(napi_value onFulfilled) const {
+  EscapableHandleScope scope(_env);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  Value thenMethod;
+  if (!Get("then").UnwrapTo(&thenMethod)) {
+    return Nothing<Promise>();
+  }
+  MaybeOrValue<Value> result =
+      thenMethod.As<Function>().Call(*this, {onFulfilled});
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()).As<Promise>());
+  }
+  return Nothing<Promise>();
+#else
+  Function thenMethod = Get("then").As<Function>();
+  MaybeOrValue<Value> result = thenMethod.Call(*this, {onFulfilled});
+  if (scope.Env().IsExceptionPending()) {
+    return Promise();
+  }
+  return scope.Escape(result).As<Promise>();
+#endif
+}
+
+inline MaybeOrValue<Promise> Promise::Then(napi_value onFulfilled,
+                                           napi_value onRejected) const {
+  EscapableHandleScope scope(_env);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  Value thenMethod;
+  if (!Get("then").UnwrapTo(&thenMethod)) {
+    return Nothing<Promise>();
+  }
+  MaybeOrValue<Value> result =
+      thenMethod.As<Function>().Call(*this, {onFulfilled, onRejected});
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()).As<Promise>());
+  }
+  return Nothing<Promise>();
+#else
+  Function thenMethod = Get("then").As<Function>();
+  MaybeOrValue<Value> result =
+      thenMethod.Call(*this, {onFulfilled, onRejected});
+  if (scope.Env().IsExceptionPending()) {
+    return Promise();
+  }
+  return scope.Escape(result).As<Promise>();
+#endif
+}
+
+inline MaybeOrValue<Promise> Promise::Catch(napi_value onRejected) const {
+  EscapableHandleScope scope(_env);
+#ifdef NODE_ADDON_API_ENABLE_MAYBE
+  Value catchMethod;
+  if (!Get("catch").UnwrapTo(&catchMethod)) {
+    return Nothing<Promise>();
+  }
+  MaybeOrValue<Value> result =
+      catchMethod.As<Function>().Call(*this, {onRejected});
+  if (result.IsJust()) {
+    return Just(scope.Escape(result.Unwrap()).As<Promise>());
+  }
+  return Nothing<Promise>();
+#else
+  Function catchMethod = Get("catch").As<Function>();
+  MaybeOrValue<Value> result = catchMethod.Call(*this, {onRejected});
+  if (scope.Env().IsExceptionPending()) {
+    return Promise();
+  }
+  return scope.Escape(result).As<Promise>();
+#endif
+}
+
+inline MaybeOrValue<Promise> Promise::Then(const Function& onFulfilled) const {
+  return Then(static_cast<napi_value>(onFulfilled));
+}
+
+inline MaybeOrValue<Promise> Promise::Then(const Function& onFulfilled,
+                                           const Function& onRejected) const {
+  return Then(static_cast<napi_value>(onFulfilled),
+              static_cast<napi_value>(onRejected));
+}
+
+inline MaybeOrValue<Promise> Promise::Catch(const Function& onRejected) const {
+  return Catch(static_cast<napi_value>(onRejected));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Buffer<T> class
 ////////////////////////////////////////////////////////////////////////////////
@@ -4630,7 +4785,8 @@ inline napi_value InstanceWrap<T>::WrappedMethod(
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
-inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
+inline NAPI_NO_SANITIZE_VPTR ObjectWrap<T>::ObjectWrap(
+    const Napi::CallbackInfo& callbackInfo) {
   napi_env env = callbackInfo.Env();
   napi_value wrapper = callbackInfo.This();
   napi_status status;
@@ -4644,7 +4800,7 @@ inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
 }
 
 template <typename T>
-inline ObjectWrap<T>::~ObjectWrap() {
+inline NAPI_NO_SANITIZE_VPTR ObjectWrap<T>::~ObjectWrap() {
   // If the JS object still exists at this point, remove the finalizer added
   // through `napi_wrap()`.
   if (!IsEmpty() && !_finalized) {
@@ -4657,8 +4813,12 @@ inline ObjectWrap<T>::~ObjectWrap() {
   }
 }
 
+// with RTTI turned on, modern compilers check to see if virtual function
+// pointers are stripped of RTTI by void casts. this is intrinsic to how Unwrap
+// works, so we inject a compiler pragma to turn off that check just for the
+// affected methods. this compiler check is on by default in Android NDK 29.
 template <typename T>
-inline T* ObjectWrap<T>::Unwrap(Object wrapper) {
+inline NAPI_NO_SANITIZE_VPTR T* ObjectWrap<T>::Unwrap(Object wrapper) {
   void* unwrapped;
   napi_status status = napi_unwrap(wrapper.Env(), wrapper, &unwrapped);
   NAPI_THROW_IF_FAILED(wrapper.Env(), status, nullptr);
@@ -6943,4 +7103,6 @@ inline void BasicEnv::PostFinalizer(FinalizerType finalizeCallback,
 
 }  // namespace Napi
 
+#undef NAPI_NO_SANITIZE_VPTR
+
 #endif  // SRC_NAPI_INL_H_

package/napi.h

@@ -543,6 +543,9 @@ class Value {
   bool IsDataView() const;    ///< Tests if a value is a JavaScript data view.
   bool IsBuffer() const;      ///< Tests if a value is a Node buffer.
   bool IsExternal() const;  ///< Tests if a value is a pointer to external data.
+#ifdef NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER
+  bool IsSharedArrayBuffer() const;
+#endif
 
   /// Casts to another type of `Napi::Value`, when the actual type is known or
   /// assumed.
@@ -1202,6 +1205,21 @@ class Object::iterator {
 };
 #endif  // NODE_ADDON_API_CPP_EXCEPTIONS
 
+#ifdef NODE_API_EXPERIMENTAL_HAS_SHAREDARRAYBUFFER
+class SharedArrayBuffer : public Object {
+ public:
+  SharedArrayBuffer();
+  SharedArrayBuffer(napi_env env, napi_value value);
+
+  static SharedArrayBuffer New(napi_env env, size_t byteLength);
+
+  static void CheckCast(napi_env env, napi_value value);
+
+  void* Data();
+  size_t ByteLength();
+};
+#endif
+
 /// A JavaScript array buffer value.
 class ArrayBuffer : public Object {
  public:
@@ -1574,7 +1592,18 @@ class Promise : public Object {
 
   static void CheckCast(napi_env env, napi_value value);
 
+  Promise();
   Promise(napi_env env, napi_value value);
+
+  MaybeOrValue<Promise> Then(napi_value onFulfilled) const;
+  MaybeOrValue<Promise> Then(napi_value onFulfilled,
+                             napi_value onRejected) const;
+  MaybeOrValue<Promise> Catch(napi_value onRejected) const;
+
+  MaybeOrValue<Promise> Then(const Function& onFulfilled) const;
+  MaybeOrValue<Promise> Then(const Function& onFulfilled,
+                             const Function& onRejected) const;
+  MaybeOrValue<Promise> Catch(const Function& onRejected) const;
 };
 
 template <typename T>

package/package.json

@@ -472,7 +472,7 @@
     "lint:fix": "eslint --fix && node tools/clang-format --fix"
   },
   "pre-commit": "lint",
-  "version": "8.4.0",
+  "version": "8.6.0",
   "support": true,
   "engines": {
     "node": "^18 || ^20 || >= 21"