Napi::ObjectWrap:是否调用析构函数?如何调用？

#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);
  ~MyObject();

private:
  static Napi::FunctionReference constructor;
  void Release();

  // 析构函数
  static void Finalizer(Napi::Env env, void* nativeObject, void* finalizeHint) {
    delete static_cast<MyObject*>(nativeObject);
  }

  // JavaScript构造函数
  static Napi::Value New(const Napi::CallbackInfo& info) {
    Napi::Env env = info.Env();
    Napi::HandleScope scope(env);

    if (info.IsConstructCall()) {
      // 创建C++对象
      MyObject* obj = new MyObject(info);
      // 将C++对象封装为JavaScript对象
      obj->Wrap(info.This());
      return info.This();
    } else {
      // 调用构造函数创建对象
      Napi::Function constructor = Napi::Function::New(env, New);
      return constructor.Call({});
    }
  }
};

Napi::FunctionReference MyObject::constructor;

Napi::Object MyObject::Init(Napi::Env env, Napi::Object exports) {
  Napi::HandleScope scope(env);

  // 定义JavaScript构造函数
  Napi::Function func = DefineClass(env, "MyObject", {
    InstanceMethod("release", &MyObject::Release)
  });

  constructor = Napi::Persistent(func);
  constructor.SuppressDestruct();

  exports.Set("MyObject", func);
  return exports;
}

MyObject::MyObject(const Napi::CallbackInfo& info) : Napi::ObjectWrap<MyObject>(info) {
  // 构造函数逻辑
}

MyObject::~MyObject() {
  // 析构函数逻辑
}

void MyObject::Release(const Napi::CallbackInfo& info) {
  // 调用析构函数释放资源
  delete this;
}

// 在Node.js模块中导出MyObject类
Napi::Object Init(Napi::Env env, Napi::Object exports) {
  return MyObject::Init(env, exports);
}

NODE_API_MODULE(addon, Init)

const addon = require('./addon');

const obj = new addon.MyObject();
// 使用obj对象...

obj.release(); // 调用析构函数释放资源