node-addon-api 3.0.1 → 3.0.2

package/napi.h

@@ -1623,10 +1623,6 @@ namespace Napi {
     operator const napi_property_descriptor&() const;
 
   private:
-    template <GetterCallback Getter>
-    static napi_value GetterCallbackWrapper(napi_env env, napi_callback_info info);
-    template <SetterCallback Setter>
-    static napi_value SetterCallbackWrapper(napi_env env, napi_callback_info info);
     napi_property_descriptor _desc;
   };
 
@@ -1647,6 +1643,114 @@ namespace Napi {
     napi_property_descriptor _desc;
   };
 
+  template <typename T, typename TCallback>
+  struct MethodCallbackData {
+    TCallback callback;
+    void* data;
+  };
+
+  template <typename T, typename TGetterCallback, typename TSetterCallback>
+  struct AccessorCallbackData {
+    TGetterCallback getterCallback;
+    TSetterCallback setterCallback;
+    void* data;
+  };
+
+  template <typename T>
+  class InstanceWrap {
+   public:
+
+    typedef void (T::*InstanceVoidMethodCallback)(const CallbackInfo& info);
+    typedef Napi::Value (T::*InstanceMethodCallback)(const CallbackInfo& info);
+    typedef Napi::Value (T::*InstanceGetterCallback)(const CallbackInfo& info);
+    typedef void (T::*InstanceSetterCallback)(const CallbackInfo& info, const Napi::Value& value);
+
+    typedef ClassPropertyDescriptor<T> PropertyDescriptor;
+
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             InstanceVoidMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             InstanceMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             InstanceVoidMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             InstanceMethodCallback method,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceVoidMethodCallback method>
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceMethodCallback method>
+    static PropertyDescriptor InstanceMethod(const char* utf8name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceVoidMethodCallback method>
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <InstanceMethodCallback method>
+    static PropertyDescriptor InstanceMethod(Symbol name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    static PropertyDescriptor InstanceAccessor(const char* utf8name,
+                                               InstanceGetterCallback getter,
+                                               InstanceSetterCallback setter,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    static PropertyDescriptor InstanceAccessor(Symbol name,
+                                               InstanceGetterCallback getter,
+                                               InstanceSetterCallback setter,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    template <InstanceGetterCallback getter, InstanceSetterCallback setter=nullptr>
+    static PropertyDescriptor InstanceAccessor(const char* utf8name,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    template <InstanceGetterCallback getter, InstanceSetterCallback setter=nullptr>
+    static PropertyDescriptor InstanceAccessor(Symbol name,
+                                               napi_property_attributes attributes = napi_default,
+                                               void* data = nullptr);
+    static PropertyDescriptor InstanceValue(const char* utf8name,
+                                            Napi::Value value,
+                                            napi_property_attributes attributes = napi_default);
+    static PropertyDescriptor InstanceValue(Symbol name,
+                                            Napi::Value value,
+                                            napi_property_attributes attributes = napi_default);
+
+   protected:
+    static void AttachPropData(napi_env env, napi_value value, const napi_property_descriptor* prop);
+
+   private:
+    using This = InstanceWrap<T>;
+
+    typedef MethodCallbackData<T, InstanceVoidMethodCallback> InstanceVoidMethodCallbackData;
+    typedef MethodCallbackData<T, InstanceMethodCallback> InstanceMethodCallbackData;
+    typedef AccessorCallbackData<T,
+                                 InstanceGetterCallback,
+                                 InstanceSetterCallback> InstanceAccessorCallbackData;
+
+    static napi_value InstanceVoidMethodCallbackWrapper(napi_env env, napi_callback_info info);
+    static napi_value InstanceMethodCallbackWrapper(napi_env env, napi_callback_info info);
+    static napi_value InstanceGetterCallbackWrapper(napi_env env, napi_callback_info info);
+    static napi_value InstanceSetterCallbackWrapper(napi_env env, napi_callback_info info);
+
+    template <InstanceSetterCallback method>
+    static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
+
+    template <InstanceSetterCallback setter> struct SetterTag {};
+
+    template <InstanceSetterCallback setter>
+    static napi_callback WrapSetter(SetterTag<setter>) noexcept { return &This::WrappedMethod<setter>; }
+    static napi_callback WrapSetter(SetterTag<nullptr>) noexcept { return nullptr; }
+  };
+
   /// Base class to be extended by C++ classes exposed to JavaScript; each C++ class instance gets
   /// "wrapped" by a JavaScript object that is managed by this class.
   ///
@@ -1673,7 +1777,7 @@ namespace Napi {
   ///         Napi::Value DoSomething(const Napi::CallbackInfo& info);
   ///     }
   template <typename T>
-  class ObjectWrap : public Reference<Object> {
+  class ObjectWrap : public InstanceWrap<T>, public Reference<Object> {
   public:
     ObjectWrap(const CallbackInfo& callbackInfo);
     virtual ~ObjectWrap();
@@ -1685,10 +1789,6 @@ namespace Napi {
     typedef Napi::Value (*StaticMethodCallback)(const CallbackInfo& info);
     typedef Napi::Value (*StaticGetterCallback)(const CallbackInfo& info);
     typedef void (*StaticSetterCallback)(const CallbackInfo& info, const Napi::Value& value);
-    typedef void (T::*InstanceVoidMethodCallback)(const CallbackInfo& info);
-    typedef Napi::Value (T::*InstanceMethodCallback)(const CallbackInfo& info);
-    typedef Napi::Value (T::*InstanceGetterCallback)(const CallbackInfo& info);
-    typedef void (T::*InstanceSetterCallback)(const CallbackInfo& info, const Napi::Value& value);
 
     typedef ClassPropertyDescriptor<T> PropertyDescriptor;
 
@@ -1750,68 +1850,12 @@ namespace Napi {
     static PropertyDescriptor StaticAccessor(Symbol name,
                                              napi_property_attributes attributes = napi_default,
                                              void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(const char* utf8name,
-                                             InstanceVoidMethodCallback method,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(const char* utf8name,
-                                             InstanceMethodCallback method,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(Symbol name,
-                                             InstanceVoidMethodCallback method,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    static PropertyDescriptor InstanceMethod(Symbol name,
-                                             InstanceMethodCallback method,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    template <InstanceVoidMethodCallback method>
-    static PropertyDescriptor InstanceMethod(const char* utf8name,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    template <InstanceMethodCallback method>
-    static PropertyDescriptor InstanceMethod(const char* utf8name,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    template <InstanceVoidMethodCallback method>
-    static PropertyDescriptor InstanceMethod(Symbol name,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    template <InstanceMethodCallback method>
-    static PropertyDescriptor InstanceMethod(Symbol name,
-                                             napi_property_attributes attributes = napi_default,
-                                             void* data = nullptr);
-    static PropertyDescriptor InstanceAccessor(const char* utf8name,
-                                               InstanceGetterCallback getter,
-                                               InstanceSetterCallback setter,
-                                               napi_property_attributes attributes = napi_default,
-                                               void* data = nullptr);
-    static PropertyDescriptor InstanceAccessor(Symbol name,
-                                               InstanceGetterCallback getter,
-                                               InstanceSetterCallback setter,
-                                               napi_property_attributes attributes = napi_default,
-                                               void* data = nullptr);
-    template <InstanceGetterCallback getter, InstanceSetterCallback setter=nullptr>
-    static PropertyDescriptor InstanceAccessor(const char* utf8name,
-                                               napi_property_attributes attributes = napi_default,
-                                               void* data = nullptr);
-    template <InstanceGetterCallback getter, InstanceSetterCallback setter=nullptr>
-    static PropertyDescriptor InstanceAccessor(Symbol name,
-                                               napi_property_attributes attributes = napi_default,
-                                               void* data = nullptr);
     static PropertyDescriptor StaticValue(const char* utf8name,
                                           Napi::Value value,
                                           napi_property_attributes attributes = napi_default);
     static PropertyDescriptor StaticValue(Symbol name,
                                           Napi::Value value,
                                           napi_property_attributes attributes = napi_default);
-    static PropertyDescriptor InstanceValue(const char* utf8name,
-                                            Napi::Value value,
-                                            napi_property_attributes attributes = napi_default);
-    static PropertyDescriptor InstanceValue(Symbol name,
-                                            Napi::Value value,
-                                            napi_property_attributes attributes = napi_default);
     virtual void Finalize(Napi::Env env);
 
   private:
@@ -1822,10 +1866,6 @@ namespace Napi {
     static napi_value StaticMethodCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticGetterCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticSetterCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceVoidMethodCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceMethodCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceGetterCallbackWrapper(napi_env env, napi_callback_info info);
-    static napi_value InstanceSetterCallbackWrapper(napi_env env, napi_callback_info info);
     static void FinalizeCallback(napi_env env, void* data, void* hint);
     static Function DefineClass(Napi::Env env,
                                 const char* utf8name,
@@ -1833,66 +1873,22 @@ namespace Napi {
                                 const napi_property_descriptor* props,
                                 void* data = nullptr);
 
-    template <typename TCallback>
-    struct MethodCallbackData {
-      TCallback callback;
-      void* data;
-    };
-    typedef MethodCallbackData<StaticVoidMethodCallback> StaticVoidMethodCallbackData;
-    typedef MethodCallbackData<StaticMethodCallback> StaticMethodCallbackData;
-    typedef MethodCallbackData<InstanceVoidMethodCallback> InstanceVoidMethodCallbackData;
-    typedef MethodCallbackData<InstanceMethodCallback> InstanceMethodCallbackData;
-
-    template <typename TGetterCallback, typename TSetterCallback>
-    struct AccessorCallbackData {
-      TGetterCallback getterCallback;
-      TSetterCallback setterCallback;
-      void* data;
-    };
-    typedef AccessorCallbackData<StaticGetterCallback, StaticSetterCallback>
-      StaticAccessorCallbackData;
-    typedef AccessorCallbackData<InstanceGetterCallback, InstanceSetterCallback>
-      InstanceAccessorCallbackData;
-
-    template <StaticVoidMethodCallback method>
-    static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
-
-    template <StaticMethodCallback method>
-    static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
-
-    template <InstanceVoidMethodCallback method>
-    static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
+    typedef MethodCallbackData<T, StaticVoidMethodCallback> StaticVoidMethodCallbackData;
+    typedef MethodCallbackData<T, StaticMethodCallback> StaticMethodCallbackData;
 
-    template <InstanceMethodCallback method>
-    static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
+    typedef AccessorCallbackData<T,
+                                 StaticGetterCallback,
+                                 StaticSetterCallback> StaticAccessorCallbackData;
 
     template <StaticSetterCallback method>
     static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
 
-    template <InstanceSetterCallback method>
-    static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
-
-    template <StaticGetterCallback   getter> struct StaticGetterTag {};
-    template <StaticSetterCallback   setter> struct StaticSetterTag {};
-    template <InstanceGetterCallback getter> struct GetterTag {};
-    template <InstanceSetterCallback setter> struct SetterTag {};
-
-    template <StaticGetterCallback getter>
-    static napi_callback WrapStaticGetter(StaticGetterTag<getter>) noexcept { return &This::WrappedMethod<getter>; }
-    static napi_callback WrapStaticGetter(StaticGetterTag<nullptr>) noexcept { return nullptr; }
+    template <StaticSetterCallback setter> struct StaticSetterTag {};
 
     template <StaticSetterCallback setter>
     static napi_callback WrapStaticSetter(StaticSetterTag<setter>) noexcept { return &This::WrappedMethod<setter>; }
     static napi_callback WrapStaticSetter(StaticSetterTag<nullptr>) noexcept { return nullptr; }
 
-    template <InstanceGetterCallback getter>
-    static napi_callback WrapGetter(GetterTag<getter>) noexcept { return &This::WrappedMethod<getter>; }
-    static napi_callback WrapGetter(GetterTag<nullptr>) noexcept { return nullptr; }
-
-    template <InstanceSetterCallback setter>
-    static napi_callback WrapSetter(SetterTag<setter>) noexcept { return &This::WrappedMethod<setter>; }
-    static napi_callback WrapSetter(SetterTag<nullptr>) noexcept { return nullptr; }
-
     bool _construction_failed = true;
   };
 
@@ -2420,6 +2416,25 @@ namespace Napi {
       static const napi_node_version* GetNodeVersion(Env env);
   };
 
+#if NAPI_VERSION > 5
+  template <typename T>
+  class Addon : public InstanceWrap<T> {
+   public:
+    static inline Object Init(Env env, Object exports);
+    static T* Unwrap(Object wrapper);
+
+   protected:
+    typedef ClassPropertyDescriptor<T> AddonProp;
+    void DefineAddon(Object exports,
+                     const std::initializer_list<AddonProp>& props);
+    Napi::Object DefineProperties(Object object,
+                                 const std::initializer_list<AddonProp>& props);
+
+   private:
+    Object entry_point_;
+  };
+#endif  // NAPI_VERSION > 5
+
 } // namespace Napi
 
 // Inline implementations of all the above class methods are included here.

package/package.json

@@ -139,6 +139,10 @@
       "name": "Kevin Eady",
       "url": "https://github.com/KevinEady"
     },
+    {
+      "name": "Koki Nishihara",
+      "url": "https://github.com/Nishikoh"
+    },
     {
       "name": "Konstantin Tarkus",
       "url": "https://github.com/koistya"
@@ -195,6 +199,10 @@
       "name": "Nurbol Alpysbayev",
       "url": "https://github.com/anurbol"
     },
+    {
+      "name": "pacop",
+      "url": "https://github.com/pacop"
+    },
     {
       "name": "Philipp Renoth",
       "url": "https://github.com/DaAitch"
@@ -239,6 +247,10 @@
       "name": "Tux3",
       "url": "https://github.com/tux3"
     },
+    {
+      "name": "Vlad Velmisov",
+      "url": "https://github.com/Velmisov"
+    },
     {
       "name": "Yohei Kishimoto",
       "url": "https://github.com/morokosi"
@@ -252,6 +264,8 @@
   "description": "Node.js API (N-API)",
   "devDependencies": {
     "benchmark": "^2.1.4",
+    "fs-extra": "^9.0.1",
+    "bindings": "^1.5.0",
     "safe-buffer": "^5.1.1"
   },
   "directories": {},
@@ -288,5 +302,5 @@
     "dev:incremental": "node test",
     "doc": "doxygen doc/Doxyfile"
   },
-  "version": "3.0.1"
+  "version": "3.0.2"
 }

package/tools/conversion.js

@@ -22,8 +22,8 @@ if (disable != "--disable" && dir != "--disable") {
        [ /[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '' ]
     ],
     'binding.gyp': [
-       [ /([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!@(node -p "require(\\\'node-addon-api\\\').include")\',' ],
-       [ /([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!@(node -p \\"require(\'node-addon-api\').include\\")",' ],
+       [ /([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\',' ],
+       [ /([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!(node -p \\"require(\'node-addon-api\').include_dir\\")",' ],
        [ /[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, '' ],
        [ /([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n      $2cflags!$2: [ $2-fno-exceptions$2 ],\n      $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n      $2xcode_settings$2: { $2GCC_ENABLE_CPP_EXCEPTIONS$2: $2YES$2,\n        $2CLANG_CXX_LIBRARY$2: $2libc++$2,\n        $2MACOSX_DEPLOYMENT_TARGET$2: $210.7$2,\n      },\n      $2msvs_settings$2: {\n        $2VCCLCompilerTool$2: { $2ExceptionHandling$2: 1 },\n      },' ],
     ]
@@ -35,8 +35,8 @@ if (disable != "--disable" && dir != "--disable") {
       [ /[ ]*"nan": *"[^"]+"(,|)[\n\r]/g, '' ]
     ],
     'binding.gyp': [
-      [ /([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!@(node -p "require(\\\'node-addon-api\\\').include")\',' ],
-      [ /([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!@(node -p \'require(\\\"node-addon-api\\\").include\')",' ],
+      [ /([ ]*)'include_dirs': \[/g, '$1\'include_dirs\': [\n$1  \'<!(node -p "require(\\\'node-addon-api\\\').include_dir")\',' ],
+      [ /([ ]*)"include_dirs": \[/g, '$1"include_dirs": [\n$1  "<!(node -p \'require(\\\"node-addon-api\\\").include_dir\')",' ],
       [ /[ ]*("|')<!\(node -e ("|'|\\"|\\')require\(("|'|\\"|\\')nan("|'|\\"|\\')\)("|'|\\"|\\')\)("|')(,|)[\r\n]/g, '' ],
       [ /([ ]*)("|')target_name("|'): ("|')(.+?)("|'),/g, '$1$2target_name$2: $4$5$6,\n      $2cflags!$2: [ $2-fno-exceptions$2 ],\n      $2cflags_cc!$2: [ $2-fno-exceptions$2 ],\n      $2defines$2: [ $2NAPI_DISABLE_CPP_EXCEPTIONS$2 ],\n      $2conditions$2: [\n        [\'OS==\"win\"\', { $2defines$2: [ $2_HAS_EXCEPTIONS=1$2 ] }]\n      ]' ],
     ]