node-addon-api 5.1.0 → 6.1.0

package/README.md

@@ -70,7 +70,7 @@ and node-addon-api.
 - **[Contributors](#contributors)**
 - **[License](#license)**
 
-## **Current version: 5.1.0**
+## **Current version: 6.1.0**
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
 

package/napi-inl.h

@@ -12,7 +12,9 @@
 
 #include <algorithm>
 #include <cstring>
+#if NAPI_HAS_THREADS
 #include <mutex>
+#endif  // NAPI_HAS_THREADS
 #include <type_traits>
 #include <utility>
 
@@ -22,9 +24,13 @@ namespace Napi {
 namespace NAPI_CPP_CUSTOM_NAMESPACE {
 #endif
 
-// Helpers to handle functions exposed from C++.
+// Helpers to handle functions exposed from C++ and internal constants.
 namespace details {
 
+// New napi_status constants not yet available in all supported versions of
+// Node.js releases. Only necessary when they are used in napi.h and napi-inl.h.
+constexpr int napi_no_external_buffers_allowed = 22;
+
 // Attach a data item to an object and delete it when the object gets
 // garbage-collected.
 // TODO: Replace this code with `napi_add_finalizer()` whenever it becomes
@@ -201,7 +207,7 @@ struct FinalizeData {
   Hint* hint;
 };
 
-#if (NAPI_VERSION > 3 && !defined(__wasm32__))
+#if (NAPI_VERSION > 3 && NAPI_HAS_THREADS)
 template <typename ContextType = void,
           typename Finalizer = std::function<void(Env, void*, ContextType*)>,
           typename FinalizerDataType = void>
@@ -295,7 +301,7 @@ napi_value DefaultCallbackWrapper(napi_env env, Napi::Function cb) {
   return cb;
 }
 #endif  // NAPI_VERSION > 4
-#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
+#endif  // NAPI_VERSION > 3 && NAPI_HAS_THREADS
 
 template <typename Getter, typename Setter>
 struct AccessorCallbackData {
@@ -736,6 +742,9 @@ inline bool Value::IsExternal() const {
 
 template <typename T>
 inline T Value::As() const {
+#ifdef NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS
+  T::CheckCast(_env, _value);
+#endif
   return T(_env, _value);
 }
 
@@ -778,6 +787,16 @@ inline Boolean Boolean::New(napi_env env, bool val) {
   return Boolean(env, value);
 }
 
+inline void Boolean::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Boolean::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "Boolean::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(
+      type == napi_boolean, "Boolean::CheckCast", "value is not napi_boolean");
+}
+
 inline Boolean::Boolean() : Napi::Value() {}
 
 inline Boolean::Boolean(napi_env env, napi_value value)
@@ -805,6 +824,16 @@ inline Number Number::New(napi_env env, double val) {
   return Number(env, value);
 }
 
+inline void Number::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Number::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "Number::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(
+      type == napi_number, "Number::CheckCast", "value is not napi_number");
+}
+
 inline Number::Number() : Value() {}
 
 inline Number::Number(napi_env env, napi_value value) : Value(env, value) {}
@@ -891,6 +920,16 @@ inline BigInt BigInt::New(napi_env env,
   return BigInt(env, value);
 }
 
+inline void BigInt::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "BigInt::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "BigInt::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(
+      type == napi_bigint, "BigInt::CheckCast", "value is not napi_bigint");
+}
+
 inline BigInt::BigInt() : Value() {}
 
 inline BigInt::BigInt(napi_env env, napi_value value) : Value(env, value) {}
@@ -940,6 +979,15 @@ inline Date Date::New(napi_env env, double val) {
   return Date(env, value);
 }
 
+inline void Date::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Date::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = napi_is_date(env, value, &result);
+  NAPI_CHECK(status == napi_ok, "Date::CheckCast", "napi_is_date failed");
+  NAPI_CHECK(result, "Date::CheckCast", "value is not date");
+}
+
 inline Date::Date() : Value() {}
 
 inline Date::Date(napi_env env, napi_value value) : Value(env, value) {}
@@ -959,6 +1007,16 @@ inline double Date::ValueOf() const {
 ////////////////////////////////////////////////////////////////////////////////
 // Name class
 ////////////////////////////////////////////////////////////////////////////////
+inline void Name::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Name::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "Name::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(type == napi_string || type == napi_symbol,
+             "Name::CheckCast",
+             "value is not napi_string or napi_symbol");
+}
 
 inline Name::Name() : Value() {}
 
@@ -1018,6 +1076,16 @@ inline String String::New(napi_env env, const char16_t* val, size_t length) {
   return String(env, value);
 }
 
+inline void String::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "String::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "String::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(
+      type == napi_string, "String::CheckCast", "value is not napi_string");
+}
+
 inline String::String() : Name() {}
 
 inline String::String(napi_env env, napi_value value) : Name(env, value) {}
@@ -1145,6 +1213,16 @@ inline MaybeOrValue<Symbol> Symbol::For(napi_env env, napi_value description) {
 #endif
 }
 
+inline void Symbol::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Symbol::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "Symbol::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(
+      type == napi_symbol, "Symbol::CheckCast", "value is not napi_symbol");
+}
+
 inline Symbol::Symbol() : Name() {}
 
 inline Symbol::Symbol(napi_env env, napi_value value) : Name(env, value) {}
@@ -1242,6 +1320,32 @@ String String::From(napi_env env, const T& value) {
   return Helper::From(env, value);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// TypeTaggable class
+////////////////////////////////////////////////////////////////////////////////
+
+inline TypeTaggable::TypeTaggable() : Value() {}
+
+inline TypeTaggable::TypeTaggable(napi_env _env, napi_value _value)
+    : Value(_env, _value) {}
+
+#if NAPI_VERSION >= 8
+
+inline void TypeTaggable::TypeTag(const napi_type_tag* type_tag) const {
+  napi_status status = napi_type_tag_object(_env, _value, type_tag);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+inline bool TypeTaggable::CheckTypeTag(const napi_type_tag* type_tag) const {
+  bool result;
+  napi_status status =
+      napi_check_object_type_tag(_env, _value, type_tag, &result);
+  NAPI_THROW_IF_FAILED(_env, status, false);
+  return result;
+}
+
+#endif  // NAPI_VERSION >= 8
+
 ////////////////////////////////////////////////////////////////////////////////
 // Object class
 ////////////////////////////////////////////////////////////////////////////////
@@ -1281,9 +1385,20 @@ inline Object Object::New(napi_env env) {
   return Object(env, value);
 }
 
-inline Object::Object() : Value() {}
+inline void Object::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Object::CheckCast", "empty value");
 
-inline Object::Object(napi_env env, napi_value value) : Value(env, value) {}
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "Object::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(
+      type == napi_object, "Object::CheckCast", "value is not napi_object");
+}
+
+inline Object::Object() : TypeTaggable() {}
+
+inline Object::Object(napi_env env, napi_value value)
+    : TypeTaggable(env, value) {}
 
 inline Object::PropertyLValue<std::string> Object::operator[](
     const char* utf8name) {
@@ -1687,11 +1802,23 @@ inline External<T> External<T>::New(napi_env env,
 }
 
 template <typename T>
-inline External<T>::External() : Value() {}
+inline void External<T>::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "External::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "External::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(type == napi_external,
+             "External::CheckCast",
+             "value is not napi_external");
+}
+
+template <typename T>
+inline External<T>::External() : TypeTaggable() {}
 
 template <typename T>
 inline External<T>::External(napi_env env, napi_value value)
-    : Value(env, value) {}
+    : TypeTaggable(env, value) {}
 
 template <typename T>
 inline T* External<T>::Data() const {
@@ -1719,6 +1846,15 @@ inline Array Array::New(napi_env env, size_t length) {
   return Array(env, value);
 }
 
+inline void Array::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Array::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = napi_is_array(env, value, &result);
+  NAPI_CHECK(status == napi_ok, "Array::CheckCast", "napi_is_array failed");
+  NAPI_CHECK(result, "Array::CheckCast", "value is not array");
+}
+
 inline Array::Array() : Object() {}
 
 inline Array::Array(napi_env env, napi_value value) : Object(env, value) {}
@@ -1743,6 +1879,7 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env, size_t byteLength) {
   return ArrayBuffer(env, value);
 }
 
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 inline ArrayBuffer ArrayBuffer::New(napi_env env,
                                     void* externalData,
                                     size_t byteLength) {
@@ -1802,6 +1939,18 @@ inline ArrayBuffer ArrayBuffer::New(napi_env env,
 
   return ArrayBuffer(env, value);
 }
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+inline void ArrayBuffer::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "ArrayBuffer::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = napi_is_arraybuffer(env, value, &result);
+  NAPI_CHECK(status == napi_ok,
+             "ArrayBuffer::CheckCast",
+             "napi_is_arraybuffer failed");
+  NAPI_CHECK(result, "ArrayBuffer::CheckCast", "value is not arraybuffer");
+}
 
 inline ArrayBuffer::ArrayBuffer() : Object() {}
 
@@ -1870,6 +2019,16 @@ inline DataView DataView::New(napi_env env,
   return DataView(env, value);
 }
 
+inline void DataView::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "DataView::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = napi_is_dataview(env, value, &result);
+  NAPI_CHECK(
+      status == napi_ok, "DataView::CheckCast", "napi_is_dataview failed");
+  NAPI_CHECK(result, "DataView::CheckCast", "value is not dataview");
+}
+
 inline DataView::DataView() : Object() {}
 
 inline DataView::DataView(napi_env env, napi_value value) : Object(env, value) {
@@ -2004,6 +2163,15 @@ inline void DataView::WriteData(size_t byteOffset, T value) const {
 ////////////////////////////////////////////////////////////////////////////////
 // TypedArray class
 ////////////////////////////////////////////////////////////////////////////////
+inline void TypedArray::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "TypedArray::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = napi_is_typedarray(env, value, &result);
+  NAPI_CHECK(
+      status == napi_ok, "TypedArray::CheckCast", "napi_is_typedarray failed");
+  NAPI_CHECK(result, "TypedArray::CheckCast", "value is not typedarray");
+}
 
 inline TypedArray::TypedArray()
     : Object(), _type(napi_typedarray_type::napi_int8_array), _length(0) {}
@@ -2086,6 +2254,23 @@ inline Napi::ArrayBuffer TypedArray::ArrayBuffer() const {
 ////////////////////////////////////////////////////////////////////////////////
 // TypedArrayOf<T> class
 ////////////////////////////////////////////////////////////////////////////////
+template <typename T>
+inline void TypedArrayOf<T>::CheckCast(napi_env env, napi_value value) {
+  TypedArray::CheckCast(env, value);
+  napi_typedarray_type type;
+  napi_status status = napi_get_typedarray_info(
+      env, value, &type, nullptr, nullptr, nullptr, nullptr);
+  NAPI_CHECK(status == napi_ok,
+             "TypedArrayOf::CheckCast",
+             "napi_is_typedarray failed");
+
+  NAPI_CHECK(
+      (type == TypedArrayTypeForPrimitiveType<T>() ||
+       (type == napi_uint8_clamped_array && std::is_same<T, uint8_t>::value)),
+      "TypedArrayOf::CheckCast",
+      "Array type must match the template parameter. (Uint8 arrays may "
+      "optionally have the \"clamped\" array type.)");
+}
 
 template <typename T>
 inline TypedArrayOf<T> TypedArrayOf<T>::New(napi_env env,
@@ -2259,6 +2444,17 @@ inline Function Function::New(napi_env env,
   return New(env, cb, utf8name.c_str(), data);
 }
 
+inline void Function::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Function::CheckCast", "empty value");
+
+  napi_valuetype type;
+  napi_status status = napi_typeof(env, value, &type);
+  NAPI_CHECK(status == napi_ok, "Function::CheckCast", "napi_typeof failed");
+  NAPI_CHECK(type == napi_function,
+             "Function::CheckCast",
+             "value is not napi_function");
+}
+
 inline Function::Function() : Object() {}
 
 inline Function::Function(napi_env env, napi_value value)
@@ -2405,6 +2601,15 @@ inline void Promise::Deferred::Reject(napi_value value) const {
   NAPI_THROW_IF_FAILED_VOID(_env, status);
 }
 
+inline void Promise::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Promise::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = napi_is_promise(env, value, &result);
+  NAPI_CHECK(status == napi_ok, "Promise::CheckCast", "napi_is_promise failed");
+  NAPI_CHECK(result, "Promise::CheckCast", "value is not promise");
+}
+
 inline Promise::Promise(napi_env env, napi_value value) : Object(env, value) {}
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -2421,6 +2626,7 @@ inline Buffer<T> Buffer<T>::New(napi_env env, size_t length) {
   return Buffer(env, value, length, static_cast<T*>(data));
 }
 
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
 template <typename T>
 inline Buffer<T> Buffer<T>::New(napi_env env, T* data, size_t length) {
   napi_value value;
@@ -2478,6 +2684,94 @@ inline Buffer<T> Buffer<T>::New(napi_env env,
   }
   return Buffer(env, value, length, data);
 }
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+template <typename T>
+inline Buffer<T> Buffer<T>::NewOrCopy(napi_env env, T* data, size_t length) {
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+  napi_value value;
+  napi_status status = napi_create_external_buffer(
+      env, length * sizeof(T), data, nullptr, nullptr, &value);
+  if (status == details::napi_no_external_buffers_allowed) {
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+    // If we can't create an external buffer, we'll just copy the data.
+    return Buffer<T>::Copy(env, data, length);
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+  }
+  NAPI_THROW_IF_FAILED(env, status, Buffer<T>());
+  return Buffer(env, value, length, data);
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+}
+
+template <typename T>
+template <typename Finalizer>
+inline Buffer<T> Buffer<T>::NewOrCopy(napi_env env,
+                                      T* data,
+                                      size_t length,
+                                      Finalizer finalizeCallback) {
+  details::FinalizeData<T, Finalizer>* finalizeData =
+      new details::FinalizeData<T, Finalizer>(
+          {std::move(finalizeCallback), nullptr});
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+  napi_value value;
+  napi_status status =
+      napi_create_external_buffer(env,
+                                  length * sizeof(T),
+                                  data,
+                                  details::FinalizeData<T, Finalizer>::Wrapper,
+                                  finalizeData,
+                                  &value);
+  if (status == details::napi_no_external_buffers_allowed) {
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+    // If we can't create an external buffer, we'll just copy the data.
+    Buffer<T> ret = Buffer<T>::Copy(env, data, length);
+    details::FinalizeData<T, Finalizer>::Wrapper(env, data, finalizeData);
+    return ret;
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+  }
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED(env, status, Buffer());
+  }
+  return Buffer(env, value, length, data);
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+}
+
+template <typename T>
+template <typename Finalizer, typename Hint>
+inline Buffer<T> Buffer<T>::NewOrCopy(napi_env env,
+                                      T* data,
+                                      size_t length,
+                                      Finalizer finalizeCallback,
+                                      Hint* finalizeHint) {
+  details::FinalizeData<T, Finalizer, Hint>* finalizeData =
+      new details::FinalizeData<T, Finalizer, Hint>(
+          {std::move(finalizeCallback), finalizeHint});
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+  napi_value value;
+  napi_status status = napi_create_external_buffer(
+      env,
+      length * sizeof(T),
+      data,
+      details::FinalizeData<T, Finalizer, Hint>::WrapperWithHint,
+      finalizeData,
+      &value);
+  if (status == details::napi_no_external_buffers_allowed) {
+#endif
+    // If we can't create an external buffer, we'll just copy the data.
+    Buffer<T> ret = Buffer<T>::Copy(env, data, length);
+    details::FinalizeData<T, Finalizer, Hint>::WrapperWithHint(
+        env, data, finalizeData);
+    return ret;
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+  }
+  if (status != napi_ok) {
+    delete finalizeData;
+    NAPI_THROW_IF_FAILED(env, status, Buffer());
+  }
+  return Buffer(env, value, length, data);
+#endif
+}
 
 template <typename T>
 inline Buffer<T> Buffer<T>::Copy(napi_env env, const T* data, size_t length) {
@@ -2488,6 +2782,16 @@ inline Buffer<T> Buffer<T>::Copy(napi_env env, const T* data, size_t length) {
   return Buffer<T>(env, value);
 }
 
+template <typename T>
+inline void Buffer<T>::CheckCast(napi_env env, napi_value value) {
+  NAPI_CHECK(value != nullptr, "Buffer::CheckCast", "empty value");
+
+  bool result;
+  napi_status status = napi_is_buffer(env, value, &result);
+  NAPI_CHECK(status == napi_ok, "Buffer::CheckCast", "napi_is_buffer failed");
+  NAPI_CHECK(result, "Buffer::CheckCast", "value is not buffer");
+}
+
 template <typename T>
 inline Buffer<T>::Buffer() : Uint8Array(), _length(0), _data(nullptr) {}
 
@@ -4720,6 +5024,8 @@ inline Napi::Env AsyncContext::Env() const {
 // AsyncWorker class
 ////////////////////////////////////////////////////////////////////////////////
 
+#if NAPI_HAS_THREADS
+
 inline AsyncWorker::AsyncWorker(const Function& callback)
     : AsyncWorker(callback, "generic") {}
 
@@ -4801,29 +5107,6 @@ inline void AsyncWorker::Destroy() {
   delete this;
 }
 
-inline AsyncWorker::AsyncWorker(AsyncWorker&& other) {
-  _env = other._env;
-  other._env = nullptr;
-  _work = other._work;
-  other._work = nullptr;
-  _receiver = std::move(other._receiver);
-  _callback = std::move(other._callback);
-  _error = std::move(other._error);
-  _suppress_destruct = other._suppress_destruct;
-}
-
-inline AsyncWorker& AsyncWorker::operator=(AsyncWorker&& other) {
-  _env = other._env;
-  other._env = nullptr;
-  _work = other._work;
-  other._work = nullptr;
-  _receiver = std::move(other._receiver);
-  _callback = std::move(other._callback);
-  _error = std::move(other._error);
-  _suppress_destruct = other._suppress_destruct;
-  return *this;
-}
-
 inline AsyncWorker::operator napi_async_work() const {
   return _work;
 }
@@ -4921,7 +5204,9 @@ inline void AsyncWorker::OnWorkComplete(Napi::Env /*env*/, napi_status status) {
   }
 }
 
-#if (NAPI_VERSION > 3 && !defined(__wasm32__))
+#endif  // NAPI_HAS_THREADS
+
+#if (NAPI_VERSION > 3 && NAPI_HAS_THREADS)
 ////////////////////////////////////////////////////////////////////////////////
 // TypedThreadSafeFunction<ContextType,DataType,CallJs> class
 ////////////////////////////////////////////////////////////////////////////////
@@ -6170,7 +6455,7 @@ inline void AsyncProgressQueueWorker<T>::ExecutionProgress::Send(
     const T* data, size_t count) const {
   _worker->SendProgress_(data, count);
 }
-#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
+#endif  // NAPI_VERSION > 3 && NAPI_HAS_THREADS
 
 ////////////////////////////////////////////////////////////////////////////////
 // Memory Management class

package/napi.h

@@ -1,11 +1,22 @@
 #ifndef SRC_NAPI_H_
 #define SRC_NAPI_H_
 
+#ifndef NAPI_HAS_THREADS
+#if !defined(__wasm__) || (defined(__EMSCRIPTEN_PTHREADS__) ||                 \
+                           (defined(__wasi__) && defined(_REENTRANT)))
+#define NAPI_HAS_THREADS 1
+#else
+#define NAPI_HAS_THREADS 0
+#endif
+#endif
+
 #include <node_api.h>
 #include <functional>
 #include <initializer_list>
 #include <memory>
+#if NAPI_HAS_THREADS
 #include <mutex>
+#endif  // NAPI_HAS_THREADS
 #include <string>
 #include <vector>
 
@@ -452,6 +463,9 @@ class Value {
   ///
   /// This conversion does NOT coerce the type. Calling any methods
   /// inappropriate for the actual value type will throw `Napi::Error`.
+  ///
+  /// If `NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS` is defined, this method
+  /// asserts that the actual type is the expected type.
   template <typename T>
   T As() const;
 
@@ -478,6 +492,8 @@ class Boolean : public Value {
                      bool value     ///< Boolean value
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Boolean();  ///< Creates a new _empty_ Boolean instance.
   Boolean(napi_env env,
           napi_value value);  ///< Wraps a Node-API value primitive.
@@ -493,6 +509,8 @@ class Number : public Value {
                     double value   ///< Number value
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Number();  ///< Creates a new _empty_ Number instance.
   Number(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -541,6 +559,8 @@ class BigInt : public Value {
                     const uint64_t* words  ///< Array of words
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   BigInt();  ///< Creates a new _empty_ BigInt instance.
   BigInt(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -572,6 +592,8 @@ class Date : public Value {
                   double value   ///< Number value
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Date();  ///< Creates a new _empty_ Date instance.
   Date(napi_env env, napi_value value);  ///< Wraps a Node-API value primitive.
   operator double() const;  ///< Converts a Date value to double primitive
@@ -583,6 +605,8 @@ class Date : public Value {
 /// A JavaScript string or symbol value (that can be used as a property name).
 class Name : public Value {
  public:
+  static void CheckCast(napi_env env, napi_value value);
+
   Name();  ///< Creates a new _empty_ Name instance.
   Name(napi_env env,
        napi_value value);  ///< Wraps a Node-API value primitive.
@@ -640,6 +664,8 @@ class String : public Name {
   template <typename T>
   static String From(napi_env env, const T& value);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   String();  ///< Creates a new _empty_ String instance.
   String(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -698,13 +724,26 @@ class Symbol : public Name {
   // Create a symbol in the global registry, napi_value describing the symbol
   static MaybeOrValue<Symbol> For(napi_env env, napi_value description);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Symbol();  ///< Creates a new _empty_ Symbol instance.
   Symbol(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
 };
 
+class TypeTaggable : public Value {
+ public:
+#if NAPI_VERSION >= 8
+  void TypeTag(const napi_type_tag* type_tag) const;
+  bool CheckTypeTag(const napi_type_tag* type_tag) const;
+#endif  // NAPI_VERSION >= 8
+ protected:
+  TypeTaggable();
+  TypeTaggable(napi_env env, napi_value value);
+};
+
 /// A JavaScript object value.
-class Object : public Value {
+class Object : public TypeTaggable {
  public:
   /// Enables property and element assignments using indexing syntax.
   ///
@@ -745,6 +784,8 @@ class Object : public Value {
   static Object New(napi_env env  ///< Node-API environment
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Object();  ///< Creates a new _empty_ Object instance.
   Object(napi_env env,
          napi_value value);  ///< Wraps a Node-API value primitive.
@@ -984,7 +1025,7 @@ class Object : public Value {
 };
 
 template <typename T>
-class External : public Value {
+class External : public TypeTaggable {
  public:
   static External New(napi_env env, T* data);
 
@@ -998,6 +1039,8 @@ class External : public Value {
                       Finalizer finalizeCallback,
                       Hint* finalizeHint);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   External();
   External(napi_env env, napi_value value);
 
@@ -1009,6 +1052,8 @@ class Array : public Object {
   static Array New(napi_env env);
   static Array New(napi_env env, size_t length);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Array();
   Array(napi_env env, napi_value value);
 
@@ -1074,6 +1119,7 @@ class ArrayBuffer : public Object {
       size_t byteLength  ///< Length of the buffer to be allocated, in bytes
   );
 
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
   /// Creates a new ArrayBuffer instance, using an external buffer with
   /// specified byte length.
   static ArrayBuffer New(
@@ -1117,6 +1163,9 @@ class ArrayBuffer : public Object {
       Hint* finalizeHint  ///< Hint (second parameter) to be passed to the
                           ///< finalize callback
   );
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+  static void CheckCast(napi_env env, napi_value value);
 
   ArrayBuffer();  ///< Creates a new _empty_ ArrayBuffer instance.
   ArrayBuffer(napi_env env,
@@ -1142,6 +1191,8 @@ class ArrayBuffer : public Object {
 ///     }
 class TypedArray : public Object {
  public:
+  static void CheckCast(napi_env env, napi_value value);
+
   TypedArray();  ///< Creates a new _empty_ TypedArray instance.
   TypedArray(napi_env env,
              napi_value value);  ///< Wraps a Node-API value primitive.
@@ -1242,6 +1293,8 @@ class TypedArrayOf : public TypedArray {
       ///< template parameter T.
   );
 
+  static void CheckCast(napi_env env, napi_value value);
+
   TypedArrayOf();  ///< Creates a new _empty_ TypedArrayOf instance.
   TypedArrayOf(napi_env env,
                napi_value value);  ///< Wraps a Node-API value primitive.
@@ -1286,6 +1339,8 @@ class DataView : public Object {
                       size_t byteOffset,
                       size_t byteLength);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   DataView();  ///< Creates a new _empty_ DataView instance.
   DataView(napi_env env,
            napi_value value);  ///< Wraps a Node-API value primitive.
@@ -1366,6 +1421,8 @@ class Function : public Object {
                       const std::string& utf8name,
                       void* data = nullptr);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Function();
   Function(napi_env env, napi_value value);
 
@@ -1422,6 +1479,8 @@ class Promise : public Object {
     napi_value _promise;
   };
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Promise(napi_env env, napi_value value);
 };
 
@@ -1429,6 +1488,7 @@ template <typename T>
 class Buffer : public Uint8Array {
  public:
   static Buffer<T> New(napi_env env, size_t length);
+#ifndef NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
   static Buffer<T> New(napi_env env, T* data, size_t length);
 
   // Finalizer must implement `void operator()(Env env, T* data)`.
@@ -1444,9 +1504,27 @@ class Buffer : public Uint8Array {
                        size_t length,
                        Finalizer finalizeCallback,
                        Hint* finalizeHint);
+#endif  // NODE_API_NO_EXTERNAL_BUFFERS_ALLOWED
+
+  static Buffer<T> NewOrCopy(napi_env env, T* data, size_t length);
+  // Finalizer must implement `void operator()(Env env, T* data)`.
+  template <typename Finalizer>
+  static Buffer<T> NewOrCopy(napi_env env,
+                             T* data,
+                             size_t length,
+                             Finalizer finalizeCallback);
+  // Finalizer must implement `void operator()(Env env, T* data, Hint* hint)`.
+  template <typename Finalizer, typename Hint>
+  static Buffer<T> NewOrCopy(napi_env env,
+                             T* data,
+                             size_t length,
+                             Finalizer finalizeCallback,
+                             Hint* finalizeHint);
 
   static Buffer<T> Copy(napi_env env, const T* data, size_t length);
 
+  static void CheckCast(napi_env env, napi_value value);
+
   Buffer();
   Buffer(napi_env env, napi_value value);
   size_t Length() const;
@@ -1791,7 +1869,7 @@ class CallbackInfo {
   Value This() const;
   void* Data() const;
   void SetData(void* data);
-  operator napi_callback_info() const;
+  explicit operator napi_callback_info() const;
 
  private:
   const size_t _staticArgCount = 6;
@@ -2432,13 +2510,11 @@ class AsyncContext {
   napi_async_context _context;
 };
 
+#if NAPI_HAS_THREADS
 class AsyncWorker {
  public:
   virtual ~AsyncWorker();
 
-  // An async worker can be moved but cannot be copied.
-  AsyncWorker(AsyncWorker&& other);
-  AsyncWorker& operator=(AsyncWorker&& other);
   NAPI_DISALLOW_ASSIGN_COPY(AsyncWorker)
 
   operator napi_async_work() const;
@@ -2497,8 +2573,9 @@ class AsyncWorker {
   std::string _error;
   bool _suppress_destruct;
 };
+#endif  // NAPI_HAS_THREADS
 
-#if (NAPI_VERSION > 3 && !defined(__wasm32__))
+#if (NAPI_VERSION > 3 && NAPI_HAS_THREADS)
 class ThreadSafeFunction {
  public:
   // This API may only be called from the main thread.
@@ -3068,7 +3145,7 @@ class AsyncProgressQueueWorker
   void Signal() const;
   void SendProgress_(const T* data, size_t count);
 };
-#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
+#endif  // NAPI_VERSION > 3 && NAPI_HAS_THREADS
 
 // Memory management.
 class MemoryManagement {

package/package.json

@@ -247,6 +247,10 @@
       "name": "Mathias Küsel",
       "url": "https://github.com/mathiask88"
     },
+    {
+      "name": "Mathias Stearn",
+      "url": "https://github.com/RedBeard0531"
+    },
     {
       "name": "Matteo Collina",
       "url": "https://github.com/mcollina"
@@ -355,6 +359,10 @@
       "name": "todoroff",
       "url": "https://github.com/todoroff"
     },
+    {
+      "name": "Toyo Li",
+      "url": "https://github.com/toyobayashi"
+    },
     {
       "name": "Tux3",
       "url": "https://github.com/tux3"
@@ -451,6 +459,6 @@
     "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
   },
   "pre-commit": "lint",
-  "version": "5.1.0",
+  "version": "6.1.0",
   "support": true
 }

package/tools/eslint-format.js

@@ -23,7 +23,7 @@ function main (args) {
   // Check js files that change on unstaged file
   const fileUnStaged = spawn(
     'git',
-    ['diff', '--name-only', FORMAT_START, filesToCheck],
+    ['diff', '--name-only', '--diff-filter=d', FORMAT_START, filesToCheck],
     {
       encoding: 'utf-8'
     }
@@ -32,7 +32,7 @@ function main (args) {
   // Check js files that change on staged file
   const fileStaged = spawn(
     'git',
-    ['diff', '--name-only', '--cached', FORMAT_START, filesToCheck],
+    ['diff', '--name-only', '--cached', '--diff-filter=d', FORMAT_START, filesToCheck],
     {
       encoding: 'utf-8'
     }