koffi 2.12.1 → 2.12.2

package/vendor/node-addon-api/test/globalObject/global_object_get_property.cc

@@ -5,25 +5,25 @@ using namespace Napi;
 
 Value GetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
+  Name key = info[0].UnsafeAs<Name>();
   return MaybeUnwrap(globalObject.Get(key));
 }
 
 Value GetPropertyWithInt32AsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  Number key = info[0].As<Napi::Number>();
+  Number key = info[0].UnsafeAs<Napi::Number>();
   return MaybeUnwrapOr(globalObject.Get(key.Uint32Value()), Value());
 }
 
 Value GetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String cStrkey = info[0].As<String>();
+  String cStrkey = info[0].UnsafeAs<String>();
   return MaybeUnwrapOr(globalObject.Get(cStrkey.Utf8Value().c_str()), Value());
 }
 
 Value GetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String cppStrKey = info[0].As<String>();
+  String cppStrKey = info[0].UnsafeAs<String>();
   return MaybeUnwrapOr(globalObject.Get(cppStrKey.Utf8Value()), Value());
 }
 

package/vendor/node-addon-api/test/globalObject/global_object_has_own_property.cc

@@ -5,7 +5,7 @@ using namespace Napi;
 
 Value HasPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
+  String key = info[0].UnsafeAs<String>();
   return Boolean::New(
       info.Env(),
       MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value().c_str()),
@@ -14,7 +14,7 @@ Value HasPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
 
 Value HasPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
+  String key = info[0].UnsafeAs<String>();
   return Boolean::New(
       info.Env(),
       MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value()), false));
@@ -22,7 +22,7 @@ Value HasPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
 
 Value HasPropertyWithNapiValueAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
+  Name key = info[0].UnsafeAs<Name>();
   return Boolean::New(info.Env(),
                       MaybeUnwrap(globalObject.HasOwnProperty(key)));
 }

package/vendor/node-addon-api/test/globalObject/global_object_set_property.cc

@@ -4,28 +4,28 @@ using namespace Napi;
 
 void SetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
+  String key = info[0].UnsafeAs<String>();
   Value value = info[1];
   globalObject.Set(key.Utf8Value().c_str(), value);
 }
 
 void SetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  String key = info[0].As<String>();
+  String key = info[0].UnsafeAs<String>();
   Value value = info[1];
   globalObject.Set(key.Utf8Value(), value);
 }
 
 void SetPropertyWithInt32AsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  Number key = info[0].As<Number>();
+  Number key = info[0].UnsafeAs<Number>();
   Value value = info[1];
   globalObject.Set(key.Uint32Value(), value);
 }
 
 void SetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
   Object globalObject = info.Env().Global();
-  Name key = info[0].As<Name>();
+  Name key = info[0].UnsafeAs<Name>();
   Value value = info[1];
   globalObject.Set(key, value);
-}
+}

package/vendor/node-addon-api/test/name.cc

@@ -21,19 +21,21 @@ Value EchoString(const CallbackInfo& info) {
 
 Value CreateString(const CallbackInfo& info) {
   String encoding = info[0].As<String>();
-  Number length = info[1].As<Number>();
+  Value length = info[1];
 
   if (encoding.Utf8Value() == "utf8") {
     if (length.IsUndefined()) {
       return String::New(info.Env(), testValueUtf8);
     } else {
-      return String::New(info.Env(), testValueUtf8, length.Uint32Value());
+      return String::New(
+          info.Env(), testValueUtf8, length.As<Number>().Uint32Value());
     }
   } else if (encoding.Utf8Value() == "utf16") {
     if (length.IsUndefined()) {
       return String::New(info.Env(), testValueUtf16);
     } else {
-      return String::New(info.Env(), testValueUtf16, length.Uint32Value());
+      return String::New(
+          info.Env(), testValueUtf16, length.As<Number>().Uint32Value());
     }
   } else {
     Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
@@ -44,12 +46,12 @@ Value CreateString(const CallbackInfo& info) {
 Value CheckString(const CallbackInfo& info) {
   String value = info[0].As<String>();
   String encoding = info[1].As<String>();
-  Number length = info[2].As<Number>();
+  Value length = info[2];
 
   if (encoding.Utf8Value() == "utf8") {
     std::string testValue = testValueUtf8;
     if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.Uint32Value());
+      testValue = testValue.substr(0, length.As<Number>().Uint32Value());
     }
 
     std::string stringValue = value;
@@ -57,7 +59,7 @@ Value CheckString(const CallbackInfo& info) {
   } else if (encoding.Utf8Value() == "utf16") {
     std::u16string testValue = testValueUtf16;
     if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.Uint32Value());
+      testValue = testValue.substr(0, length.As<Number>().Uint32Value());
     }
 
     std::u16string stringValue = value;
@@ -69,10 +71,10 @@ Value CheckString(const CallbackInfo& info) {
 }
 
 Value CreateSymbol(const CallbackInfo& info) {
-  String description = info[0].As<String>();
+  Value description = info[0];
 
   if (!description.IsUndefined()) {
-    return Symbol::New(info.Env(), description);
+    return Symbol::New(info.Env(), description.As<String>());
   } else {
     return Symbol::New(info.Env());
   }

package/vendor/node-addon-api/test/object/delete_property.cc

@@ -4,13 +4,13 @@
 using namespace Napi;
 
 Value DeletePropertyWithUint32(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Number key = info[1].As<Number>();
   return Boolean::New(info.Env(), MaybeUnwrap(obj.Delete(key.Uint32Value())));
 }
 
 Value DeletePropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return Boolean::New(
       info.Env(),
@@ -18,20 +18,20 @@ Value DeletePropertyWithNapiValue(const CallbackInfo& info) {
 }
 
 Value DeletePropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Delete(key), false));
 }
 
 Value DeletePropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return Boolean::New(
       info.Env(), MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value().c_str()), false));
 }
 
 Value DeletePropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return Boolean::New(info.Env(),
                       MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value()), false));

package/vendor/node-addon-api/test/object/get_property.cc

@@ -4,31 +4,31 @@
 using namespace Napi;
 
 Value GetPropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return MaybeUnwrapOr(obj.Get(static_cast<napi_value>(key)), Value());
 }
 
 Value GetPropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return MaybeUnwrapOr(obj.Get(key), Value());
 }
 
 Value GetPropertyWithUint32(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Number key = info[1].As<Number>();
   return MaybeUnwrap(obj.Get(key.Uint32Value()));
 }
 
 Value GetPropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return MaybeUnwrapOr(obj.Get(jsKey.Utf8Value().c_str()), Value());
 }
 
 Value GetPropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return MaybeUnwrapOr(obj.Get(jsKey.Utf8Value()), Value());
 }

package/vendor/node-addon-api/test/object/has_own_property.cc

@@ -4,7 +4,7 @@
 using namespace Napi;
 
 Value HasOwnPropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return Boolean::New(
       info.Env(),
@@ -12,14 +12,14 @@ Value HasOwnPropertyWithNapiValue(const CallbackInfo& info) {
 }
 
 Value HasOwnPropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return Boolean::New(info.Env(),
                       MaybeUnwrapOr(obj.HasOwnProperty(key), false));
 }
 
 Value HasOwnPropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return Boolean::New(
       info.Env(),
@@ -27,7 +27,7 @@ Value HasOwnPropertyWithCStyleString(const CallbackInfo& info) {
 }
 
 Value HasOwnPropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return Boolean::New(
       info.Env(), MaybeUnwrapOr(obj.HasOwnProperty(jsKey.Utf8Value()), false));

package/vendor/node-addon-api/test/object/has_property.cc

@@ -4,34 +4,34 @@
 using namespace Napi;
 
 Value HasPropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return Boolean::New(
       info.Env(), MaybeUnwrapOr(obj.Has(static_cast<napi_value>(key)), false));
 }
 
 Value HasPropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Has(key), false));
 }
 
 Value HasPropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return Boolean::New(info.Env(),
                       MaybeUnwrapOr(obj.Has(jsKey.Utf8Value().c_str()), false));
 }
 
 Value HasPropertyWithUint32(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Number jsKey = info[1].As<Number>();
   return Boolean::New(info.Env(),
                       MaybeUnwrapOr(obj.Has(jsKey.Uint32Value()), false));
 }
 
 Value HasPropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   return Boolean::New(info.Env(),
                       MaybeUnwrapOr(obj.Has(jsKey.Utf8Value()), false));

package/vendor/node-addon-api/test/object/object.cc

@@ -338,7 +338,7 @@ void Increment(const CallbackInfo& info) {
 #endif  // NAPI_CPP_EXCEPTIONS
 
 Value InstanceOf(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Function constructor = info[1].As<Function>();
   return Boolean::New(info.Env(), MaybeUnwrap(obj.InstanceOf(constructor)));
 }

package/vendor/node-addon-api/test/object/set_property.cc

@@ -4,7 +4,7 @@
 using namespace Napi;
 
 Value SetPropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   Value value = info[2];
   return Boolean::New(
@@ -13,14 +13,14 @@ Value SetPropertyWithNapiValue(const CallbackInfo& info) {
 }
 
 Value SetPropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Name key = info[1].As<Name>();
   Value value = info[2];
   return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Set(key, value), false));
 }
 
 Value SetPropertyWithUint32(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   Number key = info[1].As<Number>();
   Value value = info[2];
   return Boolean::New(info.Env(),
@@ -28,7 +28,7 @@ Value SetPropertyWithUint32(const CallbackInfo& info) {
 }
 
 Value SetPropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   Value value = info[2];
   return Boolean::New(
@@ -37,7 +37,7 @@ Value SetPropertyWithCStyleString(const CallbackInfo& info) {
 }
 
 Value SetPropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
+  Object obj = info[0].UnsafeAs<Object>();
   String jsKey = info[1].As<String>();
   Value value = info[2];
   return Boolean::New(info.Env(),

package/vendor/node-addon-api/test/object/subscript_operator.cc

@@ -8,7 +8,7 @@ Value SubscriptGetWithCStyleString(const CallbackInfo& info) {
 
   // make sure const case compiles
   const Object obj2 = info[0].As<Object>();
-  MaybeUnwrap(obj2[jsKey.Utf8Value().c_str()]).As<Boolean>();
+  MaybeUnwrap(obj2[jsKey.Utf8Value().c_str()]).As<Value>();
 
   Object obj = info[0].As<Object>();
   return obj[jsKey.Utf8Value().c_str()];
@@ -19,7 +19,7 @@ Value SubscriptGetWithCppStyleString(const CallbackInfo& info) {
 
   // make sure const case compiles
   const Object obj2 = info[0].As<Object>();
-  MaybeUnwrap(obj2[jsKey.Utf8Value()]).As<Boolean>();
+  MaybeUnwrap(obj2[jsKey.Utf8Value()]).As<Value>();
 
   Object obj = info[0].As<Object>();
   return obj[jsKey.Utf8Value()];
@@ -30,7 +30,7 @@ Value SubscriptGetAtIndex(const CallbackInfo& info) {
 
   // make sure const case compiles
   const Object obj2 = info[0].As<Object>();
-  MaybeUnwrap(obj2[index]).As<Boolean>();
+  MaybeUnwrap(obj2[index]).As<Value>();
 
   Object obj = info[0].As<Object>();
   return obj[index];

package/vendor/node-addon-api/test/object_reference.cc

@@ -224,13 +224,13 @@ void SetCastedObjects(const CallbackInfo& info) {
 Value GetFromValue(const CallbackInfo& info) {
   Env env = info.Env();
 
-  if (info[0].As<String>() == String::New(env, "weak")) {
+  if (info[0] == String::New(env, "weak")) {
     if (weak.IsEmpty()) {
       return String::New(env, "No Referenced Value");
     } else {
       return weak.Value();
     }
-  } else if (info[0].As<String>() == String::New(env, "persistent")) {
+  } else if (info[0] == String::New(env, "persistent")) {
     return persistent.Value();
   } else {
     return reference.Value();
@@ -290,7 +290,7 @@ Value GetFromGetters(const CallbackInfo& info) {
 Value GetFromGetter(const CallbackInfo& info) {
   Env env = info.Env();
 
-  if (info[0].As<String>() == String::New(env, "weak")) {
+  if (info[0] == String::New(env, "weak")) {
     if (weak.IsEmpty()) {
       return String::New(env, "No Referenced Value");
     } else {
@@ -300,7 +300,7 @@ Value GetFromGetter(const CallbackInfo& info) {
         return MaybeUnwrap(weak.Get(info[1].As<Number>().Uint32Value()));
       }
     }
-  } else if (info[0].As<String>() == String::New(env, "persistent")) {
+  } else if (info[0] == String::New(env, "persistent")) {
     if (info[1].IsString()) {
       return MaybeUnwrap(persistent.Get(info[1].As<String>().Utf8Value()));
     } else if (info[1].IsNumber()) {
@@ -322,13 +322,13 @@ Value GetFromGetter(const CallbackInfo& info) {
 Value GetCastedFromValue(const CallbackInfo& info) {
   Env env = info.Env();
 
-  if (info[0].As<String>() == String::New(env, "weak")) {
+  if (info[0] == String::New(env, "weak")) {
     if (casted_weak.IsEmpty()) {
       return String::New(env, "No Referenced Value");
     } else {
       return casted_weak.Value();
     }
-  } else if (info[0].As<String>() == String::New(env, "persistent")) {
+  } else if (info[0] == String::New(env, "persistent")) {
     return casted_persistent.Value();
   } else {
     return casted_reference.Value();
@@ -341,13 +341,13 @@ Value GetCastedFromValue(const CallbackInfo& info) {
 Value GetCastedFromGetter(const CallbackInfo& info) {
   Env env = info.Env();
 
-  if (info[0].As<String>() == String::New(env, "weak")) {
+  if (info[0] == String::New(env, "weak")) {
     if (casted_weak.IsEmpty()) {
       return String::New(env, "No Referenced Value");
     } else {
       return MaybeUnwrap(casted_weak.Get(info[1].As<Number>()));
     }
-  } else if (info[0].As<String>() == String::New(env, "persistent")) {
+  } else if (info[0] == String::New(env, "persistent")) {
     return MaybeUnwrap(casted_persistent.Get(info[1].As<Number>()));
   } else {
     return MaybeUnwrap(casted_reference.Get(info[1].As<Number>()));
@@ -360,15 +360,15 @@ Number UnrefObjects(const CallbackInfo& info) {
   Env env = info.Env();
   uint32_t num;
 
-  if (info[0].As<String>() == String::New(env, "weak")) {
+  if (info[0] == String::New(env, "weak")) {
     num = weak.Unref();
-  } else if (info[0].As<String>() == String::New(env, "persistent")) {
+  } else if (info[0] == String::New(env, "persistent")) {
     num = persistent.Unref();
-  } else if (info[0].As<String>() == String::New(env, "references")) {
+  } else if (info[0] == String::New(env, "references")) {
     num = reference.Unref();
-  } else if (info[0].As<String>() == String::New(env, "casted weak")) {
+  } else if (info[0] == String::New(env, "casted weak")) {
     num = casted_weak.Unref();
-  } else if (info[0].As<String>() == String::New(env, "casted persistent")) {
+  } else if (info[0] == String::New(env, "casted persistent")) {
     num = casted_persistent.Unref();
   } else {
     num = casted_reference.Unref();
@@ -383,15 +383,15 @@ Number RefObjects(const CallbackInfo& info) {
   Env env = info.Env();
   uint32_t num;
 
-  if (info[0].As<String>() == String::New(env, "weak")) {
+  if (info[0] == String::New(env, "weak")) {
     num = weak.Ref();
-  } else if (info[0].As<String>() == String::New(env, "persistent")) {
+  } else if (info[0] == String::New(env, "persistent")) {
     num = persistent.Ref();
-  } else if (info[0].As<String>() == String::New(env, "references")) {
+  } else if (info[0] == String::New(env, "references")) {
     num = reference.Ref();
-  } else if (info[0].As<String>() == String::New(env, "casted weak")) {
+  } else if (info[0] == String::New(env, "casted weak")) {
     num = casted_weak.Ref();
-  } else if (info[0].As<String>() == String::New(env, "casted persistent")) {
+  } else if (info[0] == String::New(env, "casted persistent")) {
     num = casted_persistent.Ref();
   } else {
     num = casted_reference.Ref();

package/vendor/node-addon-api/test/promise.cc

@@ -1,4 +1,5 @@
 #include "napi.h"
+#include "test_helper.h"
 
 using namespace Napi;
 
@@ -23,6 +24,74 @@ Value PromiseReturnsCorrectEnv(const CallbackInfo& info) {
   return Boolean::New(info.Env(), deferred.Env() == info.Env());
 }
 
+Value ThenMethodOnFulfilled(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  Function onFulfilled = info[0].As<Function>();
+
+  Promise resultPromise = MaybeUnwrap(deferred.Promise().Then(onFulfilled));
+
+  bool isPromise = resultPromise.IsPromise();
+  deferred.Resolve(Number::New(info.Env(), 42));
+
+  Object result = Object::New(info.Env());
+  result["isPromise"] = Boolean::New(info.Env(), isPromise);
+  result["promise"] = resultPromise;
+
+  return result;
+}
+
+Value ThenMethodOnFulfilledOnRejectedResolve(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  Function onFulfilled = info[0].As<Function>();
+  Function onRejected = info[1].As<Function>();
+
+  Promise resultPromise =
+      MaybeUnwrap(deferred.Promise().Then(onFulfilled, onRejected));
+
+  bool isPromise = resultPromise.IsPromise();
+  deferred.Resolve(Number::New(info.Env(), 42));
+
+  Object result = Object::New(info.Env());
+  result["isPromise"] = Boolean::New(info.Env(), isPromise);
+  result["promise"] = resultPromise;
+
+  return result;
+}
+
+Value ThenMethodOnFulfilledOnRejectedReject(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  Function onFulfilled = info[0].As<Function>();
+  Function onRejected = info[1].As<Function>();
+
+  Promise resultPromise =
+      MaybeUnwrap(deferred.Promise().Then(onFulfilled, onRejected));
+
+  bool isPromise = resultPromise.IsPromise();
+  deferred.Reject(String::New(info.Env(), "Rejected"));
+
+  Object result = Object::New(info.Env());
+  result["isPromise"] = Boolean::New(info.Env(), isPromise);
+  result["promise"] = resultPromise;
+
+  return result;
+}
+
+Value CatchMethod(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  Function onRejected = info[0].As<Function>();
+
+  Promise resultPromise = MaybeUnwrap(deferred.Promise().Catch(onRejected));
+
+  bool isPromise = resultPromise.IsPromise();
+  deferred.Reject(String::New(info.Env(), "Rejected"));
+
+  Object result = Object::New(info.Env());
+  result["isPromise"] = Boolean::New(info.Env(), isPromise);
+  result["promise"] = resultPromise;
+
+  return result;
+}
+
 Object InitPromise(Env env) {
   Object exports = Object::New(env);
 
@@ -31,6 +100,12 @@ Object InitPromise(Env env) {
   exports["rejectPromise"] = Function::New(env, RejectPromise);
   exports["promiseReturnsCorrectEnv"] =
       Function::New(env, PromiseReturnsCorrectEnv);
+  exports["thenMethodOnFulfilled"] = Function::New(env, ThenMethodOnFulfilled);
+  exports["thenMethodOnFulfilledOnRejectedResolve"] =
+      Function::New(env, ThenMethodOnFulfilledOnRejectedResolve);
+  exports["thenMethodOnFulfilledOnRejectedReject"] =
+      Function::New(env, ThenMethodOnFulfilledOnRejectedReject);
+  exports["catchMethod"] = Function::New(env, CatchMethod);
 
   return exports;
 }

package/vendor/node-addon-api/test/promise.js

@@ -17,4 +17,27 @@ async function test (binding) {
   rejecting.then(common.mustNotCall()).catch(common.mustCall());
 
   assert(binding.promise.promiseReturnsCorrectEnv());
+
+  const onFulfilled = (value) => value * 2;
+  const onRejected = (reason) => reason + '!';
+
+  const thenOnFulfilled = binding.promise.thenMethodOnFulfilled(onFulfilled);
+  assert.strictEqual(thenOnFulfilled.isPromise, true);
+  const onFulfilledValue = await thenOnFulfilled.promise;
+  assert.strictEqual(onFulfilledValue, 84);
+
+  const thenResolve = binding.promise.thenMethodOnFulfilledOnRejectedResolve(onFulfilled, onRejected);
+  assert.strictEqual(thenResolve.isPromise, true);
+  const thenResolveValue = await thenResolve.promise;
+  assert.strictEqual(thenResolveValue, 84);
+
+  const thenRejected = binding.promise.thenMethodOnFulfilledOnRejectedReject(onFulfilled, onRejected);
+  assert.strictEqual(thenRejected.isPromise, true);
+  const rejectedValue = await thenRejected.promise;
+  assert.strictEqual(rejectedValue, 'Rejected!');
+
+  const catchMethod = binding.promise.catchMethod(onRejected);
+  assert.strictEqual(catchMethod.isPromise, true);
+  const catchValue = await catchMethod.promise;
+  assert.strictEqual(catchValue, 'Rejected!');
 }

package/vendor/node-addon-api/test/require_basic_finalizers/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const { promisify } = require('util');
+const exec = promisify(require('child_process').exec);
+const { copy, remove } = require('fs-extra');
+const path = require('path');
+const assert = require('assert');
+
+async function test () {
+  const addon = 'require-basic-finalizers';
+  const ADDON_FOLDER = path.join(__dirname, 'addons', addon);
+
+  await remove(ADDON_FOLDER);
+  await copy(path.join(__dirname, 'tpl'), ADDON_FOLDER);
+
+  console.log('   >Building addon');
+
+  // Fail when NODE_ADDON_API_REQUIRE_BASIC_FINALIZERS is enabled
+  await assert.rejects(exec('npm --require-basic-finalizers install', {
+    cwd: ADDON_FOLDER
+  }), 'Addon unexpectedly compiled successfully');
+
+  // Succeed when NODE_ADDON_API_REQUIRE_BASIC_FINALIZERS is not enabled
+  return assert.doesNotReject(exec('npm install', {
+    cwd: ADDON_FOLDER
+  }));
+}
+
+module.exports = (function () {
+  // This test will only run under an experimental version test.
+  const isExperimental = Number(process.env.NAPI_VERSION) === 2147483647;
+
+  if (isExperimental) {
+    return test();
+  } else {
+    console.log('   >Skipped (non-experimental test run)');
+  }
+})();

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/addon.cc

@@ -0,0 +1,12 @@
+#include <napi.h>
+
+Napi::Object Init(Napi::Env env, Napi::Object exports) {
+  exports.Set(
+      "external",
+      Napi::External<int>::New(
+          env, new int(1), [](Napi::Env /*env*/, int* data) { delete data; }));
+
+  return exports;
+}
+
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)