converted to N-API

Author: Eugeny

.editorconfig

@@ -0,0 +1,8 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 4
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

binding.gyp

@@ -2,12 +2,21 @@
   "targets": [
     {
       "target_name": "native",
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "xcode_settings": { "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+        "CLANG_CXX_LIBRARY": "libc++",
+        "MACOSX_DEPLOYMENT_TARGET": "10.7",
+      },
+      "msvs_settings": {
+        "VCCLCompilerTool": { "ExceptionHandling": 1 },
+      },
       "sources": [
         "src/addon.cc",
         "src/worker.cc",
       ],
       "include_dirs": [
-        "<!(node -e \"require('nan')\")"
+        "<!@(node -p \"require('node-addon-api').include\")",
       ]
     }
   ]

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "macos-native-processlist",
-  "version": "1.0.2",
+  "version": "2.0.0",
   "description": "Loads the full process list on macOS",
   "main": "index.js",
   "types": "typings/macos-native-processlist.d.ts",
@@ -18,7 +18,7 @@
     "darwin"
   ],
   "dependencies": {
-    "nan": "^2.13.2"
+    "node-addon-api": "3.0.0"
   },
   "devDependencies": {
     "ava": "^3.11.1"

package.json

@@ -1,14 +1,20 @@
-#include <nan.h>
+#include <napi.h>
+#include <uv.h>
 #include "worker.h"
-using namespace Nan;
+using namespace Napi;
 
-NAN_METHOD(GetProcessList) {
-  auto callback = new Callback(info[0].As<v8::Function>());
-  AsyncQueueWorker(new Worker(callback));
+Napi::Value GetProcessList(const Napi::CallbackInfo &info)
+{
+    auto env = info.Env();
+    auto callback = info[0].As<Napi::Function>();
+    (new Worker(callback))->Queue();
+    return env.Null();
 }
 
-NAN_MODULE_INIT(Init) {
-  Export(target, "getProcessList", GetProcessList);
+Napi::Object Init(Napi::Env env, Napi::Object exports)
+{
+    exports.Set("getProcessList", Napi::Function::New(env, GetProcessList));
+    return exports;
 }
 
-NAN_MODULE_WORKER_ENABLED(NODE_GYP_MODULE_NAME, Init)
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)

src/addon.cc

@@ -1,23 +1,24 @@
 #include "worker.h"
 #include <libproc.h>
 
-using namespace Nan;
-
-Worker::Worker(Callback* callback) : AsyncWorker(callback) {
+Worker::Worker(Napi::Function &callback) : AsyncWorker(callback)
+{
     this->processes = new kinfo_proc[1024];
     processCount = new uint32_t;
 }
 
-Worker::~Worker() {
-  delete[] this->processes;
-  delete processCount;
+Worker::~Worker()
+{
+    delete[] this->processes;
+    delete processCount;
 }
 
-void Worker::Execute() {
+void Worker::Execute()
+{
     bool done;
     int err;
     size_t length = 0;
-    static const int name[] = { CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0 };
+    static const int name[] = {CTL_KERN, KERN_PROC, KERN_PROC_ALL, 0};
 
     *this->processCount = 0;
 
@@ -33,69 +34,77 @@ void Worker::Execute() {
 
     this->processes = NULL;
     done = false;
-    do {
+    do
+    {
         assert(this->processes == NULL);
 
         // Call sysctl with a NULL buffer.
 
         length = 0;
-        err = sysctl((int*)name, sizeof(name) / sizeof(*name) - 1, NULL, &length, NULL, 0);
-        if (err == -1) {
+        err = sysctl((int *)name, sizeof(name) / sizeof(*name) - 1, NULL, &length, NULL, 0);
+        if (err == -1)
+        {
             err = errno;
         }
 
         // Allocate an appropriately sized buffer based on the results
         // from the previous call.
 
-        if (err == 0) {
-            this->processes = (kinfo_proc*)malloc(length);
+        if (err == 0)
+        {
+            this->processes = (kinfo_proc *)malloc(length);
         }
 
         // Call sysctl again with the new buffer.  If we get an ENOMEM
         // error, toss away our buffer and start again.
 
-        if (err == 0) {
-            err = sysctl((int*)name, sizeof(name) / sizeof(*name) - 1, this->processes, &length, NULL, 0);
-            if (err == -1) {
+        if (err == 0)
+        {
+            err = sysctl((int *)name, sizeof(name) / sizeof(*name) - 1, this->processes, &length, NULL, 0);
+            if (err == -1)
+            {
                 err = errno;
             }
-            if (err == 0) {
+            if (err == 0)
+            {
                 done = true;
-            } else if (err == ENOMEM) {
+            }
+            else if (err == ENOMEM)
+            {
                 assert(this->processes != NULL);
                 free(this->processes);
                 this->processes = NULL;
                 err = 0;
             }
         }
-    } while (err == 0 && ! done);
+    } while (err == 0 && !done);
 
-    if (err == 0) {
+    if (err == 0)
+    {
         *this->processCount = length / sizeof(kinfo_proc);
     }
 }
 
 #define NAME_BUFFER_SIZE 4096
 
-void Worker::HandleOKCallback() {
-  HandleScope scope;
-
-  v8::Local<v8::Array> result = New<v8::Array>(*processCount);
-  for (uint32_t i = 0; i < *processCount; i++) {
-    v8::Local<v8::Object> object = New<v8::Object>();
-
-    char buffer[NAME_BUFFER_SIZE];
-    proc_name(this->processes[i].kp_proc.p_pid, buffer, NAME_BUFFER_SIZE);
-    Set(object, New<v8::String>("name").ToLocalChecked(), New<v8::String>(buffer).ToLocalChecked());
-    proc_pidpath(this->processes[i].kp_proc.p_pid, buffer, NAME_BUFFER_SIZE);
-    Set(object, New<v8::String>("path").ToLocalChecked(), New<v8::String>(buffer).ToLocalChecked());
-    Set(object, New<v8::String>("pid").ToLocalChecked(), New<v8::Number>(this->processes[i].kp_proc.p_pid));
-    Set(object, New<v8::String>("ppid").ToLocalChecked(), New<v8::Number>(this->processes[i].kp_eproc.e_ppid));
-    Set(object, New<v8::String>("pgid").ToLocalChecked(), New<v8::Number>(this->processes[i].kp_eproc.e_pgid));
-    Set(result, i, New<v8::Value>(object));
-  }
-
-  v8::Local<v8::Value> argv[] = { result };
-  AsyncResource resource("macos-native-processlist:addon.HandleOKCallback");
-  callback->Call(1, argv, &resource);
+void Worker::OnOK()
+{
+    auto env = this->Env();
+    auto result = Napi::Array::New(env);
+    for (uint32_t i = 0; i < *processCount; i++)
+    {
+        auto object = Napi::Object::New(env);
+
+        char buffer[NAME_BUFFER_SIZE];
+        proc_name(this->processes[i].kp_proc.p_pid, buffer, NAME_BUFFER_SIZE);
+        object.Set("name", Napi::String::New(env, buffer));
+        proc_pidpath(this->processes[i].kp_proc.p_pid, buffer, NAME_BUFFER_SIZE);
+        object.Set("path", Napi::String::New(env, buffer));
+        object.Set("pid", Napi::Number::New(env, this->processes[i].kp_proc.p_pid));
+        object.Set("ppid", Napi::Number::New(env, this->processes[i].kp_eproc.e_ppid));
+        object.Set("pgid", Napi::Number::New(env, this->processes[i].kp_eproc.e_pgid));
+        result.Set(i, object);
+    }
+
+    this->Callback().Call({result});
 }

src/worker.cc

@@ -1,16 +1,19 @@
 #pragma once
-#include <nan.h>
+#include <napi.h>
+#include <uv.h>
 #include <sys/sysctl.h>
 #include <pwd.h>
 
-class Worker : public Nan::AsyncWorker {
- public:
-  Worker(Nan::Callback *callback);
-  ~Worker();
+class Worker : public Napi::AsyncWorker
+{
+public:
+    Worker(Napi::Function &callback);
+    ~Worker();
 
-  void Execute();
-  void HandleOKCallback();
- private:
-  kinfo_proc* processes;
-  uint32_t* processCount;
+    void Execute();
+    void OnOK();
+
+private:
+    kinfo_proc *processes;
+    uint32_t *processCount;
 };