node-addon-api 2.0.2 → 3.0.0

package/napi.h

@@ -91,6 +91,13 @@ static_assert(sizeof(char16_t) == sizeof(wchar_t), "Size mismatch between char16
 
 #endif // NAPI_CPP_EXCEPTIONS
 
+# define NAPI_DISALLOW_ASSIGN(CLASS) void operator=(const CLASS&) = delete;
+# define NAPI_DISALLOW_COPY(CLASS) CLASS(const CLASS&) = delete;
+
+#define NAPI_DISALLOW_ASSIGN_COPY(CLASS)  \
+    NAPI_DISALLOW_ASSIGN(CLASS)           \
+    NAPI_DISALLOW_COPY(CLASS)
+
 #define NAPI_FATAL_IF_FAILED(status, location, message)  \
   do {                                                   \
     if ((status) != napi_ok) {                           \
@@ -112,24 +119,20 @@ namespace Napi {
   class Value;
   class Boolean;
   class Number;
-// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.
-// Once it is no longer experimental guard with the NAPI_VERSION in which it is
-// released instead.
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION > 5
   class BigInt;
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
 #if (NAPI_VERSION > 4)
   class Date;
 #endif
   class String;
   class Object;
   class Array;
+  class ArrayBuffer;
   class Function;
-  template <typename T> class Buffer;
   class Error;
   class PropertyDescriptor;
   class CallbackInfo;
-  template <typename T> class Reference;
   class TypedArray;
   template <typename T> class TypedArrayOf;
 
@@ -141,13 +144,10 @@ namespace Napi {
   typedef TypedArrayOf<uint32_t> Uint32Array; ///< Typed-array of unsigned 32-bit integers
   typedef TypedArrayOf<float> Float32Array;   ///< Typed-array of 32-bit floating-point values
   typedef TypedArrayOf<double> Float64Array;  ///< Typed-array of 64-bit floating-point values
-// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.
-// Once it is no longer experimental guard with the NAPI_VERSION in which it is
-// released instead.
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION > 5
   typedef TypedArrayOf<int64_t> BigInt64Array;   ///< Typed array of signed 64-bit integers
   typedef TypedArrayOf<uint64_t> BigUint64Array; ///< Typed array of unsigned 64-bit integers
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
 
   /// Defines the signature of a N-API C++ module's registration callback (init) function.
   typedef Object (*ModuleRegisterCallback)(Env env, Object exports);
@@ -166,6 +166,12 @@ namespace Napi {
   ///
   /// In the V8 JavaScript engine, a N-API environment approximately corresponds to an Isolate.
   class Env {
+#if NAPI_VERSION > 5
+  private:
+    template <typename T> static void DefaultFini(Env, T* data);
+    template <typename DataType, typename HintType>
+    static void DefaultFiniWithHint(Env, DataType* data, HintType* hint);
+#endif  // NAPI_VERSION > 5
   public:
     Env(napi_env env);
 
@@ -178,6 +184,26 @@ namespace Napi {
     bool IsExceptionPending() const;
     Error GetAndClearPendingException();
 
+    Value RunScript(const char* utf8script);
+    Value RunScript(const std::string& utf8script);
+    Value RunScript(String script);
+
+#if NAPI_VERSION > 5
+    template <typename T> T* GetInstanceData();
+
+    template <typename T> using Finalizer = void (*)(Env, T*);
+    template <typename T, Finalizer<T> fini = Env::DefaultFini<T>>
+    void SetInstanceData(T* data);
+
+    template <typename DataType, typename HintType>
+    using FinalizerWithHint = void (*)(Env, DataType*, HintType*);
+    template <typename DataType,
+              typename HintType,
+              FinalizerWithHint<DataType, HintType> fini =
+                Env::DefaultFiniWithHint<DataType, HintType>>
+    void SetInstanceData(DataType* data, HintType* hint);
+#endif  // NAPI_VERSION > 5
+
   private:
     napi_env _env;
   };
@@ -247,12 +273,9 @@ namespace Napi {
     bool IsNull() const;        ///< Tests if a value is a null JavaScript value.
     bool IsBoolean() const;     ///< Tests if a value is a JavaScript boolean.
     bool IsNumber() const;      ///< Tests if a value is a JavaScript number.
-// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.
-// Once it is no longer experimental guard with the NAPI_VERSION in which it is
-// released instead.
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION > 5
     bool IsBigInt() const;      ///< Tests if a value is a JavaScript bigint.
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
 #if (NAPI_VERSION > 4)
     bool IsDate() const;        ///< Tests if a value is a JavaScript date.
 #endif
@@ -325,10 +348,7 @@ namespace Napi {
     double DoubleValue() const;   ///< Converts a Number value to a 64-bit floating-point value.
   };
 
-// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.
-// Once it is no longer experimental guard with the NAPI_VERSION in which it is
-// released instead.
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION > 5
   /// A JavaScript bigint value.
   class BigInt : public Value {
   public:
@@ -367,7 +387,7 @@ namespace Napi {
     /// be needed to store this BigInt (i.e. the return value of `WordCount()`).
     void ToWords(int* sign_bit, size_t* word_count, uint64_t* words);
   };
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
 
 #if (NAPI_VERSION > 4)
   /// A JavaScript date value.
@@ -802,13 +822,6 @@ namespace Napi {
 
     void* Data();        ///< Gets a pointer to the data buffer.
     size_t ByteLength(); ///< Gets the length of the array buffer in bytes.
-
-  private:
-    mutable void* _data;
-    mutable size_t _length;
-
-    ArrayBuffer(napi_env env, napi_value value, void* data, size_t length);
-    void EnsureInfo() const;
   };
 
   /// A JavaScript typed-array value with unknown array type.
@@ -856,13 +869,10 @@ namespace Napi {
         : std::is_same<T, uint32_t>::value ? napi_uint32_array
         : std::is_same<T, float>::value ? napi_float32_array
         : std::is_same<T, double>::value ? napi_float64_array
-// Currently experimental guard with the definition of NAPI_EXPERIMENTAL.
-// Once it is no longer experimental guard with the NAPI_VERSION in which it is
-// released instead.
-#ifdef NAPI_EXPERIMENTAL
+#if NAPI_VERSION > 5
         : std::is_same<T, int64_t>::value ? napi_bigint64_array
         : std::is_same<T, uint64_t>::value ? napi_biguint64_array
-#endif  // NAPI_EXPERIMENTAL
+#endif  // NAPI_VERSION > 5
         : unknown_array_type;
     }
     /// !endcond
@@ -993,6 +1003,29 @@ namespace Napi {
 
   class Function : public Object {
   public:
+    typedef void (*VoidCallback)(const CallbackInfo& info);
+    typedef Value (*Callback)(const CallbackInfo& info);
+
+    template <VoidCallback cb>
+    static Function New(napi_env env,
+                        const char* utf8name = nullptr,
+                        void* data = nullptr);
+
+    template <Callback cb>
+    static Function New(napi_env env,
+                        const char* utf8name = nullptr,
+                        void* data = nullptr);
+
+    template <VoidCallback cb>
+    static Function New(napi_env env,
+                        const std::string& utf8name,
+                        void* data = nullptr);
+
+    template <Callback cb>
+    static Function New(napi_env env,
+                        const std::string& utf8name,
+                        void* data = nullptr);
+
     /// Callable must implement operator() accepting a const CallbackInfo&
     /// and return either void or Value.
     template <typename Callable>
@@ -1108,7 +1141,7 @@ namespace Napi {
     // A reference can be moved but cannot be copied.
     Reference(Reference<T>&& other);
     Reference<T>& operator =(Reference<T>&& other);
-    Reference<T>& operator =(Reference<T>&) = delete;
+    NAPI_DISALLOW_ASSIGN(Reference<T>)
 
     operator napi_ref() const;
     bool operator ==(const Reference<T> &other) const;
@@ -1153,7 +1186,7 @@ namespace Napi {
     ObjectReference& operator =(Reference<Object>&& other);
     ObjectReference(ObjectReference&& other);
     ObjectReference& operator =(ObjectReference&& other);
-    ObjectReference& operator =(ObjectReference&) = delete;
+    NAPI_DISALLOW_ASSIGN(ObjectReference)
 
     Napi::Value Get(const char* utf8name) const;
     Napi::Value Get(const std::string& utf8name) const;
@@ -1190,8 +1223,7 @@ namespace Napi {
     FunctionReference& operator =(Reference<Function>&& other);
     FunctionReference(FunctionReference&& other);
     FunctionReference& operator =(FunctionReference&& other);
-    FunctionReference(const FunctionReference&) = delete;
-    FunctionReference& operator =(FunctionReference&) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(FunctionReference)
 
     Napi::Value operator ()(const std::initializer_list<napi_value>& args) const;
 
@@ -1333,7 +1365,7 @@ namespace Napi {
     Error(Error&& other);
     Error& operator =(Error&& other);
     Error(const Error&);
-    Error& operator =(Error&);
+    Error& operator =(const Error&);
 
     const std::string& Message() const NAPI_NOEXCEPT;
     void ThrowAsJavaScriptException() const;
@@ -1381,8 +1413,7 @@ namespace Napi {
     ~CallbackInfo();
 
     // Disallow copying to prevent multiple free of _dynamicArgs
-    CallbackInfo(CallbackInfo const &) = delete;
-    void operator=(CallbackInfo const &) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(CallbackInfo)
 
     Napi::Env Env() const;
     Value NewTarget() const;
@@ -1407,6 +1438,9 @@ namespace Napi {
 
   class PropertyDescriptor {
   public:
+    typedef Napi::Value (*GetterCallback)(const Napi::CallbackInfo& info);
+    typedef void (*SetterCallback)(const Napi::CallbackInfo& info);
+
 #ifndef NODE_ADDON_API_DISABLE_DEPRECATED
     template <typename Getter>
     static PropertyDescriptor Accessor(const char* utf8name,
@@ -1474,6 +1508,36 @@ namespace Napi {
                                        void* data = nullptr);
 #endif // !NODE_ADDON_API_DISABLE_DEPRECATED
 
+    template <GetterCallback Getter>
+    static PropertyDescriptor Accessor(const char* utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter>
+    static PropertyDescriptor Accessor(const std::string& utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter>
+    static PropertyDescriptor Accessor(Name name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter, SetterCallback Setter>
+    static PropertyDescriptor Accessor(const char* utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter, SetterCallback Setter>
+    static PropertyDescriptor Accessor(const std::string& utf8name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
+    template <GetterCallback Getter, SetterCallback Setter>
+    static PropertyDescriptor Accessor(Name name,
+                                       napi_property_attributes attributes = napi_default,
+                                       void* data = nullptr);
+
     template <typename Getter>
     static PropertyDescriptor Accessor(Napi::Env env,
                                        Napi::Object object,
@@ -1559,6 +1623,10 @@ 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;
   };
 
@@ -1593,8 +1661,8 @@ namespace Napi {
   ///       public:
   ///         static void Initialize(Napi::Env& env, Napi::Object& target) {
   ///           Napi::Function constructor = DefineClass(env, "Example", {
-  ///             InstanceAccessor("value", &Example::GetSomething, &Example::SetSomething),
-  ///             InstanceMethod("doSomething", &Example::DoSomething),
+  ///             InstanceAccessor<&Example::GetSomething, &Example::SetSomething>("value"),
+  ///             InstanceMethod<&Example::DoSomething>("doSomething"),
   ///           });
   ///           target.Set("Example", constructor);
   ///         }
@@ -1648,6 +1716,22 @@ namespace Napi {
                                            StaticMethodCallback method,
                                            napi_property_attributes attributes = napi_default,
                                            void* data = nullptr);
+    template <StaticVoidMethodCallback method>
+    static PropertyDescriptor StaticMethod(const char* utf8name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
+    template <StaticVoidMethodCallback method>
+    static PropertyDescriptor StaticMethod(Symbol name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
+    template <StaticMethodCallback method>
+    static PropertyDescriptor StaticMethod(const char* utf8name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
+    template <StaticMethodCallback method>
+    static PropertyDescriptor StaticMethod(Symbol name,
+                                           napi_property_attributes attributes = napi_default,
+                                           void* data = nullptr);
     static PropertyDescriptor StaticAccessor(const char* utf8name,
                                              StaticGetterCallback getter,
                                              StaticSetterCallback setter,
@@ -1658,6 +1742,14 @@ namespace Napi {
                                              StaticSetterCallback setter,
                                              napi_property_attributes attributes = napi_default,
                                              void* data = nullptr);
+    template <StaticGetterCallback getter, StaticSetterCallback setter=nullptr>
+    static PropertyDescriptor StaticAccessor(const char* utf8name,
+                                             napi_property_attributes attributes = napi_default,
+                                             void* data = nullptr);
+    template <StaticGetterCallback getter, StaticSetterCallback setter=nullptr>
+    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,
@@ -1674,6 +1766,22 @@ namespace Napi {
                                              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,
@@ -1684,6 +1792,14 @@ namespace Napi {
                                                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);
@@ -1699,6 +1815,8 @@ namespace Napi {
     virtual void Finalize(Napi::Env env);
 
   private:
+    using This = ObjectWrap<T>;
+
     static napi_value ConstructorCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticVoidMethodCallbackWrapper(napi_env env, napi_callback_info info);
     static napi_value StaticMethodCallbackWrapper(napi_env env, napi_callback_info info);
@@ -1736,6 +1854,45 @@ namespace Napi {
     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;
+
+    template <InstanceMethodCallback method>
+    static napi_value WrappedMethod(napi_env env, napi_callback_info info) noexcept;
+
+    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>
+    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;
   };
 
@@ -1746,8 +1903,7 @@ namespace Napi {
     ~HandleScope();
 
     // Disallow copying to prevent double close of napi_handle_scope
-    HandleScope(HandleScope const &) = delete;
-    void operator=(HandleScope const &) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(HandleScope)
 
     operator napi_handle_scope() const;
 
@@ -1765,8 +1921,7 @@ namespace Napi {
     ~EscapableHandleScope();
 
     // Disallow copying to prevent double close of napi_escapable_handle_scope
-    EscapableHandleScope(EscapableHandleScope const &) = delete;
-    void operator=(EscapableHandleScope const &) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(EscapableHandleScope)
 
     operator napi_escapable_handle_scope() const;
 
@@ -1786,8 +1941,7 @@ namespace Napi {
     virtual ~CallbackScope();
 
     // Disallow copying to prevent double close of napi_callback_scope
-    CallbackScope(CallbackScope const &) = delete;
-    void operator=(CallbackScope const &) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(CallbackScope)
 
     operator napi_callback_scope() const;
 
@@ -1807,8 +1961,7 @@ namespace Napi {
 
     AsyncContext(AsyncContext&& other);
     AsyncContext& operator =(AsyncContext&& other);
-    AsyncContext(const AsyncContext&) = delete;
-    AsyncContext& operator =(AsyncContext&) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(AsyncContext)
 
     operator napi_async_context() const;
 
@@ -1826,8 +1979,7 @@ namespace Napi {
     // An async worker can be moved but cannot be copied.
     AsyncWorker(AsyncWorker&& other);
     AsyncWorker& operator =(AsyncWorker&& other);
-    AsyncWorker(const AsyncWorker&) = delete;
-    AsyncWorker& operator =(AsyncWorker&) = delete;
+    NAPI_DISALLOW_ASSIGN_COPY(AsyncWorker)
 
     operator napi_async_work() const;
 
@@ -1840,6 +1992,10 @@ namespace Napi {
     ObjectReference& Receiver();
     FunctionReference& Callback();
 
+    virtual void OnExecute(Napi::Env env);
+    virtual void OnWorkComplete(Napi::Env env,
+                                napi_status status);
+
   protected:
     explicit AsyncWorker(const Function& callback);
     explicit AsyncWorker(const Function& callback,
@@ -1873,10 +2029,10 @@ namespace Napi {
     void SetError(const std::string& error);
 
   private:
-    static void OnExecute(napi_env env, void* this_pointer);
-    static void OnWorkComplete(napi_env env,
-                               napi_status status,
-                               void* this_pointer);
+    static inline void OnAsyncWorkExecute(napi_env env, void* asyncworker);
+    static inline void OnAsyncWorkComplete(napi_env env,
+                                           napi_status status,
+                                           void* asyncworker);
 
     napi_env _env;
     napi_async_work _work;
@@ -2092,8 +2248,55 @@ namespace Napi {
     napi_threadsafe_function _tsfn;
   };
 
+  template <typename DataType>
+  class AsyncProgressWorkerBase : public AsyncWorker {
+    public:
+     virtual void OnWorkProgress(DataType* data) = 0;
+     class ThreadSafeData {
+       public:
+        ThreadSafeData(AsyncProgressWorkerBase* asyncprogressworker, DataType* data)
+          : _asyncprogressworker(asyncprogressworker), _data(data) {}
+
+        AsyncProgressWorkerBase* asyncprogressworker() { return _asyncprogressworker; };
+        DataType* data() { return _data; };
+
+       private:
+        AsyncProgressWorkerBase* _asyncprogressworker;
+        DataType* _data;
+     };
+     void OnWorkComplete(Napi::Env env, napi_status status) override;
+    protected:
+     explicit AsyncProgressWorkerBase(const Object& receiver,
+                                      const Function& callback,
+                                      const char* resource_name,
+                                      const Object& resource,
+                                      size_t queue_size = 1);
+    virtual ~AsyncProgressWorkerBase();
+
+// Optional callback of Napi::ThreadSafeFunction only available after NAPI_VERSION 4.
+// Refs: https://github.com/nodejs/node/pull/27791
+#if NAPI_VERSION > 4
+     explicit AsyncProgressWorkerBase(Napi::Env env,
+                                      const char* resource_name,
+                                      const Object& resource,
+                                      size_t queue_size = 1);
+#endif
+
+     static inline void OnAsyncWorkProgress(Napi::Env env,
+                                            Napi::Function jsCallback,
+                                            void* data);
+
+     napi_status NonBlockingCall(DataType* data);
+
+    private:
+     ThreadSafeFunction _tsfn;
+     bool _work_completed = false;
+     napi_status _complete_status;
+     static inline void OnThreadSafeFunctionFinalize(Napi::Env env, void* data, AsyncProgressWorkerBase* context);
+  };
+
   template<class T>
-  class AsyncProgressWorker : public AsyncWorker {
+  class AsyncProgressWorker : public AsyncProgressWorkerBase<void> {
     public:
      virtual ~AsyncProgressWorker();
 
@@ -2107,40 +2310,39 @@ namespace Napi {
         AsyncProgressWorker* const _worker;
      };
 
+     void OnWorkProgress(void*) override;
+
     protected:
-    explicit AsyncProgressWorker(const Function& callback);
-    explicit AsyncProgressWorker(const Function& callback,
-                         const char* resource_name);
-    explicit AsyncProgressWorker(const Function& callback,
-                         const char* resource_name,
-                         const Object& resource);
-    explicit AsyncProgressWorker(const Object& receiver,
-                         const Function& callback);
-    explicit AsyncProgressWorker(const Object& receiver,
-                         const Function& callback,
-                         const char* resource_name);
-    explicit AsyncProgressWorker(const Object& receiver,
-                         const Function& callback,
-                         const char* resource_name,
-                         const Object& resource);
+     explicit AsyncProgressWorker(const Function& callback);
+     explicit AsyncProgressWorker(const Function& callback,
+                                  const char* resource_name);
+     explicit AsyncProgressWorker(const Function& callback,
+                                  const char* resource_name,
+                                  const Object& resource);
+     explicit AsyncProgressWorker(const Object& receiver,
+                                  const Function& callback);
+     explicit AsyncProgressWorker(const Object& receiver,
+                                  const Function& callback,
+                                  const char* resource_name);
+     explicit AsyncProgressWorker(const Object& receiver,
+                                  const Function& callback,
+                                  const char* resource_name,
+                                  const Object& resource);
 
 // Optional callback of Napi::ThreadSafeFunction only available after NAPI_VERSION 4.
 // Refs: https://github.com/nodejs/node/pull/27791
 #if NAPI_VERSION > 4
-    explicit AsyncProgressWorker(Napi::Env env);
-    explicit AsyncProgressWorker(Napi::Env env,
-                         const char* resource_name);
-    explicit AsyncProgressWorker(Napi::Env env,
-                         const char* resource_name,
-                         const Object& resource);
+     explicit AsyncProgressWorker(Napi::Env env);
+     explicit AsyncProgressWorker(Napi::Env env,
+                                  const char* resource_name);
+     explicit AsyncProgressWorker(Napi::Env env,
+                                  const char* resource_name,
+                                  const Object& resource);
 #endif
-
      virtual void Execute(const ExecutionProgress& progress) = 0;
      virtual void OnProgress(const T* data, size_t count) = 0;
 
     private:
-     static void WorkProgress_(Napi::Env env, Napi::Function jsCallback, void* data);
-
      void Execute() override;
      void Signal() const;
      void SendProgress_(const T* data, size_t count);
@@ -2148,7 +2350,60 @@ namespace Napi {
      std::mutex _mutex;
      T* _asyncdata;
      size_t _asyncsize;
-     ThreadSafeFunction _tsfn;
+  };
+
+  template<class T>
+  class AsyncProgressQueueWorker : public AsyncProgressWorkerBase<std::pair<T*, size_t>> {
+    public:
+     virtual ~AsyncProgressQueueWorker() {};
+
+     class ExecutionProgress {
+        friend class AsyncProgressQueueWorker;
+       public:
+        void Signal() const;
+        void Send(const T* data, size_t count) const;
+       private:
+        explicit ExecutionProgress(AsyncProgressQueueWorker* worker) : _worker(worker) {}
+        AsyncProgressQueueWorker* const _worker;
+     };
+
+     void OnWorkComplete(Napi::Env env, napi_status status) override;
+     void OnWorkProgress(std::pair<T*, size_t>*) override;
+
+    protected:
+     explicit AsyncProgressQueueWorker(const Function& callback);
+     explicit AsyncProgressQueueWorker(const Function& callback,
+                                       const char* resource_name);
+     explicit AsyncProgressQueueWorker(const Function& callback,
+                                       const char* resource_name,
+                                       const Object& resource);
+     explicit AsyncProgressQueueWorker(const Object& receiver,
+                                       const Function& callback);
+     explicit AsyncProgressQueueWorker(const Object& receiver,
+                                       const Function& callback,
+                                       const char* resource_name);
+     explicit AsyncProgressQueueWorker(const Object& receiver,
+                                       const Function& callback,
+                                       const char* resource_name,
+                                       const Object& resource);
+
+// Optional callback of Napi::ThreadSafeFunction only available after NAPI_VERSION 4.
+// Refs: https://github.com/nodejs/node/pull/27791
+#if NAPI_VERSION > 4
+     explicit AsyncProgressQueueWorker(Napi::Env env);
+     explicit AsyncProgressQueueWorker(Napi::Env env,
+                                       const char* resource_name);
+     explicit AsyncProgressQueueWorker(Napi::Env env,
+                                       const char* resource_name,
+                                       const Object& resource);
+#endif
+     virtual void Execute(const ExecutionProgress& progress) = 0;
+     virtual void OnProgress(const T* data, size_t count) = 0;
+
+    private:
+     void Execute() override;
+     void Signal() const;
+     void SendProgress_(const T* data, size_t count);
   };
   #endif