Merge remote-tracking branch 'upstream/master' into contexted-tsfn-api-gcc-4

Author: KevinEady

CHANGELOG.md

@@ -1,5 +1,40 @@
 # node-addon-api Changelog
 
+## 2020-07-13 Version 3.0.1, @NickNaso
+
+### Notable changes:
+
+#### API
+
+- Fixed the usage of `Napi::Reference` with `Napi::TypedArray`.
+- Fixed `Napi::ObjectWrap` inheritance.
+
+#### Documentation
+
+- Updated the example for `Napi::ObjectWrap`.
+- Added documentation for instance data APIs.
+- Some minor corrections all over the documentation.
+
+#### TEST
+
+- Fixed test for `Napi::ArrayBuffer` and `Napi::Buffer`.
+- Some minor corrections all over the test suite.
+
+### Commits
+
+* [[`40c7926342`](https://github.com/nodejs/node-addon-api/commit/40c7926342)] - **build**: ensure paths with spaces can be used (Lovell Fuller) [#757](https://github.com/nodejs/node-addon-api/pull/757)
+* [[`ef16dfb4a2`](https://github.com/nodejs/node-addon-api/commit/ef16dfb4a2)] - **doc**: update ObjectWrap example (Gabriel Schulhof) [#754](https://github.com/nodejs/node-addon-api/pull/754)
+* [[`48f6762bf6`](https://github.com/nodejs/node-addon-api/commit/48f6762bf6)] - **src**: add \_\_wasm32\_\_ guards (Gus Caplan)
+* [[`bd2c5ec502`](https://github.com/nodejs/node-addon-api/commit/bd2c5ec502)] - Fixes issue 745. (#748) (Nicola Del Gobbo)
+* [[`4c01af2d87`](https://github.com/nodejs/node-addon-api/commit/4c01af2d87)] - Fix typo in CHANGELOG (#715) (Kasumi Hanazuki)
+* [[`36e1af96d5`](https://github.com/nodejs/node-addon-api/commit/36e1af96d5)] - **src**: fix use of Reference with typed arrays (Michael Dawson) [#726](https://github.com/nodejs/node-addon-api/pull/726)
+* [[`d463f02bc7`](https://github.com/nodejs/node-addon-api/commit/d463f02bc7)] - **src**: fix testEnumerables on ObjectWrap (Ferdinand Holzer) [#736](https://github.com/nodejs/node-addon-api/pull/736)
+* [[`ba7ad37d44`](https://github.com/nodejs/node-addon-api/commit/ba7ad37d44)] - **src**: fix ObjectWrap inheritance (David Halls) [#732](https://github.com/nodejs/node-addon-api/pull/732)
+* [[`31504c862b`](https://github.com/nodejs/node-addon-api/commit/31504c862b)] - **doc**: fix minor typo in object\_wrap.md (#741) (Daniel Bevenius) [#741](https://github.com/nodejs/node-addon-api/pull/741)
+* [[`beccf2145d`](https://github.com/nodejs/node-addon-api/commit/beccf2145d)] - **test**: fix up delays for array buffer test (Michael Dawson) [#737](https://github.com/nodejs/node-addon-api/pull/737)
+* [[`45cb1d9748`](https://github.com/nodejs/node-addon-api/commit/45cb1d9748)] - Correct AsyncProgressWorker link in README (#716) (Jeroen Janssen)
+* [[`381c0da60c`](https://github.com/nodejs/node-addon-api/commit/381c0da60c)] - **doc**: add instance data APIs (Gabriel Schulhof) [#708](https://github.com/nodejs/node-addon-api/pull/708)
+
 ## 2020-04-30 Version 3.0.0, @NickNaso
 
 ### Notable changes:
@@ -14,14 +49,14 @@
 - Added `Env::RunScript` method to run JavaScript code contained in a string.
 - Added templated version of `Napi::Function`.
 - Added benchmarking framework.
-- Added support for natove addon instance data.
+- Added support for native addon instance data.
 - Added `Napi::AsyncProgressQueueWorker` api.
 - Changed the guards to `NAPI_VERSION > 5`.
 - Removed N-API implementation (v6.x and v8.x support).
 - `Napi::AsyncWorker::OnWorkComplete` and `Napi::AsyncWorker::OnExecute` methods
 are override-able.
 - Removed erroneous finalizer cleanup in `Napi::ThreadSafeFunction`.
-- Disabled cahcing in `Napi::ArrayBuffer`.
+- Disabled caching in `Napi::ArrayBuffer`.
 - Explicitly disallow assign and copy operator.
 - Some minor corrections and improvements.
 

README.md

@@ -47,7 +47,7 @@ to ideas specified in the **ECMA262 Language Specification**.
 - **[Contributors](#contributors)**
 - **[License](#license)**
 
-## **Current version: 3.0.0**
+## **Current version: 3.0.1**
 
 (See [CHANGELOG.md](CHANGELOG.md) for complete Changelog)
 

doc/bigint.md

@@ -79,7 +79,7 @@ Returns the number of words needed to store this `BigInt` value.
 ### ToWords
 
 ```cpp
-void Napi::BigInt::ToWords(size_t* word_count, int* sign_bit, uint64_t* words);
+void Napi::BigInt::ToWords(int* sign_bit, size_t* word_count, uint64_t* words);
 ```
 
  - `[out] sign_bit`: Integer representing if the JavaScript `BigInt` is positive

doc/object_wrap.md

@@ -22,49 +22,57 @@ your C++ class methods.
 class Example : public Napi::ObjectWrap<Example> {
   public:
     static Napi::Object Init(Napi::Env env, Napi::Object exports);
-    Example(const Napi::CallbackInfo &info);
+    Example(const Napi::CallbackInfo& info);
+    static Napi::Value CreateNewItem(const Napi::CallbackInfo& info);
 
   private:
-    static Napi::FunctionReference constructor;
     double _value;
-    Napi::Value GetValue(const Napi::CallbackInfo &info);
-    Napi::Value SetValue(const Napi::CallbackInfo &info);
+    Napi::Value GetValue(const Napi::CallbackInfo& info);
+    Napi::Value SetValue(const Napi::CallbackInfo& info);
 };
 
 Napi::Object Example::Init(Napi::Env env, Napi::Object exports) {
     // This method is used to hook the accessor and method callbacks
     Napi::Function func = DefineClass(env, "Example", {
         InstanceMethod<&Example::GetValue>("GetValue"),
-        InstanceMethod<&Example::SetValue>("SetValue")
+        InstanceMethod<&Example::SetValue>("SetValue"),
+        StaticMethod<&Example::CreateNewItem>("CreateNewItem"),
     });
 
+    Napi::FunctionReference* constructor = new Napi::FunctionReference();
+
     // Create a peristent reference to the class constructor. This will allow
     // a function called on a class prototype and a function
     // called on instance of a class to be distinguished from each other.
-    constructor = Napi::Persistent(func);
-    // Call the SuppressDestruct() method on the static data prevent the calling
-    // to this destructor to reset the reference when the environment is no longer
-    // available.
-    constructor.SuppressDestruct();
+    *constructor = Napi::Persistent(func);
     exports.Set("Example", func);
+
+    // Store the constructor as the add-on instance data. This will allow this
+    // add-on to support multiple instances of itself running on multiple worker
+    // threads, as well as multiple instances of itself running in different
+    // contexts on the same thread.
+    //
+    // By default, the value set on the environment here will be destroyed when
+    // the add-on is unloaded using the `delete` operator, but it is also
+    // possible to supply a custom deleter.
+    env.SetInstanceData<Napi::FunctionReference>(constructor);
+
     return exports;
 }
 
-Example::Example(const Napi::CallbackInfo &info) : Napi::ObjectWrap<Example>(info) {
+Example::Example(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Example>(info) {
     Napi::Env env = info.Env();
     // ...
     Napi::Number value = info[0].As<Napi::Number>();
     this->_value = value.DoubleValue();
 }
 
-Napi::FunctionReference Example::constructor;
-
-Napi::Value Example::GetValue(const Napi::CallbackInfo &info){
+Napi::Value Example::GetValue(const Napi::CallbackInfo& info){
     Napi::Env env = info.Env();
     return Napi::Number::New(env, this->_value);
 }
 
-Napi::Value Example::SetValue(const Napi::CallbackInfo &info){
+Napi::Value Example::SetValue(const Napi::CallbackInfo& info){
     Napi::Env env = info.Env();
     // ...
     Napi::Number value = info[0].As<Napi::Number>();
@@ -78,6 +86,16 @@ Napi::Object Init (Napi::Env env, Napi::Object exports) {
     return exports;
 }
 
+// Create a new item using the constructor stored during Init.
+Napi::Value Example::CreateNewItem(const Napi::CallbackInfo& info) {
+  // Retrieve the instance data we stored during `Init()`. We only stored the
+  // constructor there, so we retrieve it here to create a new instance of the
+  // JS class the constructor represents.
+  Napi::FunctionReference* constructor =
+      info.Env().GetInstanceData<Napi::FunctionReference>();
+  return constructor->New({ Napi::Number::New(info.Env(), 42) });
+}
+
 // Register and initialize native add-on
 NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)
 ```
@@ -137,7 +155,7 @@ static T* Napi::ObjectWrap::Unwrap(Napi::Object wrapper);
 
 * `[in] wrapper`: The JavaScript object that wraps the native instance.
 
-Returns a native instace wrapped in a JavaScript object. Given the
+Returns a native instance wrapped in a JavaScript object. Given the
 Napi:Object, this allows a method to get a pointer to the wrapped
 C++ object and then reference fields, call methods, etc. within that class.
 In many cases calling Unwrap is not required, as methods can

index.js

@@ -1,8 +1,10 @@
 const path = require('path');
 
+const include = path.relative('.', __dirname);
+
 module.exports = {
-  include: `"${__dirname}"`,
-  gyp: path.join(__dirname, 'node_api.gyp:nothing'),
+  include: include,
+  gyp: path.join(include, 'node_api.gyp:nothing'),
   isNodeApiBuiltin: true,
   needsFlag: false
 };

napi-inl.h

@@ -138,7 +138,7 @@ struct FinalizeData {
   Hint* hint;
 };
 
-#if (NAPI_VERSION > 3)
+#if (NAPI_VERSION > 3 && !defined(__wasm32__))
 template <typename ContextType=void,
           typename Finalizer=std::function<void(Env, void*, ContextType*)>,
           typename FinalizerDataType=void>
@@ -234,8 +234,8 @@ napi_value DefaultCallbackWrapper(napi_env env, Napi::Function cb) {
   }
   return cb;
 }
-#endif
-#endif
+#endif  // NAPI_VERSION > 4
+#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
 
 template <typename Getter, typename Setter>
 struct AccessorCallbackData {
@@ -1779,8 +1779,14 @@ inline TypedArrayOf<T>::TypedArrayOf() : TypedArray(), _data(nullptr) {
 template <typename T>
 inline TypedArrayOf<T>::TypedArrayOf(napi_env env, napi_value value)
   : TypedArray(env, value), _data(nullptr) {
-  napi_status status = napi_get_typedarray_info(
-    _env, _value, &_type, &_length, reinterpret_cast<void**>(&_data), nullptr, nullptr);
+  napi_status status = napi_ok;
+  if (value != nullptr) {
+    status = napi_get_typedarray_info(
+      _env, _value, &_type, &_length, reinterpret_cast<void**>(&_data), nullptr, nullptr);
+  } else {
+    _type = TypedArrayTypeForPrimitiveType<T>();
+    _length = 0;
+  }
   NAPI_THROW_IF_FAILED_VOID(_env, status);
 }
 
@@ -3185,10 +3191,11 @@ inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
   napi_value wrapper = callbackInfo.This();
   napi_status status;
   napi_ref ref;
-  status = napi_wrap(env, wrapper, this, FinalizeCallback, nullptr, &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 = this;
+  Reference<Object>* instanceRef = instance;
   *instanceRef = Reference<Object>(env, ref);
 }
 
@@ -3911,7 +3918,7 @@ inline napi_value ObjectWrap<T>::InstanceSetterCallbackWrapper(
 
 template <typename T>
 inline void ObjectWrap<T>::FinalizeCallback(napi_env env, void* data, void* /*hint*/) {
-  ObjectWrap<T>* instance = static_cast<ObjectWrap<T>*>(data);
+  T* instance = static_cast<T*>(data);
   instance->Finalize(Napi::Env(env));
   delete instance;
 }
@@ -4334,7 +4341,7 @@ inline void AsyncWorker::OnWorkComplete(Napi::Env /*env*/, napi_status status) {
   }
 }
 
-#if (NAPI_VERSION > 3)
+#if (NAPI_VERSION > 3 && !defined(__wasm32__))
 ////////////////////////////////////////////////////////////////////////////////
 // ThreadSafeFunctionEx<ContextType,DataType,CallJs> class
 ////////////////////////////////////////////////////////////////////////////////
@@ -5358,7 +5365,7 @@ template<class T>
 inline void AsyncProgressQueueWorker<T>::ExecutionProgress::Send(const T* data, size_t count) const {
   _worker->SendProgress_(data, count);
 }
-#endif
+#endif  // NAPI_VERSION > 3 && !defined(__wasm32__)
 
 ////////////////////////////////////////////////////////////////////////////////
 // Memory Management class