koffi 2.7.2 → 2.7.4-beta.1

package/vendor/node-addon-api/napi.h

@@ -367,6 +367,10 @@ class Env {
     } * data;
   };
 #endif  // NAPI_VERSION > 2
+
+#if NAPI_VERSION > 8
+  const char* GetModuleFileName() const;
+#endif  // NAPI_VERSION > 8
 };
 
 /// A JavaScript value of unknown type.
@@ -1531,11 +1535,6 @@ class Buffer : public Uint8Array {
   T* Data() const;
 
  private:
-  mutable size_t _length;
-  mutable T* _data;
-
-  Buffer(napi_env env, napi_value value, size_t length, T* data);
-  void EnsureInfo() const;
 };
 
 /// Holds a counted reference to a value; initially a weak reference unless
@@ -1853,6 +1852,17 @@ class RangeError : public Error {
   RangeError(napi_env env, napi_value value);
 };
 
+#if NAPI_VERSION > 8
+class SyntaxError : public Error {
+ public:
+  static SyntaxError New(napi_env env, const char* message);
+  static SyntaxError New(napi_env env, const std::string& message);
+
+  SyntaxError();
+  SyntaxError(napi_env env, napi_value value);
+};
+#endif  // NAPI_VERSION > 8
+
 class CallbackInfo {
  public:
   CallbackInfo(napi_env env, napi_callback_info info);

package/vendor/node-addon-api/node_addon_api.gyp

@@ -0,0 +1,32 @@
+{
+  'targets': [
+    {
+      'target_name': 'node_addon_api',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_except',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['except.gypi'],
+      }
+    },
+    {
+      'target_name': 'node_addon_api_maybe',
+      'type': 'none',
+      'sources': [ 'napi.h', 'napi-inl.h' ],
+      'direct_dependent_settings': {
+        'include_dirs': [ '.' ],
+        'includes': ['noexcept.gypi'],
+        'defines': ['NODE_ADDON_API_ENABLE_MAYBE']
+      }
+    },
+  ]
+}

package/vendor/node-addon-api/package.json

@@ -407,6 +407,14 @@
     {
       "name": "Caleb Hearon",
       "url": "https://github.com/chearon"
+    },
+    {
+      "name": "Marx",
+      "url": "https://github.com/MarxJiao"
+    },
+    {
+      "name": "Ömer AKGÜL",
+      "url": "https://github.com/tuhalf"
     }
   ],
   "description": "Node.js API (Node-API)",
@@ -420,7 +428,7 @@
     "eslint-plugin-import": "^2.24.2",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^5.1.0",
-    "fs-extra": "^9.0.1",
+    "fs-extra": "^11.1.1",
     "path": "^0.12.7",
     "pre-commit": "^1.2.2",
     "safe-buffer": "^5.1.1"
@@ -467,6 +475,9 @@
     "lint:fix": "node tools/clang-format --fix && node tools/eslint-format --fix"
   },
   "pre-commit": "lint",
-  "version": "7.0.0",
-  "support": true
+  "version": "7.1.0",
+  "support": true,
+  "engines": {
+    "node": "^16 || ^18 || >= 20"
+  }
 }

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

@@ -17,6 +17,8 @@ class TestAddon : public Napi::Addon<TestAddon> {
                  {InstanceMethod("decrement", &TestAddon::Decrement)}))});
   }
 
+  ~TestAddon() { fprintf(stderr, "TestAddon::~TestAddon\n"); }
+
  private:
   Napi::Value Increment(const Napi::CallbackInfo& info) {
     return Napi::Number::New(info.Env(), ++value);
@@ -29,10 +31,14 @@ class TestAddon : public Napi::Addon<TestAddon> {
   uint32_t value = 42;
 };
 
+Napi::Value CreateAddon(const Napi::CallbackInfo& info) {
+  return TestAddon::Init(info.Env(), Napi::Object::New(info.Env()));
+}
+
 }  // end of anonymous namespace
 
 Napi::Object InitAddon(Napi::Env env) {
-  return TestAddon::Init(env, Napi::Object::New(env));
+  return Napi::Function::New<CreateAddon>(env, "CreateAddon");
 }
 
 #endif  // (NAPI_VERSION > 5)

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

@@ -1,11 +1,7 @@
 'use strict';
 
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  assert.strictEqual(binding.addon.increment(), 43);
-  assert.strictEqual(binding.addon.increment(), 44);
-  assert.strictEqual(binding.addon.subObject.decrement(), 43);
-}
+module.exports = require('./common').runTestInChildProcess({
+  suite: 'addon',
+  testName: 'workingCode',
+  expectedStderr: ['TestAddon::~TestAddon']
+});

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

@@ -4,10 +4,10 @@
 #include "test_helper.h"
 
 // An overly elaborate way to get/set a boolean stored in the instance data:
-// 0. A boolean named "verbose" is stored in the instance data. The constructor
-//    for JS `VerboseIndicator` instances is also stored in the instance data.
+// 0. The constructor for JS `VerboseIndicator` instances, which have a private
+//    member named "verbose", is stored in the instance data.
 // 1. Add a property named "verbose" onto exports served by a getter/setter.
-// 2. The getter returns a object of type VerboseIndicator, which itself has a
+// 2. The getter returns an object of type VerboseIndicator, which itself has a
 //    property named "verbose", also served by a getter/setter:
 //    * The getter returns a boolean, indicating whether "verbose" is set.
 //    * The setter sets "verbose" on the instance data.

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

@@ -1,46 +1,24 @@
 'use strict';
 
-const assert = require('assert');
-const { spawn } = require('child_process');
-const readline = require('readline');
+const common = require('./common');
 
-module.exports = require('./common').runTestWithBindingPath(test);
+module.exports = common.runTest(test);
 
-// Make sure the instance data finalizer is called at process exit. If the hint
-// is non-zero, it will be printed out by the child process.
-function testFinalizer (bindingName, hint, expected) {
-  return new Promise((resolve) => {
-    bindingName = bindingName.split('\\').join('\\\\');
-    const child = spawn(process.execPath, [
-      '-e',
-      `require('${bindingName}').addon_data(${hint}).verbose = true;`
-    ]);
-    const actual = [];
-    readline
-      .createInterface({ input: child.stderr })
-      .on('line', (line) => {
-        if (expected.indexOf(line) >= 0) {
-          actual.push(line);
-        }
-      })
-      .on('close', () => {
-        assert.deepStrictEqual(expected, actual);
-        resolve();
-      });
+async function test () {
+  await common.runTestInChildProcess({
+    suite: 'addon_data',
+    testName: 'workingCode'
   });
-}
-
-async function test (bindingName) {
-  const binding = require(bindingName).addon_data(0);
 
-  // Make sure it is possible to get/set instance data.
-  assert.strictEqual(binding.verbose.verbose, false);
-  binding.verbose = true;
-  assert.strictEqual(binding.verbose.verbose, true);
-  binding.verbose = false;
-  assert.strictEqual(binding.verbose.verbose, false);
+  await common.runTestInChildProcess({
+    suite: 'addon_data',
+    testName: 'cleanupWithoutHint',
+    expectedStderr: ['addon_data: Addon::~Addon']
+  });
 
-  await testFinalizer(bindingName, 0, ['addon_data: Addon::~Addon']);
-  await testFinalizer(bindingName, 42,
-    ['addon_data: Addon::~Addon', 'hint: 42']);
+  await common.runTestInChildProcess({
+    suite: 'addon_data',
+    testName: 'cleanupWithHint',
+    expectedStderr: ['addon_data: Addon::~Addon', 'hint: 42']
+  });
 }

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

@@ -1,6 +1,5 @@
 #if (NAPI_VERSION > 5)
 
-#define NAPI_EXPERIMENTAL
 #include "napi.h"
 
 #include "test_helper.h"

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

@@ -50,12 +50,14 @@ Object InitPromise(Env env);
 Object InitRunScript(Env env);
 #if (NAPI_VERSION > 3)
 Object InitThreadSafeFunctionCtx(Env env);
+Object InitThreadSafeFunctionException(Env env);
 Object InitThreadSafeFunctionExistingTsfn(Env env);
 Object InitThreadSafeFunctionPtr(Env env);
 Object InitThreadSafeFunctionSum(Env env);
 Object InitThreadSafeFunctionUnref(Env env);
 Object InitThreadSafeFunction(Env env);
 Object InitTypedThreadSafeFunctionCtx(Env env);
+Object InitTypedThreadSafeFunctionException(Env env);
 Object InitTypedThreadSafeFunctionExistingTsfn(Env env);
 Object InitTypedThreadSafeFunctionPtr(Env env);
 Object InitTypedThreadSafeFunctionSum(Env env);
@@ -78,7 +80,9 @@ Object InitThunkingManual(Env env);
 Object InitObjectFreezeSeal(Env env);
 Object InitTypeTaggable(Env env);
 #endif
-
+#if (NAPI_VERSION > 8)
+Object InitEnvMiscellaneous(Env env);
+#endif
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
 Object InitMaybeCheck(Env env);
 #endif
@@ -137,6 +141,8 @@ Object Init(Env env, Object exports) {
   exports.Set("symbol", InitSymbol(env));
 #if (NAPI_VERSION > 3)
   exports.Set("threadsafe_function_ctx", InitThreadSafeFunctionCtx(env));
+  exports.Set("threadsafe_function_exception",
+              InitThreadSafeFunctionException(env));
   exports.Set("threadsafe_function_existing_tsfn",
               InitThreadSafeFunctionExistingTsfn(env));
   exports.Set("threadsafe_function_ptr", InitThreadSafeFunctionPtr(env));
@@ -145,6 +151,8 @@ Object Init(Env env, Object exports) {
   exports.Set("threadsafe_function", InitThreadSafeFunction(env));
   exports.Set("typed_threadsafe_function_ctx",
               InitTypedThreadSafeFunctionCtx(env));
+  exports.Set("typed_threadsafe_function_exception",
+              InitTypedThreadSafeFunctionException(env));
   exports.Set("typed_threadsafe_function_existing_tsfn",
               InitTypedThreadSafeFunctionExistingTsfn(env));
   exports.Set("typed_threadsafe_function_ptr",
@@ -171,6 +179,9 @@ Object Init(Env env, Object exports) {
   exports.Set("object_freeze_seal", InitObjectFreezeSeal(env));
   exports.Set("type_taggable", InitTypeTaggable(env));
 #endif
+#if (NAPI_VERSION > 8)
+  exports.Set("env_misc", InitEnvMiscellaneous(env));
+#endif
 
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
   exports.Set("maybe_check", InitMaybeCheck(env));

package/vendor/node-addon-api/test/binding.gyp

@@ -26,6 +26,7 @@
         'dataview/dataview.cc',
         'dataview/dataview_read_write.cc',
         'env_cleanup.cc',
+        'env_misc.cc',
         'error.cc',
         'error_handling_for_primitives.cc',
         'external.cc',
@@ -54,6 +55,7 @@
         'run_script.cc',
         'symbol.cc',
         'threadsafe_function/threadsafe_function_ctx.cc',
+        'threadsafe_function/threadsafe_function_exception.cc',
         'threadsafe_function/threadsafe_function_existing_tsfn.cc',
         'threadsafe_function/threadsafe_function_ptr.cc',
         'threadsafe_function/threadsafe_function_sum.cc',
@@ -61,6 +63,7 @@
         'threadsafe_function/threadsafe_function.cc',
         'type_taggable.cc',
         'typed_threadsafe_function/typed_threadsafe_function_ctx.cc',
+        'typed_threadsafe_function/typed_threadsafe_function_exception.cc',
         'typed_threadsafe_function/typed_threadsafe_function_existing_tsfn.cc',
         'typed_threadsafe_function/typed_threadsafe_function_ptr.cc',
         'typed_threadsafe_function/typed_threadsafe_function_sum.cc',
@@ -94,41 +97,40 @@
   'targets': [
     {
       'target_name': 'binding',
-      'includes': ['../except.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api_except'],
       'sources': ['>@(build_sources)']
     },
     {
       'target_name': 'binding_noexcept',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources)']
     },
     {
       'target_name': 'binding_noexcept_maybe',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api_maybe'],
       'sources': ['>@(build_sources)'],
-      'defines': ['NODE_ADDON_API_ENABLE_MAYBE']
     },
     {
       'target_name': 'binding_swallowexcept',
-      'includes': ['../except.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api_except'],
       'sources': [ '>@(build_sources_swallowexcept)'],
       'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
     },
     {
       'target_name': 'binding_swallowexcept_noexcept',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources_swallowexcept)'],
       'defines': ['NODE_API_SWALLOW_UNTHROWABLE_EXCEPTIONS']
     },
     {
       'target_name': 'binding_type_check',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources_type_check)'],
       'defines': ['NODE_ADDON_API_ENABLE_TYPE_CHECK_ON_AS']
     },
     {
       'target_name': 'binding_custom_namespace',
-      'includes': ['../noexcept.gypi'],
+      'dependencies': ['../node_addon_api.gyp:node_addon_api'],
       'sources': ['>@(build_sources)'],
       'defines': ['NAPI_CPP_CUSTOM_NAMESPACE=cstm']
     },

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

@@ -0,0 +1,11 @@
+'use strict';
+const assert = require('assert');
+
+module.exports = {
+  workingCode: binding => {
+    const addon = binding.addon();
+    assert.strictEqual(addon.increment(), 43);
+    assert.strictEqual(addon.increment(), 44);
+    assert.strictEqual(addon.subObject.decrement(), 43);
+  }
+};

package/vendor/node-addon-api/test/child_processes/addon_data.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const assert = require('assert');
+
+// Make sure the instance data finalizer is called at process exit. If the hint
+// is non-zero, it will be printed out by the child process.
+const cleanupTest = (binding, hint) => {
+  binding.addon_data(hint).verbose = true;
+};
+
+module.exports = {
+  workingCode: binding => {
+    const addonData = binding.addon_data(0);
+
+    // Make sure it is possible to get/set instance data.
+    assert.strictEqual(addonData.verbose.verbose, false);
+    addonData.verbose = true;
+    assert.strictEqual(addonData.verbose.verbose, true);
+    addonData.verbose = false;
+    assert.strictEqual(addonData.verbose.verbose, false);
+  },
+  cleanupWithHint: binding => cleanupTest(binding, 42),
+  cleanupWithoutHint: binding => cleanupTest(binding, 0)
+};

package/vendor/node-addon-api/test/child_processes/objectwrap_function.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('../testUtil');
+
+module.exports = {
+  runTest: function (binding) {
+    return testUtil.runGCTests([
+      'objectwrap function',
+      () => {
+        const { FunctionTest } = binding.objectwrap_function();
+        const newConstructed = new FunctionTest();
+        const functionConstructed = FunctionTest();
+        assert(newConstructed instanceof FunctionTest);
+        assert(functionConstructed instanceof FunctionTest);
+        assert.throws(() => (FunctionTest(true)), /an exception/);
+      },
+      // Do one gc before returning.
+      () => {}
+    ]);
+  }
+};

package/vendor/node-addon-api/test/child_processes/threadsafe_function_exception.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common');
+
+module.exports = {
+  testCall: async binding => {
+    const { testCall } = binding.threadsafe_function_exception;
+
+    await new Promise(resolve => {
+      process.once('uncaughtException', common.mustCall(err => {
+        assert.strictEqual(err.message, 'test');
+        resolve();
+      }, 1));
+
+      testCall(common.mustCall(() => {
+        throw new Error('test');
+      }, 1));
+    });
+  },
+  testCallWithNativeCallback: async binding => {
+    const { testCallWithNativeCallback } = binding.threadsafe_function_exception;
+
+    await new Promise(resolve => {
+      process.once('uncaughtException', common.mustCall(err => {
+        assert.strictEqual(err.message, 'test-from-native');
+        resolve();
+      }, 1));
+
+      testCallWithNativeCallback();
+    });
+  }
+};

package/vendor/node-addon-api/test/child_processes/typed_threadsafe_function_exception.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common');
+
+module.exports = {
+  testCall: async binding => {
+    const { testCall } = binding.typed_threadsafe_function_exception;
+
+    await new Promise(resolve => {
+      process.once('uncaughtException', common.mustCall(err => {
+        assert.strictEqual(err.message, 'test-from-native');
+        resolve();
+      }, 1));
+
+      testCall();
+    });
+  }
+};

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

@@ -3,6 +3,11 @@
 const assert = require('assert');
 const path = require('path');
 const { access } = require('node:fs/promises');
+const { spawn } = require('child_process');
+const { EOL } = require('os');
+const readline = require('readline');
+
+const escapeBackslashes = (pathString) => pathString.split('\\').join('\\\\');
 
 const noop = () => {};
 
@@ -26,7 +31,7 @@ function runCallChecks (exitCode) {
       context.name,
       context.messageSegment,
       context.actual);
-    console.log(context.stack.split('\n').slice(2).join('\n'));
+    console.log(context.stack.split(EOL).slice(2).join(EOL));
   });
 
   if (failed.length) process.exit(1);
@@ -143,7 +148,7 @@ async function whichBuildType () {
       if (await checkBuildType(envBuildType)) {
         buildType = envBuildType;
       } else {
-        throw new Error(`The ${envBuildType} build doesn't exists.`);
+        throw new Error(`The ${envBuildType} build doesn't exist.`);
       }
     } else {
       throw new Error('Invalid value for NODE_API_BUILD_CONFIG environment variable. It should be set to Release or Debug.');
@@ -164,7 +169,7 @@ exports.runTest = async function (test, buildType, buildPathRoot = process.env.B
   ].map(it => require.resolve(it));
 
   for (const item of bindings) {
-    await Promise.resolve(test(require(item)))
+    await Promise.resolve(test(require(item), { bindingPath: item }))
       .finally(exports.mustCall());
   }
 };
@@ -190,3 +195,52 @@ exports.runTestWithBuildType = async function (test, buildType) {
   await Promise.resolve(test(buildType))
     .finally(exports.mustCall());
 };
+
+// Some tests have to run in their own process, otherwise they would interfere
+// with each other. Such tests export a factory function rather than the test
+// itself so as to avoid automatic instantiation, and therefore interference,
+// in the main process. Two examples are addon and addon_data, both of which
+// use Napi::Env::SetInstanceData(). This helper function provides a common
+// approach for running such tests.
+exports.runTestInChildProcess = function ({ suite, testName, expectedStderr, execArgv }) {
+  return exports.runTestWithBindingPath((bindingName) => {
+    return new Promise((resolve) => {
+      bindingName = escapeBackslashes(bindingName);
+      // Test suites are assumed to be located here.
+      const suitePath = escapeBackslashes(path.join(__dirname, '..', 'child_processes', suite));
+      const child = spawn(process.execPath, [
+        '--expose-gc',
+        ...(execArgv ?? []),
+        '-e',
+        `require('${suitePath}').${testName}(require('${bindingName}'))`
+      ]);
+      const resultOfProcess = { stderr: [] };
+
+      // Capture the exit code and signal.
+      child.on('close', (code, signal) => resolve(Object.assign(resultOfProcess, { code, signal })));
+
+      // Capture the stderr as an array of lines.
+      readline
+        .createInterface({ input: child.stderr })
+        .on('line', (line) => {
+          resultOfProcess.stderr.push(line);
+        });
+    }).then(actual => {
+      // Back up the stderr in case the assertion fails.
+      const fullStderr = actual.stderr.map(item => `from child process: ${item}`);
+      const expected = { stderr: expectedStderr, code: 0, signal: null };
+
+      if (!expectedStderr) {
+        // If we don't care about stderr, delete it.
+        delete actual.stderr;
+        delete expected.stderr;
+      } else {
+        // Otherwise we only care about expected lines in the actual stderr, so
+        // filter out everything else.
+        actual.stderr = actual.stderr.filter(line => expectedStderr.includes(line));
+      }
+
+      assert.deepStrictEqual(actual, expected, `Assertion for child process test ${suite}.${testName} failed:${EOL}` + fullStderr.join(EOL));
+    });
+  });
+};

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

@@ -0,0 +1,25 @@
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 8)
+
+using namespace Napi;
+
+namespace {
+
+Value GetModuleFileName(const CallbackInfo& info) {
+  Env env = info.Env();
+  return String::New(env, env.GetModuleFileName());
+}
+
+}  // end anonymous namespace
+
+Object InitEnvMiscellaneous(Env env) {
+  Object exports = Object::New(env);
+
+  exports["get_module_file_name"] = Function::New(env, GetModuleFileName);
+
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,12 @@
+'use strict';
+
+const assert = require('assert');
+const { pathToFileURL } = require('url');
+
+module.exports = require('./common').runTest(test);
+
+function test (binding, { bindingPath } = {}) {
+  const path = binding.env_misc.get_module_file_name();
+  const bindingFileUrl = pathToFileURL(bindingPath).toString();
+  assert(bindingFileUrl === path);
+}