koffi 2.3.17 → 2.3.19

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

@@ -16,7 +16,37 @@ const testUtil = require('./testUtil');
 
 module.exports = require('./common').runTest(test);
 
+const enumType = {
+  JS: 0, // Napi::Value
+  C_STR: 1, // const char *
+  CPP_STR: 2, // std::string
+  BOOL: 3, // bool
+  INT: 4, // uint32_t
+  DOUBLE: 5, // double
+  JS_CAST: 6 // napi_value
+};
+
+const configObjects = [
+  { keyType: enumType.C_STR, valType: enumType.JS, key: 'hello', val: 'worlds' },
+  { keyType: enumType.C_STR, valType: enumType.C_STR, key: 'hello', val: 'worldd' },
+  { keyType: enumType.C_STR, valType: enumType.BOOL, key: 'hello', val: false },
+  { keyType: enumType.C_STR, valType: enumType.DOUBLE, key: 'hello', val: 3.56 },
+  { keyType: enumType.C_STR, valType: enumType.JS_CAST, key: 'hello_cast', val: 'world' },
+  { keyType: enumType.CPP_STR, valType: enumType.JS, key: 'hello_cpp', val: 'world_js' },
+  { keyType: enumType.CPP_STR, valType: enumType.JS_CAST, key: 'hello_cpp', val: 'world_js_cast' },
+  { keyType: enumType.CPP_STR, valType: enumType.CPP_STR, key: 'hello_cpp', val: 'world_cpp_str' },
+  { keyType: enumType.CPP_STR, valType: enumType.BOOL, key: 'hello_cpp', val: true },
+  { keyType: enumType.CPP_STR, valType: enumType.DOUBLE, key: 'hello_cpp', val: 3.58 },
+  { keyType: enumType.INT, valType: enumType.JS, key: 1, val: 'hello world' },
+  { keyType: enumType.INT, valType: enumType.JS_CAST, key: 2, val: 'hello world' },
+  { keyType: enumType.INT, valType: enumType.C_STR, key: 3, val: 'hello world' },
+  { keyType: enumType.INT, valType: enumType.CPP_STR, key: 8, val: 'hello world' },
+  { keyType: enumType.INT, valType: enumType.BOOL, key: 3, val: false },
+  { keyType: enumType.INT, valType: enumType.DOUBLE, key: 4, val: 3.14159 }
+];
+
 function test (binding) {
+  binding.objectreference.moveOpTest();
   function testCastedEqual (testToCompare) {
     const compareTest = ['hello', 'world', '!'];
     if (testToCompare instanceof Array) {
@@ -74,45 +104,32 @@ function test (binding) {
 
     'Weak',
     () => {
-      binding.objectreference.setObjects('hello', 'world');
-      const test = binding.objectreference.getFromValue('weak');
-      const test2 = binding.objectreference.getFromGetter('weak', 'hello');
+      for (const configObject of configObjects) {
+        binding.objectreference.setObject(configObject);
+        const test = binding.objectreference.getFromValue('weak');
+        const test2 = binding.objectreference.getFromGetters('weak', configObject);
 
-      assert.deepEqual({ hello: 'world' }, test);
-      assert.equal('world', test2);
-      assert.equal(test.hello, test2);
-    },
-    () => {
-      binding.objectreference.setObjects('hello', 'world', 'javascript');
-      const test = binding.objectreference.getFromValue('weak');
-      const test2 = binding.objectreference.getFromValue('weak', 'hello');
+        const assertObject = {
+          [configObject.key]: configObject.val
+        };
+        assert.deepEqual(assertObject, test);
+        assert.equal(configObject.val, test2);
+      }
+    }, () => {
+      const configObjA = { keyType: enumType.INT, valType: enumType.JS, key: 0, val: 'hello' };
+      const configObjB = { keyType: enumType.INT, valType: enumType.JS, key: 1, val: 'world' };
+      binding.objectreference.setObject(configObjA);
+      binding.objectreference.setObject(configObjB);
 
-      assert.deepEqual({ hello: 'world' }, test);
-      assert.deepEqual({ hello: 'world' }, test2);
-      assert.equal(test, test2);
-    },
-    () => {
-      binding.objectreference.setObjects(1, 'hello world');
-      const test = binding.objectreference.getFromValue('weak');
-      const test2 = binding.objectreference.getFromGetter('weak', 1);
-
-      assert.deepEqual({ 1: 'hello world' }, test);
-      assert.equal('hello world', test2);
-      assert.equal(test[1], test2);
-    },
-    () => {
-      binding.objectreference.setObjects(0, 'hello');
-      binding.objectreference.setObjects(1, 'world');
       const test = binding.objectreference.getFromValue('weak');
-      const test2 = binding.objectreference.getFromGetter('weak', 0);
-      const test3 = binding.objectreference.getFromGetter('weak', 1);
-
+      const test2 = binding.objectreference.getFromGetters('weak', configObjA);
+      const test3 = binding.objectreference.getFromGetters('weak', configObjB);
       assert.deepEqual({ 1: 'world' }, test);
       assert.equal(undefined, test2);
       assert.equal('world', test3);
     },
     () => {
-      binding.objectreference.setObjects('hello', 'world');
+      binding.objectreference.setObject({ keyType: enumType.JS, valType: enumType.JS, key: 'hello', val: 'world' });
       assert.doesNotThrow(
         () => {
           let rcount = binding.objectreference.refObjects('weak');
@@ -132,16 +149,20 @@ function test (binding) {
 
     'Persistent',
     () => {
-      binding.objectreference.setObjects('hello', 'world');
-      const test = binding.objectreference.getFromValue('persistent');
-      const test2 = binding.objectreference.getFromGetter('persistent', 'hello');
+      for (const configObject of configObjects) {
+        binding.objectreference.setObject(configObject);
+        const test = binding.objectreference.getFromValue('persistent');
+        const test2 = binding.objectreference.getFromGetters('persistent', configObject);
+        const assertObject = {
+          [configObject.key]: configObject.val
+        };
 
-      assert.deepEqual({ hello: 'world' }, test);
-      assert.equal('world', test2);
-      assert.equal(test.hello, test2);
+        assert.deepEqual(assertObject, test);
+        assert.equal(configObject.val, test2);
+      }
     },
     () => {
-      binding.objectreference.setObjects('hello', 'world', 'javascript');
+      binding.objectreference.setObject({ keyType: enumType.CPP_STR, valType: enumType.JS, key: 'hello', val: 'world' });
       const test = binding.objectreference.getFromValue('persistent');
       const test2 = binding.objectreference.getFromValue('persistent', 'hello');
 
@@ -150,27 +171,21 @@ function test (binding) {
       assert.deepEqual(test, test2);
     },
     () => {
-      binding.objectreference.setObjects(1, 'hello world');
-      const test = binding.objectreference.getFromValue('persistent');
-      const test2 = binding.objectreference.getFromGetter('persistent', 1);
+      const configObjA = { keyType: enumType.INT, valType: enumType.JS, key: 0, val: 'hello' };
+      const configObjB = { keyType: enumType.INT, valType: enumType.JS, key: 1, val: 'world' };
+      binding.objectreference.setObject(configObjA);
+      binding.objectreference.setObject(configObjB);
 
-      assert.deepEqual({ 1: 'hello world' }, test);
-      assert.equal('hello world', test2);
-      assert.equal(test[1], test2);
-    },
-    () => {
-      binding.objectreference.setObjects(0, 'hello');
-      binding.objectreference.setObjects(1, 'world');
       const test = binding.objectreference.getFromValue('persistent');
-      const test2 = binding.objectreference.getFromGetter('persistent', 0);
-      const test3 = binding.objectreference.getFromGetter('persistent', 1);
+      const test2 = binding.objectreference.getFromGetters('persistent', configObjA);
+      const test3 = binding.objectreference.getFromGetters('persistent', configObjB);
 
       assert.deepEqual({ 1: 'world' }, test);
       assert.equal(undefined, test2);
       assert.equal('world', test3);
     },
     () => {
-      binding.objectreference.setObjects('hello', 'world');
+      binding.objectreference.setObject({ keyType: enumType.CPP_STR, valType: enumType.JS, key: 'hello', val: 'world' });
       assert.doesNotThrow(
         () => {
           let rcount = binding.objectreference.unrefObjects('persistent');
@@ -196,45 +211,33 @@ function test (binding) {
 
     'References',
     () => {
-      binding.objectreference.setObjects('hello', 'world');
-      const test = binding.objectreference.getFromValue();
-      const test2 = binding.objectreference.getFromGetter('hello');
-
-      assert.deepEqual({ hello: 'world' }, test);
-      assert.equal('world', test2);
-      assert.equal(test.hello, test2);
+      for (const configObject of configObjects) {
+        binding.objectreference.setObject(configObject);
+        const test = binding.objectreference.getFromValue();
+        const test2 = binding.objectreference.getFromGetters('reference', configObject);
+        const assertObject = {
+          [configObject.key]: configObject.val
+        };
+        assert.deepEqual(assertObject, test);
+        assert.equal(configObject.val, test2);
+      }
     },
     () => {
-      binding.objectreference.setObjects('hello', 'world', 'javascript');
+      const configObjA = { keyType: enumType.INT, valType: enumType.JS, key: 0, val: 'hello' };
+      const configObjB = { keyType: enumType.INT, valType: enumType.JS, key: 1, val: 'world' };
+      binding.objectreference.setObject(configObjA);
+      binding.objectreference.setObject(configObjB);
       const test = binding.objectreference.getFromValue();
-      const test2 = binding.objectreference.getFromValue('hello');
 
-      assert.deepEqual({ hello: 'world' }, test);
-      assert.deepEqual({ hello: 'world' }, test2);
-      assert.deepEqual(test, test2);
-    },
-    () => {
-      binding.objectreference.setObjects(1, 'hello world');
-      const test = binding.objectreference.getFromValue();
-      const test2 = binding.objectreference.getFromGetter(1);
-
-      assert.deepEqual({ 1: 'hello world' }, test);
-      assert.equal('hello world', test2);
-      assert.equal(test[1], test2);
-    },
-    () => {
-      binding.objectreference.setObjects(0, 'hello');
-      binding.objectreference.setObjects(1, 'world');
-      const test = binding.objectreference.getFromValue();
-      const test2 = binding.objectreference.getFromGetter(0);
-      const test3 = binding.objectreference.getFromGetter(1);
+      const test2 = binding.objectreference.getFromGetters('reference', configObjA);
+      const test3 = binding.objectreference.getFromGetters('reference', configObjB);
 
       assert.deepEqual({ 1: 'world' }, test);
       assert.equal(undefined, test2);
       assert.equal('world', test3);
     },
     () => {
-      binding.objectreference.setObjects('hello', 'world');
+      binding.objectreference.setObject({ keyType: enumType.CPP_STR, valType: enumType.JS, key: 'hello', val: 'world' });
       assert.doesNotThrow(
         () => {
           let rcount = binding.objectreference.unrefObjects('references');

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

@@ -12,6 +12,10 @@ void StaticSetter(const Napi::CallbackInfo& /*info*/,
   testStaticContextRef.Value().Set("value", value);
 }
 
+void StaticMethodVoidCb(const Napi::CallbackInfo& info) {
+  StaticSetter(info, info[0].As<Napi::Number>());
+}
+
 Napi::Value TestStaticMethod(const Napi::CallbackInfo& info) {
   std::string str = MaybeUnwrap(info[0].ToString());
   return Napi::String::New(info.Env(), str + " static");
@@ -53,6 +57,15 @@ class Test : public Napi::ObjectWrap<Test> {
     return static_cast<Test*>(info.Data())->Getter(info);
   }
 
+  static Napi::Value CanUnWrap(const Napi::CallbackInfo& info) {
+    Napi::Object wrappedObject = info[0].As<Napi::Object>();
+    std::string expectedString = info[1].As<Napi::String>();
+    Test* nativeObject = Test::Unwrap(wrappedObject);
+    std::string strVal = MaybeUnwrap(nativeObject->Getter(info).ToString());
+
+    return Napi::Boolean::New(info.Env(), strVal == expectedString);
+  }
+
   void Setter(const Napi::CallbackInfo& /*info*/, const Napi::Value& value) {
     value_ = MaybeUnwrap(value.ToString());
   }
@@ -115,7 +128,8 @@ class Test : public Napi::ObjectWrap<Test> {
         Napi::Symbol::New(env, "kTestStaticMethodTInternal");
     Napi::Symbol kTestStaticVoidMethodTInternal =
         Napi::Symbol::New(env, "kTestStaticVoidMethodTInternal");
-
+    Napi::Symbol kTestStaticVoidMethodInternal =
+        Napi::Symbol::New(env, "kTestStaticVoidMethodInternal");
     Napi::Symbol kTestValueInternal =
         Napi::Symbol::New(env, "kTestValueInternal");
     Napi::Symbol kTestAccessorInternal =
@@ -147,6 +161,8 @@ class Test : public Napi::ObjectWrap<Test> {
                             kTestStaticMethodInternal),
                 StaticValue("kTestStaticMethodTInternal",
                             kTestStaticMethodTInternal),
+                StaticValue("kTestStaticVoidMethodInternal",
+                            kTestStaticVoidMethodInternal),
                 StaticValue("kTestStaticVoidMethodTInternal",
                             kTestStaticVoidMethodTInternal),
                 StaticValue("kTestValueInternal", kTestValueInternal),
@@ -184,7 +200,11 @@ class Test : public Napi::ObjectWrap<Test> {
                     "testStaticGetSetT"),
                 StaticAccessor<&StaticGetter, &StaticSetter>(
                     kTestStaticAccessorTInternal),
-
+                StaticMethod(
+                    "testStaticVoidMethod", &StaticMethodVoidCb, napi_default),
+                StaticMethod(kTestStaticVoidMethodInternal,
+                             &StaticMethodVoidCb,
+                             napi_default),
                 StaticMethod(
                     "testStaticMethod", &TestStaticMethod, napi_enumerable),
                 StaticMethod(kTestStaticMethodInternal,
@@ -195,7 +215,7 @@ class Test : public Napi::ObjectWrap<Test> {
                 StaticMethod<&TestStaticVoidMethodT>(
                     kTestStaticVoidMethodTInternal),
                 StaticMethod<&TestStaticMethodT>(kTestStaticMethodTInternal),
-
+                StaticMethod("canUnWrap", &CanUnWrap, napi_enumerable),
                 InstanceValue("testValue",
                               Napi::Boolean::New(env, true),
                               napi_enumerable),

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

@@ -210,6 +210,10 @@ async function test (binding) {
   };
 
   const testStaticMethod = (clazz) => {
+    clazz.testStaticVoidMethod(52);
+    assert.strictEqual(clazz.testStaticGetter, 52);
+    clazz[clazz.kTestStaticVoidMethodInternal](94);
+    assert.strictEqual(clazz.testStaticGetter, 94);
     assert.strictEqual(clazz.testStaticMethod('method'), 'method static');
     assert.strictEqual(clazz[clazz.kTestStaticMethodInternal]('method'), 'method static internal');
     clazz.testStaticVoidMethodT('static method<>(const char*)');
@@ -224,7 +228,8 @@ async function test (binding) {
       'testStaticValue',
       'testStaticGetter',
       'testStaticGetSet',
-      'testStaticMethod'
+      'testStaticMethod',
+      'canUnWrap'
     ]);
 
     // for..in
@@ -238,7 +243,8 @@ async function test (binding) {
         'testStaticValue',
         'testStaticGetter',
         'testStaticGetSet',
-        'testStaticMethod'
+        'testStaticMethod',
+        'canUnWrap'
       ]);
     }
   };
@@ -260,6 +266,11 @@ async function test (binding) {
     ]);
   }
 
+  const testUnwrap = (obj, clazz) => {
+    obj.testSetter = 'unwrapTest';
+    assert(clazz.canUnWrap(obj, 'unwrapTest'));
+  };
+
   const testObj = (obj, clazz) => {
     testValue(obj, clazz);
     testAccessor(obj, clazz);
@@ -268,6 +279,7 @@ async function test (binding) {
     testEnumerables(obj, clazz);
 
     testConventions(obj, clazz);
+    testUnwrap(obj, clazz);
   };
 
   async function testClass (clazz) {

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

@@ -1,9 +1,60 @@
+#include "assert.h"
 #include "napi.h"
-
+#include "test_helper.h"
 using namespace Napi;
 
 static Reference<Buffer<uint8_t>> weak;
 
+static void RefMoveAssignTests(const Napi::CallbackInfo& info) {
+  Napi::Object obj = Napi::Object::New(info.Env());
+  obj.Set("tPro", "tTEST");
+  Napi::Reference<Napi::Object> ref = Napi::Reference<Napi::Object>::New(obj);
+  ref.SuppressDestruct();
+
+  napi_ref obj_ref = static_cast<napi_ref>(ref);
+  Napi::Reference<Napi::Object> existingRef =
+      Napi::Reference<Napi::Object>(info.Env(), obj_ref);
+  assert(ref == existingRef);
+  assert(!(ref != existingRef));
+
+  std::string val =
+      MaybeUnwrap(existingRef.Value().Get("tPro")).As<Napi::String>();
+  assert(val == "tTEST");
+  // ------------------------------------------------------------ //
+  Napi::Reference<Napi::Object> copyMoveRef = std::move(existingRef);
+  assert(copyMoveRef == ref);
+
+  Napi::Reference<Napi::Object> copyAssignRef;
+  copyAssignRef = std::move(copyMoveRef);
+  assert(copyAssignRef == ref);
+}
+
+static void ReferenceRefTests(const Napi::CallbackInfo& info) {
+  Napi::Object obj = Napi::Object::New(info.Env());
+  Napi::Reference<Napi::Object> ref = Napi::Reference<Napi::Object>::New(obj);
+
+  assert(ref.Ref() == 1);
+  assert(ref.Unref() == 0);
+}
+
+static void ReferenceResetTests(const Napi::CallbackInfo& info) {
+  Napi::Object obj = Napi::Object::New(info.Env());
+  Napi::Reference<Napi::Object> ref = Napi::Reference<Napi::Object>::New(obj);
+  assert(!ref.IsEmpty());
+
+  ref.Reset();
+  assert(ref.IsEmpty());
+
+  Napi::Object newObject = Napi::Object::New(info.Env());
+  newObject.Set("n-api", "node");
+
+  ref.Reset(newObject, 1);
+  assert(!ref.IsEmpty());
+
+  std::string val = MaybeUnwrap(ref.Value().Get("n-api")).As<Napi::String>();
+  assert(val == "node");
+}
+
 void CreateWeakArray(const CallbackInfo& info) {
   weak = Weak(Buffer<uint8_t>::New(info.Env(), 1));
   weak.SuppressDestruct();
@@ -20,5 +71,8 @@ Object InitReference(Env env) {
   exports["createWeakArray"] = Function::New(env, CreateWeakArray);
   exports["accessWeakArrayEmpty"] = Function::New(env, AccessWeakArrayEmpty);
 
+  exports["refMoveAssignTest"] = Function::New(env, RefMoveAssignTests);
+  exports["referenceRefTest"] = Function::New(env, ReferenceRefTests);
+  exports["refResetTest"] = Function::New(env, ReferenceResetTests);
   return exports;
 }

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

@@ -9,6 +9,12 @@ function test (binding) {
   return testUtil.runGCTests([
     'test reference',
     () => binding.reference.createWeakArray(),
-    () => assert.strictEqual(true, binding.reference.accessWeakArrayEmpty())
+    () => assert.strictEqual(true, binding.reference.accessWeakArrayEmpty()),
+    'test reference move op',
+    () => binding.reference.refMoveAssignTest(),
+    'test reference ref',
+    () => binding.reference.referenceRefTest(),
+    'test reference reset',
+    () => binding.reference.refResetTest()
   ]);
 }

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

@@ -0,0 +1,66 @@
+#include "napi.h"
+
+#if (NAPI_VERSION > 7)
+
+using namespace Napi;
+
+static const napi_type_tag type_tags[5] = {
+    {0xdaf987b3cc62481a, 0xb745b0497f299531},
+    {0xbb7936c374084d9b, 0xa9548d0762eeedb9},
+    {0xa5ed9ce2e4c00c38, 0},
+    {0, 0},
+    {0xa5ed9ce2e4c00c38, 0xdaf987b3cc62481a},
+};
+
+template <TypeTaggable Factory(Env), typename NodeApiClass>
+class TestTypeTaggable {
+ public:
+  static Value TypeTaggedInstance(const CallbackInfo& info) {
+    TypeTaggable instance = Factory(info.Env());
+    uint32_t type_index = info[0].As<Number>().Int32Value();
+
+    instance.TypeTag(&type_tags[type_index]);
+
+    return instance;
+  }
+
+  static Value CheckTypeTag(const CallbackInfo& info) {
+    uint32_t type_index = info[0].As<Number>().Int32Value();
+    TypeTaggable instance = info[1].As<NodeApiClass>();
+
+    return Boolean::New(info.Env(),
+                        instance.CheckTypeTag(&type_tags[type_index]));
+  }
+};
+
+TypeTaggable ObjectFactory(Env env) {
+  return Object::New(env);
+}
+
+TypeTaggable ExternalFactory(Env env) {
+  // External does not accept a nullptr for its data.
+  return External<void>::New(env, reinterpret_cast<void*>(0x1));
+}
+
+using TestObject = TestTypeTaggable<ObjectFactory, Object>;
+using TestExternal = TestTypeTaggable<ExternalFactory, External<void>>;
+
+Object InitTypeTaggable(Env env) {
+  Object exports = Object::New(env);
+
+  Object external = Object::New(env);
+  exports["external"] = external;
+  external["checkTypeTag"] = Function::New(env, &TestExternal::CheckTypeTag);
+  external["typeTaggedInstance"] =
+      Function::New(env, &TestExternal::TypeTaggedInstance);
+
+  Object object = Object::New(env);
+  exports["object"] = object;
+  object["checkTypeTag"] = Function::New(env, &TestObject::CheckTypeTag);
+  object["typeTaggedInstance"] =
+      Function::New(env, &TestObject::TypeTaggedInstance);
+
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,60 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function testTypeTaggable ({ typeTaggedInstance, checkTypeTag }) {
+  const obj1 = typeTaggedInstance(0);
+  const obj2 = typeTaggedInstance(1);
+
+  // Verify that type tags are correctly accepted.
+  assert.strictEqual(checkTypeTag(0, obj1), true);
+  assert.strictEqual(checkTypeTag(1, obj2), true);
+
+  // Verify that wrongly tagged objects are rejected.
+  assert.strictEqual(checkTypeTag(0, obj2), false);
+  assert.strictEqual(checkTypeTag(1, obj1), false);
+
+  // Verify that untagged objects are rejected.
+  assert.strictEqual(checkTypeTag(0, {}), false);
+  assert.strictEqual(checkTypeTag(1, {}), false);
+
+  // Node v14 and v16 have an issue checking type tags if the `upper` in
+  // `napi_type_tag` is 0, so these tests can only be performed on Node version
+  // >=18. See:
+  // - https://github.com/nodejs/node/issues/43786
+  // - https://github.com/nodejs/node/pull/43788
+  const nodeVersion = parseInt(process.versions.node.split('.')[0]);
+  if (nodeVersion < 18) {
+    return;
+  }
+
+  const obj3 = typeTaggedInstance(2);
+  const obj4 = typeTaggedInstance(3);
+
+  // Verify that untagged objects are rejected.
+  assert.strictEqual(checkTypeTag(0, {}), false);
+  assert.strictEqual(checkTypeTag(1, {}), false);
+
+  // Verify that type tags are correctly accepted.
+  assert.strictEqual(checkTypeTag(0, obj1), true);
+  assert.strictEqual(checkTypeTag(1, obj2), true);
+  assert.strictEqual(checkTypeTag(2, obj3), true);
+  assert.strictEqual(checkTypeTag(3, obj4), true);
+
+  // Verify that wrongly tagged objects are rejected.
+  assert.strictEqual(checkTypeTag(0, obj2), false);
+  assert.strictEqual(checkTypeTag(1, obj1), false);
+  assert.strictEqual(checkTypeTag(0, obj3), false);
+  assert.strictEqual(checkTypeTag(1, obj4), false);
+  assert.strictEqual(checkTypeTag(2, obj4), false);
+  assert.strictEqual(checkTypeTag(3, obj3), false);
+  assert.strictEqual(checkTypeTag(4, obj3), false);
+}
+
+// eslint-disable-next-line camelcase
+function test ({ type_taggable }) {
+  testTypeTaggable(type_taggable.external);
+  testTypeTaggable(type_taggable.object);
+}

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

@@ -0,0 +1,60 @@
+#include "common/test_helper.h"
+#include "napi.h"
+
+using namespace Napi;
+
+#define TYPE_CAST_TYPES(V)                                                     \
+  V(Boolean)                                                                   \
+  V(Number)                                                                    \
+  V(BigInt)                                                                    \
+  V(Date)                                                                      \
+  V(String)                                                                    \
+  V(Symbol)                                                                    \
+  V(Object)                                                                    \
+  V(Array)                                                                     \
+  V(ArrayBuffer)                                                               \
+  V(TypedArray)                                                                \
+  V(DataView)                                                                  \
+  V(Function)                                                                  \
+  V(Promise)
+
+// The following types are tested individually.
+// External
+// TypedArrayOf
+// Buffer
+
+namespace {
+#define V(Type)                                                                \
+  void TypeCast##Type(const CallbackInfo& info) { USE(info[0].As<Type>()); }
+TYPE_CAST_TYPES(V)
+#undef V
+
+void TypeCastBuffer(const CallbackInfo& info) {
+  USE(info[0].As<Buffer<uint8_t>>());
+}
+
+void TypeCastExternal(const CallbackInfo& info) {
+  USE(info[0].As<External<void>>());
+}
+
+void TypeCastTypeArrayOfUint8(const CallbackInfo& info) {
+  USE(info[0].As<TypedArrayOf<uint8_t>>());
+}
+}  // namespace
+
+Object InitValueTypeCast(Env env, Object exports) {
+  exports["external"] = External<void>::New(env, nullptr);
+
+#define V(Type) exports["typeCast" #Type] = Function::New(env, TypeCast##Type);
+  TYPE_CAST_TYPES(V)
+#undef V
+
+  exports["typeCastBuffer"] = Function::New(env, TypeCastBuffer);
+  exports["typeCastExternal"] = Function::New(env, TypeCastExternal);
+  exports["typeCastTypeArrayOfUint8"] =
+      Function::New(env, TypeCastTypeArrayOfUint8);
+
+  return exports;
+}
+
+NODE_API_MODULE(addon, InitValueTypeCast)