node-addon-api 3.0.1 → 3.0.2

package/napi-inl.h

@@ -82,6 +82,24 @@ inline napi_value WrapCallback(Callable callback) {
 #endif // NAPI_CPP_EXCEPTIONS
 }
 
+// For use in JS to C++ void callback wrappers to catch any Napi::Error
+// exceptions and rethrow them as JavaScript exceptions before returning from the
+// callback.
+template <typename Callable>
+inline void WrapVoidCallback(Callable callback) {
+#ifdef NAPI_CPP_EXCEPTIONS
+  try {
+    callback();
+  } catch (const Error& e) {
+    e.ThrowAsJavaScriptException();
+  }
+#else // NAPI_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.
+  callback();
+#endif // NAPI_CPP_EXCEPTIONS
+}
+
 template <typename Callable, typename Return>
 struct CallbackData {
   static inline
@@ -117,20 +135,66 @@ struct CallbackData<Callable, void> {
   void* data;
 };
 
+template <void (*Callback)(const CallbackInfo& info)>
+static napi_value
+TemplatedVoidCallback(napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    Callback(cbInfo);
+    return nullptr;
+  });
+}
+
+template <Napi::Value (*Callback)(const CallbackInfo& info)>
+static napi_value
+TemplatedCallback(napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    return Callback(cbInfo);
+  });
+}
+
+template <typename T,
+          Napi::Value (T::*UnwrapCallback)(const CallbackInfo& info)>
+static napi_value
+TemplatedInstanceCallback(napi_env env, napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    T* instance = T::Unwrap(cbInfo.This().As<Object>());
+    return (instance->*UnwrapCallback)(cbInfo);
+  });
+}
+
+template <typename T, void (T::*UnwrapCallback)(const CallbackInfo& info)>
+static napi_value
+TemplatedInstanceVoidCallback(napi_env env,
+                              napi_callback_info info) NAPI_NOEXCEPT {
+  return details::WrapCallback([&] {
+    CallbackInfo cbInfo(env, info);
+    T* instance = T::Unwrap(cbInfo.This().As<Object>());
+    (instance->*UnwrapCallback)(cbInfo);
+    return nullptr;
+  });
+}
+
 template <typename T, typename Finalizer, typename Hint = void>
 struct FinalizeData {
   static inline
-  void Wrapper(napi_env env, void* data, void* finalizeHint) {
-    FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
-    finalizeData->callback(Env(env), static_cast<T*>(data));
-    delete finalizeData;
+  void Wrapper(napi_env env, void* data, void* finalizeHint) noexcept {
+    WrapVoidCallback([&] {
+      FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
+      finalizeData->callback(Env(env), static_cast<T*>(data));
+      delete finalizeData;
+    });
   }
 
   static inline
-  void WrapperWithHint(napi_env env, void* data, void* finalizeHint) {
-    FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
-    finalizeData->callback(Env(env), static_cast<T*>(data), finalizeData->hint);
-    delete finalizeData;
+  void WrapperWithHint(napi_env env, void* data, void* finalizeHint) noexcept {
+    WrapVoidCallback([&] {
+      FinalizeData* finalizeData = static_cast<FinalizeData*>(finalizeHint);
+      finalizeData->callback(Env(env), static_cast<T*>(data), finalizeData->hint);
+      delete finalizeData;
+    });
   }
 
   Finalizer callback;
@@ -238,6 +302,7 @@ struct AccessorCallbackData {
 // Module registration
 ////////////////////////////////////////////////////////////////////////////////
 
+// Register an add-on based on an initializer function.
 #define NODE_API_MODULE(modname, regfunc)                 \
   napi_value __napi_ ## regfunc(napi_env env,             \
                                 napi_value exports) {     \
@@ -245,6 +310,20 @@ struct AccessorCallbackData {
   }                                                       \
   NAPI_MODULE(modname, __napi_ ## regfunc)
 
+// Register an add-on based on a subclass of `Addon<T>` with a custom Node.js
+// module name.
+#define NODE_API_NAMED_ADDON(modname, classname)                 \
+  static napi_value __napi_ ## classname(napi_env env,           \
+                                         napi_value exports) {   \
+    return Napi::RegisterModule(env, exports, &classname::Init); \
+  }                                                              \
+  NAPI_MODULE(modname, __napi_ ## classname)
+
+// Register an add-on based on a subclass of `Addon<T>` with the Node.js module
+// name given by node-gyp from the `target_name` in binding.gyp.
+#define NODE_API_ADDON(classname) \
+  NODE_API_NAMED_ADDON(NODE_GYP_MODULE_NAME, classname)
+
 // Adapt the NAPI_MODULE registration function:
 //  - Wrap the arguments in NAPI wrappers.
 //  - Catch any NAPI errors and rethrow as JS exceptions.
@@ -1808,15 +1887,12 @@ CreateFunction(napi_env env,
 template <Function::VoidCallback cb>
 inline Function Function::New(napi_env env, const char* utf8name, void* data) {
   napi_value result = nullptr;
-  napi_status status = napi_create_function(
-      env, utf8name, NAPI_AUTO_LENGTH,
-      [](napi_env env, napi_callback_info info) {
-        CallbackInfo callbackInfo(env, info);
-        return details::WrapCallback([&] {
-          cb(callbackInfo);
-          return nullptr;
-        });
-      }, data, &result);
+  napi_status status = napi_create_function(env,
+                                            utf8name,
+                                            NAPI_AUTO_LENGTH,
+                                            details::TemplatedVoidCallback<cb>,
+                                            data,
+                                            &result);
   NAPI_THROW_IF_FAILED(env, status, Function());
   return Function(env, result);
 }
@@ -1824,14 +1900,12 @@ inline Function Function::New(napi_env env, const char* utf8name, void* data) {
 template <Function::Callback cb>
 inline Function Function::New(napi_env env, const char* utf8name, void* data) {
   napi_value result = nullptr;
-  napi_status status = napi_create_function(
-      env, utf8name, NAPI_AUTO_LENGTH,
-      [](napi_env env, napi_callback_info info) {
-        CallbackInfo callbackInfo(env, info);
-        return details::WrapCallback([&] {
-          return cb(callbackInfo);
-        });
-      }, data, &result);
+  napi_status status = napi_create_function(env,
+                                            utf8name,
+                                            NAPI_AUTO_LENGTH,
+                                            details::TemplatedCallback<cb>,
+                                            data,
+                                            &result);
   NAPI_THROW_IF_FAILED(env, status, Function());
   return Function(env, result);
 }
@@ -2822,7 +2896,7 @@ PropertyDescriptor::Accessor(const char* utf8name,
   napi_property_descriptor desc = napi_property_descriptor();
 
   desc.utf8name = utf8name;
-  desc.getter = &GetterCallbackWrapper<Getter>;
+  desc.getter = details::TemplatedCallback<Getter>;
   desc.attributes = attributes;
   desc.data = data;
 
@@ -2845,7 +2919,7 @@ PropertyDescriptor::Accessor(Name name,
   napi_property_descriptor desc = napi_property_descriptor();
 
   desc.name = name;
-  desc.getter = &GetterCallbackWrapper<Getter>;
+  desc.getter = details::TemplatedCallback<Getter>;
   desc.attributes = attributes;
   desc.data = data;
 
@@ -2863,8 +2937,8 @@ PropertyDescriptor::Accessor(const char* utf8name,
   napi_property_descriptor desc = napi_property_descriptor();
 
   desc.utf8name = utf8name;
-  desc.getter = &GetterCallbackWrapper<Getter>;
-  desc.setter = &SetterCallbackWrapper<Setter>;
+  desc.getter = details::TemplatedCallback<Getter>;
+  desc.setter = details::TemplatedVoidCallback<Setter>;
   desc.attributes = attributes;
   desc.data = data;
 
@@ -2891,31 +2965,14 @@ PropertyDescriptor::Accessor(Name name,
   napi_property_descriptor desc = napi_property_descriptor();
 
   desc.name = name;
-  desc.getter = &GetterCallbackWrapper<Getter>;
-  desc.setter = &SetterCallbackWrapper<Setter>;
+  desc.getter = details::TemplatedCallback<Getter>;
+  desc.setter = details::TemplatedVoidCallback<Setter>;
   desc.attributes = attributes;
   desc.data = data;
 
   return desc;
 }
 
-template <typename PropertyDescriptor::GetterCallback Getter>
-napi_value
-PropertyDescriptor::GetterCallbackWrapper(napi_env env,
-                                          napi_callback_info info) {
-  CallbackInfo cbInfo(env, info);
-  return Getter(cbInfo);
-}
-
-template <typename PropertyDescriptor::SetterCallback Setter>
-napi_value
-PropertyDescriptor::SetterCallbackWrapper(napi_env env,
-                                          napi_callback_info info) {
-  CallbackInfo cbInfo(env, info);
-  Setter(cbInfo);
-  return nullptr;
-}
-
 template <typename Getter>
 inline PropertyDescriptor
 PropertyDescriptor::Accessor(Napi::Env env,
@@ -3143,539 +3200,652 @@ inline PropertyDescriptor::operator const napi_property_descriptor&() const {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ObjectWrap<T> class
+// InstanceWrap<T> class
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
-inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
-  napi_env env = callbackInfo.Env();
-  napi_value wrapper = callbackInfo.This();
-  napi_status status;
-  napi_ref ref;
-  T* instance = static_cast<T*>(this);
-  status = napi_wrap(env, wrapper, instance, FinalizeCallback, nullptr, &ref);
-  NAPI_THROW_IF_FAILED_VOID(env, status);
-
-  Reference<Object>* instanceRef = instance;
-  *instanceRef = Reference<Object>(env, ref);
-}
-
-template <typename T>
-inline ObjectWrap<T>::~ObjectWrap() {
-  // If the JS object still exists at this point, remove the finalizer added
-  // through `napi_wrap()`.
-  if (!IsEmpty()) {
-    Object object = Value();
-    // It is not valid to call `napi_remove_wrap()` with an empty `object`.
-    // This happens e.g. during garbage collection.
-    if (!object.IsEmpty() && _construction_failed) {
-      napi_remove_wrap(Env(), object, nullptr);
-    }
-  }
-}
-
-template<typename T>
-inline T* ObjectWrap<T>::Unwrap(Object wrapper) {
-  T* unwrapped;
-  napi_status status = napi_unwrap(wrapper.Env(), wrapper, reinterpret_cast<void**>(&unwrapped));
-  NAPI_THROW_IF_FAILED(wrapper.Env(), status, nullptr);
-  return unwrapped;
-}
-
-template <typename T>
-inline Function
-ObjectWrap<T>::DefineClass(Napi::Env env,
-                           const char* utf8name,
-                           const size_t props_count,
-                           const napi_property_descriptor* descriptors,
-                           void* data) {
+inline void InstanceWrap<T>::AttachPropData(napi_env env,
+                                       napi_value value,
+                                       const napi_property_descriptor* prop) {
   napi_status status;
-  std::vector<napi_property_descriptor> props(props_count);
-
-  // We copy the descriptors to a local array because before defining the class
-  // we must replace static method property descriptors with value property
-  // descriptors such that the value is a function-valued `napi_value` created
-  // with `CreateFunction()`.
-  //
-  // This replacement could be made for instance methods as well, but V8 aborts
-  // if we do that, because it expects methods defined on the prototype template
-  // to have `FunctionTemplate`s.
-  for (size_t index = 0; index < props_count; index++) {
-    props[index] = descriptors[index];
-    napi_property_descriptor* prop = &props[index];
-    if (prop->method == T::StaticMethodCallbackWrapper) {
-      status = CreateFunction(env,
-               utf8name,
-               prop->method,
-               static_cast<StaticMethodCallbackData*>(prop->data),
-               &(prop->value));
-      NAPI_THROW_IF_FAILED(env, status, Function());
-      prop->method = nullptr;
-      prop->data = nullptr;
-    } else if (prop->method == T::StaticVoidMethodCallbackWrapper) {
-      status = CreateFunction(env,
-               utf8name,
-               prop->method,
-               static_cast<StaticVoidMethodCallbackData*>(prop->data),
-               &(prop->value));
-      NAPI_THROW_IF_FAILED(env, status, Function());
-      prop->method = nullptr;
-      prop->data = nullptr;
-    }
-  }
-
-  napi_value value;
-  status = napi_define_class(env,
-                             utf8name,
-                             NAPI_AUTO_LENGTH,
-                             T::ConstructorCallbackWrapper,
-                             data,
-                             props_count,
-                             props.data(),
-                             &value);
-  NAPI_THROW_IF_FAILED(env, status, Function());
-
-  // After defining the class we iterate once more over the property descriptors
-  // and attach the data associated with accessors and instance methods to the
-  // newly created JavaScript class.
-  for (size_t idx = 0; idx < props_count; idx++) {
-    const napi_property_descriptor* prop = &props[idx];
-
-    if (prop->getter == T::StaticGetterCallbackWrapper ||
-        prop->setter == T::StaticSetterCallbackWrapper) {
+  if (prop->method != nullptr && !(prop->attributes & napi_static)) {
+    if (prop->method == T::InstanceVoidMethodCallbackWrapper) {
       status = Napi::details::AttachData(env,
-                          value,
-                          static_cast<StaticAccessorCallbackData*>(prop->data));
-      NAPI_THROW_IF_FAILED(env, status, Function());
+                    value,
+                    static_cast<InstanceVoidMethodCallbackData*>(prop->data));
+      NAPI_THROW_IF_FAILED_VOID(env, status);
+    } else if (prop->method == T::InstanceMethodCallbackWrapper) {
+      status = Napi::details::AttachData(env,
+                        value,
+                        static_cast<InstanceMethodCallbackData*>(prop->data));
+      NAPI_THROW_IF_FAILED_VOID(env, status);
     } else if (prop->getter == T::InstanceGetterCallbackWrapper ||
         prop->setter == T::InstanceSetterCallbackWrapper) {
       status = Napi::details::AttachData(env,
                           value,
                           static_cast<InstanceAccessorCallbackData*>(prop->data));
-      NAPI_THROW_IF_FAILED(env, status, Function());
-    } else if (prop->method != nullptr && !(prop->attributes & napi_static)) {
-      if (prop->method == T::InstanceVoidMethodCallbackWrapper) {
-        status = Napi::details::AttachData(env,
-                      value,
-                      static_cast<InstanceVoidMethodCallbackData*>(prop->data));
-        NAPI_THROW_IF_FAILED(env, status, Function());
-      } else if (prop->method == T::InstanceMethodCallbackWrapper) {
-        status = Napi::details::AttachData(env,
-                          value,
-                          static_cast<InstanceMethodCallbackData*>(prop->data));
-        NAPI_THROW_IF_FAILED(env, status, Function());
-      }
+      NAPI_THROW_IF_FAILED_VOID(env, status);
     }
   }
-
-  return Function(env, value);
-}
-
-template <typename T>
-inline Function ObjectWrap<T>::DefineClass(
-    Napi::Env env,
-    const char* utf8name,
-    const std::initializer_list<ClassPropertyDescriptor<T>>& properties,
-    void* data) {
-  return DefineClass(env,
-          utf8name,
-          properties.size(),
-          reinterpret_cast<const napi_property_descriptor*>(properties.begin()),
-          data);
-}
-
-template <typename T>
-inline Function ObjectWrap<T>::DefineClass(
-    Napi::Env env,
-    const char* utf8name,
-    const std::vector<ClassPropertyDescriptor<T>>& properties,
-    void* data) {
-  return DefineClass(env,
-           utf8name,
-           properties.size(),
-           reinterpret_cast<const napi_property_descriptor*>(properties.data()),
-           data);
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
     const char* utf8name,
-    StaticVoidMethodCallback method,
+    InstanceVoidMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  StaticVoidMethodCallbackData* callbackData = new StaticVoidMethodCallbackData({ method, data });
+  InstanceVoidMethodCallbackData* callbackData =
+    new InstanceVoidMethodCallbackData({ method, data});
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.method = T::StaticVoidMethodCallbackWrapper;
+  desc.method = T::InstanceVoidMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
     const char* utf8name,
-    StaticMethodCallback method,
+    InstanceMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  StaticMethodCallbackData* callbackData = new StaticMethodCallbackData({ method, data });
+  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.method = T::StaticMethodCallbackWrapper;
+  desc.method = T::InstanceMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
     Symbol name,
-    StaticVoidMethodCallback method,
+    InstanceVoidMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  StaticVoidMethodCallbackData* callbackData = new StaticVoidMethodCallbackData({ method, data });
+  InstanceVoidMethodCallbackData* callbackData =
+    new InstanceVoidMethodCallbackData({ method, data});
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.method = T::StaticVoidMethodCallbackWrapper;
+  desc.method = T::InstanceVoidMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
     Symbol name,
-    StaticMethodCallback method,
+    InstanceMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  StaticMethodCallbackData* callbackData = new StaticMethodCallbackData({ method, data });
+  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.method = T::StaticMethodCallbackWrapper;
+  desc.method = T::InstanceMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::StaticVoidMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+template <typename InstanceWrap<T>::InstanceVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
     const char* utf8name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.method = details::TemplatedInstanceVoidCallback<T, method>;
   desc.data = data;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::StaticVoidMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
-    Symbol name,
+template <typename InstanceWrap<T>::InstanceMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    const char* utf8name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
-  desc.name = name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.utf8name = utf8name;
+  desc.method = details::TemplatedInstanceCallback<T, method>;
   desc.data = data;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::StaticMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
-    const char* utf8name,
+template <typename InstanceWrap<T>::InstanceVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
+    Symbol name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
-  desc.utf8name = utf8name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.name = name;
+  desc.method = details::TemplatedInstanceVoidCallback<T, method>;
   desc.data = data;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::StaticMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+template <typename InstanceWrap<T>::InstanceMethodCallback method>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceMethod(
     Symbol name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.method = details::TemplatedInstanceCallback<T, method>;
   desc.data = data;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
     const char* utf8name,
-    StaticGetterCallback getter,
-    StaticSetterCallback setter,
+    InstanceGetterCallback getter,
+    InstanceSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  StaticAccessorCallbackData* callbackData =
-    new StaticAccessorCallbackData({ getter, setter, data });
+  InstanceAccessorCallbackData* callbackData =
+    new InstanceAccessorCallbackData({ getter, setter, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
+  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
   desc.data = callbackData;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
     Symbol name,
-    StaticGetterCallback getter,
-    StaticSetterCallback setter,
+    InstanceGetterCallback getter,
+    InstanceSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  StaticAccessorCallbackData* callbackData =
-    new StaticAccessorCallbackData({ getter, setter, data });
+  InstanceAccessorCallbackData* callbackData =
+    new InstanceAccessorCallbackData({ getter, setter, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
+  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
   desc.data = callbackData;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::StaticGetterCallback getter,
-          typename ObjectWrap<T>::StaticSetterCallback setter>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
+template <typename InstanceWrap<T>::InstanceGetterCallback getter,
+          typename InstanceWrap<T>::InstanceSetterCallback setter>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
     const char* utf8name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.getter = This::WrapStaticGetter(This::StaticGetterTag<getter>());
-  desc.setter = This::WrapStaticSetter(This::StaticSetterTag<setter>());
+  desc.getter = details::TemplatedInstanceCallback<T, getter>;
+  desc.setter = This::WrapSetter(This::SetterTag<setter>());
   desc.data = data;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::StaticGetterCallback getter,
-          typename ObjectWrap<T>::StaticSetterCallback setter>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
+template <typename InstanceWrap<T>::InstanceGetterCallback getter,
+          typename InstanceWrap<T>::InstanceSetterCallback setter>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceAccessor(
     Symbol name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.getter = This::WrapStaticGetter(This::StaticGetterTag<getter>());
-  desc.setter = This::WrapStaticSetter(This::StaticSetterTag<setter>());
+  desc.getter = details::TemplatedInstanceCallback<T, getter>;
+  desc.setter = This::WrapSetter(This::SetterTag<setter>());
   desc.data = data;
-  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
+  desc.attributes = attributes;
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceValue(
     const char* utf8name,
-    InstanceVoidMethodCallback method,
+    Napi::Value value,
+    napi_property_attributes attributes) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.utf8name = utf8name;
+  desc.value = value;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> InstanceWrap<T>::InstanceValue(
+    Symbol name,
+    Napi::Value value,
+    napi_property_attributes attributes) {
+  napi_property_descriptor desc = napi_property_descriptor();
+  desc.name = name;
+  desc.value = value;
+  desc.attributes = attributes;
+  return desc;
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceVoidMethodCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceVoidMethodCallbackData* callbackData =
+      reinterpret_cast<InstanceVoidMethodCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->callback;
+    (instance->*cb)(callbackInfo);
+    return nullptr;
+  });
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceMethodCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceMethodCallbackData* callbackData =
+      reinterpret_cast<InstanceMethodCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->callback;
+    return (instance->*cb)(callbackInfo);
+  });
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceGetterCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceAccessorCallbackData* callbackData =
+      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->getterCallback;
+    return (instance->*cb)(callbackInfo);
+  });
+}
+
+template <typename T>
+inline napi_value InstanceWrap<T>::InstanceSetterCallbackWrapper(
+    napi_env env,
+    napi_callback_info info) {
+  return details::WrapCallback([&] {
+    CallbackInfo callbackInfo(env, info);
+    InstanceAccessorCallbackData* callbackData =
+      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
+    callbackInfo.SetData(callbackData->data);
+    T* instance = T::Unwrap(callbackInfo.This().As<Object>());
+    auto cb = callbackData->setterCallback;
+    (instance->*cb)(callbackInfo, callbackInfo[0]);
+    return nullptr;
+  });
+}
+
+template <typename T>
+template <typename InstanceWrap<T>::InstanceSetterCallback method>
+inline napi_value InstanceWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
+  return details::WrapCallback([&] {
+    const CallbackInfo cbInfo(env, info);
+    T* instance = T::Unwrap(cbInfo.This().As<Object>());
+    (instance->*method)(cbInfo, cbInfo[0]);
+    return nullptr;
+  });
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// ObjectWrap<T> class
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
+  napi_env env = callbackInfo.Env();
+  napi_value wrapper = callbackInfo.This();
+  napi_status status;
+  napi_ref ref;
+  T* instance = static_cast<T*>(this);
+  status = napi_wrap(env, wrapper, instance, FinalizeCallback, nullptr, &ref);
+  NAPI_THROW_IF_FAILED_VOID(env, status);
+
+  Reference<Object>* instanceRef = instance;
+  *instanceRef = Reference<Object>(env, ref);
+}
+
+template <typename T>
+inline ObjectWrap<T>::~ObjectWrap() {
+  // If the JS object still exists at this point, remove the finalizer added
+  // through `napi_wrap()`.
+  if (!IsEmpty()) {
+    Object object = Value();
+    // It is not valid to call `napi_remove_wrap()` with an empty `object`.
+    // This happens e.g. during garbage collection.
+    if (!object.IsEmpty() && _construction_failed) {
+      napi_remove_wrap(Env(), object, nullptr);
+    }
+  }
+}
+
+template<typename T>
+inline T* ObjectWrap<T>::Unwrap(Object wrapper) {
+  T* unwrapped;
+  napi_status status = napi_unwrap(wrapper.Env(), wrapper, reinterpret_cast<void**>(&unwrapped));
+  NAPI_THROW_IF_FAILED(wrapper.Env(), status, nullptr);
+  return unwrapped;
+}
+
+template <typename T>
+inline Function
+ObjectWrap<T>::DefineClass(Napi::Env env,
+                           const char* utf8name,
+                           const size_t props_count,
+                           const napi_property_descriptor* descriptors,
+                           void* data) {
+  napi_status status;
+  std::vector<napi_property_descriptor> props(props_count);
+
+  // We copy the descriptors to a local array because before defining the class
+  // we must replace static method property descriptors with value property
+  // descriptors such that the value is a function-valued `napi_value` created
+  // with `CreateFunction()`.
+  //
+  // This replacement could be made for instance methods as well, but V8 aborts
+  // if we do that, because it expects methods defined on the prototype template
+  // to have `FunctionTemplate`s.
+  for (size_t index = 0; index < props_count; index++) {
+    props[index] = descriptors[index];
+    napi_property_descriptor* prop = &props[index];
+    if (prop->method == T::StaticMethodCallbackWrapper) {
+      status = CreateFunction(env,
+                             utf8name,
+                             prop->method,
+                             static_cast<StaticMethodCallbackData*>(prop->data),
+               &(prop->value));
+      NAPI_THROW_IF_FAILED(env, status, Function());
+      prop->method = nullptr;
+      prop->data = nullptr;
+    } else if (prop->method == T::StaticVoidMethodCallbackWrapper) {
+      status = CreateFunction(env,
+                         utf8name,
+                         prop->method,
+                         static_cast<StaticVoidMethodCallbackData*>(prop->data),
+                         &(prop->value));
+      NAPI_THROW_IF_FAILED(env, status, Function());
+      prop->method = nullptr;
+      prop->data = nullptr;
+    }
+  }
+
+  napi_value value;
+  status = napi_define_class(env,
+                             utf8name,
+                             NAPI_AUTO_LENGTH,
+                             T::ConstructorCallbackWrapper,
+                             data,
+                             props_count,
+                             props.data(),
+                             &value);
+  NAPI_THROW_IF_FAILED(env, status, Function());
+
+  // After defining the class we iterate once more over the property descriptors
+  // and attach the data associated with accessors and instance methods to the
+  // newly created JavaScript class.
+  for (size_t idx = 0; idx < props_count; idx++) {
+    const napi_property_descriptor* prop = &props[idx];
+
+    if (prop->getter == T::StaticGetterCallbackWrapper ||
+        prop->setter == T::StaticSetterCallbackWrapper) {
+      status = Napi::details::AttachData(env,
+                          value,
+                          static_cast<StaticAccessorCallbackData*>(prop->data));
+      NAPI_THROW_IF_FAILED(env, status, Function());
+    } else {
+      // InstanceWrap<T>::AttachPropData is responsible for attaching the data
+      // of instance methods and accessors.
+      T::AttachPropData(env, value, prop);
+    }
+  }
+
+  return Function(env, value);
+}
+
+template <typename T>
+inline Function ObjectWrap<T>::DefineClass(
+    Napi::Env env,
+    const char* utf8name,
+    const std::initializer_list<ClassPropertyDescriptor<T>>& properties,
+    void* data) {
+  return DefineClass(env,
+          utf8name,
+          properties.size(),
+          reinterpret_cast<const napi_property_descriptor*>(properties.begin()),
+          data);
+}
+
+template <typename T>
+inline Function ObjectWrap<T>::DefineClass(
+    Napi::Env env,
+    const char* utf8name,
+    const std::vector<ClassPropertyDescriptor<T>>& properties,
+    void* data) {
+  return DefineClass(env,
+           utf8name,
+           properties.size(),
+           reinterpret_cast<const napi_property_descriptor*>(properties.data()),
+           data);
+}
+
+template <typename T>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+    const char* utf8name,
+    StaticVoidMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  InstanceVoidMethodCallbackData* callbackData =
-    new InstanceVoidMethodCallbackData({ method, data});
+  StaticVoidMethodCallbackData* callbackData = new StaticVoidMethodCallbackData({ method, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.method = T::InstanceVoidMethodCallbackWrapper;
+  desc.method = T::StaticVoidMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     const char* utf8name,
-    InstanceMethodCallback method,
+    StaticMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
+  StaticMethodCallbackData* callbackData = new StaticMethodCallbackData({ method, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.method = T::InstanceMethodCallbackWrapper;
+  desc.method = T::StaticMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     Symbol name,
-    InstanceVoidMethodCallback method,
+    StaticVoidMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  InstanceVoidMethodCallbackData* callbackData =
-    new InstanceVoidMethodCallbackData({ method, data});
+  StaticVoidMethodCallbackData* callbackData = new StaticVoidMethodCallbackData({ method, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.method = T::InstanceVoidMethodCallbackWrapper;
+  desc.method = T::StaticVoidMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     Symbol name,
-    InstanceMethodCallback method,
+    StaticMethodCallback method,
     napi_property_attributes attributes,
     void* data) {
-  InstanceMethodCallbackData* callbackData = new InstanceMethodCallbackData({ method, data });
+  StaticMethodCallbackData* callbackData = new StaticMethodCallbackData({ method, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.method = T::InstanceMethodCallbackWrapper;
+  desc.method = T::StaticMethodCallbackWrapper;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::InstanceVoidMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+template <typename ObjectWrap<T>::StaticVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     const char* utf8name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.method = details::TemplatedVoidCallback<method>;
   desc.data = data;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::InstanceMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
-    const char* utf8name,
+template <typename ObjectWrap<T>::StaticVoidMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+    Symbol name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
-  desc.utf8name = utf8name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.name = name;
+  desc.method = details::TemplatedVoidCallback<method>;
   desc.data = data;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::InstanceVoidMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
-    Symbol name,
+template <typename ObjectWrap<T>::StaticMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
+    const char* utf8name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
-  desc.name = name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.utf8name = utf8name;
+  desc.method = details::TemplatedCallback<method>;
   desc.data = data;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::InstanceMethodCallback method>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceMethod(
+template <typename ObjectWrap<T>::StaticMethodCallback method>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticMethod(
     Symbol name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.method = &ObjectWrap<T>::WrappedMethod<method>;
+  desc.method = details::TemplatedCallback<method>;
   desc.data = data;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceAccessor(
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
     const char* utf8name,
-    InstanceGetterCallback getter,
-    InstanceSetterCallback setter,
+    StaticGetterCallback getter,
+    StaticSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  InstanceAccessorCallbackData* callbackData =
-    new InstanceAccessorCallbackData({ getter, setter, data });
+  StaticAccessorCallbackData* callbackData =
+    new StaticAccessorCallbackData({ getter, setter, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
+  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceAccessor(
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
     Symbol name,
-    InstanceGetterCallback getter,
-    InstanceSetterCallback setter,
+    StaticGetterCallback getter,
+    StaticSetterCallback setter,
     napi_property_attributes attributes,
     void* data) {
-  InstanceAccessorCallbackData* callbackData =
-    new InstanceAccessorCallbackData({ getter, setter, data });
+  StaticAccessorCallbackData* callbackData =
+    new StaticAccessorCallbackData({ getter, setter, data });
 
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.getter = getter != nullptr ? T::InstanceGetterCallbackWrapper : nullptr;
-  desc.setter = setter != nullptr ? T::InstanceSetterCallbackWrapper : nullptr;
+  desc.getter = getter != nullptr ? T::StaticGetterCallbackWrapper : nullptr;
+  desc.setter = setter != nullptr ? T::StaticSetterCallbackWrapper : nullptr;
   desc.data = callbackData;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::InstanceGetterCallback getter,
-          typename ObjectWrap<T>::InstanceSetterCallback setter>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceAccessor(
+template <typename ObjectWrap<T>::StaticGetterCallback getter,
+          typename ObjectWrap<T>::StaticSetterCallback setter>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
     const char* utf8name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.utf8name = utf8name;
-  desc.getter = This::WrapGetter(This::GetterTag<getter>());
-  desc.setter = This::WrapSetter(This::SetterTag<setter>());
+  desc.getter = details::TemplatedCallback<getter>;
+  desc.setter = This::WrapStaticSetter(This::StaticSetterTag<setter>());
   desc.data = data;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
 template <typename T>
-template <typename ObjectWrap<T>::InstanceGetterCallback getter,
-          typename ObjectWrap<T>::InstanceSetterCallback setter>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceAccessor(
+template <typename ObjectWrap<T>::StaticGetterCallback getter,
+          typename ObjectWrap<T>::StaticSetterCallback setter>
+inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticAccessor(
     Symbol name,
     napi_property_attributes attributes,
     void* data) {
   napi_property_descriptor desc = napi_property_descriptor();
   desc.name = name;
-  desc.getter = This::WrapGetter(This::GetterTag<getter>());
-  desc.setter = This::WrapSetter(This::SetterTag<setter>());
+  desc.getter = details::TemplatedCallback<getter>;
+  desc.setter = This::WrapStaticSetter(This::StaticSetterTag<setter>());
   desc.data = data;
-  desc.attributes = attributes;
+  desc.attributes = static_cast<napi_property_attributes>(attributes | napi_static);
   return desc;
 }
 
@@ -3699,30 +3869,6 @@ inline ClassPropertyDescriptor<T> ObjectWrap<T>::StaticValue(Symbol name,
   return desc;
 }
 
-template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceValue(
-    const char* utf8name,
-    Napi::Value value,
-    napi_property_attributes attributes) {
-  napi_property_descriptor desc = napi_property_descriptor();
-  desc.utf8name = utf8name;
-  desc.value = value;
-  desc.attributes = attributes;
-  return desc;
-}
-
-template <typename T>
-inline ClassPropertyDescriptor<T> ObjectWrap<T>::InstanceValue(
-    Symbol name,
-    Napi::Value value,
-    napi_property_attributes attributes) {
-  napi_property_descriptor desc = napi_property_descriptor();
-  desc.name = name;
-  desc.value = value;
-  desc.attributes = attributes;
-  return desc;
-}
-
 template <typename T>
 inline void ObjectWrap<T>::Finalize(Napi::Env /*env*/) {}
 
@@ -3815,68 +3961,6 @@ inline napi_value ObjectWrap<T>::StaticSetterCallbackWrapper(
   });
 }
 
-template <typename T>
-inline napi_value ObjectWrap<T>::InstanceVoidMethodCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
-  return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceVoidMethodCallbackData* callbackData =
-      reinterpret_cast<InstanceVoidMethodCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->callback;
-    (instance->*cb)(callbackInfo);
-    return nullptr;
-  });
-}
-
-template <typename T>
-inline napi_value ObjectWrap<T>::InstanceMethodCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
-  return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceMethodCallbackData* callbackData =
-      reinterpret_cast<InstanceMethodCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->callback;
-    return (instance->*cb)(callbackInfo);
-  });
-}
-
-template <typename T>
-inline napi_value ObjectWrap<T>::InstanceGetterCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
-  return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceAccessorCallbackData* callbackData =
-      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->getterCallback;
-    return (instance->*cb)(callbackInfo);
-  });
-}
-
-template <typename T>
-inline napi_value ObjectWrap<T>::InstanceSetterCallbackWrapper(
-    napi_env env,
-    napi_callback_info info) {
-  return details::WrapCallback([&] {
-    CallbackInfo callbackInfo(env, info);
-    InstanceAccessorCallbackData* callbackData =
-      reinterpret_cast<InstanceAccessorCallbackData*>(callbackInfo.Data());
-    callbackInfo.SetData(callbackData->data);
-    T* instance = Unwrap(callbackInfo.This().As<Object>());
-    auto cb = callbackData->setterCallback;
-    (instance->*cb)(callbackInfo, callbackInfo[0]);
-    return nullptr;
-  });
-}
-
 template <typename T>
 inline void ObjectWrap<T>::FinalizeCallback(napi_env env, void* data, void* /*hint*/) {
   T* instance = static_cast<T*>(data);
@@ -3884,44 +3968,6 @@ inline void ObjectWrap<T>::FinalizeCallback(napi_env env, void* data, void* /*hi
   delete instance;
 }
 
-template <typename T>
-template <typename ObjectWrap<T>::StaticVoidMethodCallback method>
-inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
-  return details::WrapCallback([&] {
-    method(CallbackInfo(env, info));
-    return nullptr;
-  });
-}
-
-template <typename T>
-template <typename ObjectWrap<T>::StaticMethodCallback method>
-inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
-  return details::WrapCallback([&] {
-    return method(CallbackInfo(env, info));
-  });
-}
-
-template <typename T>
-template <typename ObjectWrap<T>::InstanceVoidMethodCallback method>
-inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
-  return details::WrapCallback([&] {
-    const CallbackInfo cbInfo(env, info);
-    T* instance = Unwrap(cbInfo.This().As<Object>());
-    (instance->*method)(cbInfo);
-    return nullptr;
-  });
-}
-
-template <typename T>
-template <typename ObjectWrap<T>::InstanceMethodCallback method>
-inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
-  return details::WrapCallback([&] {
-    const CallbackInfo cbInfo(env, info);
-    T* instance = Unwrap(cbInfo.This().As<Object>());
-    return (instance->*method)(cbInfo);
-  });
-}
-
 template <typename T>
 template <typename ObjectWrap<T>::StaticSetterCallback method>
 inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
@@ -3932,17 +3978,6 @@ inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info
   });
 }
 
-template <typename T>
-template <typename ObjectWrap<T>::InstanceSetterCallback method>
-inline napi_value ObjectWrap<T>::WrappedMethod(napi_env env, napi_callback_info info) noexcept {
-  return details::WrapCallback([&] {
-    const CallbackInfo cbInfo(env, info);
-    T* instance = Unwrap(cbInfo.This().As<Object>());
-    (instance->*method)(cbInfo, cbInfo[0]);
-    return nullptr;
-  });
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 // HandleScope class
 ////////////////////////////////////////////////////////////////////////////////
@@ -5000,6 +5035,49 @@ inline const napi_node_version* VersionManagement::GetNodeVersion(Env env) {
   return result;
 }
 
+#if NAPI_VERSION > 5
+////////////////////////////////////////////////////////////////////////////////
+// Addon<T> class
+////////////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+inline Object Addon<T>::Init(Env env, Object exports) {
+  T* addon = new T(env, exports);
+  env.SetInstanceData(addon);
+  return addon->entry_point_;
+}
+
+template <typename T>
+inline T* Addon<T>::Unwrap(Object wrapper) {
+  return wrapper.Env().GetInstanceData<T>();
+}
+
+template <typename T>
+inline void
+Addon<T>::DefineAddon(Object exports,
+                      const std::initializer_list<AddonProp>& props) {
+  DefineProperties(exports, props);
+  entry_point_ = exports;
+}
+
+template <typename T>
+inline Napi::Object
+Addon<T>::DefineProperties(Object object,
+                           const std::initializer_list<AddonProp>& props) {
+  const napi_property_descriptor* properties =
+    reinterpret_cast<const napi_property_descriptor*>(props.begin());
+  size_t size = props.size();
+  napi_status status = napi_define_properties(object.Env(),
+                                              object,
+                                              size,
+                                              properties);
+  NAPI_THROW_IF_FAILED(object.Env(), status, object);
+  for (size_t idx = 0; idx < size; idx++)
+    T::AttachPropData(object.Env(), object, &properties[idx]);
+  return object;
+}
+#endif  // NAPI_VERSION > 5
+
 } // namespace Napi
 
 #endif // SRC_NAPI_INL_H_