napi_value newTarget;

napi_value thisArg;

napi_value* argv;

void* data;

uint16_t argc;

public:

JSString(const JSString&) = delete;

JSString(JSString&& other) {

_string = other._string;

other._string = nullptr;

}

JSString(const char* string, size_t length = NAPI_AUTO_LENGTH)

: _string{CreateUTF8(string, length)} {

}

JSString(const JSChar* string, size_t length = NAPI_AUTO_LENGTH)

: _string{JSStringCreateWithCharacters(string, length == NAPI_AUTO_LENGTH ? std::char_traits<JSChar>::length(string) : length)} {

}

~JSString() {

if (_string != nullptr) {

JSStringRelease(_string);

}

}

static JSString Attach(JSStringRef string) {

return {string};

}

operator JSStringRef() const {

return _string;

}

size_t Length() const {

return JSStringGetLength(_string);

}

size_t LengthUTF8() const {

std::vector<char> buffer(JSStringGetMaximumUTF8CStringSize(_string));

return JSStringGetUTF8CString(_string, buffer.data(), buffer.size()) - 1;

}

size_t LengthLatin1() const {

// Latin1 has the same length as Unicode.

return JSStringGetLength(_string);

}

void CopyTo(JSChar* buf, size_t bufsize, size_t* result) const {

size_t length{JSStringGetLength(_string)};

const JSChar* chars{JSStringGetCharactersPtr(_string)};

size_t size{std::min(length, bufsize - 1)};

std::memcpy(buf, chars, size);

buf[size] = 0;

if (result != nullptr) {

*result = size;

}

}

void CopyToUTF8(char* buf, size_t bufsize, size_t* result) const {

size_t size{JSStringGetUTF8CString(_string, buf, bufsize)};

if (result != nullptr) {

// JSStringGetUTF8CString returns size with null terminator.

*result = size - 1;

}

}

void CopyToLatin1(char* buf, size_t bufsize, size_t* result) const {

size_t length{JSStringGetLength(_string)};

const JSChar* chars{JSStringGetCharactersPtr(_string)};

size_t size{std::min(length, bufsize - 1)};

for (int i = 0; i < size; ++i) {

const JSChar ch{chars[i]};

buf[i] = (ch < 256) ? ch : '?';

}

if (result != nullptr) {

*result = size;

}

}

private:

static JSStringRef CreateUTF8(const char* string, size_t length) {

if (length == NAPI_AUTO_LENGTH) {

return JSStringCreateWithUTF8CString(string);

}

std::u16string u16str{std::wstring_convert<

std::codecvt_utf8_utf16<char16_t>, char16_t>{}.from_bytes(string, string + length)};

return JSStringCreateWithCharacters(reinterpret_cast<JSChar*>(u16str.data()), u16str.size());

}

JSString(JSStringRef string)

: _string{string} {

}

JSStringRef _string;

env->last_error.error_code = napi_ok;

env->last_error.engine_error_code = 0;

env->last_error.engine_reserved = nullptr;

return napi_ok;

env->last_error.error_code = error_code;

env->last_error.engine_error_code = engine_error_code;

env->last_error.engine_reserved = engine_reserved;

return error_code;

napi_value error,

napi_value code,

const char* code_cstring) {

napi_value code_value{code};

if (code_value == nullptr) {

code_value = ToNapi(JSValueMakeString(env->context, JSString(code_cstring)));

} else {

RETURN_STATUS_IF_FALSE(env, JSValueIsString(env->context, ToJSValue(code_value)), napi_string_expected);

}

CHECK_NAPI(napi_set_named_property(env, error, "code", code_value));

return napi_ok;

Constructor,

External,

Function,

Reference,

Wrapper,

public:

NativeType Type() const {

return _type;

}

template<typename T>

static T* Get(JSObjectRef obj) {

return reinterpret_cast<T*>(JSObjectGetPrivate(obj));

}

template<typename T>

static T* FindInPrototypeChain(JSContextRef ctx, JSObjectRef obj) {

while (true) {

JSValueRef exception{};

JSObjectRef prototype = JSValueToObject(ctx, JSObjectGetPrototype(ctx, obj), &exception);

if (exception != nullptr) {

return nullptr;

}

NativeInfo* info = Get<NativeInfo>(prototype);

if (info != nullptr && info->Type() == T::StaticType) {

return reinterpret_cast<T*>(info);

}

obj = prototype;

}

}

template<typename T>

static T* GetNativeInfo(JSContextRef ctx, JSObjectRef obj, const char * propertyKey) {

JSValueRef exception {};

JSValueRef native_info = JSObjectGetProperty(ctx, obj, JSString(propertyKey), &exception);

NativeInfo* info = Get<NativeInfo>(JSValueToObject(ctx, native_info, &exception));

if (info != nullptr && info->Type() == T::StaticType) {

return reinterpret_cast<T*>(info);

}

return nullptr;

}

static void SetNativeInfoKey(JSContextRef ctx, JSObjectRef obj, JSClassRef classRef,JSValueRef propertyKey, void * data) {

JSObjectRef info{JSObjectMake(ctx, classRef, data)};

JSObjectSetPropertyForKey(ctx, obj, propertyKey, info, kJSPropertyAttributeDontEnum | kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete, nullptr);

}

static void SetNativeInfo(JSContextRef ctx, JSObjectRef obj, JSClassRef classRef, const char * propertyKey, void * data) {

JSObjectRef info{JSObjectMake(ctx, classRef, data)};

JSObjectSetProperty(ctx, obj, JSString(propertyKey), info, kJSPropertyAttributeDontEnum | kJSPropertyAttributeReadOnly | kJSPropertyAttributeDontDelete, nullptr);

}

protected:

NativeInfo(NativeType type)

: _type{type} {}

private:

NativeType _type;

public:

static const NativeType StaticType = NativeType::Constructor;

static napi_status Create(napi_env env,

const char* utf8name,

size_t length,

napi_callback cb,

void* data,

napi_value* result) {

ConstructorInfo* info{new ConstructorInfo(env, utf8name, length, cb, data)};

if (info == nullptr) {

return napi_set_last_error(env, napi_generic_failure);

}

JSObjectRef constructor{JSObjectMakeConstructor(env->context, info->_class, CallAsConstructor)};

JSValueRef exception{};

if (length) {

napi_value name;

napi_create_string_utf8(env, utf8name, length, &name);

JSObjectSetProperty(env->context, constructor, JSString("name"), ToJSValue(name), kJSPropertyAttributeNone, &exception);

}

JSObjectRef prototype{(JSObjectRef) JSObjectGetProperty(env->context, constructor, JSString("prototype"), &exception)};

NativeInfo::SetNativeInfo(env->context, constructor, info->_class, "[[jsc_constructor_info]]", info);

JSObjectSetProperty(env->context, prototype, JSString("constructor"), constructor,

kJSPropertyAttributeNone, &exception);

CHECK_JSC(env, exception);

*result = ToNapi(constructor);

return napi_ok;

}

private:

ConstructorInfo(napi_env env, const char* name, size_t length, napi_callback cb, void* data)

: NativeInfo{NativeType::Constructor}

, _env{env}

, _name{name, (length == NAPI_AUTO_LENGTH ? std::strlen(name) : length)}

, _cb{cb}

, _data{data} {

JSClassDefinition classDefinition{kJSClassDefinitionEmpty};

classDefinition.className = _name.data();

classDefinition.finalize = Finalize;

_class = JSClassCreate(&classDefinition);

}

~ConstructorInfo() {

JSClassRelease(_class);

}

// JSObjectCallAsConstructorCallback

static JSObjectRef CallAsConstructor(JSContextRef ctx,

JSObjectRef constructor,

size_t argumentCount,

const JSValueRef arguments[],

JSValueRef* exception) {

ConstructorInfo* info = NativeInfo::GetNativeInfo<ConstructorInfo>(ctx, constructor, "[[jsc_constructor_info]]");

// Make sure any errors encountered last time we were in N-API are gone.

napi_clear_last_error(info->_env);

JSObjectRef instance{JSObjectMake(ctx, info->_class, nullptr)};

napi_callback_info__ cbinfo{};

cbinfo.thisArg = ToNapi(instance);

cbinfo.newTarget = ToNapi(constructor);

cbinfo.argc = argumentCount;

cbinfo.argv = ToNapi(arguments);

cbinfo.data = info->_data;

napi_value result = info->_cb(info->_env, &cbinfo);

if (info->_env->last_exception != nullptr) {

*exception = info->_env->last_exception;

info->_env->last_exception = nullptr;

}

return ToJSObject(info->_env, result);

}

// JSObjectFinalizeCallback

static void Finalize(JSObjectRef object) {

ConstructorInfo* info = NativeInfo::Get<ConstructorInfo>(object);

if (!info) return;

assert(info->Type() == NativeType::Constructor);

delete info;

}

private:

napi_env _env;

std::string _name;

napi_callback _cb;

void* _data;

JSClassRef _class;

public:

static const NativeType StaticType = NativeType::Function;

static napi_status Create(napi_env env,

const char* utf8name,

size_t length,

napi_callback cb,

void* data,

napi_value* result) {

FunctionInfo* info{new FunctionInfo(env, cb, data)};

if (info == nullptr) {

return napi_set_last_error(env, napi_generic_failure);

}

JSObjectRef function = JSObjectMake(env->context, xyz::functionInfoClass, info);

*result = ToNapi(function);

return napi_ok;

}

private:

FunctionInfo(napi_env env, napi_callback cb, void* data)

: NativeInfo{NativeType::Function}

, _env{env}

, _cb{cb}

, _data{data} {

std::call_once(xyz::functionInfoOnceFlag, []() {

JSClassDefinition definition{kJSClassDefinitionEmpty};

definition.className = "NapiFunctionCallback";

definition.callAsFunction = FunctionInfo::CallAsFunction;

definition.attributes = kJSClassAttributeNoAutomaticPrototype;

definition.initialize = FunctionInfo::initialize;

definition.finalize = Finalize;

xyz::functionInfoClass = JSClassCreate(&definition);

});

}

~FunctionInfo() {}

static void initialize(JSContextRef ctx, JSObjectRef object) {

JSObjectRef global = JSContextGetGlobalObject(ctx);

JSValueRef value =

JSObjectGetProperty(ctx, global, JSString("Function"), nullptr);

JSObjectRef funcCtor = JSValueToObject(ctx, value, nullptr);

if (!funcCtor) {

// We can't do anything if Function is not an object

return;

}

JSValueRef funcProto = JSObjectGetPrototype(ctx, funcCtor);

JSObjectSetPrototype(ctx, object, funcProto);

}

// JSObjectCallAsFunctionCallback

static JSValueRef CallAsFunction(JSContextRef ctx,

JSObjectRef function,

JSObjectRef thisObject,

size_t argumentCount,

const JSValueRef arguments[],

JSValueRef* exception) {

FunctionInfo* info = reinterpret_cast<FunctionInfo *>(JSObjectGetPrivate(function));

// Make sure any errors encountered last time we were in N-API are gone.

napi_clear_last_error(info->_env);

napi_callback_info__ cbinfo{};

cbinfo.thisArg = ToNapi(thisObject);

cbinfo.newTarget = nullptr;

cbinfo.argc = argumentCount;

cbinfo.argv = ToNapi(arguments);

cbinfo.data = info->_data;

napi_value result = info->_cb(info->_env, &cbinfo);

if (info->_env->last_exception != nullptr) {

*exception = info->_env->last_exception;

info->_env->last_exception = nullptr;

}

return ToJSValue(result);

}

// JSObjectFinalizeCallback

static void Finalize(JSObjectRef object) {

FunctionInfo* info = NativeInfo::Get<FunctionInfo>(object);

assert(info->Type() == NativeType::Function);

delete info;

}

napi_env _env;

napi_callback _cb;

void* _data;

public:

static const NativeType StaticType = TType;

~BaseInfoT() {

JSClassRelease(_class);

}

napi_env Env() const {

return _env;

}

void Data(void* value) {

_data = value;

}

void* Data() const {

return _data;

}

using FinalizerT = std::function<void(T*)>;

void AddFinalizer(FinalizerT finalizer) {

_finalizers.push_back(finalizer);

}

protected:

BaseInfoT(napi_env env, const char* className)

: NativeInfo{TType}

, _env{env} {

JSClassDefinition definition{kJSClassDefinitionEmpty};

definition.className = className;

definition.finalize = Finalize;

_class = JSClassCreate(&definition);

}

// JSObjectFinalizeCallback

static void Finalize(JSObjectRef object) {

T* info = Get<T>(object);

assert(info->Type() == TType);

for (const FinalizerT& finalizer : info->_finalizers) {

finalizer(info);

}

delete info;

}

napi_env _env;

void* _data{};

std::vector<FinalizerT> _finalizers{};

JSClassRef _class{};

public:

static napi_status Create(napi_env env,

void* data,

napi_finalize finalize_cb,

void* finalize_hint,

napi_value* result) {

ExternalInfo* info = new ExternalInfo(env);

if (info == nullptr) {

return napi_set_last_error(env, napi_generic_failure);

}

info->Data(data);

if (finalize_cb != nullptr) {

info->AddFinalizer([finalize_cb, finalize_hint](ExternalInfo* info) {

finalize_cb(info->Env(), info->Data(), finalize_hint);

});

}

*result = ToNapi(JSObjectMake(env->context, info->_class, info));

return napi_ok;

}

private:

ExternalInfo(napi_env env)

: BaseInfoT{env, "Native (External)"} {

}

public:

static napi_status Initialize(napi_env env, napi_value object, FinalizerT finalizer) {

napi_valuetype type;

napi_typeof(env, object, &type);

if (type == napi_object || type == napi_function) {

ReferenceInfo* info = new ReferenceInfo(env);

if (info == nullptr) {

return napi_set_last_error(env, napi_generic_failure);

}

// JSObjectRef ref{JSObjectMake(env->context, info->_class, info)};

// JSObjectSetPrototype(env->context, prototype, JSObjectGetPrototype(env->context, ToJSObject(env, object)));

// JSObjectSetPrototype(env->context, ToJSObject(env, object), prototype);

NativeInfo::SetNativeInfo(env->context, ToJSObject(env, object), info->_class, "[[jsc_reference_info]]", info);

info->AddFinalizer(finalizer);

}

return napi_ok;

}

private:

ReferenceInfo(napi_env env)

: BaseInfoT{env, "Native (Reference)"} {

}

public:

static napi_status Wrap(napi_env env, napi_value object, WrapperInfo** result) {

WrapperInfo* info{};

napi_value propertyKey;

napi_create_string_utf8(env, "[[jsc_wrapper_info]]", NAPI_AUTO_LENGTH, &propertyKey);

bool hasOwnProperty;

napi_has_own_property(env, object, propertyKey, &hasOwnProperty);

if (hasOwnProperty) {

return napi_generic_failure;

}

if (info == nullptr) {

info = new WrapperInfo(env);

if (info == nullptr) {

return napi_set_last_error(env, napi_generic_failure);

}

NativeInfo::SetNativeInfoKey(env->context, ToJSObject(env, object), info->_class, ToJSValue(propertyKey), info);

}

*result = info;

return napi_ok;

}

static napi_status Unwrap(napi_env env, napi_value object, WrapperInfo** result) {

*result = NativeInfo::GetNativeInfo<WrapperInfo>(env->context, ToJSObject(env, object), "[[jsc_wrapper_info]]");

return napi_ok;

}

private:

WrapperInfo(napi_env env)

: BaseInfoT{env, "Native (Wrapper)"} {

}

public:

static napi_status Create(napi_env env,

void* external_data,

size_t byte_length,

napi_finalize finalize_cb,

void* finalize_hint,

napi_value* result) {

ExternalArrayBufferInfo* info{new ExternalArrayBufferInfo(env, finalize_cb, finalize_hint)};

if (info == nullptr) {

return napi_set_last_error(env, napi_generic_failure);

}

JSValueRef exception{};

*result = ToNapi(JSObjectMakeArrayBufferWithBytesNoCopy(

env->context,

external_data,

byte_length,

BytesDeallocator,

info,

&exception));

CHECK_JSC(env, exception);

return napi_ok;

}

private:

ExternalArrayBufferInfo(napi_env env, napi_finalize finalize_cb, void* hint)

: _env{env}

, _cb{finalize_cb}

, _hint{hint} {

}

// JSTypedArrayBytesDeallocator

static void BytesDeallocator(void* bytes, void* deallocatorContext) {

ExternalArrayBufferInfo* info{reinterpret_cast<ExternalArrayBufferInfo*>(deallocatorContext)};

if (info->_cb != nullptr) {

info->_cb(info->_env, bytes, info->_hint);

}

delete info;

}

napi_env _env;

napi_finalize _cb;

void* _hint;

napi_ref__(napi_value value, uint32_t count)

: _value{value}

, _count{count} {

}

napi_status init(napi_env env) {

// track the ref values to support weak refs

auto pair{env->active_ref_values.insert(_value)};

if (pair.second) {

CHECK_NAPI(ReferenceInfo::Initialize(env, _value, [value = _value](ReferenceInfo* info) {

info->Env()->active_ref_values.erase(value);

}));

}

if (_count != 0) {

protect(env);

}

return napi_ok;

}

void deinit(napi_env env) {

if (_count != 0) {

unprotect(env);

}

_value = nullptr;

_count = 0;

}

void ref(napi_env env) {

if (_count++ == 0) {

protect(env);

}

}

void unref(napi_env env) {

if (--_count == 0) {

unprotect(env);

}

}

uint32_t count() const {

return _count;

}

napi_value value(napi_env env) const {

if (env->active_ref_values.find(_value) == env->active_ref_values.end()) {

return nullptr;

}

return _value;

}

private:

void protect(napi_env env) {

_iter = env->strong_refs.insert(env->strong_refs.end(), this);

JSValueProtect(env->context, ToJSValue(_value));

}

void unprotect(napi_env env) {

env->strong_refs.erase(_iter);

JSValueUnprotect(env->context, ToJSValue(_value));

}

napi_value _value{};

uint32_t _count{};

std::list<napi_ref>::iterator _iter{};

while (!strong_refs.empty()) {

napi_ref ref{strong_refs.front()};

ref->deinit(this);

}

const napi_extended_error_info** result) {

CHECK_ENV(env);

CHECK_ARG(env, result);

// you must update this assert to reference the last message

// in the napi_status enum each time a new error message is added.

// We don't have a napi_status_last as this would result in an ABI

// change each time a message was added.

static_assert(

std::size(error_messages) == napi_bigint_expected + 1,

"Count of error messages must match count of error values");

assert(env->last_error.error_code <= napi_callback_scope_mismatch);

// Wait until someone requests the last error information to fetch the error

// message string

env->last_error.error_message =

error_messages[env->last_error.error_code];

*result = &env->last_error;

return napi_ok;

const char* utf8name,

size_t length,

napi_callback cb,

void* callback_data,

napi_value* result) {

CHECK_ENV(env);

CHECK_ARG(env, result);

CHECK_NAPI(FunctionInfo::Create(env, utf8name, length, cb, callback_data, result));

return napi_ok;

const char* utf8name,

size_t length,

napi_callback cb,

void* data,

size_t property_count,

const napi_property_descriptor* properties,

napi_value* result) {

CHECK_ENV(env);

CHECK_ARG(env, result);

napi_value constructor{};

CHECK_NAPI(ConstructorInfo::Create(env, utf8name, length, cb, data, &constructor));

int instancePropertyCount{0};

int staticPropertyCount{0};

for (size_t i = 0; i < property_count; i++) {

if ((properties[i].attributes & napi_static) != 0) {

staticPropertyCount++;

} else {

instancePropertyCount++;

}

}

std::vector<napi_property_descriptor> staticDescriptors{};

std::vector<napi_property_descriptor> instanceDescriptors{};

staticDescriptors.reserve(staticPropertyCount);

instanceDescriptors.reserve(instancePropertyCount);

for (size_t i = 0; i < property_count; i++) {

if ((properties[i].attributes & napi_static) != 0) {

staticDescriptors.push_back(properties[i]);

} else {

instanceDescriptors.push_back(properties[i]);

}

}

if (staticPropertyCount > 0) {

CHECK_NAPI(napi_define_properties(env,

constructor,

staticDescriptors.size(),

staticDescriptors.data()));

}

if (instancePropertyCount > 0) {

napi_value prototype{};

CHECK_NAPI(napi_get_named_property(env, constructor, "prototype", &prototype));

CHECK_NAPI(napi_define_properties(env,

prototype,

instanceDescriptors.size(),

instanceDescriptors.data()));

}

*result = constructor;

return napi_ok;

napi_value object,

napi_value* result) {

CHECK_ENV(env);

CHECK_ARG(env, result);

napi_value global{}, object_ctor{}, function{};

CHECK_NAPI(napi_get_global(env, &global));

CHECK_NAPI(napi_get_named_property(env, global, "Object", &object_ctor));

CHECK_NAPI(napi_get_named_property(env, object_ctor, "getOwnPropertyNames", &function));

CHECK_NAPI(napi_call_function(env, object_ctor, function, 0, nullptr, result));

return napi_ok;

napi_value object,

napi_value key,

napi_value value) {

CHECK_ENV(env);

CHECK_ARG(env, key);

CHECK_ARG(env, value);

JSValueRef exception{};

JSString key_str{ToJSString(env, key, &exception)};

CHECK_JSC(env, exception);

JSObjectSetProperty(

env->context,

ToJSObject(env, object),

key_str,

ToJSValue(value),

kJSPropertyAttributeNone,

&exception);

CHECK_JSC(env, exception);

return napi_ok;

napi_value object,

napi_value key,

bool* result) {

CHECK_ENV(env);

CHECK_ARG(env, result);

CHECK_ARG(env, key);

JSValueRef exception{};

JSString key_str{ToJSString(env, key, &exception)};

CHECK_JSC(env, exception);

*result = JSObjectHasProperty(

env->context,

ToJSObject(env, object),

key_str);

return napi_ok;

napi_value object,

napi_value key,

napi_value* result) {

CHECK_ENV(env);

CHECK_ARG(env, key);

CHECK_ARG(env, result);

JSValueRef exception{};

JSString key_str{ToJSString(env, key, &exception)};

CHECK_JSC(env, exception);

*result = ToNapi(JSObjectGetProperty(

env->context,

ToJSObject(env, object),

key_str,

&exception));

CHECK_JSC(env, exception);

return napi_ok;

napi_value object,

napi_value key,

bool* result) {

CHECK_ENV(env);

CHECK_ARG(env, result);

JSValueRef exception{};

JSString key_str{ToJSString(env, key, &exception)};

CHECK_JSC(env, exception);

*result = JSObjectDeleteProperty(

env->context,

ToJSObject(env, object),

key_str,

&exception);

CHECK_JSC(env, exception);

return napi_ok;

napi_value object,

napi_value key,

bool* result) {

CHECK_ENV(env);

CHECK_ARG(env, result);

napi_value global{}, object_ctor{}, function{}, value{};

CHECK_NAPI(napi_get_global(env, &global));

CHECK_NAPI(napi_get_named_property(env, global, "Object", &object_ctor));

CHECK_NAPI(napi_get_named_property(env, object_ctor, "hasOwnProperty", &function));

CHECK_NAPI(napi_call_function(env, object_ctor, function, 0, nullptr, &value));

*result = JSValueToBoolean(env->context, ToJSValue(value));

return napi_ok;

napi_value object,

const char* utf8name,

napi_value value) {

CHECK_ENV(env);

CHECK_ARG(env, value);

JSValueRef exception{};

JSObjectSetProperty(

env->context,

ToJSObject(env, object),

JSString(utf8name),

ToJSValue(value),

kJSPropertyAttributeNone,

&exception);

CHECK_JSC(env, exception);

return napi_ok;

napi_value object,

const char* utf8name,