js/promise.go

@@ -102,14 +102,14 @@ func (p *Promise) ensurePending() {
 }
 
 func (p *Promise) settle() {
-	st := napi.CallThreadsafeFunction(p.ThreadsafeFunction)
+	st := napi.CallThreadsafeFunction(p.ThreadsafeFunction, napi.Blocking)
 	if st != napi.StatusOK {
 		panic(napi.StatusError(st))
 	}
 }
 
 func (p *Promise) release() {
-	st := napi.ReleaseThreadsafeFunction(p.ThreadsafeFunction)
+	st := napi.ReleaseThreadsafeFunction(p.ThreadsafeFunction, napi.Release)
 	if st == napi.StatusClosing {
 		p.ThreadsafeFunction = nil
 	} else if st != napi.StatusOK {

js_native_api.go

@@ -339,3 +339,862 @@ func GetInstanceData(env Env) (any, Status) {
 
 	return provider.GetUserData(), status
 }
+
+func CreateBuffer(env Env, length int) (Value, *byte, Status) {
+	var result Value
+	var data *byte
+	status := Status(C.napi_create_buffer(
+		C.napi_env(env),
+		C.size_t(length),
+		(**C.void)(unsafe.Pointer(&data)),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, data, status
+}
+
+func CreateExternal(env Env, data unsafe.Pointer, finalize Finalize, finalizeHint unsafe.Pointer) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_external(
+		C.napi_env(env),
+		data,
+		C.napi_finalize(finalize),
+		finalizeHint,
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetValueInt32(env Env, value Value) (int32, Status) {
+	var result int32
+	status := Status(C.napi_get_value_int32(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.int32_t)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetValueUint32(env Env, value Value) (uint32, Status) {
+	var result uint32
+	status := Status(C.napi_get_value_uint32(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.uint32_t)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetValueInt64(env Env, value Value) (int64, Status) {
+	var result int64
+	status := Status(C.napi_get_value_int64(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.int64_t)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetValueBigIntInt64(env Env, value Value) (int64, bool, Status) {
+	var result int64
+	var lossless bool
+	status := Status(C.napi_get_value_bigint_int64(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.int64_t)(unsafe.Pointer(&result)),
+		(*C.bool)(unsafe.Pointer(&lossless)),
+	))
+	return result, lossless, status
+}
+
+func GetValueBigIntWords(env Env, value Value, signBit int, wordCount int, words *uint64) Status {
+	return Status(C.napi_get_value_bigint_words(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.int)(unsafe.Pointer(&signBit)),
+		(*C.size_t)(unsafe.Pointer(&wordCount)),
+		(*C.uint64_t)(unsafe.Pointer(words)),
+	))
+}
+
+func GetValueExternal(env Env, value Value) (unsafe.Pointer, Status) {
+	var result unsafe.Pointer
+	status := Status(C.napi_get_value_external(
+		C.napi_env(env),
+		C.napi_value(value),
+		&result,
+	))
+	return result, status
+}
+
+func CoerceToBool(env Env, value Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_coerce_to_bool(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CoerceToNumber(env Env, value Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_coerce_to_number(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CoerceToObject(env Env, value Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_coerce_to_object(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CoerceToString(env Env, value Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_coerce_to_string(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateBufferCopy(env Env, data []byte) (Value, *byte, Status) {
+	var result Value
+	var copiedData *byte
+	status := Status(C.napi_create_buffer_copy(
+		C.napi_env(env),
+		C.size_t(len(data)),
+		unsafe.Pointer(&data[0]),
+		(**C.void)(unsafe.Pointer(&copiedData)),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, copiedData, status
+}
+
+func GetBufferInfo(env Env, value Value) (*byte, int, Status) {
+	var data *byte
+	var length C.size_t
+	status := Status(C.napi_get_buffer_info(
+		C.napi_env(env),
+		C.napi_value(value),
+		(**C.void)(unsafe.Pointer(&data)),
+		&length,
+	))
+	return data, int(length), status
+}
+
+func GetArrayLength(env Env, value Value) (int, Status) {
+	var length C.uint32_t
+	status := Status(C.napi_get_array_length(
+		C.napi_env(env),
+		C.napi_value(value),
+		&length,
+	))
+	return int(length), status
+}
+
+func GetPrototype(env Env, value Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_prototype(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func InstanceOf(env Env, object, constructor Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_instanceof(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.napi_value(constructor),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsArray(env Env, value Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_array(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsBuffer(env Env, value Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_buffer(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsError(env Env, value Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_error(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsPromise(env Env, value Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_promise(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsTypedArray(env Env, value Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_typedarray(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetTypedArrayInfo(env Env, value Value) (TypedArrayType, int, *byte, Status) {
+	var type_ TypedArrayType
+	var length C.size_t
+	var data *byte
+	status := Status(C.napi_get_typedarray_info(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.napi_typedarray_type)(unsafe.Pointer(&type_)),
+		&length,
+		(**C.void)(unsafe.Pointer(&data)),
+	))
+	return type_, int(length), data, status
+}
+
+func CreateTypedArray(env Env, type_ TypedArrayType, length int, arrayBuffer Value, byteOffset int) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_typedarray(
+		C.napi_env(env),
+		C.napi_typedarray_type(type_),
+		C.size_t(length),
+		C.napi_value(arrayBuffer),
+		C.size_t(byteOffset),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func AdjustExternalMemory(env Env, change int64) (int64, Status) {
+	var result int64
+	status := Status(C.napi_adjust_external_memory(
+		C.napi_env(env),
+		C.int64_t(change),
+		(*C.int64_t)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateDataView(env Env, length int, arrayBuffer Value, byteOffset int) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_dataview(
+		C.napi_env(env),
+		C.size_t(length),
+		C.napi_value(arrayBuffer),
+		C.size_t(byteOffset),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetDataViewInfo(env Env, value Value) (int, *byte, Status) {
+	var length C.size_t
+	var data *byte
+	status := Status(C.napi_get_dataview_info(
+		C.napi_env(env),
+		C.napi_value(value),
+		&length,
+		(**C.void)(unsafe.Pointer(&data)),
+	))
+	return int(length), data, status
+}
+
+func GetAllPropertyNames(env Env, object Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_all_property_names(
+		C.napi_env(env),
+		C.napi_value(object),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func HasOwnProperty(env Env, object, key Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_has_own_property(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.napi_value(key),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func HasProperty(env Env, object, key Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_has_property(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.napi_value(key),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetPropertyNames(env Env, object Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_property_names(
+		C.napi_env(env),
+		C.napi_value(object),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func DefineProperties(env Env, object Value, properties []PropertyDescriptor) Status {
+	return Status(C.napi_define_properties(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.size_t(len(properties)),
+		(*C.napi_property_descriptor)(unsafe.Pointer(&properties[0])),
+	))
+}
+
+func Wrap(env Env, jsObject Value, nativeObject unsafe.Pointer, finalize Finalize, finalizeHint unsafe.Pointer) Status {
+	return Status(C.napi_wrap(
+		C.napi_env(env),
+		C.napi_value(jsObject),
+		nativeObject,
+		C.napi_finalize(finalize),
+		finalizeHint,
+		(*C.napi_value)(unsafe.Pointer(&jsObject)),
+	))
+}
+
+func Unwrap(env Env, jsObject Value) (unsafe.Pointer, Status) {
+	var nativeObject unsafe.Pointer
+	status := Status(C.napi_unwrap(
+		C.napi_env(env),
+		C.napi_value(jsObject),
+		&nativeObject,
+	))
+	return nativeObject, status
+}
+
+func RemoveWrap(env Env, jsObject Value) Status {
+	return Status(C.napi_remove_wrap(
+		C.napi_env(env),
+		C.napi_value(jsObject),
+	))
+}
+
+func OpenHandleScope(env Env) (HandleScope, Status) {
+	var scope HandleScope
+	status := Status(C.napi_open_handle_scope(
+		C.napi_env(env),
+		(*C.napi_handle_scope)(unsafe.Pointer(&scope)),
+	))
+	return scope, status
+}
+
+func CloseHandleScope(env Env, scope HandleScope) Status {
+	return Status(C.napi_close_handle_scope(
+		C.napi_env(env),
+		C.napi_handle_scope(scope),
+	))
+}
+
+func OpenEscapableHandleScope(env Env) (EscapableHandleScope, Status) {
+	var scope EscapableHandleScope
+	status := Status(C.napi_open_escapable_handle_scope(
+		C.napi_env(env),
+		(*C.napi_escapable_handle_scope)(unsafe.Pointer(&scope)),
+	))
+	return scope, status
+}
+
+func CloseEscapableHandleScope(env Env, scope EscapableHandleScope) Status {
+	return Status(C.napi_close_escapable_handle_scope(
+		C.napi_env(env),
+		C.napi_escapable_handle_scope(scope),
+	))
+}
+
+func EscapeHandle(env Env, scope EscapableHandleScope, escapee Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_escape_handle(
+		C.napi_env(env),
+		C.napi_escapable_handle_scope(scope),
+		C.napi_value(escapee),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateReference(env Env, value Value, initialRefcount int) (Reference, Status) {
+	var ref Reference
+	status := Status(C.napi_create_reference(
+		C.napi_env(env),
+		C.napi_value(value),
+		C.uint32_t(initialRefcount),
+		(*C.napi_ref)(unsafe.Pointer(&ref)),
+	))
+	return ref, status
+}
+
+func DeleteReference(env Env, ref Reference) Status {
+	return Status(C.napi_delete_reference(
+		C.napi_env(env),
+		C.napi_ref(ref),
+	))
+}
+
+func ReferenceRef(env Env, ref Reference) (int, Status) {
+	var result C.uint32_t
+	status := Status(C.napi_reference_ref(
+		C.napi_env(env),
+		C.napi_ref(ref),
+		&result,
+	))
+	return int(result), status
+}
+
+func ReferenceUnref(env Env, ref Reference) (int, Status) {
+	var result C.uint32_t
+	status := Status(C.napi_reference_unref(
+		C.napi_env(env),
+		C.napi_ref(ref),
+		&result,
+	))
+	return int(result), status
+}
+
+func GetReferenceValue(env Env, ref Reference) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_reference_value(
+		C.napi_env(env),
+		C.napi_ref(ref),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetValueBigIntUint64(env Env, value Value) (uint64, bool, Status) {
+	var result uint64
+	var lossless bool
+	status := Status(C.napi_get_value_bigint_uint64(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.uint64_t)(unsafe.Pointer(&result)),
+		(*C.bool)(unsafe.Pointer(&lossless)),
+	))
+	return result, lossless, status
+}
+
+func CreateBigIntInt64(env Env, value int64) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_bigint_int64(
+		C.napi_env(env),
+		C.int64_t(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateBigIntUint64(env Env, value uint64) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_bigint_uint64(
+		C.napi_env(env),
+		C.uint64_t(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateBigIntWords(env Env, signBit int, wordCount int, words *uint64) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_bigint_words(
+		C.napi_env(env),
+		C.int(signBit),
+		C.size_t(wordCount),
+		(*C.uint64_t)(unsafe.Pointer(words)),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsDate(env Env, value Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_date(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsDetachedArrayBuffer(env Env, value Value) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_detached_arraybuffer(
+		C.napi_env(env),
+		C.napi_value(value),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func DetachArrayBuffer(env Env, value Value) Status {
+	return Status(C.napi_detach_arraybuffer(
+		C.napi_env(env),
+		C.napi_value(value),
+	))
+}
+
+func CreateArrayBuffer(env Env, length int) (Value, *byte, Status) {
+	var result Value
+	var data *byte
+	status := Status(C.napi_create_arraybuffer(
+		C.napi_env(env),
+		C.size_t(length),
+		(**C.void)(unsafe.Pointer(&data)),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, data, status
+}
+
+func GetArrayBufferInfo(env Env, value Value) (*byte, int, Status) {
+	var data *byte
+	var length C.size_t
+	status := Status(C.napi_get_arraybuffer_info(
+		C.napi_env(env),
+		C.napi_value(value),
+		(**C.void)(unsafe.Pointer(&data)),
+		&length,
+	))
+	return data, int(length), status
+}
+
+func CreateExternalArrayBuffer(env Env, data unsafe.Pointer, length int, finalize Finalize, finalizeHint unsafe.Pointer) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_external_arraybuffer(
+		C.napi_env(env),
+		data,
+		C.size_t(length),
+		C.napi_finalize(finalize),
+		finalizeHint,
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetElement(env Env, object Value, index int) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_element(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.uint32_t(index),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetProperty(env Env, object, key Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_property(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.napi_value(key),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func DeleteProperty(env Env, object, key Value) Status {
+	return Status(C.napi_delete_property(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.napi_value(key),
+	))
+}
+
+func SetNamedProperty(env Env, object Value, name string, value Value) Status {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+	return Status(C.napi_set_named_property(
+		C.napi_env(env),
+		C.napi_value(object),
+		cname,
+		C.napi_value(value),
+	))
+}
+
+func GetNamedProperty(env Env, object Value, name string) (Value, Status) {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+	var result Value
+	status := Status(C.napi_get_named_property(
+		C.napi_env(env),
+		C.napi_value(object),
+		cname,
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func HasNamedProperty(env Env, object Value, name string) (bool, Status) {
+	cname := C.CString(name)
+	defer C.free(unsafe.Pointer(cname))
+	var result bool
+	status := Status(C.napi_has_named_property(
+		C.napi_env(env),
+		C.napi_value(object),
+		cname,
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func HasElement(env Env, object Value, index int) (bool, Status) {
+	var result bool
+	status := Status(C.napi_has_element(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.uint32_t(index),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func DeleteElement(env Env, object Value, index int) Status {
+	return Status(C.napi_delete_element(
+		C.napi_env(env),
+		C.napi_value(object),
+		C.uint32_t(index),
+	))
+}
+
+func ObjectFreeze(env Env, object Value) Status {
+	return Status(C.napi_object_freeze(
+		C.napi_env(env),
+		C.napi_value(object),
+	))
+}
+
+func ObjectSeal(env Env, object Value) Status {
+	return Status(C.napi_object_seal(
+		C.napi_env(env),
+		C.napi_value(object),
+	))
+}
+
+func ThrowTypeError(env Env, code, msg string) Status {
+	codeCStr, msgCCstr := C.CString(code), C.CString(msg)
+	defer C.free(unsafe.Pointer(codeCStr))
+	defer C.free(unsafe.Pointer(msgCCstr))
+
+	return Status(C.napi_throw_type_error(
+		C.napi_env(env),
+		codeCStr,
+		msgCCstr,
+	))
+}
+
+func ThrowRangeError(env Env, code, msg string) Status {
+	codeCStr, msgCCstr := C.CString(code), C.CString(msg)
+	defer C.free(unsafe.Pointer(codeCStr))
+	defer C.free(unsafe.Pointer(msgCCstr))
+
+	return Status(C.napi_throw_range_error(
+		C.napi_env(env),
+		codeCStr,
+		msgCCstr,
+	))
+}
+
+func CreateTypeError(env Env, code, msg Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_type_error(
+		C.napi_env(env),
+		C.napi_value(code),
+		C.napi_value(msg),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateRangeError(env Env, code, msg Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_range_error(
+		C.napi_env(env),
+		C.napi_value(code),
+		C.napi_value(msg),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func IsExceptionPending(env Env) (bool, Status) {
+	var result bool
+	status := Status(C.napi_is_exception_pending(
+		C.napi_env(env),
+		(*C.bool)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetAndClearLastException(env Env) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_and_clear_last_exception(
+		C.napi_env(env),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+type CallbackScope struct {
+	scope C.napi_callback_scope
+}
+
+// OpenCallbackScope Function to open a callback scope
+func OpenCallbackScope(env Env, resourceObject, context Value) (CallbackScope, Status) {
+	var scope CallbackScope
+	status := Status(C.napi_open_callback_scope(
+		C.napi_env(env),
+		C.napi_value(resourceObject),
+		C.napi_value(context),
+		(*C.napi_callback_scope)(unsafe.Pointer(&scope.scope)),
+	))
+	return scope, status
+}
+
+// CloseCallbackScope Function to close a callback scope
+func CloseCallbackScope(env Env, scope CallbackScope) Status {
+	return Status(C.napi_close_callback_scope(
+		C.napi_env(env),
+		scope.scope,
+	))
+}
+
+// GetExtendedErrorInfo Function to retrieve extended error information
+func GetExtendedErrorInfo(env Env) (*C.napi_extended_error_info, Status) {
+	var errorInfo *C.napi_extended_error_info
+	status := Status(C.napi_get_last_error_info(
+		C.napi_env(env),
+		&errorInfo,
+	))
+	return errorInfo, status
+}
+
+func CreateInt32(env Env, value int32) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_int32(
+		C.napi_env(env),
+		C.int32_t(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateUint32(env Env, value uint32) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_uint32(
+		C.napi_env(env),
+		C.uint32_t(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateInt64(env Env, value int64) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_int64(
+		C.napi_env(env),
+		C.int64_t(value),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateStringLatin1(env Env, str string) (Value, Status) {
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	var result Value
+	status := Status(C.napi_create_string_latin1(
+		C.napi_env(env),
+		cstr,
+		C.size_t(len([]byte(str))),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateStringUtf16(env Env, str []uint16) (Value, Status) {
+	var result Value
+	status := Status(C.napi_create_string_utf16(
+		C.napi_env(env),
+		(*C.char16_t)(unsafe.Pointer(&str[0])),
+		C.size_t(len(str)),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CallFunction(env Env, recv Value, fn Value, argc int, argv []Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_call_function(
+		C.napi_env(env),
+		C.napi_value(recv),
+		C.napi_value(fn),
+		C.size_t(argc),
+		(*C.napi_value)(unsafe.Pointer(&argv[0])),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func GetNewTarget(env Env, info CallbackInfo) (Value, Status) {
+	var result Value
+	status := Status(C.napi_get_new_target(
+		C.napi_env(env),
+		C.napi_callback_info(info),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func NewInstance(env Env, constructor Value, argc int, argv []Value) (Value, Status) {
+	var result Value
+	status := Status(C.napi_new_instance(
+		C.napi_env(env),
+		C.napi_value(constructor),
+		C.size_t(argc),
+		(*C.napi_value)(unsafe.Pointer(&argv[0])),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}

node_api.go

@@ -113,11 +113,12 @@ func CreateThreadsafeFunction(
 
 func CallThreadsafeFunction(
 	fn ThreadsafeFunction,
+	mode ThreadsafeFunctionCallMode,
 ) Status {
 	return Status(C.napi_call_threadsafe_function(
 		C.napi_threadsafe_function(fn),
 		nil,
-		C.napi_tsfn_blocking,
+		C.napi_threadsafe_function_call_mode(mode),
 	))
 }
 
@@ -129,9 +130,174 @@ func AcquireThreadsafeFunction(fn ThreadsafeFunction) Status {
 
 func ReleaseThreadsafeFunction(
 	fn ThreadsafeFunction,
+	mode ThreadsafeFunctionReleaseMode,
 ) Status {
 	return Status(C.napi_release_threadsafe_function(
 		C.napi_threadsafe_function(fn),
-		C.napi_tsfn_release,
+		C.napi_threadsafe_function_release_mode(mode),
+	))
+}
+
+func GetThreadsafeFunctionContext(
+	fn ThreadsafeFunction,
+) (unsafe.Pointer, Status) {
+	var context unsafe.Pointer
+	status := Status(C.napi_get_threadsafe_function_context(
+		C.napi_threadsafe_function(fn),
+		&context,
+	))
+	return context, status
+}
+
+func RefThreadsafeFunction(env Env, fn ThreadsafeFunction) Status {
+	return Status(C.napi_ref_threadsafe_function(
+		C.napi_env(env),
+		C.napi_threadsafe_function(fn),
+	))
+}
+
+func UnrefThreadsafeFunction(env Env, fn ThreadsafeFunction) Status {
+	return Status(C.napi_unref_threadsafe_function(
+		C.napi_env(env),
+		C.napi_threadsafe_function(fn),
+	))
+}
+
+func DestroyThreadsafeFunction(tsfn ThreadsafeFunction) Status {
+	return Status(C.napi_destroy_threadsafe_function(tsfn))
+}
+
+func BasicEnv(env Env) Status {
+	return Status(C.node_api_basic_env(C.napi_env(env)))
+}
+
+func BasicFinalize(env Env, finalizeData, finalizeHint unsafe.Pointer) Status {
+	return Status(C.node_api_basic_finalize(
+		C.napi_env(env),
+		finalizeData,
+		finalizeHint,
+	))
+}
+
+func ThrowSyntaxError(env Env, code, msg string) Status {
+	codeCStr, msgCStr := C.CString(code), C.CString(msg)
+	defer C.free(unsafe.Pointer(codeCStr))
+	defer C.free(unsafe.Pointer(msgCStr))
+
+	return Status(C.node_api_throw_syntax_error(
+		C.napi_env(env),
+		codeCStr,
+		msgCStr,
+	))
+}
+
+func CreateSyntaxError(env Env, code, msg Value) (Value, Status) {
+	var result Value
+	status := Status(C.node_api_create_syntax_error(
+		C.napi_env(env),
+		C.napi_value(code),
+		C.napi_value(msg),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func SymbolFor(env Env, description Value) (Value, Status) {
+	var result Value
+	status := Status(C.node_api_symbol_for(
+		C.napi_env(env),
+		C.napi_value(description),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateBufferFromArrayBuffer(env Env, arrayBuffer Value, byteOffset, length int) (Value, *byte, Status) {
+	var result Value
+	var data *byte
+	status := Status(C.node_api_create_buffer_from_arraybuffer(
+		C.napi_env(env),
+		C.napi_value(arrayBuffer),
+		C.size_t(byteOffset),
+		C.size_t(length),
+		(**C.void)(unsafe.Pointer(&data)),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, data, status
+}
+
+func CreateExternalStringLatin1(env Env, str string, finalize Finalize, finalizeHint unsafe.Pointer) (Value, Status) {
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	var result Value
+	status := Status(C.node_api_create_external_string_latin1(
+		C.napi_env(env),
+		cstr,
+		C.size_t(len([]byte(str))),
+		C.napi_finalize(finalize),
+		finalizeHint,
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreateExternalStringUtf16(env Env, str []uint16, finalize Finalize, finalizeHint unsafe.Pointer) (Value, Status) {
+	var result Value
+	status := Status(C.node_api_create_external_string_utf16(
+		C.napi_env(env),
+		(*C.char16_t)(unsafe.Pointer(&str[0])),
+		C.size_t(len(str)),
+		C.napi_finalize(finalize),
+		finalizeHint,
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreatePropertyKeyLatin1(env Env, str string) (Value, Status) {
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	var result Value
+	status := Status(C.node_api_create_property_key_latin1(
+		C.napi_env(env),
+		cstr,
+		C.size_t(len([]byte(str))),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreatePropertyKeyUtf16(env Env, str []uint16) (Value, Status) {
+	var result Value
+	status := Status(C.node_api_create_property_key_utf16(
+		C.napi_env(env),
+		(*C.char16_t)(unsafe.Pointer(&str[0])),
+		C.size_t(len(str)),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func CreatePropertyKeyUtf8(env Env, str string) (Value, Status) {
+	cstr := C.CString(str)
+	defer C.free(unsafe.Pointer(cstr))
+
+	var result Value
+	status := Status(C.node_api_create_property_key_utf8(
+		C.napi_env(env),
+		cstr,
+		C.size_t(len([]byte(str))),
+		(*C.napi_value)(unsafe.Pointer(&result)),
+	))
+	return result, status
+}
+
+func PostFinalizer(env Env, finalizeData, finalizeHint unsafe.Pointer) Status {
+	return Status(C.node_api_post_finalizer(
+		C.napi_env(env),
+		finalizeData,
+		finalizeHint,
 	))
 }

property_attrib_type.go

@@ -0,0 +1,18 @@
+package napi
+
+/*
+#include <node/node_api.h>
+*/
+import "C"
+
+type PropertyAttributes C.napi_property_attributes
+
+const (
+	Default           PropertyAttributes = C.napi_default
+	Writable          PropertyAttributes = C.napi_writable
+	Enumerable        PropertyAttributes = C.napi_enumerable
+	Configurable      PropertyAttributes = C.napi_configurable
+	Static            PropertyAttributes = C.napi_static
+	DefaultMethod     PropertyAttributes = C.napi_default_method
+	DefaultJSProperty PropertyAttributes = C.napi_default_jsproperty
+)

threadsafe_function_type.go

@@ -0,0 +1,20 @@
+package napi
+
+/*
+#include <node/node_api.h>
+*/
+import "C"
+
+type ThreadsafeFunctionReleaseMode C.napi_threadsafe_function_release_mode
+
+const (
+	Release ThreadsafeFunctionReleaseMode = C.napi_tsfn_release
+	Abort   ThreadsafeFunctionReleaseMode = C.napi_tsfn_abort
+)
+
+type ThreadsafeFunctionCallMode C.napi_threadsafe_function_call_mode
+
+const (
+	NonBlocking ThreadsafeFunctionCallMode = C.napi_tsfn_nonblocking
+	Blocking    ThreadsafeFunctionCallMode = C.napi_tsfn_blocking
+)

typed_array_type.go

@@ -0,0 +1,22 @@
+package napi
+
+/*
+#include <node/node_api.h>
+*/
+import "C"
+
+type TypedArrayType C.napi_typedarray_type
+
+const (
+	TypedArrayInt8Array         TypedArrayType = C.napi_int8_array
+	TypedArrayUint8Array        TypedArrayType = C.napi_uint8_array
+	TypedArrayUint8ClampedArray TypedArrayType = C.napi_uint8_clamped_array
+	TypedArrayInt16Array        TypedArrayType = C.napi_int16_array
+	TypedArrayUint16Array       TypedArrayType = C.napi_uint16_array
+	TypedArrayInt32Array        TypedArrayType = C.napi_int32_array
+	TypedArrayUint32Array       TypedArrayType = C.napi_uint32_array
+	TypedArrayFloat32Array      TypedArrayType = C.napi_float32_array
+	TypedArrayFloat64Array      TypedArrayType = C.napi_float64_array
+	TypedArrayBigInt64Array     TypedArrayType = C.napi_bigint64_array
+	TypedArrayBigUint64Array    TypedArrayType = C.napi_biguint64_array
+)

types.go

@@ -0,0 +1,28 @@
+package napi
+
+import "unsafe"
+
+type PropertyDescriptor struct {
+	Utf8name   string
+	Name       Value
+	Method     Callback
+	Getter     Callback
+	Setter     Callback
+	Value      Value
+	Attributes PropertyAttributes
+	Data       unsafe.Pointer
+}
+
+type Finalize func(env Env, finalizeData, finalizeHint unsafe.Pointer)
+
+type Reference struct {
+	Ref unsafe.Pointer
+}
+
+type EscapableHandleScope struct {
+	Scope unsafe.Pointer
+}
+
+type HandleScope struct {
+	Scope unsafe.Pointer
+}

value_type.go

@@ -5,7 +5,7 @@ package napi
 */
 import "C"
 
-type ValueType int
+type ValueType C.napi_valuetype
 
 const (
 	ValueTypeUndefined ValueType = C.napi_undefined