What is the best way to inherit from EventTarget on the native side?

[gabrielschulhof]

As I work on https://github.com/nodejs/webidl-napi I see that some of the interfaces described in webgpu.idl extend EventTarget. We now have EventTarget in Node.js. So, are there some links that point me to how to use it from a native add-on? I don't think I can inherit from it outright except via prototype assignment.

Looking at https://www.nearform.com/blog/node-js-and-the-struggles-of-being-an-eventtarget/ so far.

[jasnell]

During bootstrap, we could pass a reference to the EventTarget class constructor down into c++ land and store a reference to it in the Environment. From there, it would be a matter of inheriting from it's FunctionTemplate. We'd have to make sure it would play nicely with the bootstrap snapshot logic (/cc @joyeecheung )

[joyeecheung]

That sounds like how AsyncWrap::GetConstructorTemplate work, which is run at bootstrap (the template is captured in node_mksnapshot), so it should work fine.

[joyeecheung]

Oh wait, we are talking about getting a v8::FunctionTemplate from a v8::Function created from JS..I don't think it's possible to do that with a V8 API?

[jasnell]

I'll see what I can do to make it work

[jasnell]

Ok, #36088 will get us part of the way there. It stores references to the EventTarget and Event constructors on Environment. Those can be used at the native layer to create instances or subclasses. I have not implemented any of that part here yet tho.

[joyeecheung]

I wonder if the implementation of a WebIDL interface can be done in a way similar to how https://github.com/jsdom/webidl2js works - generating JS code that defines classes, whose methods call into native bindings with whatever arguments specified in the definition (and maybe generate the argument unwrapping too), instead of generating native code that define such classes. The implementation is still mostly done in C/C++ but it seems easier (and more readable) to just generate the glue in JS.

[jasnell]

Certainly possible I'd suppose but a much larger concern than what's brought up here.

[gabrielschulhof]

@joyeecheung I'm working on https://github.com/nodejs/webidl-napi which processes a WebIDL file and produces C++ code that defines an add-on such that its exports contains the interfaces defined in the WebIDL. Hopefully there will soon be support for polluting the global namespace as well. Doing that seems to be popular in browser land. There are some significant chunks still missing, with support for WebIDL's: interface Something : EventTarget {...}; having spawned this conversation.

[jasnell]

@gabrielschulhof .. as far as n-api support is concerned, what are you imagining? We can easily have an API like the following:

napi_status napi_create_eventtarget(napi_env env, napi_value* result);
napi_status napi_create_event(napi_env, napi_value name, napi_value* result);

napi_status napi_eventtarget_dispatch(napi_env env, napi_value eventarget, napi_value event);
napi_status napi_eventtarget_addlistener(napi_env, napi_value eventarget, napi_value name, napi_value handler, napi_value options);
napi_status napi_eventtarget_removelistener(napi_env, napi_value eventtarget, napi_value name, napi_value handler);

Which could allow creating instances of EventTarget and Event from native addons but it wouldn't address creating new classes that inherit from those.

napi_define_class does not currently provide a way of specifying inheritance and, unless I missed it, there is no way to set the prototype of an object in N-API yet. So there would be some additional work needed.

[gabrielschulhof]

@jasnell in N-API we can do, courtesy of @addaleax's EventTarget talk,

class NotAnEventEmitter {}
const obj = new NotAnEventEmitter();

// ✨ Magic inheritance change ✨
EventEmitter.call(obj);
Object.setPrototypeOf(obj, EventEmitter.prototype);

// obj is now an EventEmitter:
obj.on('message', console.log);
obj.emit('message', 'Hello, world!');

By doing

napi_value global, Object, setPrototypeOf;
napi_get_global(env, &global);
napi_get_named_property(env, global, "Object", &Object);
napi_get_named_property(env, global, Object, "setPrototypeOf", &setPrototypeOf);
napi_call_function(env, Object, setPrototypeOf, ...);

on the native side, but that is not true inheritance because, as @joyeecheung pointed out, we don't have the FunctionTemplate, and we do not have a way of retrieving the EventTarget FunctionTemplate. Nevertheless, for EventTarget and Event, this approach might be sufficient. We could even guard against prototype abuse with napi_type_tag_object of the resulting instances.

In terms of adding new N-APIs like napi_create_eventtarget I don't know if we should go down that path until we have need to access internals because these APIs are not strictly engine APIs but W3C APIs, so they stretch the mandate of N-API a bit.

As far as generic inheritance is concerned, I was thinking about (and this is a slightly different topic from EventTarget) saving the FunctionTemplate in a v8::Private-keyed property of the constructor it produces. Then, we could do napi_define_subclass with the documented caveat that it only works for deriving subclasses from superclasses that were themselves created with either napi_define_class or napi_define_subclass. It would allow add-on maintainers to define expose class hierarchies as well as individual classes, as long as all members of the hierarchy were defined using napi_define_class and napi_define_subclass.

[gabrielschulhof]

Re: generic inheritance, we'd have to check what can be done in other engines too, before going ahead with a new N-API.

[gabrielschulhof]

Here's a harebrained scheme^W^Wpossible implementation of generic inheritance:

static napi_status napi_define_subclass(napi_env env,
                                        napi_value parent_ctor,
                                        const char* name,
                                        size_t length,
                                        napi_callback ctor,
                                        napi_callback native_getSuperParams,
                                        size_t n_props,
                                        napi_property_descriptor* props,
                                        void* data,
                                        napi_value* child_ctor) {
  std::string formal_args_remainder;
  std::string class_body;
  std::string key;
  std::string propname;
  size_t idx, n_params;

  for (idx = 0, n_params = 0; idx < n_props; idx++) {
    if (!(props[idx].attributes & napi_static)) {
      if (props[idx].name != nullptr) {
        propname = "prop" + std::to_string(n_params++);
        formal_args_remainder += ", " + propname;
        key = "[" + propname + "]";
      } else {
        key = std::string(props[idx].utf8name);
      }
      if (props[idx].value != nullptr) {
        propname = "prop" + std::to_string(n_params++);
        formal_args_remainder += ", " + propname;
        class_body += "    " + key + " = " + propname + ";\n";
      } else if (props[idx].method != nullptr) {
        propname = "prop" + std::to_string(n_params++);
        formal_args_remainder += ", " + propname;
        class_body += "    " + key + "() { return " + propname +
            ".apply(this, arguments); }\n";
      } else {
        if (props[idx].getter != nullptr) {
          propname = "prop" + std::to_string(n_params++);
          formal_args_remainder += ", " + propname;
          class_body += "    get " + key + "() { return " + propname +
            ".apply(this, arguments); }\n";
        }
        if (props[idx].setter != nullptr) {
          propname = "prop" + std::to_string(n_params++);
          formal_args_remainder += ", " + propname;
          class_body += "    set " + key + "(x) { return " + propname +
            ".apply(this, arguments); }\n";
        }
      }
    }
  }

  std::string str =
      "(function(parent, ctor, getSuperParams" + formal_args_remainder + ") {\n"
      "  class " + name + " extends parent {\n"
      "    constructor(){\n"
      "      super(...getSuperParams(arguments));\n"
      "      ctor.apply(this, arguments);\n"
      "    }\n"
      + class_body +
      "  }\n"
      "  return " + name + ";\n"
      "})";


  napi_value call_args[n_params + 3];
  call_args[0] = parent_ctor;
  NAPI_CALL(napi_create_function(env, name, length, ctor, data, &call_args[1]));
  NAPI_CALL(napi_create_function(env,
                                 name,
                                 length,
                                 native_getSuperParams,
                                 data,
                                 &call_args[2]));
  for (idx = 0, n_params = 3; idx < n_props; idx++) {
    if (!(props[idx].attributes & napi_static)) {
      if (props[idx].name != nullptr) {
        call_args[n_params++] = props[idx].name;
      }
      if (props[idx].value != nullptr) {
        call_args[n_params++] = props[idx].value;
      } else if (props[idx].method != nullptr) {
        napi_value method;
        NAPI_CALL(napi_create_function(env,
                                       props[idx].utf8name,
                                       NAPI_AUTO_LENGTH,
                                       props[idx].method,
                                       props[idx].data,
                                       &method));
        call_args[n_params++] = method;
      } else {
        if (props[idx].getter != nullptr) {
          napi_value getter;
          NAPI_CALL(napi_create_function(env,
                                         props[idx].utf8name,
                                         NAPI_AUTO_LENGTH,
                                         props[idx].getter,
                                         props[idx].data,
                                         &getter));
          call_args[n_params++] = getter;
        }
        if (props[idx].setter != nullptr) {
          napi_value setter;
          NAPI_CALL(napi_create_function(env,
                                         props[idx].utf8name,
                                         NAPI_AUTO_LENGTH,
                                         props[idx].setter,
                                         props[idx].data,
                                         &setter));
          call_args[n_params++] = setter;
        }
      }
    }
  }

  napi_value js_str;
  NAPI_CALL(napi_create_string_utf8(env,
                                    str.c_str(),
                                    NAPI_AUTO_LENGTH,
                                    &js_str));

  napi_value fn;
  NAPI_CALL(napi_run_script(env, js_str, &fn));

  napi_value result;
  NAPI_CALL(napi_call_function(env,
                               fn,
                               fn,
                               sizeof(call_args) / sizeof(*call_args),
                               call_args,
                               &result));

  for (idx = 0; idx < n_props; idx++)
    if (props[idx].attributes & napi_static)
      NAPI_CALL(napi_define_properties(env, result, 1, &props[idx]));

  *child_ctor = result;
  return napi_ok;
}

[joyeecheung]

Aha, of course we can just call into JS for the inheritance ;) I wonder if we still need to save EventTarget once it's available from the global object though, but maybe it's good to have something that's guaranteed to be authentic