diff options
Diffstat (limited to 'cli/napi/js_native_api.rs')
| -rw-r--r-- | cli/napi/js_native_api.rs | 4933 |
1 files changed, 2842 insertions, 2091 deletions
diff --git a/cli/napi/js_native_api.rs b/cli/napi/js_native_api.rs index 428c4a04a..cbce113dc 100644 --- a/cli/napi/js_native_api.rs +++ b/cli/napi/js_native_api.rs @@ -1,2016 +1,3046 @@ // Copyright 2018-2024 the Deno authors. All rights reserved. MIT license. #![allow(non_upper_case_globals)] +#![deny(unsafe_op_in_unsafe_fn)] + +const NAPI_VERSION: u32 = 9; use deno_runtime::deno_napi::*; use libc::INT_MAX; -use v8::BackingStore; -use v8::UniqueRef; +use super::util::check_new_from_utf8; +use super::util::check_new_from_utf8_len; use super::util::get_array_buffer_ptr; +use super::util::make_external_backing_store; +use super::util::napi_clear_last_error; +use super::util::napi_set_last_error; +use super::util::v8_name_from_property_descriptor; +use crate::check_arg; +use crate::check_env; use deno_runtime::deno_napi::function::create_function; use deno_runtime::deno_napi::function::create_function_template; use deno_runtime::deno_napi::function::CallbackInfo; +use napi_sym::napi_sym; use std::ptr::NonNull; -#[macro_export] -macro_rules! check_env { - ($env: expr) => { - if $env.is_null() { - return napi_invalid_arg; - } - }; +#[derive(Debug, Clone, Copy, PartialEq)] +enum ReferenceOwnership { + Runtime, + Userland, } -#[inline] -unsafe fn napi_value_unchecked(val: napi_value) -> v8::Local<v8::Value> { - transmute::<napi_value, v8::Local<v8::Value>>(val) +enum ReferenceState { + Strong(v8::Global<v8::Value>), + Weak(v8::Weak<v8::Value>), } -#[macro_export] -macro_rules! return_error_status_if_false { - ($env: expr, $condition: expr, $status: ident) => { - if !$condition { - return Err( - $crate::napi::js_native_api::napi_set_last_error( - $env, - $status, - 0, - std::ptr::null_mut(), - ) - .into(), - ); - } - }; +struct Reference { + env: *mut Env, + state: ReferenceState, + ref_count: u32, + ownership: ReferenceOwnership, + finalize_cb: Option<napi_finalize>, + finalize_data: *mut c_void, + finalize_hint: *mut c_void, } -#[macro_export] -macro_rules! return_status_if_false { - ($env: expr, $condition: expr, $status: ident) => { - if !$condition { - return $crate::napi::js_native_api::napi_set_last_error( - $env, - $status, - 0, - std::ptr::null_mut(), - ); +impl Reference { + fn new( + env: *mut Env, + value: v8::Local<v8::Value>, + initial_ref_count: u32, + ownership: ReferenceOwnership, + finalize_cb: Option<napi_finalize>, + finalize_data: *mut c_void, + finalize_hint: *mut c_void, + ) -> Box<Self> { + let isolate = unsafe { &mut *(*env).isolate_ptr }; + + let mut reference = Box::new(Reference { + env, + state: ReferenceState::Strong(v8::Global::new(isolate, value)), + ref_count: initial_ref_count, + ownership, + finalize_cb, + finalize_data, + finalize_hint, + }); + + if initial_ref_count == 0 { + reference.set_weak(); } - }; -} -fn check_new_from_utf8_len<'s>( - env: *mut Env, - str_: *const c_char, - len: usize, -) -> Result<v8::Local<'s, v8::String>, napi_status> { - return_error_status_if_false!( - env, - (len == NAPI_AUTO_LENGTH) || len <= INT_MAX as _, - napi_invalid_arg - ); - return_error_status_if_false!(env, !str_.is_null(), napi_invalid_arg); - let string = if len == NAPI_AUTO_LENGTH { - let result = unsafe { std::ffi::CStr::from_ptr(str_ as *const _) }.to_str(); - return_error_status_if_false!(env, result.is_ok(), napi_generic_failure); - result.unwrap() - } else { - let string = unsafe { std::slice::from_raw_parts(str_ as *const u8, len) }; - let result = std::str::from_utf8(string); - return_error_status_if_false!(env, result.is_ok(), napi_generic_failure); - result.unwrap() - }; - let result = { - let env = unsafe { &mut *env }; - v8::String::new(&mut env.scope(), string) - }; - return_error_status_if_false!(env, result.is_some(), napi_generic_failure); - Ok(result.unwrap()) -} + reference + } -#[inline] -fn check_new_from_utf8<'s>( - env: *mut Env, - str_: *const c_char, -) -> Result<v8::Local<'s, v8::String>, napi_status> { - check_new_from_utf8_len(env, str_, NAPI_AUTO_LENGTH) -} + fn ref_(&mut self) -> u32 { + self.ref_count += 1; + if self.ref_count == 1 { + self.set_strong(); + } + self.ref_count + } -#[macro_export] -macro_rules! status_call { - ($call: expr) => { - let status = $call; - if status != napi_ok { - return status; + fn unref(&mut self) -> u32 { + let old_ref_count = self.ref_count; + if self.ref_count > 0 { + self.ref_count -= 1; } - }; -} + if old_ref_count == 1 && self.ref_count == 0 { + self.set_weak(); + } + self.ref_count + } -// Macro to check napi arguments. -// If nullptr, return napi_invalid_arg. -#[macro_export] -macro_rules! check_arg { - ($env: expr, $ptr: expr) => { - $crate::return_status_if_false!($env, !$ptr.is_null(), napi_invalid_arg); - }; -} + fn reset(&mut self) { + self.finalize_cb = None; + self.finalize_data = std::ptr::null_mut(); + self.finalize_hint = std::ptr::null_mut(); + } -macro_rules! check_arg_option { - ($env: expr, $opt: expr) => { - $crate::return_status_if_false!($env, $opt.is_some(), napi_invalid_arg); - }; -} + fn set_strong(&mut self) { + if let ReferenceState::Weak(w) = &self.state { + let isolate = unsafe { &mut *(*self.env).isolate_ptr }; + if let Some(g) = w.to_global(isolate) { + self.state = ReferenceState::Strong(g); + } + } + } -fn napi_clear_last_error(env: *mut Env) { - let env = unsafe { &mut *env }; - env.last_error.error_code = napi_ok; - env.last_error.engine_error_code = 0; - env.last_error.engine_reserved = std::ptr::null_mut(); - env.last_error.error_message = std::ptr::null_mut(); -} + fn set_weak(&mut self) { + let reference = self as *mut Reference; + if let ReferenceState::Strong(g) = &self.state { + let cb = Box::new(move |_: &mut v8::Isolate| { + Reference::weak_callback(reference) + }); + let isolate = unsafe { &mut *(*self.env).isolate_ptr }; + self.state = + ReferenceState::Weak(v8::Weak::with_finalizer(isolate, g, cb)); + } + } -pub(crate) fn napi_set_last_error( - env: *mut Env, - error_code: napi_status, - engine_error_code: i32, - engine_reserved: *mut c_void, -) -> napi_status { - let env = unsafe { &mut *env }; - env.last_error.error_code = error_code; - env.last_error.engine_error_code = engine_error_code; - env.last_error.engine_reserved = engine_reserved; - error_code -} + fn weak_callback(reference: *mut Reference) { + let reference = unsafe { &mut *reference }; -/// Returns napi_value that represents a new JavaScript Array. -#[napi_sym::napi_sym] -fn napi_create_array(env: *mut Env, result: *mut napi_value) -> napi_status { - check_env!(env); - check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::Array::new(&mut env.scope(), 0).into(); - napi_ok -} + let finalize_cb = reference.finalize_cb; + let finalize_data = reference.finalize_data; + let finalize_hint = reference.finalize_hint; + reference.reset(); -#[napi_sym::napi_sym] -fn napi_create_array_with_length( - env: *mut Env, - len: i32, - result: *mut napi_value, -) -> napi_status { - check_env!(env); - check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::Array::new(&mut env.scope(), len).into(); - napi_ok -} + if let Some(finalize_cb) = finalize_cb { + unsafe { + finalize_cb(reference.env as _, finalize_data, finalize_hint); + } + } -#[napi_sym::napi_sym] -fn napi_create_arraybuffer( - env: *mut Env, - len: usize, - data: *mut *mut u8, - result: *mut napi_value, -) -> napi_status { - check_env!(env); - check_arg!(env, result); - let env = unsafe { &mut *env }; + if reference.ownership == ReferenceOwnership::Runtime { + unsafe { drop(Reference::from_raw(reference)) } + } + } - let value = v8::ArrayBuffer::new(&mut env.scope(), len); - if !data.is_null() { - *data = get_array_buffer_ptr(value); + fn into_raw(r: Box<Reference>) -> *mut Reference { + Box::into_raw(r) } - *result = value.into(); - napi_ok + unsafe fn from_raw(r: *mut Reference) -> Box<Reference> { + unsafe { Box::from_raw(r) } + } + + unsafe fn remove(r: *mut Reference) { + let r = unsafe { &mut *r }; + if r.ownership == ReferenceOwnership::Userland { + r.reset(); + } else { + unsafe { drop(Reference::from_raw(r)) } + } + } } -#[napi_sym::napi_sym] -fn napi_create_bigint_int64( +#[napi_sym] +fn napi_get_last_error_info( env: *mut Env, - value: i64, - result: *mut napi_value, + result: *mut *const napi_extended_error_info, ) -> napi_status { - check_env!(env); + let env = check_env!(env); check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::BigInt::new_from_i64(&mut env.scope(), value).into(); + + if env.last_error.error_code == napi_ok { + napi_clear_last_error(env); + } else { + env.last_error.error_message = + ERROR_MESSAGES[env.last_error.error_code as usize].as_ptr(); + } + + unsafe { + *result = &env.last_error; + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_bigint_uint64( - env: *mut Env, - value: u64, +#[napi_sym] +fn napi_create_function( + env: &mut Env, + name: *const c_char, + length: usize, + cb: napi_callback, + cb_info: napi_callback_info, result: *mut napi_value, ) -> napi_status { - check_env!(env); check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::BigInt::new_from_u64(&mut env.scope(), value).into(); + check_arg!(env, cb); + + let name = if !name.is_null() { + match unsafe { check_new_from_utf8_len(env, name, length) } { + Ok(s) => Some(s), + Err(status) => return status, + } + } else { + None + }; + + unsafe { + *result = create_function(env, name, cb, cb_info).into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_bigint_words( - env: *mut Env, - sign_bit: bool, - word_count: usize, - words: *const u64, - result: *mut napi_value, +#[napi_sym] +#[allow(clippy::too_many_arguments)] +fn napi_define_class<'s>( + env: &'s mut Env, + utf8name: *const c_char, + length: usize, + constructor: napi_callback, + callback_data: *mut c_void, + property_count: usize, + properties: *const napi_property_descriptor, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - check_arg!(env, words); - let env = unsafe { &mut *env }; check_arg!(env, result); + check_arg!(env, constructor); - if word_count > INT_MAX as _ { - return napi_invalid_arg; + if property_count > 0 { + check_arg!(env, properties); } - match v8::BigInt::new_from_words( - &mut env.scope(), - sign_bit, - std::slice::from_raw_parts(words, word_count), - ) { - Some(value) => { - *result = value.into(); + let name = match unsafe { check_new_from_utf8_len(env, utf8name, length) } { + Ok(string) => string, + Err(status) => return status, + }; + + let tpl = unsafe { + create_function_template(env, Some(name), constructor, callback_data) + }; + + let napi_properties: &[napi_property_descriptor] = if property_count > 0 { + unsafe { std::slice::from_raw_parts(properties, property_count) } + } else { + &[] + }; + let mut static_property_count = 0; + + for p in napi_properties { + if p.attributes & napi_static != 0 { + // Will be handled below + static_property_count += 1; + continue; } - None => { - return napi_invalid_arg; + + let name = match unsafe { v8_name_from_property_descriptor(env, p) } { + Ok(name) => name, + Err(status) => return status, + }; + + let method = p.method; + let getter = p.getter; + let setter = p.setter; + + if getter.is_some() || setter.is_some() { + let getter: Option<v8::Local<v8::FunctionTemplate>> = if getter.is_some() + { + Some(unsafe { create_function_template(env, None, p.getter, p.data) }) + } else { + None + }; + let setter: Option<v8::Local<v8::FunctionTemplate>> = if setter.is_some() + { + Some(unsafe { create_function_template(env, None, p.setter, p.data) }) + } else { + None + }; + + let mut accessor_property = v8::PropertyAttribute::NONE; + if getter.is_some() + && setter.is_some() + && (p.attributes & napi_writable) == 0 + { + accessor_property = + accessor_property | v8::PropertyAttribute::READ_ONLY; + } + if p.attributes & napi_enumerable == 0 { + accessor_property = + accessor_property | v8::PropertyAttribute::DONT_ENUM; + } + if p.attributes & napi_configurable == 0 { + accessor_property = + accessor_property | v8::PropertyAttribute::DONT_DELETE; + } + + let proto = tpl.prototype_template(&mut env.scope()); + proto.set_accessor_property(name, getter, setter, accessor_property); + } else if method.is_some() { + let function = + unsafe { create_function_template(env, None, p.method, p.data) }; + let proto = tpl.prototype_template(&mut env.scope()); + proto.set(name, function.into()); + } else { + let proto = tpl.prototype_template(&mut env.scope()); + proto.set(name, p.value.unwrap().into()); } } + let env_ptr = env as *mut Env; + let value: v8::Local<v8::Value> = + tpl.get_function(&mut env.scope()).unwrap().into(); + + unsafe { + *result = value.into(); + } + + if static_property_count > 0 { + let mut static_descriptors = Vec::with_capacity(static_property_count); + + for p in napi_properties { + if p.attributes & napi_static != 0 { + static_descriptors.push(*p); + } + } + + crate::status_call!(unsafe { + napi_define_properties( + env_ptr, + *result, + static_descriptors.len(), + static_descriptors.as_ptr(), + ) + }); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_buffer( +#[napi_sym] +fn napi_get_property_names( env: *mut Env, - len: usize, - data: *mut *mut u8, + object: napi_value, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = v8::ArrayBuffer::new(&mut env.scope(), len); - if !data.is_null() { - *data = get_array_buffer_ptr(value); + unsafe { + napi_get_all_property_names( + env, + object, + napi_key_include_prototypes, + napi_key_enumerable | napi_key_skip_symbols, + napi_key_numbers_to_strings, + result, + ) } - let value = v8::Uint8Array::new(&mut env.scope(), value, 0, len).unwrap(); - let value: v8::Local<v8::Value> = value.into(); - *result = value.into(); - napi_ok } -#[napi_sym::napi_sym] -fn napi_create_buffer_copy( - env: *mut Env, - len: usize, - data: *mut u8, - result_data: *mut *mut u8, - result: *mut napi_value, +#[napi_sym] +fn napi_get_all_property_names<'s>( + env: &'s mut Env, + object: napi_value, + key_mode: napi_key_collection_mode, + key_filter: napi_key_filter, + key_conversion: napi_key_conversion, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = v8::ArrayBuffer::new(&mut env.scope(), len); - let ptr = get_array_buffer_ptr(value); - std::ptr::copy(data, ptr, len); - if !result_data.is_null() { - *result_data = ptr; - } - let value = v8::Uint8Array::new(&mut env.scope(), value, 0, len).unwrap(); - let value: v8::Local<v8::Value> = value.into(); - *result = value.into(); + check_arg!(env, result); + + let scope = &mut env.scope(); + + let Some(obj) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + let mut filter = v8::PropertyFilter::ALL_PROPERTIES; + + if key_filter & napi_key_writable != 0 { + filter = filter | v8::PropertyFilter::ONLY_WRITABLE; + } + if key_filter & napi_key_enumerable != 0 { + filter = filter | v8::PropertyFilter::ONLY_ENUMERABLE; + } + if key_filter & napi_key_configurable != 0 { + filter = filter | v8::PropertyFilter::ONLY_CONFIGURABLE; + } + if key_filter & napi_key_skip_strings != 0 { + filter = filter | v8::PropertyFilter::SKIP_STRINGS; + } + if key_filter & napi_key_skip_symbols != 0 { + filter = filter | v8::PropertyFilter::SKIP_SYMBOLS; + } + + let key_mode = match key_mode { + napi_key_include_prototypes => v8::KeyCollectionMode::IncludePrototypes, + napi_key_own_only => v8::KeyCollectionMode::OwnOnly, + _ => return napi_invalid_arg, + }; + + let key_conversion = match key_conversion { + napi_key_keep_numbers => v8::KeyConversionMode::KeepNumbers, + napi_key_numbers_to_strings => v8::KeyConversionMode::ConvertToString, + _ => return napi_invalid_arg, + }; + + let filter = v8::GetPropertyNamesArgsBuilder::new() + .mode(key_mode) + .property_filter(filter) + .index_filter(v8::IndexFilter::IncludeIndices) + .key_conversion(key_conversion) + .build(); + + let property_names = match obj.get_property_names(scope, filter) { + Some(n) => n, + None => return napi_generic_failure, + }; + + unsafe { + *result = property_names.into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_coerce_to_bool( - env: *mut Env, +#[napi_sym] +fn napi_set_property( + env: &mut Env, + object: napi_value, + key: napi_value, value: napi_value, - result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let coerced = value.to_boolean(&mut env.scope()); - let value: v8::Local<v8::Value> = coerced.into(); - *result = value.into(); + check_arg!(env, key); + check_arg!(env, value); + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + if object.set(scope, key.unwrap(), value.unwrap()).is_none() { + return napi_generic_failure; + }; + napi_ok } -#[napi_sym::napi_sym] -fn napi_coerce_to_number( - env: *mut Env, - value: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_has_property( + env: &mut Env, + object: napi_value, + key: napi_value, + result: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let Some(coerced) = value.to_number(&mut env.scope()) else { - return napi_number_expected; + check_arg!(env, key); + check_arg!(env, result); + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; }; - let value: v8::Local<v8::Value> = coerced.into(); - *result = value.into(); + + let Some(has) = object.has(scope, key.unwrap()) else { + return napi_generic_failure; + }; + + unsafe { + *result = has; + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_coerce_to_object( - env: *mut Env, - value: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_get_property<'s>( + env: &'s mut Env, + object: napi_value, + key: napi_value, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let coerced = value.to_object(&mut env.scope()).unwrap(); - let value: v8::Local<v8::Value> = coerced.into(); - *result = value.into(); + check_arg!(env, key); + check_arg!(env, result); + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + let Some(value) = object.get(scope, key.unwrap()) else { + return napi_generic_failure; + }; + + unsafe { + *result = value.into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_coerce_to_string( - env: *mut Env, - value: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_delete_property( + env: &mut Env, + object: napi_value, + key: napi_value, + result: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let coerced = value.to_string(&mut env.scope()).unwrap(); - let value: v8::Local<v8::Value> = coerced.into(); - *result = value.into(); + check_arg!(env, key); + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + let Some(deleted) = object.delete(scope, key.unwrap()) else { + return napi_generic_failure; + }; + + if !result.is_null() { + unsafe { + *result = deleted; + } + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_dataview( - env: *mut Env, - len: usize, - data: *mut *mut u8, - byte_offset: usize, - result: *mut napi_value, +#[napi_sym] +fn napi_has_own_property( + env: &mut Env, + object: napi_value, + key: napi_value, + result: *mut bool, ) -> napi_status { - check_env!(env); - check_arg!(env, data); - let env = unsafe { &mut *env }; + check_arg!(env, key); check_arg!(env, result); - let value = v8::ArrayBuffer::new(&mut env.scope(), len); - if !data.is_null() { - *data = get_array_buffer_ptr(value); - } - let context = &mut env.scope().get_current_context(); - let global = context.global(&mut env.scope()); - let data_view_name = v8::String::new(&mut env.scope(), "DataView").unwrap(); - let data_view = global.get(&mut env.scope(), data_view_name.into()).unwrap(); - let Ok(data_view) = v8::Local::<v8::Function>::try_from(data_view) else { - return napi_function_expected; + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; }; - let byte_offset = v8::Number::new(&mut env.scope(), byte_offset as f64); - let byte_length = v8::Number::new(&mut env.scope(), len as f64); - let value = data_view - .new_instance( - &mut env.scope(), - &[value.into(), byte_offset.into(), byte_length.into()], - ) - .unwrap(); - let value: v8::Local<v8::Value> = value.into(); - *result = value.into(); - napi_ok -} -#[napi_sym::napi_sym] -fn napi_create_date( - env: *mut Env, - time: f64, - result: *mut napi_value, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value: v8::Local<v8::Value> = - v8::Date::new(&mut env.scope(), time).unwrap().into(); - *result = value.into(); + let Ok(key) = v8::Local::<v8::Name>::try_from(key.unwrap()) else { + return napi_name_expected; + }; + + let Some(has_own) = object.has_own_property(scope, key) else { + return napi_generic_failure; + }; + + unsafe { + *result = has_own; + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_double( - env: *mut Env, - value: f64, - result: *mut napi_value, +#[napi_sym] +fn napi_has_named_property<'s>( + env: &'s mut Env, + object: napi_value<'s>, + utf8name: *const c_char, + result: *mut bool, ) -> napi_status { - check_env!(env); + let env_ptr = env as *mut Env; check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::Number::new(&mut env.scope(), value).into(); + + let Some(object) = object.and_then(|o| o.to_object(&mut env.scope())) else { + return napi_object_expected; + }; + + let key = match unsafe { check_new_from_utf8(env_ptr, utf8name) } { + Ok(key) => key, + Err(status) => return status, + }; + + let Some(has_property) = object.has(&mut env.scope(), key.into()) else { + return napi_generic_failure; + }; + + unsafe { + *result = has_property; + } + napi_ok } -fn set_error_code( - env: *mut Env, - error: v8::Local<v8::Value>, - code: napi_value, - code_cstring: *const c_char, +#[napi_sym] +fn napi_set_named_property<'s>( + env: &'s mut Env, + object: napi_value<'s>, + utf8name: *const c_char, + value: napi_value<'s>, ) -> napi_status { - if code.is_some() || !code_cstring.is_null() { - let err_object: v8::Local<v8::Object> = error.try_into().unwrap(); + check_arg!(env, value); + let env_ptr = env as *mut Env; - let code_value: v8::Local<v8::Value> = if code.is_some() { - let mut code_value = unsafe { napi_value_unchecked(code) }; - return_status_if_false!( - env, - code_value.is_string(), - napi_string_expected - ); - code_value - } else { - let name = match check_new_from_utf8(env, code_cstring) { - Ok(s) => s, - Err(status) => return status, - }; - name.into() - }; + let Some(object) = object.and_then(|o| o.to_object(&mut env.scope())) else { + return napi_object_expected; + }; + + let key = match unsafe { check_new_from_utf8(env_ptr, utf8name) } { + Ok(key) => key, + Err(status) => return status, + }; - let mut scope = unsafe { &mut *env }.scope(); - let code_key = v8::String::new(&mut scope, "code").unwrap(); + let value = value.unwrap(); - if err_object - .set(&mut scope, code_key.into(), code_value) - .is_none() - { - return napi_generic_failure; - } + if !object + .set(&mut env.scope(), key.into(), value) + .unwrap_or(false) + { + return napi_generic_failure; } napi_ok } -#[napi_sym::napi_sym] -fn napi_create_error( - env: *mut Env, - code: napi_value, - msg: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_get_named_property<'s>( + env: &'s mut Env, + object: napi_value<'s>, + utf8name: *const c_char, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - check_arg_option!(env, msg); check_arg!(env, result); - let mut message_value = napi_value_unchecked(msg); - return_status_if_false!(env, message_value.is_string(), napi_string_expected); - let error_obj = v8::Exception::error( - &mut unsafe { &mut *env }.scope(), - message_value.try_into().unwrap(), - ); - status_call!(set_error_code(env, error_obj, code, std::ptr::null())); - *result = error_obj.into(); - napi_clear_last_error(env); + let env_ptr = env as *mut Env; + + let Some(object) = object.and_then(|o| o.to_object(&mut env.scope())) else { + return napi_object_expected; + }; + + let key = match unsafe { check_new_from_utf8(env_ptr, utf8name) } { + Ok(key) => key, + Err(status) => return status, + }; + + let Some(value) = object.get(&mut env.scope(), key.into()) else { + return napi_generic_failure; + }; + + unsafe { + *result = value.into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_type_error( - env: *mut Env, - code: napi_value, - msg: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_set_element<'s>( + env: &'s mut Env, + object: napi_value<'s>, + index: u32, + value: napi_value<'s>, ) -> napi_status { - check_env!(env); - check_arg_option!(env, msg); - check_arg!(env, result); - let mut message_value = napi_value_unchecked(msg); - return_status_if_false!(env, message_value.is_string(), napi_string_expected); - let error_obj = v8::Exception::type_error( - &mut unsafe { &mut *env }.scope(), - message_value.try_into().unwrap(), - ); - status_call!(set_error_code(env, error_obj, code, std::ptr::null())); - *result = error_obj.into(); - napi_clear_last_error(env); + check_arg!(env, value); + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + if !object + .set_index(scope, index, value.unwrap()) + .unwrap_or(false) + { + return napi_generic_failure; + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_range_error( - env: *mut Env, - code: napi_value, - msg: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_has_element( + env: &mut Env, + object: napi_value, + index: u32, + result: *mut bool, ) -> napi_status { - check_env!(env); - check_arg_option!(env, msg); check_arg!(env, result); - let mut message_value = napi_value_unchecked(msg); - return_status_if_false!(env, message_value.is_string(), napi_string_expected); - let error_obj = v8::Exception::range_error( - &mut unsafe { &mut *env }.scope(), - message_value.try_into().unwrap(), - ); - status_call!(set_error_code(env, error_obj, code, std::ptr::null())); - *result = error_obj.into(); - napi_clear_last_error(env); - napi_ok -} -#[napi_sym::napi_sym] -fn napi_create_external( - env_ptr: *mut Env, - value: *mut c_void, - finalize_cb: napi_finalize, - finalize_hint: *mut c_void, - result: *mut napi_value, -) -> napi_status { - check_env!(env_ptr); - let env = unsafe { &mut *env_ptr }; - let external: v8::Local<v8::Value> = - v8::External::new(&mut env.scope(), value).into(); + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + let Some(has) = object.has_index(scope, index) else { + return napi_generic_failure; + }; - let value = weak_local(env_ptr, external, value, finalize_cb, finalize_hint); + unsafe { + *result = has; + } - *result = transmute(value); napi_ok } -pub type BackingStoreDeleterCallback = unsafe extern "C" fn( - data: *mut c_void, - byte_length: usize, - deleter_data: *mut c_void, -); +#[napi_sym] +fn napi_get_element<'s>( + env: &'s mut Env, + object: napi_value, + index: u32, + result: *mut napi_value<'s>, +) -> napi_status { + check_arg!(env, result); -extern "C" { - fn v8__ArrayBuffer__NewBackingStore__with_data( - data: *mut c_void, - byte_length: usize, - deleter: BackingStoreDeleterCallback, - deleter_data: *mut c_void, - ) -> *mut BackingStore; -} + let scope = &mut env.scope(); -struct BufferFinalizer { - env: *mut Env, - finalize_cb: napi_finalize, - finalize_data: *mut c_void, - finalize_hint: *mut c_void, -} + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; -impl BufferFinalizer { - fn into_raw(self) -> *mut BufferFinalizer { - Box::into_raw(Box::new(self)) + let Some(value) = object.get_index(scope, index) else { + return napi_generic_failure; + }; + + unsafe { + *result = value.into(); } + + napi_ok } -impl Drop for BufferFinalizer { - fn drop(&mut self) { +#[napi_sym] +fn napi_delete_element( + env: &mut Env, + object: napi_value, + index: u32, + result: *mut bool, +) -> napi_status { + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + let Some(deleted) = object.delete_index(scope, index) else { + return napi_generic_failure; + }; + + if !result.is_null() { unsafe { - (self.finalize_cb)(self.env as _, self.finalize_data, self.finalize_hint); + *result = deleted; } } -} -pub extern "C" fn backing_store_deleter_callback( - data: *mut c_void, - _byte_length: usize, - deleter_data: *mut c_void, -) { - let mut finalizer = - unsafe { Box::from_raw(deleter_data as *mut BufferFinalizer) }; - - finalizer.finalize_data = data; + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_external_arraybuffer( - env_ptr: *mut Env, - data: *mut c_void, - byte_length: usize, - finalize_cb: napi_finalize, - finalize_hint: *mut c_void, - result: *mut napi_value, +#[napi_sym] +fn napi_define_properties( + env: &mut Env, + object: napi_value, + property_count: usize, + properties: *const napi_property_descriptor, ) -> napi_status { - check_env!(env_ptr); - let env = unsafe { &mut *env_ptr }; + let env_ptr = env as *mut Env; - let finalizer = BufferFinalizer { - env: env_ptr, - finalize_data: ptr::null_mut(), - finalize_cb, - finalize_hint, + if property_count > 0 { + check_arg!(env, properties); + } + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; }; - let store: UniqueRef<BackingStore> = - transmute(v8__ArrayBuffer__NewBackingStore__with_data( - data, - byte_length, - backing_store_deleter_callback, - finalizer.into_raw() as _, - )); + let properties = if property_count == 0 { + &[] + } else { + unsafe { std::slice::from_raw_parts(properties, property_count) } + }; + for property in properties { + let property_name = + match unsafe { v8_name_from_property_descriptor(env_ptr, property) } { + Ok(name) => name, + Err(status) => return status, + }; - let ab = - v8::ArrayBuffer::with_backing_store(&mut env.scope(), &store.make_shared()); - let value: v8::Local<v8::Value> = ab.into(); + let writable = property.attributes & napi_writable != 0; + let enumerable = property.attributes & napi_enumerable != 0; + let configurable = property.attributes & napi_configurable != 0; + + if property.getter.is_some() || property.setter.is_some() { + let local_getter: v8::Local<v8::Value> = if property.getter.is_some() { + unsafe { + create_function(env_ptr, None, property.getter, property.data).into() + } + } else { + v8::undefined(scope).into() + }; + let local_setter: v8::Local<v8::Value> = if property.setter.is_some() { + unsafe { + create_function(env_ptr, None, property.setter, property.data).into() + } + } else { + v8::undefined(scope).into() + }; + + let mut desc = + v8::PropertyDescriptor::new_from_get_set(local_getter, local_setter); + desc.set_enumerable(enumerable); + desc.set_configurable(configurable); + + if !object + .define_property(scope, property_name, &desc) + .unwrap_or(false) + { + return napi_invalid_arg; + } + } else if property.method.is_some() { + let method: v8::Local<v8::Value> = { + let function = unsafe { + create_function(env_ptr, None, property.method, property.data) + }; + function.into() + }; + + let mut desc = + v8::PropertyDescriptor::new_from_value_writable(method, writable); + desc.set_enumerable(enumerable); + desc.set_configurable(configurable); + + if !object + .define_property(scope, property_name, &desc) + .unwrap_or(false) + { + return napi_generic_failure; + } + } else { + let value = property.value.unwrap(); + + if enumerable & writable & configurable { + if !object + .create_data_property(scope, property_name, value) + .unwrap_or(false) + { + return napi_invalid_arg; + } + } else { + let mut desc = + v8::PropertyDescriptor::new_from_value_writable(value, writable); + desc.set_enumerable(enumerable); + desc.set_configurable(configurable); + + if !object + .define_property(scope, property_name, &desc) + .unwrap_or(false) + { + return napi_invalid_arg; + } + } + } + } - *result = value.into(); napi_ok } -#[napi_sym::napi_sym] -fn napi_create_external_buffer( - env_ptr: *mut Env, - byte_length: usize, - data: *mut c_void, - finalize_cb: napi_finalize, - finalize_hint: *mut c_void, - result: *mut napi_value, -) -> napi_status { - check_env!(env_ptr); - let env = unsafe { &mut *env_ptr }; - let finalizer = BufferFinalizer { - env: env_ptr, - finalize_data: ptr::null_mut(), - finalize_cb, - finalize_hint, +#[napi_sym] +fn napi_object_freeze(env: &mut Env, object: napi_value) -> napi_status { + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; }; - let store: UniqueRef<BackingStore> = - transmute(v8__ArrayBuffer__NewBackingStore__with_data( - data, - byte_length, - backing_store_deleter_callback, - finalizer.into_raw() as _, - )); + if !object + .set_integrity_level(scope, v8::IntegrityLevel::Frozen) + .unwrap_or(false) + { + return napi_generic_failure; + } - let ab = - v8::ArrayBuffer::with_backing_store(&mut env.scope(), &store.make_shared()); - let value = - v8::Uint8Array::new(&mut env.scope(), ab, 0, byte_length).unwrap(); - let value: v8::Local<v8::Value> = value.into(); - *result = value.into(); napi_ok } -#[napi_sym::napi_sym] -fn napi_create_function( +#[napi_sym] +fn napi_object_seal(env: &mut Env, object: napi_value) -> napi_status { + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + if !object + .set_integrity_level(scope, v8::IntegrityLevel::Sealed) + .unwrap_or(false) + { + return napi_generic_failure; + } + + napi_ok +} + +#[napi_sym] +fn napi_is_array( env: *mut Env, - name: *const c_char, - length: usize, - cb: napi_callback, - cb_info: napi_callback_info, - result: *mut napi_value, + value: napi_value, + result: *mut bool, ) -> napi_status { - check_env!(env); + let env = check_env!(env); + check_arg!(env, value); check_arg!(env, result); - check_arg_option!(env, cb); - let name = if let Some(name) = name.as_ref() { - match check_new_from_utf8_len(env, name, length) { - Ok(s) => Some(s), - Err(status) => return status, + let value = value.unwrap(); + + unsafe { + *result = value.is_array(); + } + + napi_clear_last_error(env) +} + +#[napi_sym] +fn napi_get_array_length( + env: &mut Env, + value: napi_value, + result: *mut u32, +) -> napi_status { + check_arg!(env, value); + check_arg!(env, result); + + let value = value.unwrap(); + + match v8::Local::<v8::Array>::try_from(value) { + Ok(array) => { + unsafe { + *result = array.length(); + } + napi_ok } - } else { - None - }; + Err(_) => napi_array_expected, + } +} + +#[napi_sym] +fn napi_strict_equals( + env: &mut Env, + lhs: napi_value, + rhs: napi_value, + result: *mut bool, +) -> napi_status { + check_arg!(env, lhs); + check_arg!(env, rhs); + check_arg!(env, result); + + unsafe { + *result = lhs.unwrap().strict_equals(rhs.unwrap()); + } - *result = create_function(env, name, cb, cb_info).into(); napi_ok } -#[napi_sym::napi_sym] -fn napi_create_int32( - env: *mut Env, - value: i32, - result: *mut napi_value, +#[napi_sym] +fn napi_get_prototype<'s>( + env: &'s mut Env, + object: napi_value, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::Integer::new(&mut env.scope(), value).into(); + + let scope = &mut env.scope(); + + let Some(object) = object.and_then(|o| o.to_object(scope)) else { + return napi_object_expected; + }; + + let Some(proto) = object.get_prototype(scope) else { + return napi_generic_failure; + }; + + unsafe { + *result = proto.into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_create_uint32( - env: *mut Env, - value: u32, +#[napi_sym] +fn napi_create_object( + env_ptr: *mut Env, result: *mut napi_value, ) -> napi_status { - check_env!(env); + let env = check_env!(env_ptr); check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::Integer::new_from_unsigned(&mut env.scope(), value).into(); - napi_ok + + unsafe { + *result = v8::Object::new(&mut env.scope()).into(); + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] -fn napi_create_int64( - env: *mut Env, - value: i64, +#[napi_sym] +fn napi_create_array( + env_ptr: *mut Env, result: *mut napi_value, ) -> napi_status { - check_env!(env); + let env = check_env!(env_ptr); check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::Number::new(&mut env.scope(), value as f64).into(); - napi_ok -} -#[napi_sym::napi_sym] -fn napi_create_object(env: *mut Env, result: *mut napi_value) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let object = v8::Object::new(&mut env.scope()); - *result = object.into(); - napi_ok + unsafe { + *result = v8::Array::new(&mut env.scope(), 0).into(); + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] -fn napi_create_promise( - env: *mut Env, - deferred: *mut napi_deferred, - promise_out: *mut napi_value, +#[napi_sym] +fn napi_create_array_with_length( + env_ptr: *mut Env, + length: usize, + result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let resolver = v8::PromiseResolver::new(&mut env.scope()).unwrap(); - let mut global = v8::Global::new(&mut env.scope(), resolver); - let mut global_ptr = global.into_raw(); - let promise = resolver.get_promise(&mut env.scope()); - *deferred = global_ptr.as_mut() as *mut _ as napi_deferred; - *promise_out = promise.into(); + let env = check_env!(env_ptr); + check_arg!(env, result); - napi_ok + unsafe { + *result = v8::Array::new(&mut env.scope(), length as _).into(); + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] -fn napi_create_reference( - env: *mut Env, - value: napi_value, - _initial_refcount: u32, - result: *mut napi_ref, +#[napi_sym] +fn napi_create_string_latin1( + env_ptr: *mut Env, + string: *const c_char, + length: usize, + result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; + let env = check_env!(env_ptr); + if length > 0 { + check_arg!(env, string); + } + crate::return_status_if_false!( + env, + (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _, + napi_invalid_arg + ); - let value = napi_value_unchecked(value); - let global = v8::Global::new(&mut env.scope(), value); - let mut global_ptr = global.into_raw(); - *result = transmute::<NonNull<v8::Value>, napi_ref>(global_ptr); - napi_ok + let buffer = if length > 0 { + unsafe { + std::slice::from_raw_parts( + string as _, + if length == NAPI_AUTO_LENGTH { + std::ffi::CStr::from_ptr(string).to_bytes().len() + } else { + length + }, + ) + } + } else { + &[] + }; + + let Some(string) = v8::String::new_from_one_byte( + &mut env.scope(), + buffer, + v8::NewStringType::Normal, + ) else { + return napi_set_last_error(env_ptr, napi_generic_failure); + }; + + unsafe { + *result = string.into(); + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] -fn napi_create_string_latin1( - env: *mut Env, - string: *const u8, +#[napi_sym] +fn napi_create_string_utf8( + env_ptr: *mut Env, + string: *const c_char, length: usize, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; + let env = check_env!(env_ptr); if length > 0 { check_arg!(env, string); } - check_arg!(env, result); - return_status_if_false!( + crate::return_status_if_false!( env, (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _, napi_invalid_arg ); - let string = if length == NAPI_AUTO_LENGTH { - std::ffi::CStr::from_ptr(string as *const _) - .to_str() - .unwrap() - .as_bytes() + let buffer = if length > 0 { + unsafe { + std::slice::from_raw_parts( + string as _, + if length == NAPI_AUTO_LENGTH { + std::ffi::CStr::from_ptr(string).to_bytes().len() + } else { + length + }, + ) + } } else { - std::slice::from_raw_parts(string, length) + &[] }; - let Some(v8str) = v8::String::new_from_one_byte( + + let Some(string) = v8::String::new_from_utf8( &mut env.scope(), - string, + buffer, v8::NewStringType::Normal, ) else { - return napi_generic_failure; + return napi_set_last_error(env_ptr, napi_generic_failure); }; - *result = v8str.into(); - napi_ok + unsafe { + *result = string.into(); + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_create_string_utf16( - env: *mut Env, + env_ptr: *mut Env, string: *const u16, length: usize, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; + let env = check_env!(env_ptr); if length > 0 { check_arg!(env, string); } - check_arg!(env, result); - return_status_if_false!( + crate::return_status_if_false!( env, (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _, napi_invalid_arg ); - let string = if length == NAPI_AUTO_LENGTH { - let s = std::ffi::CStr::from_ptr(string as *const _) - .to_str() - .unwrap(); - std::slice::from_raw_parts(s.as_ptr() as *const u16, s.len()) + let buffer = if length > 0 { + unsafe { + std::slice::from_raw_parts( + string, + if length == NAPI_AUTO_LENGTH { + let mut length = 0; + while *(string.add(length)) != 0 { + length += 1; + } + length + } else { + length + }, + ) + } } else { - std::slice::from_raw_parts(string, length) + &[] }; - match v8::String::new_from_two_byte( + let Some(string) = v8::String::new_from_two_byte( &mut env.scope(), - string, + buffer, v8::NewStringType::Normal, - ) { - Some(v8str) => { - *result = v8str.into(); - } - None => return napi_generic_failure, + ) else { + return napi_set_last_error(env_ptr, napi_generic_failure); + }; + + unsafe { + *result = string.into(); } - napi_ok + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] -fn napi_create_string_utf8( - env: *mut Env, - string: *const u8, +#[napi_sym] +fn node_api_create_external_string_latin1( + env_ptr: *mut Env, + _string: *const c_char, + _length: usize, + _nogc_finalize_callback: napi_finalize, + _finalize_hint: *mut c_void, + _result: *mut napi_value, + _copied: *mut bool, +) -> napi_status { + return napi_set_last_error(env_ptr, napi_generic_failure); +} + +#[napi_sym] +fn node_api_create_external_string_utf16( + env_ptr: *mut Env, + _string: *const u16, + _length: usize, + _nogc_finalize_callback: napi_finalize, + _finalize_hint: *mut c_void, + _result: *mut napi_value, + _copied: *mut bool, +) -> napi_status { + return napi_set_last_error(env_ptr, napi_generic_failure); +} + +#[napi_sym] +fn node_api_create_property_key_utf16( + env_ptr: *mut Env, + string: *const u16, length: usize, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; + let env = check_env!(env_ptr); if length > 0 { check_arg!(env, string); } - check_arg!(env, result); - return_status_if_false!( + crate::return_status_if_false!( env, (length == NAPI_AUTO_LENGTH) || length <= INT_MAX as _, napi_invalid_arg ); - let string = if length == NAPI_AUTO_LENGTH { - std::ffi::CStr::from_ptr(string as *const _) - .to_str() - .unwrap() + let buffer = if length > 0 { + unsafe { + std::slice::from_raw_parts( + string, + if length == NAPI_AUTO_LENGTH { + let mut length = 0; + while *(string.add(length)) != 0 { + length += 1; + } + length + } else { + length + }, + ) + } } else { - let string = std::slice::from_raw_parts(string, length); - std::str::from_utf8(string).unwrap() + &[] }; - let v8str = v8::String::new(&mut env.scope(), string).unwrap(); - *result = v8str.into(); + + let Some(string) = v8::String::new_from_two_byte( + &mut env.scope(), + buffer, + v8::NewStringType::Internalized, + ) else { + return napi_set_last_error(env_ptr, napi_generic_failure); + }; + + unsafe { + *result = string.into(); + } + + return napi_clear_last_error(env_ptr); +} + +#[napi_sym] +fn napi_create_double( + env_ptr: *mut Env, + value: f64, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, result); + + unsafe { + *result = v8::Number::new(&mut env.scope(), value).into(); + } + + napi_clear_last_error(env_ptr) +} + +#[napi_sym] +fn napi_create_int32( + env_ptr: *mut Env, + value: i32, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, result); + + unsafe { + *result = v8::Integer::new(&mut env.scope(), value).into(); + } + + napi_clear_last_error(env_ptr) +} + +#[napi_sym] +fn napi_create_uint32( + env_ptr: *mut Env, + value: u32, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, result); + + unsafe { + *result = v8::Integer::new_from_unsigned(&mut env.scope(), value).into(); + } + + napi_clear_last_error(env_ptr) +} + +#[napi_sym] +fn napi_create_int64( + env_ptr: *mut Env, + value: i64, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, result); + + unsafe { + *result = v8::Number::new(&mut env.scope(), value as _).into(); + } + + napi_clear_last_error(env_ptr) +} + +#[napi_sym] +fn napi_create_bigint_int64( + env_ptr: *mut Env, + value: i64, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, result); + + unsafe { + *result = v8::BigInt::new_from_i64(&mut env.scope(), value).into(); + } + + napi_clear_last_error(env_ptr) +} + +#[napi_sym] +fn napi_create_bigint_uint64( + env_ptr: *mut Env, + value: u64, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, result); + + unsafe { + *result = v8::BigInt::new_from_u64(&mut env.scope(), value).into(); + } + + napi_clear_last_error(env_ptr) +} + +#[napi_sym] +fn napi_create_bigint_words<'s>( + env: &'s mut Env, + sign_bit: bool, + word_count: usize, + words: *const u64, + result: *mut napi_value<'s>, +) -> napi_status { + check_arg!(env, words); + check_arg!(env, result); + + if word_count > INT_MAX as _ { + return napi_invalid_arg; + } + + match v8::BigInt::new_from_words(&mut env.scope(), sign_bit, unsafe { + std::slice::from_raw_parts(words, word_count) + }) { + Some(value) => unsafe { + *result = value.into(); + }, + None => { + return napi_generic_failure; + } + } napi_ok } -#[napi_sym::napi_sym] -fn napi_create_symbol( +#[napi_sym] +fn napi_get_boolean( env: *mut Env, + value: bool, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env); + check_arg!(env, result); + + unsafe { + *result = v8::Boolean::new(env.isolate(), value).into(); + } + + return napi_clear_last_error(env); +} + +#[napi_sym] +fn napi_create_symbol( + env_ptr: *mut Env, description: napi_value, result: *mut napi_value, ) -> napi_status { - check_env!(env); + let env = check_env!(env_ptr); check_arg!(env, result); - let env = unsafe { &mut *env }; - let scope = &mut env.scope(); let description = if let Some(d) = *description { - let Some(d) = d.to_string(scope) else { - return napi_string_expected; + let Some(d) = d.to_string(&mut env.scope()) else { + return napi_set_last_error(env, napi_string_expected); }; Some(d) } else { None }; - *result = v8::Symbol::new(scope, description).into(); - napi_ok + + unsafe { + *result = v8::Symbol::new(&mut env.scope(), description).into(); + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] -fn napi_create_typedarray( +#[napi_sym] +fn node_api_symbol_for( env: *mut Env, - ty: napi_typedarray_type, + utf8description: *const c_char, length: usize, - arraybuffer: napi_value, - byte_offset: usize, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let ab = napi_value_unchecked(arraybuffer); - let Ok(ab) = v8::Local::<v8::ArrayBuffer>::try_from(ab) else { - return napi_arraybuffer_expected; - }; - let typedarray: v8::Local<v8::Value> = match ty { - napi_uint8_array => { - v8::Uint8Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_uint8_clamped_array => { - v8::Uint8ClampedArray::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_int8_array => { - v8::Int8Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_uint16_array => { - v8::Uint16Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_int16_array => { - v8::Int16Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_uint32_array => { - v8::Uint32Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_int32_array => { - v8::Int32Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_float32_array => { - v8::Float32Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_float64_array => { - v8::Float64Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_bigint64_array => { - v8::BigInt64Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() - } - napi_biguint64_array => { - v8::BigUint64Array::new(&mut env.scope(), ab, byte_offset, length) - .unwrap() - .into() + { + let env = check_env!(env); + check_arg!(env, result); + + let description_string = + match unsafe { check_new_from_utf8_len(env, utf8description, length) } { + Ok(s) => s, + Err(status) => return napi_set_last_error(env, status), + }; + + unsafe { + *result = + v8::Symbol::for_key(&mut env.scope(), description_string).into(); } - _ => { - return napi_invalid_arg; + } + + napi_clear_last_error(env) +} + +macro_rules! napi_create_error_impl { + ($env_ptr:ident, $code:ident, $msg:ident, $result:ident, $error:ident) => {{ + let env_ptr = $env_ptr; + let code = $code; + let msg = $msg; + let result = $result; + + let env = check_env!(env_ptr); + check_arg!(env, msg); + check_arg!(env, result); + + let Some(message) = + msg.and_then(|v| v8::Local::<v8::String>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_string_expected); + }; + + let error = v8::Exception::$error(&mut env.scope(), message); + + if let Some(code) = *code { + let error_obj: v8::Local<v8::Object> = error.try_into().unwrap(); + let code_key = v8::String::new(&mut env.scope(), "code").unwrap(); + if !error_obj + .set(&mut env.scope(), code_key.into(), code) + .unwrap_or(false) + { + return napi_set_last_error(env_ptr, napi_generic_failure); + } + } + + unsafe { + *result = error.into(); } + + return napi_clear_last_error(env_ptr); + }}; +} + +#[napi_sym] +fn napi_create_error( + env_ptr: *mut Env, + code: napi_value, + msg: napi_value, + result: *mut napi_value, +) -> napi_status { + napi_create_error_impl!(env_ptr, code, msg, result, error) +} + +#[napi_sym] +fn napi_create_type_error( + env_ptr: *mut Env, + code: napi_value, + msg: napi_value, + result: *mut napi_value, +) -> napi_status { + napi_create_error_impl!(env_ptr, code, msg, result, type_error) +} + +#[napi_sym] +fn napi_create_range_error( + env_ptr: *mut Env, + code: napi_value, + msg: napi_value, + result: *mut napi_value, +) -> napi_status { + napi_create_error_impl!(env_ptr, code, msg, result, range_error) +} + +#[napi_sym] +fn node_api_create_syntax_error( + env_ptr: *mut Env, + code: napi_value, + msg: napi_value, + result: *mut napi_value, +) -> napi_status { + napi_create_error_impl!(env_ptr, code, msg, result, syntax_error) +} + +pub fn get_value_type(value: v8::Local<v8::Value>) -> Option<napi_valuetype> { + if value.is_undefined() { + Some(napi_undefined) + } else if value.is_null() { + Some(napi_null) + } else if value.is_external() { + Some(napi_external) + } else if value.is_boolean() { + Some(napi_boolean) + } else if value.is_number() { + Some(napi_number) + } else if value.is_big_int() { + Some(napi_bigint) + } else if value.is_string() { + Some(napi_string) + } else if value.is_symbol() { + Some(napi_symbol) + } else if value.is_function() { + Some(napi_function) + } else if value.is_object() { + Some(napi_object) + } else { + None + } +} + +#[napi_sym] +fn napi_typeof( + env: *mut Env, + value: napi_value, + result: *mut napi_valuetype, +) -> napi_status { + let env = check_env!(env); + check_arg!(env, value); + check_arg!(env, result); + + let Some(ty) = get_value_type(value.unwrap()) else { + return napi_set_last_error(env, napi_invalid_arg); }; - *result = typedarray.into(); + + unsafe { + *result = ty; + } + + napi_clear_last_error(env) +} + +#[napi_sym] +fn napi_get_undefined(env: *mut Env, result: *mut napi_value) -> napi_status { + let env = check_env!(env); + check_arg!(env, result); + + unsafe { + *result = v8::undefined(&mut env.scope()).into(); + } + + return napi_clear_last_error(env); +} + +#[napi_sym] +fn napi_get_null(env: *mut Env, result: *mut napi_value) -> napi_status { + let env = check_env!(env); + check_arg!(env, result); + + unsafe { + *result = v8::null(&mut env.scope()).into(); + } + + return napi_clear_last_error(env); +} + +#[napi_sym] +fn napi_get_cb_info( + env: *mut Env, + cbinfo: napi_callback_info, + argc: *mut i32, + argv: *mut napi_value, + this_arg: *mut napi_value, + data: *mut *mut c_void, +) -> napi_status { + let env = check_env!(env); + check_arg!(env, cbinfo); + + let cbinfo: &CallbackInfo = unsafe { &*(cbinfo as *const CallbackInfo) }; + let args = unsafe { &*(cbinfo.args as *const v8::FunctionCallbackArguments) }; + + if !argv.is_null() { + check_arg!(env, argc); + let argc = unsafe { *argc as usize }; + for i in 0..argc { + let mut arg = args.get(i as _); + unsafe { + *argv.add(i) = arg.into(); + } + } + } + + if !argc.is_null() { + unsafe { + *argc = args.length(); + } + } + + if !this_arg.is_null() { + unsafe { + *this_arg = args.this().into(); + } + } + + if !data.is_null() { + unsafe { + *data = cbinfo.cb_info; + } + } + + napi_clear_last_error(env); napi_ok } -#[napi_sym::napi_sym] -fn napi_make_callback( +#[napi_sym] +fn napi_get_new_target( env: *mut Env, - async_context: *mut c_void, + cbinfo: napi_callback_info, + result: *mut napi_value, +) -> napi_status { + let env = check_env!(env); + check_arg!(env, cbinfo); + check_arg!(env, result); + + let cbinfo: &CallbackInfo = unsafe { &*(cbinfo as *const CallbackInfo) }; + let args = unsafe { &*(cbinfo.args as *const v8::FunctionCallbackArguments) }; + + unsafe { + *result = args.new_target().into(); + } + + return napi_clear_last_error(env); +} + +#[napi_sym] +fn napi_call_function( + env_ptr: *mut Env, recv: napi_value, func: napi_value, - argc: isize, + argc: usize, argv: *const napi_value, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg_option!(env, recv); - if argc > 0 { + let env = check_env!(env_ptr); + check_arg!(env, recv); + let args = if argc > 0 { check_arg!(env, argv); + unsafe { + std::slice::from_raw_parts(argv as *mut v8::Local<v8::Value>, argc) + } + } else { + &[] + }; + + let Some(func) = + func.and_then(|f| v8::Local::<v8::Function>::try_from(f).ok()) + else { + return napi_set_last_error(env, napi_function_expected); + }; + + let Some(v) = func.call(&mut env.scope(), recv.unwrap(), args) else { + return napi_set_last_error(env_ptr, napi_generic_failure); + }; + + if !result.is_null() { + unsafe { + *result = v.into(); + } } - if !async_context.is_null() { - log::info!("napi_make_callback: async_context is not supported"); + return napi_clear_last_error(env_ptr); +} + +#[napi_sym] +fn napi_get_global(env: *mut Env, result: *mut napi_value) -> napi_status { + let env = check_env!(env); + check_arg!(env, result); + + unsafe { + *result = std::mem::transmute::<NonNull<v8::Value>, v8::Local<v8::Value>>( + env.global, + ) + .into(); } - let recv = napi_value_unchecked(recv); - let func = napi_value_unchecked(func); + return napi_clear_last_error(env); +} - let Ok(func) = v8::Local::<v8::Function>::try_from(func) else { - return napi_function_expected; +#[napi_sym] +fn napi_throw(env: *mut Env, error: napi_value) -> napi_status { + let env = check_env!(env); + check_arg!(env, error); + + if env.last_exception.is_some() { + return napi_pending_exception; + } + + let error = error.unwrap(); + env.scope().throw_exception(error); + let error = v8::Global::new(&mut env.scope(), error); + env.last_exception = Some(error); + + napi_clear_last_error(env) +} + +macro_rules! napi_throw_error_impl { + ($env:ident, $code:ident, $msg:ident, $error:ident) => {{ + let env = check_env!($env); + let env_ptr = env as *mut Env; + let code = $code; + let msg = $msg; + + if env.last_exception.is_some() { + return napi_pending_exception; + } + + let str_ = match unsafe { check_new_from_utf8(env, msg) } { + Ok(s) => s, + Err(status) => return status, + }; + + let error = v8::Exception::$error(&mut env.scope(), str_); + + if !code.is_null() { + let error_obj: v8::Local<v8::Object> = error.try_into().unwrap(); + let code = match unsafe { check_new_from_utf8(env_ptr, code) } { + Ok(s) => s, + Err(status) => return napi_set_last_error(env, status), + }; + let code_key = v8::String::new(&mut env.scope(), "code").unwrap(); + if !error_obj + .set(&mut env.scope(), code_key.into(), code.into()) + .unwrap_or(false) + { + return napi_set_last_error(env, napi_generic_failure); + } + } + + env.scope().throw_exception(error); + let error = v8::Global::new(&mut env.scope(), error); + env.last_exception = Some(error); + + napi_clear_last_error(env) + }}; +} + +#[napi_sym] +fn napi_throw_error( + env: *mut Env, + code: *const c_char, + msg: *const c_char, +) -> napi_status { + napi_throw_error_impl!(env, code, msg, error) +} + +#[napi_sym] +fn napi_throw_type_error( + env: *mut Env, + code: *const c_char, + msg: *const c_char, +) -> napi_status { + napi_throw_error_impl!(env, code, msg, type_error) +} + +#[napi_sym] +fn napi_throw_range_error( + env: *mut Env, + code: *const c_char, + msg: *const c_char, +) -> napi_status { + napi_throw_error_impl!(env, code, msg, range_error) +} + +#[napi_sym] +fn node_api_throw_syntax_error( + env: *mut Env, + code: *const c_char, + msg: *const c_char, +) -> napi_status { + napi_throw_error_impl!(env, code, msg, syntax_error) +} + +#[napi_sym] +fn napi_is_error( + env: *mut Env, + value: napi_value, + result: *mut bool, +) -> napi_status { + let env = check_env!(env); + check_arg!(env, value); + check_arg!(env, result); + + unsafe { + *result = value.unwrap().is_native_error(); + } + + return napi_clear_last_error(env); +} + +#[napi_sym] +fn napi_get_value_double( + env_ptr: *mut Env, + value: napi_value, + result: *mut f64, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); + + let Some(number) = + value.and_then(|v| v8::Local::<v8::Number>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_number_expected); }; - let argv: &[v8::Local<v8::Value>] = - transmute(std::slice::from_raw_parts(argv, argc as usize)); - let ret = func.call(&mut env.scope(), recv, argv); - *result = transmute::<Option<v8::Local<v8::Value>>, napi_value>(ret); - napi_ok + + unsafe { + *result = number.value(); + } + + return napi_clear_last_error(env_ptr); +} + +#[napi_sym] +fn napi_get_value_int32( + env_ptr: *mut Env, + value: napi_value, + result: *mut i32, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); + + let Some(value) = value.unwrap().int32_value(&mut env.scope()) else { + return napi_set_last_error(env, napi_number_expected); + }; + + unsafe { + *result = value; + } + + return napi_clear_last_error(env_ptr); +} + +#[napi_sym] +fn napi_get_value_uint32( + env_ptr: *mut Env, + value: napi_value, + result: *mut u32, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); + + let Some(value) = value.unwrap().uint32_value(&mut env.scope()) else { + return napi_set_last_error(env, napi_number_expected); + }; + + unsafe { + *result = value; + } + + return napi_clear_last_error(env_ptr); +} + +#[napi_sym] +fn napi_get_value_int64( + env_ptr: *mut Env, + value: napi_value, + result: *mut i64, +) -> napi_status { + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); + + let Some(number) = + value.and_then(|v| v8::Local::<v8::Number>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_number_expected); + }; + + let value = number.value(); + + unsafe { + if value.is_finite() { + *result = value as _; + } else { + *result = 0; + } + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_value_bigint_int64( - env: *mut Env, + env_ptr: *mut Env, value: napi_value, result: *mut i64, lossless: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let bigint = value.to_big_int(&mut env.scope()).unwrap(); + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); + check_arg!(env, lossless); + + let Some(bigint) = + value.and_then(|v| v8::Local::<v8::BigInt>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_bigint_expected); + }; + let (result_, lossless_) = bigint.i64_value(); - *result = result_; - *lossless = lossless_; - // TODO(bartlomieju): - // napi_clear_last_error() - napi_ok + + unsafe { + *result = result_; + *lossless = lossless_; + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_value_bigint_uint64( - env: *mut Env, + env_ptr: *mut Env, value: napi_value, result: *mut u64, lossless: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let bigint = value.to_big_int(&mut env.scope()).unwrap(); + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); + check_arg!(env, lossless); + + let Some(bigint) = + value.and_then(|v| v8::Local::<v8::BigInt>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_bigint_expected); + }; + let (result_, lossless_) = bigint.u64_value(); - *result = result_; - *lossless = lossless_; - // TODO(bartlomieju): - // napi_clear_last_error() - napi_ok + + unsafe { + *result = result_; + *lossless = lossless_; + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_value_bigint_words( - env: *mut Env, + env_ptr: *mut Env, value: napi_value, sign_bit: *mut i32, word_count: *mut usize, words: *mut u64, ) -> napi_status { - check_env!(env); - // TODO(bartlomieju): - // check_arg!(env, value); + let env = check_env!(env_ptr); + check_arg!(env, value); check_arg!(env, word_count); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let big = match value.to_big_int(&mut env.scope()) { - Some(b) => b, - None => return napi_bigint_expected, + let Some(bigint) = + value.and_then(|v| v8::Local::<v8::BigInt>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_bigint_expected); }; + let word_count_int; if sign_bit.is_null() && words.is_null() { - word_count_int = big.word_count(); + word_count_int = bigint.word_count(); } else { check_arg!(env, sign_bit); check_arg!(env, words); - let out_words = std::slice::from_raw_parts_mut(words, *word_count); - let (sign, slice_) = big.to_words_array(out_words); + let out_words = + unsafe { std::slice::from_raw_parts_mut(words, *word_count) }; + let (sign, slice_) = bigint.to_words_array(out_words); word_count_int = slice_.len(); - *sign_bit = sign as i32; + unsafe { + *sign_bit = sign as i32; + } } - *word_count = word_count_int; - // TODO(bartlomieju): - // napi_clear_last_error() - napi_ok + unsafe { + *word_count = word_count_int; + } + + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_value_bool( - env: *mut Env, + env_ptr: *mut Env, value: napi_value, result: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - *result = value.boolean_value(&mut env.scope()); - napi_ok -} + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); -#[napi_sym::napi_sym] -fn napi_get_value_double( - env: *mut Env, - value: napi_value, - result: *mut f64, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - return_status_if_false!(env, value.is_number(), napi_number_expected); - *result = value.number_value(&mut env.scope()).unwrap(); - napi_ok -} + let Some(boolean) = + value.and_then(|v| v8::Local::<v8::Boolean>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_boolean_expected); + }; -#[napi_sym::napi_sym] -fn napi_get_value_external( - _env: *mut Env, - value: napi_value, - result: *mut *mut c_void, -) -> napi_status { - let value = napi_value_unchecked(value); - let ext = v8::Local::<v8::External>::try_from(value).unwrap(); - *result = ext.value(); - napi_ok -} + unsafe { + *result = boolean.is_true(); + } -#[napi_sym::napi_sym] -fn napi_get_value_int32( - env: *mut Env, - value: napi_value, - result: *mut i32, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - *result = value.int32_value(&mut env.scope()).unwrap(); - napi_ok + return napi_clear_last_error(env_ptr); } -#[napi_sym::napi_sym] -fn napi_get_value_int64( - env: *mut Env, - value: napi_value, - result: *mut i64, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - *result = value.integer_value(&mut env.scope()).unwrap(); - napi_ok -} - -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_value_string_latin1( - env: *mut Env, + env_ptr: *mut Env, value: napi_value, - buf: *mut u8, + buf: *mut c_char, bufsize: usize, result: *mut usize, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - - let value = napi_value_unchecked(value); - - if !value.is_string() && !value.is_string_object() { - return napi_string_expected; - } + let env = check_env!(env_ptr); + check_arg!(env, value); - let v8str = value.to_string(&mut env.scope()).unwrap(); - let string_len = v8str.utf8_length(&mut env.scope()); + let Some(value) = + value.and_then(|v| v8::Local::<v8::String>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_string_expected); + }; if buf.is_null() { - *result = string_len; + check_arg!(env, result); + unsafe { + *result = value.length(); + } } else if bufsize != 0 { - let buffer = std::slice::from_raw_parts_mut(buf, bufsize - 1); - let copied = v8str.write_one_byte( + let buffer = + unsafe { std::slice::from_raw_parts_mut(buf as _, bufsize - 1) }; + let copied = value.write_one_byte( &mut env.scope(), buffer, 0, v8::WriteOptions::NO_NULL_TERMINATION, ); - buf.add(copied).write(0); + unsafe { + buf.add(copied).write(0); + } if !result.is_null() { - *result = copied; + unsafe { + *result = copied; + } } } else if !result.is_null() { - *result = string_len; + unsafe { + *result = 0; + } } - napi_ok + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_value_string_utf8( - env: *mut Env, + env_ptr: *mut Env, value: napi_value, buf: *mut u8, bufsize: usize, result: *mut usize, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - - let value = napi_value_unchecked(value); + let env = check_env!(env_ptr); + check_arg!(env, value); - if !value.is_string() && !value.is_string_object() { - return napi_string_expected; - } - - let v8str = value.to_string(&mut env.scope()).unwrap(); - let string_len = v8str.utf8_length(&mut env.scope()); + let Some(value) = + value.and_then(|v| v8::Local::<v8::String>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_string_expected); + }; if buf.is_null() { - *result = string_len; + check_arg!(env, result); + unsafe { + *result = value.length(); + } } else if bufsize != 0 { - let buffer = std::slice::from_raw_parts_mut(buf, bufsize - 1); - let copied = v8str.write_utf8( + let buffer = + unsafe { std::slice::from_raw_parts_mut(buf as _, bufsize - 1) }; + let copied = value.write_utf8( &mut env.scope(), buffer, None, - v8::WriteOptions::NO_NULL_TERMINATION - | v8::WriteOptions::REPLACE_INVALID_UTF8, + v8::WriteOptions::REPLACE_INVALID_UTF8 + | v8::WriteOptions::NO_NULL_TERMINATION, ); - buf.add(copied).write(0); + unsafe { + buf.add(copied).write(0); + } if !result.is_null() { - *result = copied; + unsafe { + *result = copied; + } } } else if !result.is_null() { - *result = string_len; + unsafe { + *result = 0; + } } - napi_ok + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_value_string_utf16( - env: *mut Env, + env_ptr: *mut Env, value: napi_value, buf: *mut u16, bufsize: usize, result: *mut usize, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - - let value = napi_value_unchecked(value); - - if !value.is_string() && !value.is_string_object() { - return napi_string_expected; - } + let env = check_env!(env_ptr); + check_arg!(env, value); - let v8str = value.to_string(&mut env.scope()).unwrap(); - let string_len = v8str.length(); + let Some(value) = + value.and_then(|v| v8::Local::<v8::String>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_string_expected); + }; if buf.is_null() { - *result = string_len; + check_arg!(env, result); + unsafe { + *result = value.length(); + } } else if bufsize != 0 { - let buffer = std::slice::from_raw_parts_mut(buf, bufsize - 1); - let copied = v8str.write( + let buffer = + unsafe { std::slice::from_raw_parts_mut(buf as _, bufsize - 1) }; + let copied = value.write( &mut env.scope(), buffer, 0, v8::WriteOptions::NO_NULL_TERMINATION, ); - buf.add(copied).write(0); + unsafe { + buf.add(copied).write(0); + } if !result.is_null() { - *result = copied; + unsafe { + *result = copied; + } } } else if !result.is_null() { - *result = string_len; + unsafe { + *result = 0; + } } - napi_ok + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] -fn napi_get_value_uint32( - env: *mut Env, +#[napi_sym] +fn napi_coerce_to_bool<'s>( + env: &'s mut Env, value: napi_value, - result: *mut u32, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - *result = value.uint32_value(&mut env.scope()).unwrap(); + check_arg!(env, value); + check_arg!(env, result); + + let coerced = value.unwrap().to_boolean(&mut env.scope()); + + unsafe { + *result = coerced.into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_add_finalizer( - env_ptr: *mut Env, - js_object: napi_value, - native_object: *mut c_void, - finalize_cb: napi_finalize, - finalize_hint: *mut c_void, - result: *mut napi_ref, +#[napi_sym] +fn napi_coerce_to_number<'s>( + env: &'s mut Env, + value: napi_value, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, result); - let value = napi_value_unchecked(js_object); - let value = - weak_local(env_ptr, value, native_object, finalize_cb, finalize_hint); + let Some(coerced) = value.unwrap().to_number(&mut env.scope()) else { + return napi_number_expected; + }; - if !result.is_null() { - *result = transmute(value); + unsafe { + *result = coerced.into(); } napi_ok } -#[napi_sym::napi_sym] -fn napi_adjust_external_memory( - env: *mut Env, - change_in_bytes: i64, - adjusted_value: *mut i64, +#[napi_sym] +fn napi_coerce_to_object<'s>( + env: &'s mut Env, + value: napi_value, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - check_arg!(env, adjusted_value); + check_arg!(env, value); + check_arg!(env, result); - let env = unsafe { &mut *env }; - let isolate = &mut *env.isolate_ptr; - *adjusted_value = - isolate.adjust_amount_of_external_allocated_memory(change_in_bytes); + let Some(coerced) = value.unwrap().to_object(&mut env.scope()) else { + return napi_object_expected; + }; + + unsafe { + *result = coerced.into(); + } - napi_clear_last_error(env); napi_ok } -#[napi_sym::napi_sym] -fn napi_call_function( - env: *mut Env, - recv: napi_value, - func: napi_value, - argc: usize, - argv: *const napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_coerce_to_string<'s>( + env: &'s mut Env, + value: napi_value, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let recv = napi_value_unchecked(recv); - let func = napi_value_unchecked(func); - let Ok(func) = v8::Local::<v8::Function>::try_from(func) else { - return napi_function_expected; + check_arg!(env, value); + check_arg!(env, result); + + let Some(coerced) = value.unwrap().to_string(&mut env.scope()) else { + return napi_string_expected; }; - let argv: &[v8::Local<v8::Value>] = - transmute(std::slice::from_raw_parts(argv, argc)); - let ret = func.call(&mut env.scope(), recv, argv); - if !result.is_null() { - *result = transmute::<Option<v8::Local<v8::Value>>, napi_value>(ret); + unsafe { + *result = coerced.into(); } napi_ok } -#[napi_sym::napi_sym] -fn napi_close_escapable_handle_scope( - _env: *mut Env, - _scope: napi_escapable_handle_scope, +#[napi_sym] +fn napi_wrap( + env: &mut Env, + js_object: napi_value, + native_object: *mut c_void, + finalize_cb: Option<napi_finalize>, + finalize_hint: *mut c_void, + result: *mut napi_ref, ) -> napi_status { - // TODO: do this properly - napi_ok -} + check_arg!(env, js_object); + let env_ptr = env as *mut Env; -#[napi_sym::napi_sym] -fn napi_close_handle_scope( - env: *mut Env, - _scope: napi_handle_scope, -) -> napi_status { - let env = &mut *env; - if env.open_handle_scopes == 0 { - return napi_handle_scope_mismatch; + let Some(obj) = + js_object.and_then(|v| v8::Local::<v8::Object>::try_from(v).ok()) + else { + return napi_invalid_arg; + }; + + let napi_wrap = v8::Local::new(&mut env.scope(), &env.shared().napi_wrap); + + if obj + .has_private(&mut env.scope(), napi_wrap) + .unwrap_or(false) + { + return napi_invalid_arg; + } + + if !result.is_null() { + check_arg!(env, finalize_cb); } - // TODO: We are not opening a handle scope, therefore we cannot close it - // TODO: this is also not implemented in napi_open_handle_scope - // let _scope = &mut *(scope as *mut v8::HandleScope); - env.open_handle_scopes -= 1; + + let ownership = if result.is_null() { + ReferenceOwnership::Runtime + } else { + ReferenceOwnership::Userland + }; + let reference = Reference::new( + env_ptr, + obj.into(), + 0, + ownership, + finalize_cb, + native_object, + finalize_hint, + ); + + let reference = Reference::into_raw(reference) as *mut c_void; + + if !result.is_null() { + check_arg!(env, finalize_cb); + unsafe { + *result = reference; + } + } + + let external = v8::External::new(&mut env.scope(), reference); + assert!(obj + .set_private(&mut env.scope(), napi_wrap, external.into()) + .unwrap()); + napi_ok } -#[napi_sym::napi_sym] -fn napi_define_class( - env_ptr: *mut Env, - name: *const c_char, - length: isize, - constructor: napi_callback, - callback_data: *mut c_void, - property_count: usize, - properties: *const napi_property_descriptor, - result: *mut napi_value, +fn unwrap( + env: &mut Env, + obj: napi_value, + result: *mut *mut c_void, + keep: bool, ) -> napi_status { - check_env!(env_ptr); - let env = unsafe { &mut *env_ptr }; - check_arg!(env, result); - check_arg_option!(env, constructor); - - if property_count > 0 { - check_arg!(env, properties); + check_arg!(env, obj); + if keep { + check_arg!(env, result); } - let name = if length == -1 { - let Ok(s) = std::ffi::CStr::from_ptr(name).to_str() else { - return napi_invalid_arg; - }; - s - } else { - let slice = std::slice::from_raw_parts(name as *const u8, length as usize); - std::str::from_utf8(slice).unwrap() + let Some(obj) = obj.and_then(|v| v8::Local::<v8::Object>::try_from(v).ok()) + else { + return napi_invalid_arg; + }; + + let napi_wrap = v8::Local::new(&mut env.scope(), &env.shared().napi_wrap); + let Some(val) = obj.get_private(&mut env.scope(), napi_wrap) else { + return napi_invalid_arg; }; - let tpl = - create_function_template(env_ptr, Some(name), constructor, callback_data); + let Ok(external) = v8::Local::<v8::External>::try_from(val) else { + return napi_invalid_arg; + }; - let scope = &mut env.scope(); - let napi_properties: &[napi_property_descriptor] = - std::slice::from_raw_parts(properties, property_count); - let mut static_property_count = 0; + let reference = external.value() as *mut Reference; + let reference = unsafe { &mut *reference }; - for p in napi_properties { - if p.attributes & napi_static != 0 { - // Will be handled below - static_property_count += 1; - continue; + if !result.is_null() { + unsafe { + *result = reference.finalize_data; } + } - let name = if !p.utf8name.is_null() { - let name_str = CStr::from_ptr(p.utf8name).to_str().unwrap(); - v8::String::new(scope, name_str).unwrap() - } else { - transmute::<napi_value, v8::Local<v8::String>>(p.name) - }; + if !keep { + assert!(obj + .delete_private(&mut env.scope(), napi_wrap) + .unwrap_or(false)); + unsafe { Reference::remove(reference) }; + } - let method = p.method; - let getter = p.getter; - let setter = p.setter; + napi_ok +} - if getter.is_some() || setter.is_some() { - let getter: Option<v8::Local<v8::FunctionTemplate>> = if getter.is_some() - { - Some(create_function_template(env_ptr, None, p.getter, p.data)) - } else { - None - }; - let setter: Option<v8::Local<v8::FunctionTemplate>> = if setter.is_some() - { - Some(create_function_template(env_ptr, None, p.setter, p.data)) - } else { - None - }; +#[napi_sym] +fn napi_unwrap( + env: &mut Env, + obj: napi_value, + result: *mut *mut c_void, +) -> napi_status { + unwrap(env, obj, result, true) +} - let mut accessor_property = v8::PropertyAttribute::NONE; - if getter.is_some() - && setter.is_some() - && (p.attributes & napi_writable) == 0 - { - accessor_property = - accessor_property | v8::PropertyAttribute::READ_ONLY; - } - if p.attributes & napi_enumerable == 0 { - accessor_property = - accessor_property | v8::PropertyAttribute::DONT_ENUM; - } - if p.attributes & napi_configurable == 0 { - accessor_property = - accessor_property | v8::PropertyAttribute::DONT_DELETE; - } +#[napi_sym] +fn napi_remove_wrap( + env: &mut Env, + obj: napi_value, + result: *mut *mut c_void, +) -> napi_status { + unwrap(env, obj, result, false) +} - let proto = tpl.prototype_template(scope); - proto.set_accessor_property( - name.into(), - getter, - setter, - accessor_property, - ); - } else if method.is_some() { - let function = create_function_template(env_ptr, None, p.method, p.data); - let proto = tpl.prototype_template(scope); - proto.set(name.into(), function.into()); - } else { - let proto = tpl.prototype_template(scope); - proto.set( - name.into(), - transmute::<napi_value, v8::Local<v8::Data>>(p.value), - ); - } - } +struct ExternalWrapper { + data: *mut c_void, + type_tag: Option<napi_type_tag>, +} - let value: v8::Local<v8::Value> = tpl.get_function(scope).unwrap().into(); - *result = value.into(); +#[napi_sym] +fn napi_create_external<'s>( + env: &'s mut Env, + data: *mut c_void, + finalize_cb: Option<napi_finalize>, + finalize_hint: *mut c_void, + result: *mut napi_value<'s>, +) -> napi_status { + let env_ptr = env as *mut Env; + check_arg!(env, result); - if static_property_count > 0 { - let mut static_descriptors = Vec::with_capacity(static_property_count); + let wrapper = Box::new(ExternalWrapper { + data, + type_tag: None, + }); - for p in napi_properties { - if p.attributes & napi_static != 0 { - static_descriptors.push(*p); - } - } + let wrapper = Box::into_raw(wrapper); + let external = v8::External::new(&mut env.scope(), wrapper as _); - status_call!(napi_define_properties( + if let Some(finalize_cb) = finalize_cb { + Reference::into_raw(Reference::new( env_ptr, - *result, - static_descriptors.len(), - static_descriptors.as_ptr(), + external.into(), + 0, + ReferenceOwnership::Runtime, + Some(finalize_cb), + data, + finalize_hint, )); } + unsafe { + *result = external.into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_define_properties( - env_ptr: *mut Env, - obj: napi_value, - property_count: usize, - properties: *const napi_property_descriptor, +#[napi_sym] +fn napi_type_tag_object( + env: &mut Env, + object_or_external: napi_value, + type_tag: *const napi_type_tag, ) -> napi_status { - check_env!(env_ptr); - let env = unsafe { &mut *env_ptr }; - if property_count > 0 { - check_arg!(env, properties); + check_arg!(env, object_or_external); + check_arg!(env, type_tag); + + let val = object_or_external.unwrap(); + + if let Ok(external) = v8::Local::<v8::External>::try_from(val) { + let wrapper_ptr = external.value() as *mut ExternalWrapper; + let wrapper = unsafe { &mut *wrapper_ptr }; + if wrapper.type_tag.is_some() { + return napi_invalid_arg; + } + wrapper.type_tag = Some(unsafe { *type_tag }); + return napi_ok; } - let scope = &mut env.scope(); + let Some(object) = val.to_object(&mut env.scope()) else { + return napi_object_expected; + }; + + let key = v8::Local::new(&mut env.scope(), &env.shared().type_tag); - let Ok(object) = v8::Local::<v8::Object>::try_from(napi_value_unchecked(obj)) + if object.has_private(&mut env.scope(), key).unwrap_or(false) { + return napi_invalid_arg; + } + + let slice = unsafe { std::slice::from_raw_parts(type_tag as *const u64, 2) }; + let Some(tag) = v8::BigInt::new_from_words(&mut env.scope(), false, slice) else { - return napi_object_expected; + return napi_generic_failure; }; - let properties = std::slice::from_raw_parts(properties, property_count); - for property in properties { - let name = if !property.utf8name.is_null() { - let name_str = CStr::from_ptr(property.utf8name).to_str().unwrap(); - let Some(name_v8_str) = v8::String::new(scope, name_str) else { - return napi_generic_failure; - }; - name_v8_str.into() - } else { - let property_value = napi_value_unchecked(property.name); - let Ok(prop) = v8::Local::<v8::Name>::try_from(property_value) else { - return napi_name_expected; + if !object + .set_private(&mut env.scope(), key, tag.into()) + .unwrap_or(false) + { + return napi_generic_failure; + } + + napi_ok +} + +#[napi_sym] +fn napi_check_object_type_tag( + env: &mut Env, + object_or_external: napi_value, + type_tag: *const napi_type_tag, + result: *mut bool, +) -> napi_status { + check_arg!(env, object_or_external); + check_arg!(env, type_tag); + check_arg!(env, result); + + let type_tag = unsafe { *type_tag }; + + let val = object_or_external.unwrap(); + + if let Ok(external) = v8::Local::<v8::External>::try_from(val) { + let wrapper_ptr = external.value() as *mut ExternalWrapper; + let wrapper = unsafe { &mut *wrapper_ptr }; + unsafe { + *result = match wrapper.type_tag { + Some(t) => t == type_tag, + None => false, }; - prop }; + return napi_ok; + } - if property.getter.is_some() || property.setter.is_some() { - let local_getter: v8::Local<v8::Value> = if property.getter.is_some() { - create_function(env_ptr, None, property.getter, property.data).into() - } else { - v8::undefined(scope).into() - }; - let local_setter: v8::Local<v8::Value> = if property.setter.is_some() { - create_function(env_ptr, None, property.setter, property.data).into() - } else { - v8::undefined(scope).into() - }; + let Some(object) = val.to_object(&mut env.scope()) else { + return napi_object_expected; + }; - let mut desc = - v8::PropertyDescriptor::new_from_get_set(local_getter, local_setter); - desc.set_enumerable(property.attributes & napi_enumerable != 0); - desc.set_configurable(property.attributes & napi_configurable != 0); + let key = v8::Local::new(&mut env.scope(), &env.shared().type_tag); - let define_maybe = object.define_property(scope, name, &desc); - return_status_if_false!( - env_ptr, - define_maybe.is_some(), - napi_invalid_arg - ); - } else if property.method.is_some() { - let value: v8::Local<v8::Value> = { - let function = - create_function(env_ptr, None, property.method, property.data); - function.into() + let Some(val) = object.get_private(&mut env.scope(), key) else { + return napi_generic_failure; + }; + + unsafe { + *result = false; + } + + if let Ok(bigint) = v8::Local::<v8::BigInt>::try_from(val) { + let mut words = [0u64; 2]; + let (sign, words) = bigint.to_words_array(&mut words); + if !sign { + let pass = if words.len() == 2 { + type_tag.lower == words[0] && type_tag.upper == words[1] + } else if words.len() == 1 { + type_tag.lower == words[0] && type_tag.upper == 0 + } else if words.is_empty() { + type_tag.lower == 0 && type_tag.upper == 0 + } else { + false }; - return_status_if_false!( - env_ptr, - object.set(scope, name.into(), value).is_some(), - napi_invalid_arg - ); - } else { - let value = napi_value_unchecked(property.value); - return_status_if_false!( - env_ptr, - object.set(scope, name.into(), value).is_some(), - napi_invalid_arg - ); + unsafe { + *result = pass; + } } } napi_ok } -#[napi_sym::napi_sym] -fn napi_delete_element( +#[napi_sym] +fn napi_get_value_external( env: *mut Env, value: napi_value, - index: u32, - result: *mut bool, + result: *mut *mut c_void, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let obj = value.to_object(&mut env.scope()).unwrap(); - *result = obj.delete_index(&mut env.scope(), index).unwrap_or(false); - napi_ok + let env = check_env!(env); + check_arg!(env, value); + check_arg!(env, result); + + let Some(external) = + value.and_then(|v| v8::Local::<v8::External>::try_from(v).ok()) + else { + return napi_set_last_error(env, napi_invalid_arg); + }; + + let wrapper_ptr = external.value() as *const ExternalWrapper; + let wrapper = unsafe { &*wrapper_ptr }; + + unsafe { + *result = wrapper.data; + } + + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_delete_property( +#[napi_sym] +fn napi_create_reference( env: *mut Env, - object: napi_value, - key: napi_value, - result: *mut bool, + value: napi_value, + initial_refcount: u32, + result: *mut napi_ref, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg_option!(env, key); + let env = check_env!(env); + check_arg!(env, value); check_arg!(env, result); - let scope = &mut env.scope(); - let Some(object) = object.map(|o| o.to_object(scope)).flatten() else { - return napi_invalid_arg; - }; + let value = value.unwrap(); - let Some(deleted) = object.delete(scope, key.unwrap_unchecked()) else { - return napi_generic_failure; - }; + let reference = Reference::new( + env, + value, + initial_refcount, + ReferenceOwnership::Userland, + None, + std::ptr::null_mut(), + std::ptr::null_mut(), + ); - *result = deleted; - napi_ok + let ptr = Reference::into_raw(reference); + + unsafe { + *result = ptr as _; + } + + napi_clear_last_error(env) } -// TODO: properly implement ref counting stuff -#[napi_sym::napi_sym] -fn napi_delete_reference(_env: *mut Env, _nref: napi_ref) -> napi_status { - napi_ok +#[napi_sym] +fn napi_delete_reference(env: *mut Env, ref_: napi_ref) -> napi_status { + let env = check_env!(env); + check_arg!(env, ref_); + + let reference = unsafe { Reference::from_raw(ref_ as _) }; + + drop(reference); + + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_detach_arraybuffer(env: *mut Env, value: napi_value) -> napi_status { - check_env!(env); +#[napi_sym] +fn napi_reference_ref( + env: *mut Env, + ref_: napi_ref, + result: *mut u32, +) -> napi_status { + let env = check_env!(env); + check_arg!(env, ref_); - let value = napi_value_unchecked(value); - let Ok(ab) = v8::Local::<v8::ArrayBuffer>::try_from(value) else { - return napi_arraybuffer_expected; - }; + let reference = unsafe { &mut *(ref_ as *mut Reference) }; - if !ab.is_detachable() { - return napi_detachable_arraybuffer_expected; - } + let count = reference.ref_(); - // Expected to crash for None. - ab.detach(None).unwrap(); + if !result.is_null() { + unsafe { + *result = count; + } + } - napi_clear_last_error(env); - napi_ok + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_escape_handle<'s>( - _env: *mut Env, - _handle_scope: napi_escapable_handle_scope, - escapee: napi_value<'s>, - result: *mut napi_value<'s>, +#[napi_sym] +fn napi_reference_unref( + env: *mut Env, + ref_: napi_ref, + result: *mut u32, ) -> napi_status { - // TODO - *result = escapee; - napi_ok -} + let env = check_env!(env); + check_arg!(env, ref_); -#[napi_sym::napi_sym] -fn napi_get_all_property_names(_env: *mut Env) -> napi_status { - // TODO - napi_ok + let reference = unsafe { &mut *(ref_ as *mut Reference) }; + + if reference.ref_count == 0 { + return napi_set_last_error(env, napi_generic_failure); + } + + let count = reference.unref(); + + if !result.is_null() { + unsafe { + *result = count; + } + } + + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_get_and_clear_last_exception( - env: *mut Env, +#[napi_sym] +fn napi_get_reference_value( + env_ptr: *mut Env, + ref_: napi_ref, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - // TODO: just return undefined for now we don't cache - // exceptions in env. - let value: v8::Local<v8::Value> = v8::undefined(&mut env.scope()).into(); - *result = value.into(); - napi_ok + let env = check_env!(env_ptr); + check_arg!(env, ref_); + check_arg!(env, result); + + let reference = unsafe { &mut *(ref_ as *mut Reference) }; + + let value = match &reference.state { + ReferenceState::Strong(g) => Some(v8::Local::new(&mut env.scope(), g)), + ReferenceState::Weak(w) => w.to_local(&mut env.scope()), + }; + + unsafe { + *result = value.into(); + } + + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] -fn napi_get_array_length( - _env: *mut Env, - value: napi_value, - result: *mut u32, +#[napi_sym] +fn napi_open_handle_scope( + env: *mut Env, + _result: *mut napi_handle_scope, ) -> napi_status { - let value = napi_value_unchecked(value); - *result = v8::Local::<v8::Array>::try_from(value).unwrap().length(); - napi_ok + let env = check_env!(env); + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_get_arraybuffer_info( - _env: *mut Env, - value: napi_value, - data: *mut *mut u8, - length: *mut usize, +#[napi_sym] +fn napi_close_handle_scope( + env: *mut Env, + _scope: napi_handle_scope, ) -> napi_status { - let value = napi_value_unchecked(value); - let buf = v8::Local::<v8::ArrayBuffer>::try_from(value).unwrap(); - if !data.is_null() { - *data = get_array_buffer_ptr(buf); - } - if !length.is_null() { - *length = buf.byte_length(); - } - napi_ok + let env = check_env!(env); + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_get_boolean( +#[napi_sym] +fn napi_open_escapable_handle_scope( env: *mut Env, - value: bool, - result: *mut napi_value, + _result: *mut napi_escapable_handle_scope, ) -> napi_status { - check_env!(env); - check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::Boolean::new(env.isolate(), value).into(); - napi_ok + let env = check_env!(env); + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_get_buffer_info( +#[napi_sym] +fn napi_close_escapable_handle_scope( env: *mut Env, - value: napi_value, - data: *mut *mut u8, - length: *mut usize, + _scope: napi_escapable_handle_scope, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let Ok(buf) = v8::Local::<v8::ArrayBufferView>::try_from(value) else { - return napi_arraybuffer_expected; - }; - let buffer_name = v8::String::new(&mut env.scope(), "buffer").unwrap(); - let Ok(abuf) = v8::Local::<v8::ArrayBuffer>::try_from( - buf.get(&mut env.scope(), buffer_name.into()).unwrap(), - ) else { - return napi_arraybuffer_expected; - }; - if !data.is_null() { - *data = get_array_buffer_ptr(abuf); - } - if !length.is_null() { - *length = abuf.byte_length(); - } - napi_ok + let env = check_env!(env); + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_get_cb_info( +#[napi_sym] +fn napi_escape_handle<'s>( env: *mut Env, - cbinfo: napi_callback_info, - argc: *mut i32, - argv: *mut napi_value, - this_arg: *mut napi_value, - data: *mut *mut c_void, + _scope: napi_escapable_handle_scope, + escapee: napi_value<'s>, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg!(env, cbinfo); + let env = check_env!(env); - let cbinfo: &CallbackInfo = &*(cbinfo as *const CallbackInfo); - let args = &*(cbinfo.args as *const v8::FunctionCallbackArguments); - - if !argv.is_null() { - check_arg!(env, argc); - let mut v_argv = std::slice::from_raw_parts_mut(argv, argc as usize); - for i in 0..*argc { - let mut arg = args.get(i); - v_argv[i as usize] = arg.into(); - } + unsafe { + *result = escapee; } - if !argc.is_null() { - *argc = args.length(); - } + napi_clear_last_error(env) +} - if !this_arg.is_null() { - let mut this = args.this(); - *this_arg = this.into(); +#[napi_sym] +fn napi_new_instance<'s>( + env: &'s mut Env, + constructor: napi_value, + argc: usize, + argv: *const napi_value, + result: *mut napi_value<'s>, +) -> napi_status { + check_arg!(env, constructor); + if argc > 0 { + check_arg!(env, argv); } + check_arg!(env, result); - if !data.is_null() { - *data = cbinfo.cb_info; + let Some(func) = + constructor.and_then(|v| v8::Local::<v8::Function>::try_from(v).ok()) + else { + return napi_invalid_arg; + }; + + let args = if argc > 0 { + unsafe { + std::slice::from_raw_parts(argv as *mut v8::Local<v8::Value>, argc) + } + } else { + &[] + }; + + let Some(value) = func.new_instance(&mut env.scope(), args) else { + return napi_pending_exception; + }; + + unsafe { + *result = value.into(); } - napi_clear_last_error(env); napi_ok } -#[napi_sym::napi_sym] -fn napi_get_dataview_info( - env: *mut Env, - value: napi_value, - data: *mut *mut u8, - length: *mut usize, +#[napi_sym] +fn napi_instanceof( + env: &mut Env, + object: napi_value, + constructor: napi_value, + result: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let Ok(buf) = v8::Local::<v8::DataView>::try_from(value) else { - return napi_invalid_arg; + check_arg!(env, object); + check_arg!(env, result); + + let Some(ctor) = constructor.and_then(|v| v.to_object(&mut env.scope())) + else { + return napi_object_expected; }; - let buffer_name = v8::String::new(&mut env.scope(), "buffer").unwrap(); - let Ok(abuf) = v8::Local::<v8::ArrayBuffer>::try_from( - buf.get(&mut env.scope(), buffer_name.into()).unwrap(), - ) else { - return napi_invalid_arg; + + if !ctor.is_function() { + unsafe { + napi_throw_type_error( + env, + "ERR_NAPI_CONS_FUNCTION\0".as_ptr() as _, + "Constructor must be a function\0".as_ptr() as _, + ); + } + return napi_function_expected; + } + + let Some(res) = object.unwrap().instance_of(&mut env.scope(), ctor) else { + return napi_generic_failure; }; - if !data.is_null() { - *data = get_array_buffer_ptr(abuf); + + unsafe { + *result = res; } - *length = abuf.byte_length(); + napi_ok } -#[napi_sym::napi_sym] -fn napi_get_date_value( - env: *mut Env, - value: napi_value, - result: *mut f64, +#[napi_sym] +fn napi_is_exception_pending( + env_ptr: *mut Env, + result: *mut bool, ) -> napi_status { - check_env!(env); - let value = napi_value_unchecked(value); - return_status_if_false!(env, value.is_date(), napi_date_expected); - let env = unsafe { &mut *env }; - let Ok(date) = v8::Local::<v8::Date>::try_from(value) else { - return napi_date_expected; - }; - // TODO: should be value of - *result = date.number_value(&mut env.scope()).unwrap(); - napi_ok + let env = check_env!(env_ptr); + check_arg!(env, result); + + unsafe { + *result = env.last_exception.is_some(); + } + + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] -fn napi_get_element( - env: *mut Env, - object: napi_value, - index: u32, +#[napi_sym] +fn napi_get_and_clear_last_exception( + env_ptr: *mut Env, result: *mut napi_value, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let object = napi_value_unchecked(object); - let Ok(object) = v8::Local::<v8::Object>::try_from(object) else { - return napi_invalid_arg; - }; - let value: v8::Local<v8::Value> = - object.get_index(&mut env.scope(), index).unwrap(); - *result = value.into(); - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_get_global(env: *mut Env, result: *mut napi_value) -> napi_status { - check_env!(env); + let env = check_env!(env_ptr); check_arg!(env, result); - let value: v8::Local<v8::Value> = - transmute::<NonNull<v8::Value>, v8::Local<v8::Value>>((*env).global); - *result = value.into(); - napi_clear_last_error(env); - napi_ok + let ex: v8::Local<v8::Value> = + if let Some(last_exception) = env.last_exception.take() { + v8::Local::new(&mut env.scope(), last_exception) + } else { + v8::undefined(&mut env.scope()).into() + }; + + unsafe { + *result = ex.into(); + } + + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] -fn napi_get_instance_data( +#[napi_sym] +fn napi_is_arraybuffer( env: *mut Env, - result: *mut *mut c_void, + value: napi_value, + result: *mut bool, ) -> napi_status { - let env = &mut *env; - let shared = env.shared(); - *result = shared.instance_data; - napi_ok -} + let env = check_env!(env); + check_arg!(env, value); + check_arg!(env, result); -// TODO(bartlomieju): this function is broken -#[napi_sym::napi_sym] -fn napi_get_last_error_info( - _env: *mut Env, - error_code: *mut *const napi_extended_error_info, -) -> napi_status { - let err_info = Box::new(napi_extended_error_info { - error_message: std::ptr::null(), - engine_reserved: std::ptr::null_mut(), - engine_error_code: 0, - error_code: napi_ok, - }); + unsafe { + *result = value.unwrap().is_array_buffer(); + } - *error_code = Box::into_raw(err_info); - napi_ok + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_get_named_property( - env: *mut Env, - object: napi_value, - utf8_name: *const c_char, - result: *mut napi_value, +#[napi_sym] +fn napi_create_arraybuffer<'s>( + env: &'s mut Env, + len: usize, + data: *mut *mut c_void, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let object = napi_value_unchecked(object); - let utf8_name = std::ffi::CStr::from_ptr(utf8_name); - let name = - v8::String::new(&mut env.scope(), &utf8_name.to_string_lossy()).unwrap(); - let value: v8::Local<v8::Value> = object - .to_object(&mut env.scope()) - .unwrap() - .get(&mut env.scope(), name.into()) - .unwrap(); - *result = value.into(); - napi_ok -} + check_arg!(env, result); -#[napi_sym::napi_sym] -fn napi_get_new_target( - _env: &mut Env, - cbinfo: &CallbackInfo, - result: &mut v8::Local<v8::Value>, -) -> napi_status { - let info = &*(cbinfo.args as *const v8::FunctionCallbackArguments); - *result = info.new_target(); - napi_ok -} + let buffer = v8::ArrayBuffer::new(&mut env.scope(), len); + + if !data.is_null() { + unsafe { + *data = get_array_buffer_ptr(buffer) as _; + } + } + + unsafe { + *result = buffer.into(); + } -#[napi_sym::napi_sym] -fn napi_get_null(env: *mut Env, result: *mut napi_value) -> napi_status { - check_env!(env); - check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::null(env.isolate()).into(); napi_ok } -#[napi_sym::napi_sym] -fn napi_get_property( - env: *mut Env, - object: napi_value, - key: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_create_external_arraybuffer<'s>( + env: &'s mut Env, + data: *mut c_void, + byte_length: usize, + finalize_cb: napi_finalize, + finalize_hint: *mut c_void, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let object = transmute::<napi_value, v8::Local<v8::Object>>(object); - let key = napi_value_unchecked(key); - let value: v8::Local<v8::Value> = object.get(&mut env.scope(), key).unwrap(); - *result = value.into(); + check_arg!(env, result); + + let store = make_external_backing_store( + env, + data, + byte_length, + std::ptr::null_mut(), + finalize_cb, + finalize_hint, + ); + + let ab = + v8::ArrayBuffer::with_backing_store(&mut env.scope(), &store.make_shared()); + let value: v8::Local<v8::Value> = ab.into(); + + unsafe { + *result = value.into(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_get_property_names( +#[napi_sym] +fn napi_get_arraybuffer_info( env: *mut Env, - object: napi_value, - result: *mut napi_value, + value: napi_value, + data: *mut *mut u8, + length: *mut usize, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let object = napi_value_unchecked(object); - let array: v8::Local<v8::Array> = object - .to_object(&mut env.scope()) - .unwrap() - .get_property_names(&mut env.scope(), Default::default()) - .unwrap(); - let value: v8::Local<v8::Value> = array.into(); - *result = value.into(); + let env = check_env!(env); + check_arg!(env, value); + + let Some(buf) = + value.and_then(|v| v8::Local::<v8::ArrayBuffer>::try_from(v).ok()) + else { + return napi_set_last_error(env, napi_invalid_arg); + }; + + if !data.is_null() { + unsafe { + *data = get_array_buffer_ptr(buf); + } + } + + if !length.is_null() { + unsafe { + *length = buf.byte_length(); + } + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_get_prototype( +#[napi_sym] +fn napi_is_typedarray( env: *mut Env, value: napi_value, - result: *mut napi_value, + result: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let obj = value.to_object(&mut env.scope()).unwrap(); - let proto = obj.get_prototype(&mut env.scope()).unwrap(); - *result = proto.into(); + let env = check_env!(env); + check_arg!(env, value); + check_arg!(env, result); + + unsafe { + *result = value.unwrap().is_typed_array(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_get_reference_value( - env: *mut Env, - reference: napi_ref, - result: *mut napi_value, +#[napi_sym] +fn napi_create_typedarray<'s>( + env: &'s mut Env, + ty: napi_typedarray_type, + length: usize, + arraybuffer: napi_value, + byte_offset: usize, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let value = transmute::<napi_ref, v8::Local<v8::Value>>(reference); - *result = value.into(); + check_arg!(env, arraybuffer); + check_arg!(env, result); + + let Some(ab) = + arraybuffer.and_then(|v| v8::Local::<v8::ArrayBuffer>::try_from(v).ok()) + else { + return napi_arraybuffer_expected; + }; + + macro_rules! create { + ($TypedArray:ident, $size_of_element:expr) => {{ + let soe = $size_of_element; + if soe > 1 && byte_offset % soe != 0 { + let message = v8::String::new( + &mut env.scope(), + format!( + "start offset of {} should be multiple of {}", + stringify!($TypedArray), + soe + ) + .as_str(), + ) + .unwrap(); + let exc = v8::Exception::range_error(&mut env.scope(), message); + env.scope().throw_exception(exc); + return napi_pending_exception; + } + + if length * soe + byte_offset > ab.byte_length() { + let message = + v8::String::new(&mut env.scope(), "Invalid typed array length") + .unwrap(); + let exc = v8::Exception::range_error(&mut env.scope(), message); + env.scope().throw_exception(exc); + return napi_pending_exception; + } + + let Some(ta) = + v8::$TypedArray::new(&mut env.scope(), ab, byte_offset, length) + else { + return napi_generic_failure; + }; + ta.into() + }}; + } + + let typedarray: v8::Local<v8::Value> = match ty { + napi_uint8_array => create!(Uint8Array, 1), + napi_uint8_clamped_array => create!(Uint8ClampedArray, 1), + napi_int8_array => create!(Int8Array, 1), + napi_uint16_array => create!(Uint16Array, 2), + napi_int16_array => create!(Int16Array, 2), + napi_uint32_array => create!(Uint32Array, 4), + napi_int32_array => create!(Int32Array, 4), + napi_float32_array => create!(Float32Array, 4), + napi_float64_array => create!(Float64Array, 8), + napi_bigint64_array => create!(BigInt64Array, 8), + napi_biguint64_array => create!(BigUint64Array, 8), + _ => { + return napi_invalid_arg; + } + }; + + unsafe { + *result = typedarray.into(); + } + napi_ok } -#[napi_sym::napi_sym] +#[napi_sym] fn napi_get_typedarray_info( - env: *mut Env, + env_ptr: *mut Env, typedarray: napi_value, type_: *mut napi_typedarray_type, length: *mut usize, @@ -2018,364 +3048,278 @@ fn napi_get_typedarray_info( arraybuffer: *mut napi_value, byte_offset: *mut usize, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(typedarray); - let Ok(array) = v8::Local::<v8::TypedArray>::try_from(value) else { - return napi_invalid_arg; + let env = check_env!(env_ptr); + check_arg!(env, typedarray); + + let Some(array) = + typedarray.and_then(|v| v8::Local::<v8::TypedArray>::try_from(v).ok()) + else { + return napi_set_last_error(env_ptr, napi_invalid_arg); }; if !type_.is_null() { - if value.is_int8_array() { - *type_ = napi_int8_array; - } else if value.is_uint8_array() { - *type_ = napi_uint8_array; - } else if value.is_uint8_clamped_array() { - *type_ = napi_uint8_clamped_array; - } else if value.is_int16_array() { - *type_ = napi_int16_array; - } else if value.is_uint16_array() { - *type_ = napi_uint16_array; - } else if value.is_int32_array() { - *type_ = napi_int32_array; - } else if value.is_uint32_array() { - *type_ = napi_uint32_array; - } else if value.is_float32_array() { - *type_ = napi_float32_array; - } else if value.is_float64_array() { - *type_ = napi_float64_array; + let tatype = if array.is_int8_array() { + napi_int8_array + } else if array.is_uint8_array() { + napi_uint8_array + } else if array.is_uint8_clamped_array() { + napi_uint8_clamped_array + } else if array.is_int16_array() { + napi_int16_array + } else if array.is_uint16_array() { + napi_uint16_array + } else if array.is_int32_array() { + napi_int32_array + } else if array.is_uint32_array() { + napi_uint32_array + } else if array.is_float32_array() { + napi_float32_array + } else if array.is_float64_array() { + napi_float64_array + } else if array.is_big_int64_array() { + napi_bigint64_array + } else if array.is_big_uint64_array() { + napi_biguint64_array + } else { + unreachable!(); + }; + + unsafe { + *type_ = tatype; } } if !length.is_null() { - *length = array.length(); + unsafe { + *length = array.length(); + } } - if !data.is_null() || !arraybuffer.is_null() { - let buf = array.buffer(&mut env.scope()).unwrap(); - if !data.is_null() { - *data = get_array_buffer_ptr(buf) as *mut c_void; + if !data.is_null() { + unsafe { + *data = array.data(); } - if !arraybuffer.is_null() { + } + + if !arraybuffer.is_null() { + let buf = array.buffer(&mut env.scope()).unwrap(); + unsafe { *arraybuffer = buf.into(); } } if !byte_offset.is_null() { - *byte_offset = array.byte_offset(); + unsafe { + *byte_offset = array.byte_offset(); + } } - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_get_undefined(env: *mut Env, result: *mut napi_value) -> napi_status { - check_env!(env); - check_arg!(env, result); - let env = unsafe { &mut *env }; - *result = v8::undefined(env.isolate()).into(); - napi_ok -} - -pub const NAPI_VERSION: u32 = 8; - -#[napi_sym::napi_sym] -fn napi_get_version(_: napi_env, version: *mut u32) -> napi_status { - *version = NAPI_VERSION; - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_has_element( - env: *mut Env, - value: napi_value, - index: u32, - result: *mut bool, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let obj = value.to_object(&mut env.scope()).unwrap(); - *result = obj.has_index(&mut env.scope(), index).unwrap_or(false); - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_has_named_property( - env: *mut Env, - value: napi_value, - key: *const c_char, - result: *mut bool, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let obj = value.to_object(&mut env.scope()).unwrap(); - let key = CStr::from_ptr(key).to_str().unwrap(); - let key = v8::String::new(&mut env.scope(), key).unwrap(); - *result = obj.has(&mut env.scope(), key.into()).unwrap_or(false); - napi_ok + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] -fn napi_has_own_property( - env: *mut Env, - object: napi_value, - key: napi_value, - result: *mut bool, +#[napi_sym] +fn napi_create_dataview<'s>( + env: &'s mut Env, + byte_length: usize, + arraybuffer: napi_value, + byte_offset: usize, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg_option!(env, key); + check_arg!(env, arraybuffer); check_arg!(env, result); - let scope = &mut env.scope(); - let Some(object) = object.map(|o| o.to_object(scope)).flatten() else { + let Some(buffer) = + arraybuffer.and_then(|v| v8::Local::<v8::ArrayBuffer>::try_from(v).ok()) + else { return napi_invalid_arg; }; - if key.is_none() { - return napi_invalid_arg; + if byte_length + byte_offset > buffer.byte_length() { + unsafe { + return napi_throw_range_error( + env, + "ERR_NAPI_INVALID_DATAVIEW_ARGS\0".as_ptr() as _, + "byte_offset + byte_length should be less than or equal to the size in bytes of the array passed in\0".as_ptr() as _, + ); + } } - let Ok(key) = v8::Local::<v8::Name>::try_from(key.unwrap()) else { - return napi_name_expected; - }; - let Some(has_own) = object.has_own_property(scope, key) else { - return napi_generic_failure; + // let dataview = v8::DataView::new(&mut env, buffer, byte_offset, byte_length); + let dataview = { + let context = &mut env.scope().get_current_context(); + let global = context.global(&mut env.scope()); + let data_view_name = v8::String::new(&mut env.scope(), "DataView").unwrap(); + let data_view = + global.get(&mut env.scope(), data_view_name.into()).unwrap(); + let Ok(data_view) = v8::Local::<v8::Function>::try_from(data_view) else { + return napi_function_expected; + }; + let byte_offset = v8::Number::new(&mut env.scope(), byte_offset as f64); + let byte_length = v8::Number::new(&mut env.scope(), byte_length as f64); + let Some(dv) = data_view.new_instance( + &mut env.scope(), + &[buffer.into(), byte_offset.into(), byte_length.into()], + ) else { + return napi_generic_failure; + }; + dv }; - *result = has_own; + unsafe { + *result = dataview.into(); + } napi_ok } -#[napi_sym::napi_sym] -fn napi_has_property( +#[napi_sym] +fn napi_is_dataview( env: *mut Env, - object: napi_value, - key: napi_value, + value: napi_value, result: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg_option!(env, key); + let env = check_env!(env); + check_arg!(env, value); check_arg!(env, result); - let scope = &mut env.scope(); - let Some(object) = object.map(|o| o.to_object(scope)).flatten() else { - return napi_invalid_arg; - }; + unsafe { + *result = value.unwrap().is_data_view(); + } - let Some(has) = object.has(scope, key.unwrap_unchecked()) else { - return napi_generic_failure; - }; - *result = has; - napi_ok + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_instanceof( - env: *mut Env, - value: napi_value, - constructor: napi_value, - result: *mut bool, +#[napi_sym] +fn napi_get_dataview_info( + env_ptr: *mut Env, + dataview: napi_value, + byte_length: *mut usize, + data: *mut *mut c_void, + arraybuffer: *mut napi_value, + byte_offset: *mut usize, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg_option!(env, constructor); - check_arg_option!(env, value); + let env = check_env!(env_ptr); + check_arg!(env, dataview); - let value = napi_value_unchecked(value); - let constructor = napi_value_unchecked(constructor); - let Some(ctor) = constructor.to_object(&mut env.scope()) else { - return napi_object_expected; - }; - if !ctor.is_function() { - return napi_function_expected; - } - let Some(res) = value.instance_of(&mut env.scope(), ctor) else { - return napi_generic_failure; + let Some(array) = + dataview.and_then(|v| v8::Local::<v8::DataView>::try_from(v).ok()) + else { + return napi_invalid_arg; }; - *result = res; - napi_ok -} + if !byte_length.is_null() { + unsafe { + *byte_length = array.byte_length(); + } + } -#[napi_sym::napi_sym] -fn napi_is_array( - _env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - let value = napi_value_unchecked(value); - *result = value.is_array(); - napi_ok -} + if !arraybuffer.is_null() { + let Some(buffer) = array.buffer(&mut env.scope()) else { + return napi_generic_failure; + }; -#[napi_sym::napi_sym] -fn napi_is_arraybuffer( - _env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - let value = napi_value_unchecked(value); - *result = value.is_array_buffer(); - napi_ok -} + unsafe { + *arraybuffer = buffer.into(); + } + } -#[napi_sym::napi_sym] -fn napi_is_buffer( - _env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - let value = napi_value_unchecked(value); - // TODO: should we assume Buffer as Uint8Array in Deno? - // or use std/node polyfill? - *result = value.is_typed_array(); - napi_ok -} + if !data.is_null() { + unsafe { + *data = array.data(); + } + } -#[napi_sym::napi_sym] -fn napi_is_dataview( - _env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - let value = napi_value_unchecked(value); - *result = value.is_data_view(); - napi_ok -} + if !byte_offset.is_null() { + unsafe { + *byte_offset = array.byte_offset(); + } + } -#[napi_sym::napi_sym] -fn napi_is_date( - _env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - let value = napi_value_unchecked(value); - *result = value.is_date(); - napi_ok + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] -fn napi_is_detached_arraybuffer( - env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - check_env!(env); +#[napi_sym] +fn napi_get_version(env: *mut Env, result: *mut u32) -> napi_status { + let env = check_env!(env); check_arg!(env, result); - let value = napi_value_unchecked(value); - - *result = match v8::Local::<v8::ArrayBuffer>::try_from(value) { - Ok(array_buffer) => array_buffer.was_detached(), - Err(_) => false, - }; - - napi_clear_last_error(env); + unsafe { + *result = NAPI_VERSION; + } - napi_ok + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_is_error( - env: *mut Env, - value: napi_value, - result: *mut bool, +#[napi_sym] +fn napi_create_promise<'s>( + env: &'s mut Env, + deferred: *mut napi_deferred, + promise: *mut napi_value<'s>, ) -> napi_status { - { - check_env!(env); - if value.is_none() { - return napi_invalid_arg; - } - check_arg!(env, result); + check_arg!(env, deferred); + check_arg!(env, promise); - let value = napi_value_unchecked(value); - *result = value.is_native_error(); - } - napi_clear_last_error(env); - napi_ok -} + let resolver = v8::PromiseResolver::new(&mut env.scope()).unwrap(); -#[napi_sym::napi_sym] -fn napi_is_exception_pending(_env: *mut Env, result: *mut bool) -> napi_status { - // TODO - *result = false; - napi_ok -} + let global = v8::Global::new(&mut env.scope(), resolver); + let global_ptr = global.into_raw().as_ptr() as napi_deferred; -#[napi_sym::napi_sym] -fn napi_is_promise( - _env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - let value = napi_value_unchecked(value); - *result = value.is_promise(); - napi_ok -} + let p = resolver.get_promise(&mut env.scope()); -#[napi_sym::napi_sym] -fn napi_is_typedarray( - _env: *mut Env, - value: napi_value, - result: *mut bool, -) -> napi_status { - let value = napi_value_unchecked(value); - *result = value.is_typed_array(); - napi_ok -} + unsafe { + *deferred = global_ptr; + } + + unsafe { + *promise = p.into(); + } -#[napi_sym::napi_sym] -fn napi_new_instance( - env: *mut Env, - constructor: napi_value, - argc: usize, - argv: *const napi_value, - result: *mut napi_value, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let constructor = napi_value_unchecked(constructor); - let Ok(constructor) = v8::Local::<v8::Function>::try_from(constructor) else { - return napi_function_expected; - }; - let args: &[v8::Local<v8::Value>] = - transmute(std::slice::from_raw_parts(argv, argc)); - let inst = constructor.new_instance(&mut env.scope(), args).unwrap(); - let value: v8::Local<v8::Value> = inst.into(); - *result = value.into(); napi_ok } -#[napi_sym::napi_sym] -fn napi_object_freeze( +#[napi_sym] +fn napi_resolve_deferred( env: &mut Env, - object: v8::Local<v8::Value>, + deferred: napi_deferred, + result: napi_value, ) -> napi_status { - let object = object.to_object(&mut env.scope()).unwrap(); - if object - .set_integrity_level(&mut env.scope(), v8::IntegrityLevel::Frozen) - .is_none() + check_arg!(env, result); + check_arg!(env, deferred); + + let isolate = unsafe { &mut *env.isolate_ptr }; + let deferred_ptr = + unsafe { NonNull::new_unchecked(deferred as *mut v8::PromiseResolver) }; + let global = unsafe { v8::Global::from_raw(isolate, deferred_ptr) }; + let resolver = v8::Local::new(&mut env.scope(), global); + + if !resolver + .resolve(&mut env.scope(), result.unwrap()) + .unwrap_or(false) { return napi_generic_failure; - }; + } napi_ok } -#[napi_sym::napi_sym] -fn napi_object_seal( +#[napi_sym] +fn napi_reject_deferred( env: &mut Env, - object: v8::Local<v8::Value>, + deferred: napi_deferred, + result: napi_value, ) -> napi_status { - let object = object.to_object(&mut env.scope()).unwrap(); - if object - .set_integrity_level(&mut env.scope(), v8::IntegrityLevel::Sealed) - .is_none() + check_arg!(env, result); + check_arg!(env, deferred); + + let isolate = unsafe { &mut *env.isolate_ptr }; + let deferred_ptr = + unsafe { NonNull::new_unchecked(deferred as *mut v8::PromiseResolver) }; + let global = unsafe { v8::Global::from_raw(isolate, deferred_ptr) }; + let resolver = v8::Local::new(&mut env.scope(), global); + + if !resolver + .reject(&mut env.scope(), result.unwrap()) + .unwrap_or(false) { return napi_generic_failure; } @@ -2383,453 +3327,260 @@ fn napi_object_seal( napi_ok } -#[napi_sym::napi_sym] -fn napi_open_escapable_handle_scope( - _env: *mut Env, - _result: *mut napi_escapable_handle_scope, +#[napi_sym] +fn napi_is_promise( + env: *mut Env, + value: napi_value, + is_promise: *mut bool, ) -> napi_status { - // TODO: do this properly - napi_ok + let env = check_env!(env); + check_arg!(env, value); + check_arg!(env, is_promise); + + unsafe { + *is_promise = value.unwrap().is_promise(); + } + + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_open_handle_scope( - env: *mut Env, - _result: *mut napi_handle_scope, +#[napi_sym] +fn napi_create_date<'s>( + env: &'s mut Env, + time: f64, + result: *mut napi_value<'s>, ) -> napi_status { - let env = &mut *env; + check_arg!(env, result); - // TODO: this is also not implemented in napi_close_handle_scope - // *result = &mut env.scope() as *mut _ as napi_handle_scope; - env.open_handle_scopes += 1; - napi_ok -} + let Some(date) = v8::Date::new(&mut env.scope(), time) else { + return napi_generic_failure; + }; -#[napi_sym::napi_sym] -fn napi_reference_ref() -> napi_status { - // TODO - napi_ok -} + unsafe { + *result = date.into(); + } -#[napi_sym::napi_sym] -fn napi_reference_unref() -> napi_status { - // TODO napi_ok } -#[napi_sym::napi_sym] -fn napi_reject_deferred( +#[napi_sym] +fn napi_is_date( env: *mut Env, - deferred: napi_deferred, - error: napi_value, + value: napi_value, + is_date: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; + let env = check_env!(env); + check_arg!(env, value); + check_arg!(env, is_date); - let deferred_ptr = - NonNull::new_unchecked(deferred as *mut v8::PromiseResolver); - // TODO(@littledivy): Use Global::from_raw instead casting to local. - // SAFETY: Isolate is still alive unless the module is doing something weird, - // global data is the size of a pointer. - // Global pointer is obtained from napi_create_promise - let resolver = transmute::< - NonNull<v8::PromiseResolver>, - v8::Local<v8::PromiseResolver>, - >(deferred_ptr); - resolver - .reject(&mut env.scope(), napi_value_unchecked(error)) - .unwrap(); - napi_ok -} + unsafe { + *is_date = value.unwrap().is_date(); + } -#[napi_sym::napi_sym] -fn napi_remove_wrap(env: *mut Env, value: napi_value) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let obj = value.to_object(&mut env.scope()).unwrap(); - let shared = &*(env.shared as *const EnvShared); - let napi_wrap = v8::Local::new(&mut env.scope(), &shared.napi_wrap); - obj.delete_private(&mut env.scope(), napi_wrap).unwrap(); - napi_ok + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_resolve_deferred( - env: *mut Env, - deferred: napi_deferred, - result: napi_value, +#[napi_sym] +fn napi_get_date_value( + env: &mut Env, + value: napi_value, + result: *mut f64, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let deferred_ptr = - NonNull::new_unchecked(deferred as *mut v8::PromiseResolver); - // TODO(@littledivy): Use Global::from_raw instead casting to local. - // SAFETY: Isolate is still alive unless the module is doing something weird, - // global data is the size of a pointer. - // Global pointer is obtained from napi_create_promise - let resolver = transmute::< - NonNull<v8::PromiseResolver>, - v8::Local<v8::PromiseResolver>, - >(deferred_ptr); - resolver - .resolve(&mut env.scope(), napi_value_unchecked(result)) - .unwrap(); + check_arg!(env, result); + + let Some(date) = value.and_then(|v| v8::Local::<v8::Date>::try_from(v).ok()) + else { + return napi_date_expected; + }; + + unsafe { + *result = date.value_of(); + } + napi_ok } -#[napi_sym::napi_sym] -fn napi_run_script( - env: *mut Env, +#[napi_sym] +fn napi_run_script<'s>( + env: &'s mut Env, script: napi_value, - result: *mut napi_value, + result: *mut napi_value<'s>, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; + check_arg!(env, script); + check_arg!(env, result); - let script = napi_value_unchecked(script); - if !script.is_string() { - // TODO: - // napi_set_last_error + let Some(script) = + script.and_then(|v| v8::Local::<v8::String>::try_from(v).ok()) + else { return napi_string_expected; - } - let script = script.to_string(&mut env.scope()).unwrap(); + }; - let script = v8::Script::compile(&mut env.scope(), script, None); - if script.is_none() { + let Some(script) = v8::Script::compile(&mut env.scope(), script, None) else { return napi_generic_failure; - } - let script = script.unwrap(); - let rv = script.run(&mut env.scope()); + }; - if let Some(rv) = rv { - *result = rv.into(); - } else { + let Some(rv) = script.run(&mut env.scope()) else { return napi_generic_failure; + }; + + unsafe { + *result = rv.into(); } napi_ok } -#[napi_sym::napi_sym] -fn napi_set_element( - env: *mut Env, - object: napi_value, - index: u32, +#[napi_sym] +fn napi_add_finalizer( + env_ptr: *mut Env, value: napi_value, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let object = napi_value_unchecked(object); - let Ok(object) = v8::Local::<v8::Object>::try_from(object) else { - return napi_invalid_arg; - }; - let value = napi_value_unchecked(value); - object.set_index(&mut env.scope(), index, value).unwrap(); - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_set_instance_data( - env: *mut Env, - data: *mut c_void, + finalize_data: *mut c_void, finalize_cb: Option<napi_finalize>, finalize_hint: *mut c_void, + result: *mut napi_ref, ) -> napi_status { - let env = &mut *env; - let shared = env.shared_mut(); - shared.instance_data = data; - shared.data_finalize = if finalize_cb.is_some() { - finalize_cb - } else { - None - }; - shared.data_finalize_hint = finalize_hint; - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_set_named_property( - env: *mut Env, - object: napi_value, - name: *const c_char, - value: napi_value, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let name = CStr::from_ptr(name).to_str().unwrap(); - let object = transmute::<napi_value, v8::Local<v8::Object>>(object); - let value = napi_value_unchecked(value); - let name = v8::String::new(&mut env.scope(), name).unwrap(); - object.set(&mut env.scope(), name.into(), value).unwrap(); - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_set_property( - env: *mut Env, - object: napi_value, - key: napi_value, - value: napi_value, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg_option!(env, key); - check_arg_option!(env, value); + let env = check_env!(env_ptr); + check_arg!(env, value); + check_arg!(env, finalize_cb); - let scope = &mut env.scope(); - let Some(object) = object.map(|o| o.to_object(scope)).flatten() else { - return napi_invalid_arg; + let Some(value) = + value.and_then(|v| v8::Local::<v8::Object>::try_from(v).ok()) + else { + return napi_set_last_error(env, napi_invalid_arg); }; - if object - .set(scope, key.unwrap_unchecked(), value.unwrap_unchecked()) - .is_none() - { - return napi_generic_failure; + let ownership = if result.is_null() { + ReferenceOwnership::Runtime + } else { + ReferenceOwnership::Userland }; - napi_ok -} - -#[napi_sym::napi_sym] -fn napi_strict_equals( - env: *mut Env, - lhs: napi_value, - rhs: napi_value, - result: *mut bool, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - check_arg_option!(env, lhs); - check_arg_option!(env, rhs); + let reference = Reference::new( + env, + value.into(), + 0, + ownership, + finalize_cb, + finalize_data, + finalize_hint, + ); - *result = lhs.unwrap_unchecked().strict_equals(rhs.unwrap_unchecked()); - napi_ok -} + if !result.is_null() { + unsafe { + *result = Reference::into_raw(reference) as _; + } + } -#[napi_sym::napi_sym] -fn napi_throw(env: *mut Env, error: napi_value) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let error = napi_value_unchecked(error); - env.scope().throw_exception(error); - napi_ok + napi_clear_last_error(env_ptr) } -#[napi_sym::napi_sym] -fn napi_throw_error( +#[napi_sym] +fn node_api_post_finalizer( env: *mut Env, - code: *const c_char, - msg: *const c_char, + _finalize_cb: napi_finalize, + _finalize_data: *mut c_void, + _finalize_hint: *mut c_void, ) -> napi_status { - // TODO: add preamble here - - { - check_env!(env); - let str_ = match check_new_from_utf8(env, msg) { - Ok(s) => s, - Err(status) => return status, - }; - - let error = { - let env = unsafe { &mut *env }; - let scope = &mut env.scope(); - v8::Exception::error(scope, str_) - }; - status_call!(set_error_code( - env, - error, - transmute::<*mut (), napi_value>(std::ptr::null_mut()), - code, - )); - - unsafe { &mut *env }.scope().throw_exception(error); - } - napi_clear_last_error(env); - napi_ok + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_throw_range_error( +#[napi_sym] +fn napi_adjust_external_memory( env: *mut Env, - code: *const c_char, - msg: *const c_char, + change_in_bytes: i64, + adjusted_value: *mut i64, ) -> napi_status { - // TODO: add preamble here + let env = check_env!(env); + check_arg!(env, adjusted_value); - { - check_env!(env); - let str_ = match check_new_from_utf8(env, msg) { - Ok(s) => s, - Err(status) => return status, - }; - let error = { - let env = unsafe { &mut *env }; - let scope = &mut env.scope(); - v8::Exception::range_error(scope, str_) - }; - status_call!(set_error_code( - env, - error, - transmute::<*mut (), napi_value>(std::ptr::null_mut()), - code, - )); - unsafe { &mut *env }.scope().throw_exception(error); + let isolate = unsafe { &mut *env.isolate_ptr }; + + unsafe { + *adjusted_value = + isolate.adjust_amount_of_external_allocated_memory(change_in_bytes); } - napi_clear_last_error(env); - napi_ok + + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_throw_type_error( +#[napi_sym] +fn napi_set_instance_data( env: *mut Env, - code: *const c_char, - msg: *const c_char, + data: *mut c_void, + finalize_cb: Option<napi_finalize>, + finalize_hint: *mut c_void, ) -> napi_status { - // TODO: add preamble here + let env = check_env!(env); - { - check_env!(env); - let str_ = match check_new_from_utf8(env, msg) { - Ok(s) => s, - Err(status) => return status, - }; - let error = { - let env = unsafe { &mut *env }; - let scope = &mut env.scope(); - v8::Exception::type_error(scope, str_) - }; - status_call!(set_error_code( - env, - error, - transmute::<*mut (), napi_value>(std::ptr::null_mut()), - code, - )); - unsafe { &mut *env }.scope().throw_exception(error); - } - napi_clear_last_error(env); - napi_ok -} + env.shared_mut().instance_data = Some(InstanceData { + data, + finalize_cb, + finalize_hint, + }); -pub fn get_value_type(value: v8::Local<v8::Value>) -> Option<napi_valuetype> { - if value.is_undefined() { - Some(napi_undefined) - } else if value.is_null() { - Some(napi_null) - } else if value.is_external() { - Some(napi_external) - } else if value.is_boolean() { - Some(napi_boolean) - } else if value.is_number() { - Some(napi_number) - } else if value.is_big_int() { - Some(napi_bigint) - } else if value.is_string() { - Some(napi_string) - } else if value.is_symbol() { - Some(napi_symbol) - } else if value.is_function() { - Some(napi_function) - } else if value.is_object() { - Some(napi_object) - } else { - None - } + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn napi_typeof( +#[napi_sym] +fn napi_get_instance_data( env: *mut Env, - value: napi_value, - result: *mut napi_valuetype, + data: *mut *mut c_void, ) -> napi_status { - check_env!(env); - check_arg_option!(env, value); - check_arg!(env, result); + let env = check_env!(env); + check_arg!(env, data); - let Some(ty) = get_value_type(value.unwrap()) else { - return napi_invalid_arg; + let instance_data = match &env.shared().instance_data { + Some(v) => v.data, + None => std::ptr::null_mut(), }; - *result = ty; - napi_ok -} -#[napi_sym::napi_sym] -fn napi_unwrap( - env: *mut Env, - value: napi_value, - result: *mut *mut c_void, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let obj = value.to_object(&mut env.scope()).unwrap(); - let shared = &*(env.shared as *const EnvShared); - let napi_wrap = v8::Local::new(&mut env.scope(), &shared.napi_wrap); - let ext = obj.get_private(&mut env.scope(), napi_wrap).unwrap(); - let Some(ext) = v8::Local::<v8::External>::try_from(ext).ok() else { - return napi_invalid_arg; - }; - *result = ext.value(); - napi_ok -} + unsafe { *data = instance_data }; -#[napi_sym::napi_sym] -fn napi_wrap( - env: *mut Env, - value: napi_value, - native_object: *mut c_void, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - let value = napi_value_unchecked(value); - let obj = value.to_object(&mut env.scope()).unwrap(); - let shared = &*(env.shared as *const EnvShared); - let napi_wrap = v8::Local::new(&mut env.scope(), &shared.napi_wrap); - let ext = v8::External::new(&mut env.scope(), native_object); - obj.set_private(&mut env.scope(), napi_wrap, ext.into()); - napi_ok + napi_clear_last_error(env) } -#[napi_sym::napi_sym] -fn node_api_throw_syntax_error( - env: *mut Env, - _code: *const c_char, - msg: *const c_char, -) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; +#[napi_sym] +fn napi_detach_arraybuffer(env: *mut Env, value: napi_value) -> napi_status { + let env = check_env!(env); + check_arg!(env, value); - // let code = CStr::from_ptr(code).to_str().unwrap(); - let msg = CStr::from_ptr(msg).to_str().unwrap(); + let Some(ab) = + value.and_then(|v| v8::Local::<v8::ArrayBuffer>::try_from(v).ok()) + else { + return napi_set_last_error(env, napi_arraybuffer_expected); + }; - // let code = v8::String::new(&mut env.scope(), code).unwrap(); - let msg = v8::String::new(&mut env.scope(), msg).unwrap(); + if !ab.is_detachable() { + return napi_set_last_error(env, napi_detachable_arraybuffer_expected); + } - let error = v8::Exception::syntax_error(&mut env.scope(), msg); - env.scope().throw_exception(error); + // Expected to crash for None. + ab.detach(None).unwrap(); + napi_clear_last_error(env); napi_ok } -#[napi_sym::napi_sym] -fn node_api_create_syntax_error( - env: *mut Env, - _code: napi_value, - msg: napi_value, - result: *mut napi_value, +#[napi_sym] +fn napi_is_detached_arraybuffer( + env_ptr: *mut Env, + arraybuffer: napi_value, + result: *mut bool, ) -> napi_status { - check_env!(env); - let env = unsafe { &mut *env }; - - // let code = napi_value_unchecked(code); - let msg = napi_value_unchecked(msg); + let env = check_env!(env_ptr); + check_arg!(env, arraybuffer); + check_arg!(env, result); - let msg = msg.to_string(&mut env.scope()).unwrap(); + let is_detached = match arraybuffer + .and_then(|v| v8::Local::<v8::ArrayBuffer>::try_from(v).ok()) + { + Some(ab) => ab.was_detached(), + None => false, + }; - let error = v8::Exception::syntax_error(&mut env.scope(), msg); - *result = error.into(); + unsafe { + *result = is_detached; + } - napi_ok + napi_clear_last_error(env) } |