koffi 0.9.1 → 0.9.4

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

@@ -0,0 +1,59 @@
+'use strict';
+const assert = require('assert');
+
+/**
+ *
+ * ThreadSafeFunction Tests: Thread Id Sums
+ *
+ * Every native C++ function that utilizes the TSFN will call the registered
+ * callback with the thread id. Passing Array.prototype.push with a bound array
+ * will push the thread id to the array. Therefore, starting `N` threads, we
+ * will expect the sum of all elements in the array to be `(N-1) * (N) / 2` (as
+ * thread IDs are 0-based)
+ *
+ * We check different methods of passing a ThreadSafeFunction around multiple
+ * threads:
+ *  - `testWithTSFN`: The main thread creates the TSFN. Then, it creates
+ *    threads, passing the TSFN at thread construction. The number of threads is
+ *    static (known at TSFN creation).
+ *  - `testDelayedTSFN`: The main thread creates threads, passing a promise to a
+ *    TSFN at construction. Then, it creates the TSFN, and resolves each
+ *    threads' promise. The number of threads is static.
+ *  - `testAcquire`: The native binding returns a function to start a new. A
+ *    call to this function will return `false` once `N` calls have been made.
+ *    Each thread will acquire its own use of the TSFN, call it, and then
+ *    release.
+ */
+
+const THREAD_COUNT = 5;
+const EXPECTED_SUM = (THREAD_COUNT - 1) * (THREAD_COUNT) / 2;
+
+module.exports = require('../common').runTest(test);
+
+/** @param {number[]} N */
+const sum = (N) => N.reduce((sum, n) => sum + n, 0);
+
+function test(binding) {
+  async function check(bindingFunction) {
+    const calls = [];
+    const result = await bindingFunction(THREAD_COUNT, Array.prototype.push.bind(calls));
+    assert.ok(result);
+    assert.equal(sum(calls), EXPECTED_SUM);
+  }
+
+  async function checkAcquire() {
+    const calls = [];
+    const { promise, createThread, stopThreads } = binding.typed_threadsafe_function_sum.testAcquire(Array.prototype.push.bind(calls));
+    for (let i = 0; i < THREAD_COUNT; i++) {
+      createThread();
+    }
+    stopThreads();
+    const result = await promise;
+    assert.ok(result);
+    assert.equal(sum(calls), EXPECTED_SUM);
+  }
+
+  return check(binding.typed_threadsafe_function_sum.testDelayedTSFN)
+    .then(() => check(binding.typed_threadsafe_function_sum.testWithTSFN))
+    .then(() => checkAcquire());
+}

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

@@ -0,0 +1,53 @@
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+using TSFN = TypedThreadSafeFunction<>;
+using ContextType = std::nullptr_t;
+using FinalizerDataType = void;
+static Value TestUnref(const CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Object global = env.Global();
+  Object resource = info[0].As<Object>();
+  Function cb = info[1].As<Function>();
+  Function setTimeout = MaybeUnwrap(global.Get("setTimeout")).As<Function>();
+  TSFN* tsfn = new TSFN;
+
+  *tsfn = TSFN::New(
+      info.Env(),
+      cb,
+      resource,
+      "Test",
+      1,
+      1,
+      nullptr,
+      [tsfn](Napi::Env /* env */, FinalizerDataType*, ContextType*) {
+        delete tsfn;
+      },
+      static_cast<FinalizerDataType*>(nullptr));
+
+  tsfn->BlockingCall();
+
+  setTimeout.Call(
+      global,
+      {Function::New(
+           env, [tsfn](const CallbackInfo& info) { tsfn->Unref(info.Env()); }),
+       Number::New(env, 100)});
+
+  return info.Env().Undefined();
+}
+
+}  // namespace
+
+Object InitTypedThreadSafeFunctionUnref(Env env) {
+  Object exports = Object::New(env);
+  exports["testUnref"] = Function::New(env, TestUnref);
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,53 @@
+'use strict';
+
+const assert = require('assert');
+
+const isMainProcess = process.argv[1] != __filename;
+
+/**
+ * In order to test that the event loop exits even with an active TSFN, we need
+ * to spawn a new process for the test.
+ *   - Main process: spawns new node instance, executing this script
+ *   - Child process: creates TSFN. Native module Unref's via setTimeout after some time but does NOT call Release.
+ *
+ * Main process should expect child process to exit.
+ */
+
+if (isMainProcess) {
+  module.exports = require('../common').runTestWithBindingPath(test);
+} else {
+  test(process.argv[2]);
+}
+
+function test(bindingFile) {
+  if (isMainProcess) {
+    // Main process
+    return new Promise((resolve, reject) => {
+      const child = require('../napi_child').spawn(process.argv[0], [
+        '--expose-gc', __filename, bindingFile
+      ], { stdio: 'inherit' });
+
+      let timeout = setTimeout( function() {
+        child.kill();
+        timeout = 0;
+        reject(new Error("Expected child to die"));
+      }, 5000);
+
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        timeout = 0;
+        reject(new Error(err));
+      })
+
+      child.on("close", (code) => {
+        if (timeout) clearTimeout(timeout);
+        assert.strictEqual(code, 0, "Expected return value 0");
+        resolve();
+      });
+    });
+  } else {
+    // Child process
+    const binding = require(bindingFile);
+    binding.typed_threadsafe_function_unref.testUnref({}, () => { });
+  }
+}

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

@@ -0,0 +1,58 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  [
+    ['bigint64', BigInt64Array],
+    ['biguint64', BigUint64Array],
+  ].forEach(([type, Constructor]) => {
+    try {
+      const length = 4;
+      const t = binding.typedarray.createTypedArray(type, length);
+      assert.ok(t instanceof Constructor);
+      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
+      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
+
+      t[3] = 11n;
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
+      binding.typedarray.setTypedArrayElement(t, 3, 22n);
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
+      assert.strictEqual(t[3], 22n);
+
+      const b = binding.typedarray.getTypedArrayBuffer(t);
+      assert.ok(b instanceof ArrayBuffer);
+    } catch (e) {
+      console.log(type, Constructor);
+      throw e;
+    }
+
+    try {
+      const length = 4;
+      const offset = 8;
+      const b = new ArrayBuffer(offset + 64 * 4);
+
+      const t = binding.typedarray.createTypedArray(type, length, b, offset);
+      assert.ok(t instanceof Constructor);
+      assert.strictEqual(binding.typedarray.getTypedArrayType(t), type);
+      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
+
+      t[3] = 11n;
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11n);
+      binding.typedarray.setTypedArrayElement(t, 3, 22n);
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22n);
+      assert.strictEqual(t[3], 22n);
+
+      assert.strictEqual(binding.typedarray.getTypedArrayBuffer(t), b);
+    } catch (e) {
+      console.log(type, Constructor);
+      throw e;
+    }
+  });
+
+  assert.throws(() => {
+    binding.typedarray.createInvalidTypedArray();
+  }, /Invalid (pointer passed as )?argument/);
+}

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

@@ -0,0 +1,216 @@
+#include "napi.h"
+
+using namespace Napi;
+
+#if defined(NAPI_HAS_CONSTEXPR)
+#define NAPI_TYPEDARRAY_NEW(className, env, length, type) className::New(env, length)
+#define NAPI_TYPEDARRAY_NEW_BUFFER(className, env, length, buffer, bufferOffset, type) \
+  className::New(env, length, buffer, bufferOffset)
+#else
+#define NAPI_TYPEDARRAY_NEW(className, env, length, type) className::New(env, length, type)
+#define NAPI_TYPEDARRAY_NEW_BUFFER(className, env, length, buffer, bufferOffset, type) \
+  className::New(env, length, buffer, bufferOffset, type)
+#endif
+
+namespace {
+
+Value CreateTypedArray(const CallbackInfo& info) {
+  std::string arrayType = info[0].As<String>();
+  size_t length = info[1].As<Number>().Uint32Value();
+  ArrayBuffer buffer = info[2].As<ArrayBuffer>();
+  size_t bufferOffset = info[3].IsUndefined() ? 0 : info[3].As<Number>().Uint32Value();
+
+  if (arrayType == "int8") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Int8Array, info.Env(), length, napi_int8_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Int8Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_int8_array);
+  } else if (arrayType == "uint8") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Uint8Array, info.Env(), length, napi_uint8_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Uint8Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_uint8_array);
+  } else if (arrayType == "uint8_clamped") {
+    return buffer.IsUndefined() ?
+      Uint8Array::New(info.Env(), length, napi_uint8_clamped_array) :
+      Uint8Array::New(info.Env(), length, buffer, bufferOffset, napi_uint8_clamped_array);
+  } else if (arrayType == "int16") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Int16Array, info.Env(), length, napi_int16_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Int16Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_int16_array);
+  } else if (arrayType == "uint16") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Uint16Array, info.Env(), length, napi_uint16_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Uint16Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_uint16_array);
+  } else if (arrayType == "int32") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Int32Array, info.Env(), length, napi_int32_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Int32Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_int32_array);
+  } else if (arrayType == "uint32") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Uint32Array, info.Env(), length, napi_uint32_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Uint32Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_uint32_array);
+  } else if (arrayType == "float32") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Float32Array, info.Env(), length, napi_float32_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Float32Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_float32_array);
+  } else if (arrayType == "float64") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(Float64Array, info.Env(), length, napi_float64_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(Float64Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_float64_array);
+#if (NAPI_VERSION > 5)
+  } else if (arrayType == "bigint64") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(BigInt64Array, info.Env(), length, napi_bigint64_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(BigInt64Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_bigint64_array);
+  } else if (arrayType == "biguint64") {
+    return buffer.IsUndefined() ?
+      NAPI_TYPEDARRAY_NEW(BigUint64Array, info.Env(), length, napi_biguint64_array) :
+      NAPI_TYPEDARRAY_NEW_BUFFER(BigUint64Array, info.Env(), length, buffer, bufferOffset,
+                                 napi_biguint64_array);
+#endif
+  } else {
+    Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CreateInvalidTypedArray(const CallbackInfo& info) {
+  return NAPI_TYPEDARRAY_NEW_BUFFER(Int8Array, info.Env(), 1, ArrayBuffer(), 0, napi_int8_array);
+}
+
+Value GetTypedArrayType(const CallbackInfo& info) {
+  TypedArray array = info[0].As<TypedArray>();
+  switch (array.TypedArrayType()) {
+    case napi_int8_array: return String::New(info.Env(), "int8");
+    case napi_uint8_array: return String::New(info.Env(), "uint8");
+    case napi_uint8_clamped_array: return String::New(info.Env(), "uint8_clamped");
+    case napi_int16_array: return String::New(info.Env(), "int16");
+    case napi_uint16_array: return String::New(info.Env(), "uint16");
+    case napi_int32_array: return String::New(info.Env(), "int32");
+    case napi_uint32_array: return String::New(info.Env(), "uint32");
+    case napi_float32_array: return String::New(info.Env(), "float32");
+    case napi_float64_array: return String::New(info.Env(), "float64");
+#if (NAPI_VERSION > 5)
+    case napi_bigint64_array: return String::New(info.Env(), "bigint64");
+    case napi_biguint64_array: return String::New(info.Env(), "biguint64");
+#endif
+    default: return String::New(info.Env(), "invalid");
+  }
+}
+
+Value GetTypedArrayLength(const CallbackInfo& info) {
+  TypedArray array = info[0].As<TypedArray>();
+  return Number::New(info.Env(), static_cast<double>(array.ElementLength()));
+}
+
+Value GetTypedArrayBuffer(const CallbackInfo& info) {
+  TypedArray array = info[0].As<TypedArray>();
+  return array.ArrayBuffer();
+}
+
+Value GetTypedArrayElement(const CallbackInfo& info) {
+  TypedArray array = info[0].As<TypedArray>();
+  size_t index = info[1].As<Number>().Uint32Value();
+  switch (array.TypedArrayType()) {
+    case napi_int8_array:
+      return Number::New(info.Env(), array.As<Int8Array>()[index]);
+    case napi_uint8_array:
+      return Number::New(info.Env(), array.As<Uint8Array>()[index]);
+    case napi_uint8_clamped_array:
+      return Number::New(info.Env(), array.As<Uint8Array>()[index]);
+    case napi_int16_array:
+      return Number::New(info.Env(), array.As<Int16Array>()[index]);
+    case napi_uint16_array:
+      return Number::New(info.Env(), array.As<Uint16Array>()[index]);
+    case napi_int32_array:
+      return Number::New(info.Env(), array.As<Int32Array>()[index]);
+    case napi_uint32_array:
+      return Number::New(info.Env(), array.As<Uint32Array>()[index]);
+    case napi_float32_array:
+      return Number::New(info.Env(), array.As<Float32Array>()[index]);
+    case napi_float64_array:
+      return Number::New(info.Env(), array.As<Float64Array>()[index]);
+#if (NAPI_VERSION > 5)
+    case napi_bigint64_array:
+      return BigInt::New(info.Env(), array.As<BigInt64Array>()[index]);
+    case napi_biguint64_array:
+      return BigInt::New(info.Env(), array.As<BigUint64Array>()[index]);
+#endif
+    default:
+      Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
+      return Value();
+  }
+}
+
+void SetTypedArrayElement(const CallbackInfo& info) {
+  TypedArray array = info[0].As<TypedArray>();
+  size_t index = info[1].As<Number>().Uint32Value();
+  Number value = info[2].As<Number>();
+  switch (array.TypedArrayType()) {
+    case napi_int8_array:
+      array.As<Int8Array>()[index] = static_cast<int8_t>(value.Int32Value());
+      break;
+    case napi_uint8_array:
+      array.As<Uint8Array>()[index] = static_cast<uint8_t>(value.Uint32Value());
+      break;
+    case napi_uint8_clamped_array:
+      array.As<Uint8Array>()[index] = static_cast<uint8_t>(value.Uint32Value());
+      break;
+    case napi_int16_array:
+      array.As<Int16Array>()[index] = static_cast<int16_t>(value.Int32Value());
+      break;
+    case napi_uint16_array:
+      array.As<Uint16Array>()[index] = static_cast<uint16_t>(value.Uint32Value());
+      break;
+    case napi_int32_array:
+      array.As<Int32Array>()[index] = value.Int32Value();
+      break;
+    case napi_uint32_array:
+      array.As<Uint32Array>()[index] = value.Uint32Value();
+      break;
+    case napi_float32_array:
+      array.As<Float32Array>()[index] = value.FloatValue();
+      break;
+    case napi_float64_array:
+      array.As<Float64Array>()[index] = value.DoubleValue();
+      break;
+#if (NAPI_VERSION > 5)
+    case napi_bigint64_array: {
+      bool lossless;
+      array.As<BigInt64Array>()[index] = value.As<BigInt>().Int64Value(&lossless);
+      break;
+    }
+    case napi_biguint64_array: {
+      bool lossless;
+      array.As<BigUint64Array>()[index] = value.As<BigInt>().Uint64Value(&lossless);
+      break;
+    }
+#endif
+    default:
+      Error::New(info.Env(), "Invalid typed-array type.").ThrowAsJavaScriptException();
+  }
+}
+
+} // end anonymous namespace
+
+Object InitTypedArray(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createTypedArray"] = Function::New(env, CreateTypedArray);
+  exports["createInvalidTypedArray"] = Function::New(env, CreateInvalidTypedArray);
+  exports["getTypedArrayType"] = Function::New(env, GetTypedArrayType);
+  exports["getTypedArrayLength"] = Function::New(env, GetTypedArrayLength);
+  exports["getTypedArrayBuffer"] = Function::New(env, GetTypedArrayBuffer);
+  exports["getTypedArrayElement"] = Function::New(env, GetTypedArrayElement);
+  exports["setTypedArrayElement"] = Function::New(env, SetTypedArrayElement);
+
+  return exports;
+}

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

@@ -0,0 +1,69 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  const testData = [
+    [ 'int8', Int8Array ],
+    [ 'uint8', Uint8Array ],
+    [ 'uint8_clamped', Uint8ClampedArray ],
+    [ 'int16', Int16Array ],
+    [ 'uint16', Uint16Array ],
+    [ 'int32', Int32Array ],
+    [ 'uint32', Uint32Array ],
+    [ 'float32', Float32Array ],
+    [ 'float64', Float64Array ],
+  ];
+
+  testData.forEach(data => {
+    try {
+      const length = 4;
+      const t = binding.typedarray.createTypedArray(data[0], length);
+      assert.ok(t instanceof data[1]);
+      assert.strictEqual(binding.typedarray.getTypedArrayType(t), data[0]);
+      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
+
+      t[3] = 11;
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11);
+      binding.typedarray.setTypedArrayElement(t, 3, 22);
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22);
+      assert.strictEqual(t[3], 22);
+
+      const b = binding.typedarray.getTypedArrayBuffer(t);
+      assert.ok(b instanceof ArrayBuffer);
+    } catch (e) {
+      console.log(data);
+      throw e;
+    }
+  });
+
+  testData.forEach(data => {
+    try {
+      const length = 4;
+      const offset = 8;
+      const b = new ArrayBuffer(offset + 64 * 4);
+
+      const t = binding.typedarray.createTypedArray(data[0], length, b, offset);
+      assert.ok(t instanceof data[1]);
+      assert.strictEqual(binding.typedarray.getTypedArrayType(t), data[0]);
+      assert.strictEqual(binding.typedarray.getTypedArrayLength(t), length);
+
+      t[3] = 11;
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 11);
+      binding.typedarray.setTypedArrayElement(t, 3, 22);
+      assert.strictEqual(binding.typedarray.getTypedArrayElement(t, 3), 22);
+      assert.strictEqual(t[3], 22);
+
+      assert.strictEqual(binding.typedarray.getTypedArrayBuffer(t), b);
+    } catch (e) {
+      console.log(data);
+      throw e;
+    }
+  });
+
+  assert.throws(() => {
+    binding.typedarray.createInvalidTypedArray();
+  }, /Invalid (pointer passed as )?argument/);
+}

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

@@ -0,0 +1,27 @@
+#include "napi.h"
+
+using namespace Napi;
+
+Value getNapiVersion(const CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    uint32_t napi_version = VersionManagement::GetNapiVersion(env);
+    return Number::New(env, napi_version);
+}
+
+Value getNodeVersion(const CallbackInfo& info) {
+    Napi::Env env = info.Env();
+    const napi_node_version*  node_version = VersionManagement::GetNodeVersion(env);
+    Object version = Object::New(env);
+    version.Set("major", Number::New(env, node_version->major));
+    version.Set("minor", Number::New(env, node_version->minor));
+    version.Set("patch", Number::New(env, node_version->patch));
+    version.Set("release", String::New(env, node_version->release));
+    return version;
+}
+
+Object InitVersionManagement(Env env) {
+    Object exports = Object::New(env);
+    exports["getNapiVersion"] = Function::New(env, getNapiVersion);
+    exports["getNodeVersion"] = Function::New(env, getNodeVersion);
+    return exports;
+}

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

@@ -0,0 +1,31 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function parseVersion() {
+    const expected = {};
+    expected.napi = parseInt(process.versions.napi);
+    expected.release = process.release.name;
+    const nodeVersion = process.versions.node.split('.');
+    expected.major = parseInt(nodeVersion[0]);
+    expected.minor = parseInt(nodeVersion[1]);
+    expected.patch = parseInt(nodeVersion[2]);
+    return expected;
+}
+
+function test(binding) {
+
+    const expected = parseVersion();
+
+    const napiVersion = binding.version_management.getNapiVersion();
+    assert.strictEqual(napiVersion, expected.napi);
+
+    const nodeVersion = binding.version_management.getNodeVersion();
+    assert.strictEqual(nodeVersion.major, expected.major);
+    assert.strictEqual(nodeVersion.minor, expected.minor);
+    assert.strictEqual(nodeVersion.patch, expected.patch);
+    assert.strictEqual(nodeVersion.release, expected.release);
+
+}

package/vendor/node-addon-api/tools/README.md

@@ -0,0 +1,73 @@
+# Tools
+
+## clang-format
+
+The clang-format checking tools is designed to check changed lines of code compared to given git-refs.
+
+## Migration Script
+
+The migration tool is designed to reduce repetitive work in the migration process. However, the script is not aiming to convert every thing for you. There are usually some small fixes and major reconstruction required.
+
+### How To Use
+
+To run the conversion script, first make sure you have the latest `node-addon-api` in your `node_modules` directory.
+```
+npm install node-addon-api
+```
+
+Then run the script passing your project directory
+```
+node ./node_modules/node-addon-api/tools/conversion.js ./
+```
+
+After finish, recompile and debug things that are missed by the script.
+
+
+### Quick Fixes
+Here is the list of things that can be fixed easily.
+  1. Change your methods' return value to void if it doesn't return value to JavaScript.
+  2. Use `.` to access attribute or to invoke member function in Napi::Object instead of `->`.
+  3. `Napi::New(env, value);` to `Napi::[Type]::New(env, value);
+
+
+### Major Reconstructions
+The implementation of `Napi::ObjectWrap` is significantly different from NAN's. `Napi::ObjectWrap` takes a pointer to the wrapped object and creates a reference to the wrapped object inside ObjectWrap constructor. `Napi::ObjectWrap` also associates wrapped object's instance methods to Javascript module instead of static methods like NAN.
+
+So if you use Nan::ObjectWrap in your module, you will need to execute the following steps.
+
+  1. Convert your [ClassName]::New function to a constructor function that takes a `Napi::CallbackInfo`. Declare it as
+```
+[ClassName](const Napi::CallbackInfo& info);
+```
+and define it as
+```
+[ClassName]::[ClassName](const Napi::CallbackInfo& info) : Napi::ObjectWrap<[ClassName]>(info){
+  ...
+}
+```
+This way, the `Napi::ObjectWrap` constructor will be invoked after the object has been instantiated and `Napi::ObjectWrap` can use the `this` pointer to create a reference to the wrapped object.
+
+  2. Move your original constructor code into the new constructor. Delete your original constructor.
+  3. In your class initialization function, associate native methods in the following way.
+```
+Napi::FunctionReference constructor;
+
+void [ClassName]::Init(Napi::Env env, Napi::Object exports, Napi::Object module) {
+  Napi::HandleScope scope(env);
+  Napi::Function ctor = DefineClass(env, "Canvas", {
+    InstanceMethod<&[ClassName]::Func1>("Func1"),
+    InstanceMethod<&[ClassName]::Func2>("Func2"),
+    InstanceAccessor<&[ClassName]::ValueGetter>("Value"),
+    StaticMethod<&[ClassName]::StaticMethod>("MethodName"),
+    InstanceValue("Value", Napi::[Type]::New(env, value)),
+  });
+
+  constructor = Napi::Persistent(ctor);
+  constructor .SuppressDestruct();
+  exports.Set("[ClassName]", ctor);
+}
+```
+  4. In function where you need to Unwrap the ObjectWrap in NAN like `[ClassName]* native = Nan::ObjectWrap::Unwrap<[ClassName]>(info.This());`, use `this` pointer directly as the unwrapped object as each ObjectWrap instance is associated with a unique object instance.
+
+
+If you still find issues after following this guide, please leave us an issue describing your problem and we will try to resolve it.