Doing extends on the native side

binding.cc

#include <stdio.h>
#include <node.h>

static void
NativeClassConstructor(const v8::FunctionCallbackInfo<v8::Value>& info) {
}

static void
NativeClassProtoMethod(const v8::FunctionCallbackInfo<v8::Value>& info) {
  fprintf(stderr, "NativeClassProtoMethod was called\n");
}

static v8::Local<v8::Value>
CreateNativeClassLocal(v8::Isolate* isolate, bool createMethod) {
  v8::Local<v8::Context> context = isolate->GetCurrentContext();

  v8::Local<v8::FunctionTemplate> nativeClass =
      v8::FunctionTemplate::New(isolate, NativeClassConstructor);
  if (createMethod) {
    v8::Local<v8::FunctionTemplate> nativeClassProtoMethod =
        v8::FunctionTemplate::New(isolate, NativeClassProtoMethod,
            v8::Local<v8::Value>(),
            v8::Signature::New(isolate, nativeClass));
    nativeClass->PrototypeTemplate()
        ->Set(isolate, "classMethod", nativeClassProtoMethod);
  }
  return nativeClass->GetFunction(context).ToLocalChecked();
}

static void
CreateNativeClass(const v8::FunctionCallbackInfo<v8::Value>& info) {
  info.GetReturnValue().Set(CreateNativeClassLocal(info.GetIsolate(), true));
}

static void
SubclassMe(const v8::FunctionCallbackInfo<v8::Value>& info) {
  // Cannot use FunctionTemplate::Inherit because we don't have the
  // FunctionTemplate for info[0].

  v8::Isolate* isolate = info.GetIsolate();
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::Local<v8::Value> subclass = CreateNativeClassLocal(isolate, false);
  v8::Local<v8::Value> superclass = info[0];
  v8::Local<v8::Value> subProto = subclass.As<v8::Object>()
      ->Get(context,
          v8::String::NewFromUtf8(isolate, "prototype", v8::NewStringType::kNormal)
              .ToLocalChecked()).ToLocalChecked();
  v8::Local<v8::Value> superProto = superclass.As<v8::Object>()
      ->Get(context,
          v8::String::NewFromUtf8(isolate, "prototype", v8::NewStringType::kNormal)
              .ToLocalChecked()).ToLocalChecked();
  subProto.As<v8::Object>()
      ->Set(context,
          v8::String::NewFromUtf8(isolate, "__proto__", v8::NewStringType::kNormal)
            .ToLocalChecked(),
          superProto).FromJust();
  info.GetReturnValue().Set(subclass);
}

static void Init(v8::Local<v8::Object> exports,
                 v8::Local<v8::Value> module,
                 v8::Local<v8::Context> context) {
  v8::Isolate* isolate = context->GetIsolate();
  exports->Set(context,
      v8::String::NewFromUtf8(isolate, "subclassMe", v8::NewStringType::kNormal)
          .ToLocalChecked(),
      v8::FunctionTemplate::New(isolate, SubclassMe)
          ->GetFunction(context).ToLocalChecked()).FromJust();
  exports->Set(context,
      v8::String::NewFromUtf8(isolate, "createNativeClass",
          v8::NewStringType::kNormal).ToLocalChecked(),
      v8::FunctionTemplate::New(isolate, CreateNativeClass)
          ->GetFunction(context).ToLocalChecked()).FromJust();
}

NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME, Init)

binding.gyp

{
  'targets': [
    {
      'target_name': 'binding',
      'sources': [ 'binding.cc' ]
    }
  ]
}

index.js

const binding = require('./build/Debug/binding');

function subclassMe(superclass) {
  class Subclass extends superclass {
  }
  return Subclass;
}

const JSSuperClass = class {
  classMethod() {
    console.log("JS Superclass prototype method was called");
  }
};


const NativeSuperClass = binding.createNativeClass();

// scenario 1: Superclass was created by JS and subclassing is performed by JS
const JSSubClassOfJSSuperClass = subclassMe(JSSuperClass);
(new JSSubClassOfJSSuperClass()).classMethod();

// scenario 2: Superclass was created by native and subclassing is performed by JS
const JSSubClassOfNativeSuperClass = subclassMe(NativeSuperClass);
(new JSSubClassOfNativeSuperClass()).classMethod();

// scenario 3: Superclass was created by JS and subclassing is performed by native
const NativeSubClassOfJSSuperClass = binding.subclassMe(JSSuperClass);
(new NativeSubClassOfJSSuperClass()).classMethod();

// scenario 4: Superclass was created by native and subclassing is performed by native
const NativeSubClassOfNativeSuperClass = binding.subclassMe(NativeSuperClass);
(new NativeSubClassOfNativeSuperClass()).classMethod();

package.json

{
  "name": "test-inheritance2",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "",
  "license": "ISC"
}