koffi 2.3.4 → 2.3.6-beta.1

package/vendor/node-addon-api/test/object/object_deprecated.js

@@ -4,23 +4,18 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   if (!('object_deprecated' in binding)) {
     return;
   }
-  function assertPropertyIs(obj, key, attribute) {
-    const propDesc = Object.getOwnPropertyDescriptor(obj, key);
-    assert.ok(propDesc);
-    assert.ok(propDesc[attribute]);
-  }
 
-  function assertPropertyIsNot(obj, key, attribute) {
+  function assertPropertyIsNot (obj, key, attribute) {
     const propDesc = Object.getOwnPropertyDescriptor(obj, key);
     assert.ok(propDesc);
     assert.ok(!propDesc[attribute]);
   }
 
-  function testDefineProperties(nameType) {
+  function testDefineProperties (nameType) {
     const obj = {};
     binding.object.defineProperties(obj, nameType);
 

package/vendor/node-addon-api/test/object/object_freeze_seal.js

@@ -4,58 +4,58 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-    {
-        const obj = { x: 'a', y: 'b', z: 'c' };
-        assert.strictEqual(binding.object_freeze_seal.freeze(obj), true);
-        assert.strictEqual(Object.isFrozen(obj), true);
-        assert.throws(() => {
-          obj.x = 10;
-        }, /Cannot assign to read only property 'x' of object '#<Object>/);
-        assert.throws(() => {
-          obj.w = 15;
-        }, /Cannot add property w, object is not extensible/);
-        assert.throws(() => {
-          delete obj.x;
-        }, /Cannot delete property 'x' of #<Object>/);
-    }
-
-    {
-        const obj = new Proxy({ x: 'a', y: 'b', z: 'c' }, {
-          preventExtensions() {
-            throw new Error('foo');
-          },
-        });
-
-        assert.throws(() => {
-          binding.object_freeze_seal.freeze(obj);
-        }, /foo/);
-    }
-
-    {
-        const obj = { x: 'a', y: 'b', z: 'c' };
-        assert.strictEqual(binding.object_freeze_seal.seal(obj), true);
-        assert.strictEqual(Object.isSealed(obj), true);
-        assert.throws(() => {
-          obj.w = 'd';
-        }, /Cannot add property w, object is not extensible/);
-        assert.throws(() => {
-          delete obj.x;
-        }, /Cannot delete property 'x' of #<Object>/);
-        // Sealed objects allow updating existing properties,
-        // so this should not throw.
-        obj.x = 'd';
-    }
-
-    {
-        const obj = new Proxy({ x: 'a', y: 'b', z: 'c' }, {
-          preventExtensions() {
-            throw new Error('foo');
-          },
-        });
-
-        assert.throws(() => {
-          binding.object_freeze_seal.seal(obj);
-        }, /foo/);
-    }
+function test (binding) {
+  {
+    const obj = { x: 'a', y: 'b', z: 'c' };
+    assert.strictEqual(binding.object_freeze_seal.freeze(obj), true);
+    assert.strictEqual(Object.isFrozen(obj), true);
+    assert.throws(() => {
+      obj.x = 10;
+    }, /Cannot assign to read only property 'x' of object '#<Object>/);
+    assert.throws(() => {
+      obj.w = 15;
+    }, /Cannot add property w, object is not extensible/);
+    assert.throws(() => {
+      delete obj.x;
+    }, /Cannot delete property 'x' of #<Object>/);
+  }
+
+  {
+    const obj = new Proxy({ x: 'a', y: 'b', z: 'c' }, {
+      preventExtensions () {
+        throw new Error('foo');
+      }
+    });
+
+    assert.throws(() => {
+      binding.object_freeze_seal.freeze(obj);
+    }, /foo/);
+  }
+
+  {
+    const obj = { x: 'a', y: 'b', z: 'c' };
+    assert.strictEqual(binding.object_freeze_seal.seal(obj), true);
+    assert.strictEqual(Object.isSealed(obj), true);
+    assert.throws(() => {
+      obj.w = 'd';
+    }, /Cannot add property w, object is not extensible/);
+    assert.throws(() => {
+      delete obj.x;
+    }, /Cannot delete property 'x' of #<Object>/);
+    // Sealed objects allow updating existing properties,
+    // so this should not throw.
+    obj.x = 'd';
+  }
+
+  {
+    const obj = new Proxy({ x: 'a', y: 'b', z: 'c' }, {
+      preventExtensions () {
+        throw new Error('foo');
+      }
+    });
+
+    assert.throws(() => {
+      binding.object_freeze_seal.seal(obj);
+    }, /foo/);
+  }
 }

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

@@ -0,0 +1,39 @@
+#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},
+};
+
+Value TypeTaggedInstance(const CallbackInfo& info) {
+  Object instance = Object::New(info.Env());
+  uint32_t type_index = info[0].As<Number>().Int32Value();
+
+  instance.TypeTag(&type_tags[type_index]);
+
+  return instance;
+}
+
+Value CheckTypeTag(const CallbackInfo& info) {
+  uint32_t type_index = info[0].As<Number>().Int32Value();
+  Object instance = info[1].As<Object>();
+
+  return Boolean::New(info.Env(),
+                      instance.CheckTypeTag(&type_tags[type_index]));
+}
+
+Object InitObjectTypeTag(Env env) {
+  Object exports = Object::New(env);
+  exports["checkTypeTag"] = Function::New(env, CheckTypeTag);
+  exports["typedTaggedInstance"] = Function::New(env, TypeTaggedInstance);
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/object/object_type_tag.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+// eslint-disable-next-line camelcase
+function test ({ object_type_tag }) {
+  const obj1 = object_type_tag.typedTaggedInstance(0);
+  const obj2 = object_type_tag.typedTaggedInstance(1);
+
+  // Verify that type tags are correctly accepted.
+  assert.strictEqual(object_type_tag.checkTypeTag(0, obj1), true);
+  assert.strictEqual(object_type_tag.checkTypeTag(1, obj2), true);
+
+  // Verify that wrongly tagged objects are rejected.
+  assert.strictEqual(object_type_tag.checkTypeTag(0, obj2), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(1, obj1), false);
+
+  // Verify that untagged objects are rejected.
+  assert.strictEqual(object_type_tag.checkTypeTag(0, {}), false);
+  assert.strictEqual(object_type_tag.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 = object_type_tag.typedTaggedInstance(2);
+  const obj4 = object_type_tag.typedTaggedInstance(3);
+
+  // Verify that untagged objects are rejected.
+  assert.strictEqual(object_type_tag.checkTypeTag(0, {}), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(1, {}), false);
+
+  // Verify that type tags are correctly accepted.
+  assert.strictEqual(object_type_tag.checkTypeTag(0, obj1), true);
+  assert.strictEqual(object_type_tag.checkTypeTag(1, obj2), true);
+  assert.strictEqual(object_type_tag.checkTypeTag(2, obj3), true);
+  assert.strictEqual(object_type_tag.checkTypeTag(3, obj4), true);
+
+  // Verify that wrongly tagged objects are rejected.
+  assert.strictEqual(object_type_tag.checkTypeTag(0, obj2), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(1, obj1), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(0, obj3), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(1, obj4), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(2, obj4), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(3, obj3), false);
+  assert.strictEqual(object_type_tag.checkTypeTag(4, obj3), false);
+}

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

@@ -4,8 +4,8 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function testProperty(obj, key, value, nativeGetProperty, nativeSetProperty) {
+function test (binding) {
+  function testProperty (obj, key, value, nativeGetProperty, nativeSetProperty) {
     nativeSetProperty(obj, key, value);
     assert.strictEqual(nativeGetProperty(obj, key), value);
   }

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

@@ -16,13 +16,13 @@ const testUtil = require('./testUtil');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
-  function testCastedEqual(testToCompare) {
-    var compare_test = ["hello", "world", "!"];
+function test (binding) {
+  function testCastedEqual (testToCompare) {
+    const compareTest = ['hello', 'world', '!'];
     if (testToCompare instanceof Array) {
-      assert.deepEqual(compare_test, testToCompare);
+      assert.deepEqual(compareTest, testToCompare);
     } else if (testToCompare instanceof String) {
-      assert.deepEqual("No Referenced Value", testToCompare);
+      assert.deepEqual('No Referenced Value', testToCompare);
     } else {
       assert.fail();
     }
@@ -32,11 +32,11 @@ function test(binding) {
     'Weak Casted Array',
     () => {
       binding.objectreference.setCastedObjects();
-      var test = binding.objectreference.getCastedFromValue("weak");
-      var test2 = new Array();
-      test2[0] = binding.objectreference.getCastedFromGetter("weak", 0);
-      test2[1] = binding.objectreference.getCastedFromGetter("weak", 1);
-      test2[2] = binding.objectreference.getCastedFromGetter("weak", 2);
+      const test = binding.objectreference.getCastedFromValue('weak');
+      const test2 = [];
+      test2[0] = binding.objectreference.getCastedFromGetter('weak', 0);
+      test2[1] = binding.objectreference.getCastedFromGetter('weak', 1);
+      test2[2] = binding.objectreference.getCastedFromGetter('weak', 2);
 
       testCastedEqual(test);
       testCastedEqual(test2);
@@ -45,11 +45,11 @@ function test(binding) {
     'Persistent Casted Array',
     () => {
       binding.objectreference.setCastedObjects();
-      const test = binding.objectreference.getCastedFromValue("persistent");
-      const test2 = new Array();
-      test2[0] = binding.objectreference.getCastedFromGetter("persistent", 0);
-      test2[1] = binding.objectreference.getCastedFromGetter("persistent", 1);
-      test2[2] = binding.objectreference.getCastedFromGetter("persistent", 2);
+      const test = binding.objectreference.getCastedFromValue('persistent');
+      const test2 = [];
+      test2[0] = binding.objectreference.getCastedFromGetter('persistent', 0);
+      test2[1] = binding.objectreference.getCastedFromGetter('persistent', 1);
+      test2[2] = binding.objectreference.getCastedFromGetter('persistent', 2);
 
       assert.ok(test instanceof Array);
       assert.ok(test2 instanceof Array);
@@ -61,10 +61,10 @@ function test(binding) {
     () => {
       binding.objectreference.setCastedObjects();
       const test = binding.objectreference.getCastedFromValue();
-      const test2 = new Array();
-      test2[0] = binding.objectreference.getCastedFromGetter("reference", 0);
-      test2[1] = binding.objectreference.getCastedFromGetter("reference", 1);
-      test2[2] = binding.objectreference.getCastedFromGetter("reference", 2);
+      const test2 = [];
+      test2[0] = binding.objectreference.getCastedFromGetter('reference', 0);
+      test2[1] = binding.objectreference.getCastedFromGetter('reference', 1);
+      test2[2] = binding.objectreference.getCastedFromGetter('reference', 2);
 
       assert.ok(test instanceof Array);
       assert.ok(test2 instanceof Array);
@@ -74,57 +74,57 @@ function test(binding) {
 
     'Weak',
     () => {
-      binding.objectreference.setObjects("hello", "world");
-      const test = binding.objectreference.getFromValue("weak");
-      const test2 = binding.objectreference.getFromGetter("weak", "hello");
+      binding.objectreference.setObjects('hello', 'world');
+      const test = binding.objectreference.getFromValue('weak');
+      const test2 = binding.objectreference.getFromGetter('weak', 'hello');
 
-      assert.deepEqual({ hello: "world"}, test);
-      assert.equal("world", test2);
-      assert.equal(test["hello"], test2);
+      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");
+      binding.objectreference.setObjects('hello', 'world', 'javascript');
+      const test = binding.objectreference.getFromValue('weak');
+      const test2 = binding.objectreference.getFromValue('weak', 'hello');
 
-      assert.deepEqual({ hello: "world" }, test);
-      assert.deepEqual({ hello: "world" }, test2);
+      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);
+      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.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);
+      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);
 
-      assert.deepEqual({ 1: "world" }, test);
+      assert.deepEqual({ 1: 'world' }, test);
       assert.equal(undefined, test2);
-      assert.equal("world", test3);
+      assert.equal('world', test3);
     },
     () => {
-      binding.objectreference.setObjects("hello", "world");
+      binding.objectreference.setObjects('hello', 'world');
       assert.doesNotThrow(
         () => {
-          var rcount = binding.objectreference.refObjects("weak");
+          let rcount = binding.objectreference.refObjects('weak');
           assert.equal(rcount, 1);
-          rcount = binding.objectreference.unrefObjects("weak");
+          rcount = binding.objectreference.unrefObjects('weak');
           assert.equal(rcount, 0);
         },
         Error
       );
       assert.throws(
         () => {
-          binding.objectreference.unrefObjects("weak");
+          binding.objectreference.unrefObjects('weak');
         },
         Error
       );
@@ -132,63 +132,63 @@ function test(binding) {
 
     'Persistent',
     () => {
-      binding.objectreference.setObjects("hello", "world");
-      const test = binding.objectreference.getFromValue("persistent");
-      const test2 = binding.objectreference.getFromGetter("persistent", "hello");
+      binding.objectreference.setObjects('hello', 'world');
+      const test = binding.objectreference.getFromValue('persistent');
+      const test2 = binding.objectreference.getFromGetter('persistent', 'hello');
 
-      assert.deepEqual({ hello: "world" }, test);
-      assert.equal("world", test2);
-      assert.equal(test["hello"], test2);
+      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("persistent");
-      const test2 = binding.objectreference.getFromValue("persistent", "hello");
+      binding.objectreference.setObjects('hello', 'world', 'javascript');
+      const test = binding.objectreference.getFromValue('persistent');
+      const test2 = binding.objectreference.getFromValue('persistent', 'hello');
 
-      assert.deepEqual({ hello: "world" }, test);
-      assert.deepEqual({ hello: "world" }, test2);
+      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("persistent");
-      const test2 = binding.objectreference.getFromGetter("persistent", 1);
+      binding.objectreference.setObjects(1, 'hello world');
+      const test = binding.objectreference.getFromValue('persistent');
+      const test2 = binding.objectreference.getFromGetter('persistent', 1);
 
-      assert.deepEqual({ 1: "hello world"}, test);
-      assert.equal("hello world", test2);
+      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);
+      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);
 
-      assert.deepEqual({ 1: "world"}, test);
+      assert.deepEqual({ 1: 'world' }, test);
       assert.equal(undefined, test2);
-      assert.equal("world", test3);
+      assert.equal('world', test3);
     },
     () => {
-      binding.objectreference.setObjects("hello", "world");
+      binding.objectreference.setObjects('hello', 'world');
       assert.doesNotThrow(
         () => {
-          var rcount = binding.objectreference.unrefObjects("persistent");
+          let rcount = binding.objectreference.unrefObjects('persistent');
           assert.equal(rcount, 0);
-          rcount = binding.objectreference.refObjects("persistent");
+          rcount = binding.objectreference.refObjects('persistent');
           assert.equal(rcount, 1);
-          rcount = binding.objectreference.unrefObjects("persistent");
+          rcount = binding.objectreference.unrefObjects('persistent');
           assert.equal(rcount, 0);
-          rcount = binding.objectreference.refObjects("persistent");
+          rcount = binding.objectreference.refObjects('persistent');
           assert.equal(rcount, 1);
-          rcount = binding.objectreference.unrefObjects("persistent");
+          rcount = binding.objectreference.unrefObjects('persistent');
           assert.equal(rcount, 0);
         },
         Error
       );
       assert.throws(
         () => {
-          binding.objectreference.unrefObjects("persistent");
+          binding.objectreference.unrefObjects('persistent');
         },
         Error
       );
@@ -196,64 +196,64 @@ function test(binding) {
 
     'References',
     () => {
-      binding.objectreference.setObjects("hello", "world");
+      binding.objectreference.setObjects('hello', 'world');
       const test = binding.objectreference.getFromValue();
-      const test2 = binding.objectreference.getFromGetter("hello");
+      const test2 = binding.objectreference.getFromGetter('hello');
 
-      assert.deepEqual({ hello: "world" }, test);
-      assert.equal("world", test2);
-      assert.equal(test["hello"], test2);
+      assert.deepEqual({ hello: 'world' }, test);
+      assert.equal('world', test2);
+      assert.equal(test.hello, test2);
     },
     () => {
-      binding.objectreference.setObjects("hello", "world", "javascript");
+      binding.objectreference.setObjects('hello', 'world', 'javascript');
       const test = binding.objectreference.getFromValue();
-      const test2 = binding.objectreference.getFromValue("hello");
+      const test2 = binding.objectreference.getFromValue('hello');
 
-      assert.deepEqual({ hello: "world" }, test);
-      assert.deepEqual({ hello: "world" }, test2);
+      assert.deepEqual({ hello: 'world' }, test);
+      assert.deepEqual({ hello: 'world' }, test2);
       assert.deepEqual(test, test2);
     },
     () => {
-      binding.objectreference.setObjects(1, "hello world");
+      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.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");
+      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);
 
-      assert.deepEqual({ 1: "world"}, test);
+      assert.deepEqual({ 1: 'world' }, test);
       assert.equal(undefined, test2);
-      assert.equal("world", test3);
+      assert.equal('world', test3);
     },
     () => {
-      binding.objectreference.setObjects("hello", "world");
+      binding.objectreference.setObjects('hello', 'world');
       assert.doesNotThrow(
         () => {
-          var rcount = binding.objectreference.unrefObjects("references");
+          let rcount = binding.objectreference.unrefObjects('references');
           assert.equal(rcount, 1);
-          rcount = binding.objectreference.refObjects("references");
+          rcount = binding.objectreference.refObjects('references');
           assert.equal(rcount, 2);
-          rcount = binding.objectreference.unrefObjects("references");
+          rcount = binding.objectreference.unrefObjects('references');
           assert.equal(rcount, 1);
-          rcount = binding.objectreference.unrefObjects("references");
+          rcount = binding.objectreference.unrefObjects('references');
           assert.equal(rcount, 0);
         },
         Error
       );
       assert.throws(
         () => {
-          binding.objectreference.unrefObjects("references");
+          binding.objectreference.unrefObjects('references');
         },
         Error
       );
     }
-  ])
-};
+  ]);
+}