koffi 0.9.34 → 0.9.37

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

@@ -0,0 +1,31 @@
+#include "napi.h"
+
+using namespace Napi;
+
+void SetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<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>();
+  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>();
+  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>();
+  Value value = info[1];
+  globalObject.Set(key, value);
+}

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

@@ -0,0 +1,58 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  const KEY_TYPE = {
+        C_STR: 'KEY_AS_C_STRING',
+        CPP_STR: 'KEY_AS_CPP_STRING',
+        NAPI:  'KEY_AS_NAPI_VALUES',
+        INT_32: 'KEY_AS_INT_32_NUM'
+    };
+
+    function setGlobalObjectKeyValue(key, value, keyType) {
+        switch(keyType)
+        {
+            case KEY_TYPE.CPP_STR:
+            binding.globalObject.setPropertyWithCppStyleString(key,value);
+            break;
+
+            case KEY_TYPE.C_STR:
+            binding.globalObject.setPropertyWithCStyleString(key,value);
+            break;
+
+            case KEY_TYPE.INT_32:
+            binding.globalObject.setPropertyWithInt32(key,value);
+            break;
+
+            case KEY_TYPE.NAPI:
+            binding.globalObject.setPropertyWithNapiValue(key,value);
+            break;
+        }
+    }
+
+    function assertErrMessageIsThrown(nativeObjectSetFunction, errMsg) {
+        assert.throws(() => {
+          nativeObjectSetFunction(undefined, 1);
+        }, errMsg);
+      }
+
+
+    setGlobalObjectKeyValue("cKey","cValue",KEY_TYPE.CPP_STR);
+    setGlobalObjectKeyValue(1,10,KEY_TYPE.INT_32);
+    setGlobalObjectKeyValue("napi_key","napi_value",KEY_TYPE.NAPI);
+    setGlobalObjectKeyValue("cppKey","cppValue",KEY_TYPE.CPP_STR);
+    setGlobalObjectKeyValue("circular",global,KEY_TYPE.NAPI);
+
+    assert.deepStrictEqual(global["circular"], global);
+    assert.deepStrictEqual(global["cppKey"],"cppValue");
+    assert.deepStrictEqual(global["napi_key"],"napi_value");
+    assert.deepStrictEqual(global[1],10);
+    assert.deepStrictEqual(global["cKey"],"cValue");
+
+    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCppStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.setPropertyWithInt32, 'Error: A number was expected');
+}

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

@@ -0,0 +1,60 @@
+#include "napi.h"
+#include "string.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+using namespace Napi;
+
+Value createScope(const CallbackInfo& info) {
+  {
+    HandleScope scope(info.Env());
+    String::New(info.Env(), "inner-scope");
+  }
+  return String::New(info.Env(), "scope");
+}
+
+Value escapeFromScope(const CallbackInfo& info) {
+  Value result;
+  {
+    EscapableHandleScope scope(info.Env());
+    result = scope.Escape(String::New(info.Env(), "inner-scope"));
+  }
+  return result;
+}
+
+#define LOOP_MAX 1000000
+Value stressEscapeFromScope(const CallbackInfo& info) {
+  Value result;
+  for (int i = 0; i < LOOP_MAX; i++) {
+    EscapableHandleScope scope(info.Env());
+    char buffer[128];
+    snprintf(buffer, 128, "%d", i);
+    std::string name = std::string("inner-scope") + std::string(buffer);
+    Value newValue = String::New(info.Env(), name.c_str());
+    if (i == (LOOP_MAX -1)) {
+      result = scope.Escape(newValue);
+    }
+  }
+  return result;
+}
+
+Value doubleEscapeFromScope(const CallbackInfo& info) {
+  Value result;
+  {
+    EscapableHandleScope scope(info.Env());
+    result = scope.Escape(String::New(info.Env(), "inner-scope"));
+    result = scope.Escape(String::New(info.Env(), "inner-scope"));
+  }
+  return result;
+}
+
+Object InitHandleScope(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createScope"] = Function::New(env, createScope);
+  exports["escapeFromScope"] = Function::New(env, escapeFromScope);
+  exports["stressEscapeFromScope"] = Function::New(env, stressEscapeFromScope);
+  exports["doubleEscapeFromScope"] = Function::New(env, doubleEscapeFromScope);
+
+  return exports;
+}

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

@@ -0,0 +1,14 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  assert.strictEqual(binding.handlescope.createScope(), 'scope');
+  assert.strictEqual(binding.handlescope.escapeFromScope(), 'inner-scope');
+  assert.strictEqual(binding.handlescope.stressEscapeFromScope(), 'inner-scope999999');
+  assert.throws(() => binding.handlescope.doubleEscapeFromScope(),
+                Error,
+                ' napi_escape_handle already called on scope');
+}

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

@@ -0,0 +1,159 @@
+'use strict';
+
+const majorNodeVersion = process.versions.node.split('.')[0];
+
+if (typeof global.gc !== 'function') {
+  // Construct the correct (version-dependent) command-line args.
+  const args = ['--expose-gc'];
+  const majorV8Version = process.versions.v8.split('.')[0];
+  if (majorV8Version < 9) {
+    args.push('--no-concurrent-array-buffer-freeing');
+  }
+  if (majorNodeVersion >= 14) {
+    args.push('--no-concurrent-array-buffer-sweeping');
+  }
+  args.push(__filename);
+
+  const child = require('./napi_child').spawnSync(process.argv[0], args, {
+    stdio: 'inherit'
+  });
+
+  if (child.signal) {
+    console.error(`Tests aborted with ${child.signal}`);
+    process.exitCode = 1;
+  } else {
+    process.exitCode = child.status;
+  }
+  process.exit(process.exitCode);
+}
+
+const testModules = [];
+
+const fs = require('fs');
+const path = require('path');
+
+let filterCondition = process.env.npm_config_filter || '';
+let filterConditionFiles = [];
+
+if (filterCondition !== '') {
+  filterCondition = require('../unit-test/matchModules').matchWildCards(process.env.npm_config_filter);
+  filterConditionFiles = filterCondition.split(' ').length > 0 ? filterCondition.split(' ') : [filterCondition];
+}
+
+const filterConditionsProvided = filterConditionFiles.length > 0;
+
+function checkFilterCondition (fileName, parsedFilepath) {
+  let result = false;
+
+  if (!filterConditionsProvided) return true;
+  if (filterConditionFiles.includes(parsedFilepath)) result = true;
+  if (filterConditionFiles.includes(fileName)) result = true;
+  return result;
+}
+
+// TODO(RaisinTen): Update this when the test filenames
+// are changed into test_*.js.
+function loadTestModules (currentDirectory = __dirname, pre = '') {
+  fs.readdirSync(currentDirectory).forEach((file) => {
+    if (currentDirectory === __dirname && (
+      file === 'binding.cc' ||
+          file === 'binding.gyp' ||
+          file === 'build' ||
+          file === 'common' ||
+          file === 'napi_child.js' ||
+          file === 'testUtil.js' ||
+          file === 'thunking_manual.cc' ||
+          file === 'thunking_manual.js' ||
+          file === 'index.js' ||
+          file[0] === '.')) {
+      return;
+    }
+    const absoluteFilepath = path.join(currentDirectory, file);
+    const parsedFilepath = path.parse(file);
+    const parsedPath = path.parse(currentDirectory);
+
+    if (fs.statSync(absoluteFilepath).isDirectory()) {
+      if (fs.existsSync(absoluteFilepath + '/index.js')) {
+        if (checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
+          testModules.push(pre + file);
+        }
+      } else {
+        loadTestModules(absoluteFilepath, pre + file + '/');
+      }
+    } else {
+      if (parsedFilepath.ext === '.js' && checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
+        testModules.push(pre + parsedFilepath.name);
+      }
+    }
+  });
+}
+
+loadTestModules();
+
+process.config.target_defaults.default_configuration =
+  fs
+    .readdirSync(path.join(__dirname, process.env.REL_BUILD_PATH || '', 'build'))
+    .filter((item) => (item === 'Debug' || item === 'Release'))[0];
+
+let napiVersion = Number(process.versions.napi);
+if (process.env.NAPI_VERSION) {
+  // we need this so that we don't try run tests that rely
+  // on methods that are not available in the NAPI_VERSION
+  // specified
+  napiVersion = process.env.NAPI_VERSION;
+}
+console.log('napiVersion:' + napiVersion);
+
+if (napiVersion < 3) {
+  testModules.splice(testModules.indexOf('env_cleanup'), 1);
+  testModules.splice(testModules.indexOf('callbackscope'), 1);
+  testModules.splice(testModules.indexOf('version_management'), 1);
+}
+
+if (napiVersion < 4 && !filterConditionsProvided) {
+  testModules.splice(testModules.indexOf('asyncprogressqueueworker'), 1);
+  testModules.splice(testModules.indexOf('asyncprogressworker'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ctx'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_existing_tsfn'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ptr'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_sum'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_unref'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function'), 1);
+}
+
+if (napiVersion < 5 && !filterConditionsProvided) {
+  testModules.splice(testModules.indexOf('date'), 1);
+}
+
+if (napiVersion < 6 && !filterConditionsProvided) {
+  testModules.splice(testModules.indexOf('addon'), 1);
+  testModules.splice(testModules.indexOf('addon_data'), 1);
+  testModules.splice(testModules.indexOf('bigint'), 1);
+  testModules.splice(testModules.indexOf('typedarray-bigint'), 1);
+}
+
+if (majorNodeVersion < 12 && !filterConditionsProvided) {
+  testModules.splice(testModules.indexOf('objectwrap_worker_thread'), 1);
+  testModules.splice(testModules.indexOf('error_terminating_environment'), 1);
+}
+
+if (napiVersion < 8 && !filterConditionsProvided) {
+  testModules.splice(testModules.indexOf('object/object_freeze_seal'), 1);
+}
+
+(async function () {
+  console.log(`Testing with Node-API Version '${napiVersion}'.`);
+
+  if (filterConditionsProvided) { console.log('Starting test suite\n', testModules); } else { console.log('Starting test suite\n'); }
+
+  // Requiring each module runs tests in the module.
+  for (const name of testModules) {
+    console.log(`Running test '${name}'`);
+    await require('./' + name);
+  }
+
+  console.log('\nAll tests passed!');
+})().catch((error) => {
+  console.log(error);
+  process.exit(1);
+});

package/vendor/node-addon-api/test/maybe/check.cc

@@ -0,0 +1,23 @@
+#include "napi.h"
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+
+using namespace Napi;
+
+namespace {
+
+void VoidCallback(const CallbackInfo& info) {
+  Function fn = info[0].As<Function>();
+
+  Maybe<Value> it = fn.Call({});
+
+  it.Check();
+}
+
+}  // end anonymous namespace
+
+Object InitMaybeCheck(Env env) {
+  Object exports = Object::New(env);
+  exports.Set("voidCallback", Function::New(env, VoidCallback));
+  return exports;
+}
+#endif

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

@@ -0,0 +1,38 @@
+'use strict';
+
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+const os = require('os');
+
+const napiChild = require('../napi_child');
+
+module.exports = test(require(`../build/${buildType}/binding_noexcept_maybe.node`).maybe_check);
+
+function test(binding) {
+  if (process.argv.includes('child')) {
+    child(binding);
+    return;
+  }
+  const cp = napiChild.spawn(process.execPath, [__filename, 'child'], {
+    stdio: ['ignore', 'inherit', 'pipe'],
+  });
+  cp.stderr.setEncoding('utf8');
+  let stderr = '';
+  cp.stderr.on('data', chunk => {
+    stderr += chunk;
+  });
+  cp.on('exit', (code, signal) => {
+    if (process.platform === 'win32') {
+      assert.strictEqual(code, 128 + 6 /* SIGABRT */);
+    } else {
+      assert.strictEqual(signal, 'SIGABRT');
+    }
+    assert.ok(stderr.match(/FATAL ERROR: Napi::Maybe::Check Maybe value is Nothing./));
+  });
+}
+
+function child(binding) {
+  binding.voidCallback(() => {
+    throw new Error('foobar');
+  })
+}

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

@@ -0,0 +1,17 @@
+#include "napi.h"
+
+using namespace Napi;
+
+Value externalAllocatedMemory(const CallbackInfo& info) {
+    int64_t kSize = 1024 * 1024;
+    int64_t baseline = MemoryManagement::AdjustExternalMemory(info.Env(), 0);
+    int64_t tmp = MemoryManagement::AdjustExternalMemory(info.Env(), kSize);
+    tmp = MemoryManagement::AdjustExternalMemory(info.Env(), -kSize);
+    return Boolean::New(info.Env(), tmp == baseline);
+}
+
+Object InitMemoryManagement(Env env) {
+    Object exports = Object::New(env);
+    exports["externalAllocatedMemory"] = Function::New(env, externalAllocatedMemory);
+    return exports;
+}

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

@@ -0,0 +1,9 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+    assert.strictEqual(binding.memory_management.externalAllocatedMemory(), true)
+}

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

@@ -0,0 +1,23 @@
+#include "napi.h"
+
+using namespace Napi;
+
+Value createExternal(const CallbackInfo& info) {
+  FunctionReference ref = Reference<Function>::New(info[0].As<Function>(), 1);
+  auto ret = External<char>::New(
+      info.Env(),
+      nullptr,
+      [ref = std::move(ref)](Napi::Env /*env*/, char* /*data*/) {
+        ref.Call({});
+      });
+
+  return ret;
+}
+
+Object InitMovableCallbacks(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createExternal"] = Function::New(env, createExternal);
+
+  return exports;
+}

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

@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('./common');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(binding => test(binding.movable_callbacks));
+
+async function test(binding) {
+  await testUtil.runGCTests([
+    'External',
+    () => {
+      const fn = common.mustCall(() => {
+        // noop
+      }, 1);
+      const external = binding.createExternal(fn);
+    },
+    () => {
+      // noop, wait for gc
+    }
+  ]);
+}

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

@@ -0,0 +1,108 @@
+#include "napi.h"
+
+using namespace Napi;
+
+const char* testValueUtf8 = "123456789";
+const char16_t* testValueUtf16 = NAPI_WIDE_TEXT("123456789");
+
+Value EchoString(const CallbackInfo& info) {
+  String value = info[0].As<String>();
+  String encoding = info[1].As<String>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    return String::New(info.Env(), value.Utf8Value().c_str());
+  } else if (encoding.Utf8Value() == "utf16") {
+    return String::New(info.Env(), value.Utf16Value().c_str());
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CreateString(const CallbackInfo& info) {
+  String encoding = info[0].As<String>();
+  Number length = info[1].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf8);
+    } else {
+      return String::New(info.Env(), testValueUtf8, length.Uint32Value());
+    }
+  } else if (encoding.Utf8Value() == "utf16") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf16);
+    } else {
+      return String::New(info.Env(), testValueUtf16, length.Uint32Value());
+    }
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CheckString(const CallbackInfo& info) {
+  String value = info[0].As<String>();
+  String encoding = info[1].As<String>();
+  Number length = info[2].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    std::string testValue = testValueUtf8;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else if (encoding.Utf8Value() == "utf16") {
+    std::u16string testValue = testValueUtf16;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::u16string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CreateSymbol(const CallbackInfo& info) {
+  String description = info[0].As<String>();
+
+  if (!description.IsUndefined()) {
+    return Symbol::New(info.Env(), description);
+  } else {
+    return Symbol::New(info.Env());
+  }
+}
+
+Value CheckSymbol(const CallbackInfo& info) {
+  return Boolean::New(info.Env(), info[0].Type() == napi_symbol);
+}
+
+void NullStringShouldThrow(const CallbackInfo& info) {
+  const char* nullStr = nullptr;
+  String::New(info.Env(), nullStr);
+}
+
+void NullString16ShouldThrow(const CallbackInfo& info) {
+  const char16_t* nullStr = nullptr;
+  String::New(info.Env(), nullStr);
+}
+
+Object InitName(Env env) {
+  Object exports = Object::New(env);
+
+  exports["echoString"] = Function::New(env, EchoString);
+  exports["createString"] = Function::New(env, CreateString);
+  exports["nullStringShouldThrow"] = Function::New(env, NullStringShouldThrow);
+  exports["nullString16ShouldThrow"] =
+      Function::New(env, NullString16ShouldThrow);
+  exports["checkString"] = Function::New(env, CheckString);
+  exports["createSymbol"] = Function::New(env, CreateSymbol);
+  exports["checkSymbol"] = Function::New(env, CheckSymbol);
+
+  return exports;
+}

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

@@ -0,0 +1,59 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  const expected = '123456789';
+
+
+  assert.throws(binding.name.nullStringShouldThrow, {
+    name: 'Error',
+    message: 'Error in native callback',
+  });
+  assert.ok(binding.name.checkString(expected, 'utf8'));
+  assert.ok(binding.name.checkString(expected, 'utf16'));
+  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf8', 3));
+  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf16', 3));
+
+  const str1 = binding.name.createString('utf8');
+  assert.strictEqual(str1, expected);
+  assert.ok(binding.name.checkString(str1, 'utf8'));
+  assert.ok(binding.name.checkString(str1, 'utf16'));
+
+  const substr1 = binding.name.createString('utf8', 3);
+  assert.strictEqual(substr1, expected.substr(0, 3));
+  assert.ok(binding.name.checkString(substr1, 'utf8', 3));
+  assert.ok(binding.name.checkString(substr1, 'utf16', 3));
+
+  const str2 = binding.name.createString('utf16');
+  assert.strictEqual(str1, expected);
+  assert.ok(binding.name.checkString(str2, 'utf8'));
+  assert.ok(binding.name.checkString(str2, 'utf16'));
+
+  const substr2 = binding.name.createString('utf16', 3);
+  assert.strictEqual(substr1, expected.substr(0, 3));
+  assert.ok(binding.name.checkString(substr2, 'utf8', 3));
+  assert.ok(binding.name.checkString(substr2, 'utf16', 3));
+
+  assert.ok(binding.name.checkSymbol(Symbol()));
+  assert.ok(binding.name.checkSymbol(Symbol('test')));
+
+  const sym1 = binding.name.createSymbol();
+  assert.strictEqual(typeof sym1, 'symbol');
+  assert.ok(binding.name.checkSymbol(sym1));
+
+  const sym2 = binding.name.createSymbol('test');
+  assert.strictEqual(typeof sym2, 'symbol');
+  assert.ok(binding.name.checkSymbol(sym1));
+
+  // Check for off-by-one errors which might only appear for strings of certain sizes,
+  // due to how std::string increments its capacity in chunks.
+  const longString = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+  for (let i = 10; i <= longString.length; i++) {
+    const str = longString.substr(0, i);
+    assert.strictEqual(binding.name.echoString(str, 'utf8'), str);
+    assert.strictEqual(binding.name.echoString(str, 'utf16'), str);
+  }
+}

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

@@ -0,0 +1,14 @@
+// Makes sure that child processes are spawned appropriately.
+exports.spawnSync = function(command, args, options) {
+  if (require('../index').needsFlag) {
+    args.splice(0, 0, '--napi-modules');
+  }
+  return require('child_process').spawnSync(command, args, options);
+};
+
+exports.spawn = function(command, args, options) {
+  if (require('../index').needsFlag) {
+    args.splice(0, 0, '--napi-modules');
+  }
+  return require('child_process').spawn(command, args, options);
+};

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

@@ -0,0 +1,38 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value DeletePropertyWithUint32(const CallbackInfo& info) {
+  Object obj = info[0].As<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>();
+  Name key = info[1].As<Name>();
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(obj.Delete(static_cast<napi_value>(key)), false));
+}
+
+Value DeletePropertyWithNapiWrapperValue(const CallbackInfo& info) {
+  Object obj = info[0].As<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>();
+  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>();
+  String jsKey = info[1].As<String>();
+  return Boolean::New(info.Env(),
+                      MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value()), false));
+}