Upgrade node-addon-api Object Wrap example for multi-context support

multiple_load_object_wrap/node-addon-api/addon.cc

@@ -0,0 +1,8 @@
+#include <napi.h>
+#include "myobject.h"
+
+Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
+  return MyObject::Init(env, exports);
+}
+
+NODE_API_MODULE(addon, InitAll)

multiple_load_object_wrap/node-addon-api/addon.js

@@ -0,0 +1,42 @@
+const addon = require('bindings')('addon');
+const {Worker, isMainThread, workerData} = require('worker_threads');
+const os = require('os');
+
+if (isMainThread) {
+    (async function main() {
+        const threads = new Promise(resolve => {
+            const size = os.cpus().length * 2;
+            let wait = size;
+
+            for (let i = 0; i < size; i++) {
+                const worker = new Worker(__filename, {workerData: i});
+
+                worker.on('exit', () => {
+                    wait--;
+                    if (wait === 0) {
+                        resolve();
+                    }
+                });
+            }
+        });
+
+        work('main');
+        await threads;
+    })();
+} else {
+    work(workerData);
+}
+
+function work(id) {
+    const obj = new addon.MyObject(10);
+    for (let i = 0; i < 10; i++) {
+        console.log(id, obj.plusOne());
+    }
+
+    console.log(id, obj.multiply().value());
+    console.log(id, obj.multiply(10).value());
+
+    const newobj = obj.multiply(-1);
+    console.log(id, newobj.value());
+    console.log(id, obj === newobj);
+}

multiple_load_object_wrap/node-addon-api/binding.gyp

@@ -0,0 +1,14 @@
+{
+  "targets": [
+    {
+      "target_name": "addon",
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "sources": [ "addon.cc", "myobject.cc" ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
+    }
+  ]
+}

multiple_load_object_wrap/node-addon-api/myobject.cc

@@ -0,0 +1,69 @@
+#include "myobject.h"
+
+class AddonData {
+public:
+  AddonData(Napi::Function func) {
+    MyObjectConstructor = Napi::Persistent(func);
+    MyObjectConstructor.SuppressDestruct();
+  }
+
+  Napi::FunctionReference MyObjectConstructor;
+};
+
+Napi::Object MyObject::Init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+
+  Napi::Function func =
+      DefineClass(env,
+                  "MyObject",
+                  {InstanceMethod("plusOne", &MyObject::PlusOne),
+                   InstanceMethod("value", &MyObject::GetValue),
+                   InstanceMethod("multiply", &MyObject::Multiply)});
+
+  env.SetInstanceData(new AddonData(func));
+
+  exports.Set("MyObject", func);
+  return exports;
+}
+
+MyObject::MyObject(const Napi::CallbackInfo& info)
+    : Napi::ObjectWrap<MyObject>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  int length = info.Length();
+
+  if (length <= 0 || !info[0].IsNumber()) {
+    Napi::TypeError::New(env, "Number expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Number value = info[0].As<Napi::Number>();
+  this->value_ = value.DoubleValue();
+}
+
+Napi::Value MyObject::GetValue(const Napi::CallbackInfo& info) {
+  double num = this->value_;
+
+  return Napi::Number::New(info.Env(), num);
+}
+
+Napi::Value MyObject::PlusOne(const Napi::CallbackInfo& info) {
+  this->value_ = this->value_ + 1;
+
+  return MyObject::GetValue(info);
+}
+
+Napi::Value MyObject::Multiply(const Napi::CallbackInfo& info) {
+  Napi::Number multiple;
+  if (info.Length() <= 0 || !info[0].IsNumber()) {
+    multiple = Napi::Number::New(info.Env(), 1);
+  } else {
+    multiple = info[0].As<Napi::Number>();
+  }
+
+  Napi::Object obj = info.Env().GetInstanceData<AddonData>()->MyObjectConstructor.New(
+      {Napi::Number::New(info.Env(), this->value_ * multiple.DoubleValue())});
+
+  return obj;
+}

multiple_load_object_wrap/node-addon-api/myobject.h

@@ -0,0 +1,19 @@
+#ifndef MYOBJECT_H
+#define MYOBJECT_H
+
+#include <napi.h>
+
+class MyObject : public Napi::ObjectWrap<MyObject> {
+ public:
+  static Napi::Object Init(Napi::Env env, Napi::Object exports);
+  MyObject(const Napi::CallbackInfo& info);
+
+ private:
+  Napi::Value GetValue(const Napi::CallbackInfo& info);
+  Napi::Value PlusOne(const Napi::CallbackInfo& info);
+  Napi::Value Multiply(const Napi::CallbackInfo& info);
+
+  double value_;
+};
+
+#endif

multiple_load_object_wrap/node-addon-api/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "object_wrap",
+  "version": "0.0.0",
+  "description": "Multiple load example of ObjectWrap",
+  "main": "addon.js",
+  "private": true,
+  "gypfile": true,
+  "engines": {
+    "node": ">= 14.0.0"
+  },
+  "dependencies": {
+    "bindings": "~1.2.1",
+    "node-addon-api": "^3.0.0"
+  }
+}