use crate::napi::*;
use std::ffi::{c_char, CString};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Thrown(pub String);
pub type Result<T> = std::result::Result<T, Thrown>;
pub fn ok(status: napi_status, what: &str) -> Result<()> {
match status == NAPI_OK {
true => Ok(()),
false => Err(Thrown(format!("{what} failed (napi status {status})"))),
}
}
pub fn undefined(env: napi_env) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
ok(unsafe { napi_get_undefined(env, &mut out) }, "undefined")?;
Ok(out)
}
pub fn null(env: napi_env) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
ok(unsafe { napi_get_null(env, &mut out) }, "null")?;
Ok(out)
}
pub fn boolean(env: napi_env, value: bool) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
ok(unsafe { napi_get_boolean(env, value, &mut out) }, "boolean")?;
Ok(out)
}
pub fn number(env: napi_env, value: f64) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
ok(
unsafe { napi_create_double(env, value, &mut out) },
"number",
)?;
Ok(out)
}
pub fn string(env: napi_env, value: &str) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
ok(
unsafe {
napi_create_string_utf8(env, value.as_ptr() as *const c_char, value.len(), &mut out)
},
"string",
)?;
Ok(out)
}
pub fn object(env: napi_env) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
ok(unsafe { napi_create_object(env, &mut out) }, "object")?;
Ok(out)
}
pub fn array_buffer(env: napi_env, bytes: &[u8]) -> Result<napi_value> {
let mut data: *mut std::ffi::c_void = std::ptr::null_mut();
let mut out = std::ptr::null_mut();
ok(
unsafe { napi_create_arraybuffer(env, bytes.len(), &mut data, &mut out) },
"ArrayBuffer",
)?;
if !bytes.is_empty() {
unsafe { std::ptr::copy_nonoverlapping(bytes.as_ptr(), data as *mut u8, bytes.len()) };
}
Ok(out)
}
pub fn array(env: napi_env, items: &[napi_value]) -> Result<napi_value> {
let mut out = std::ptr::null_mut();
ok(
unsafe { napi_create_array_with_length(env, items.len(), &mut out) },
"array",
)?;
for (i, item) in items.iter().enumerate() {
ok(
unsafe { napi_set_element(env, out, i as u32, *item) },
"array element",
)?;
}
Ok(out)
}
pub fn set(env: napi_env, object: napi_value, name: &str, value: napi_value) -> Result<()> {
let name = CString::new(name).map_err(|_| Thrown("a property name held a NUL".into()))?;
ok(
unsafe { napi_set_named_property(env, object, name.as_ptr(), value) },
"set property",
)
}
pub fn get(env: napi_env, object: napi_value, name: &str) -> Result<Option<napi_value>> {
let cname = CString::new(name).map_err(|_| Thrown("a property name held a NUL".into()))?;
let mut has = false;
ok(
unsafe { napi_has_named_property(env, object, cname.as_ptr(), &mut has) },
"has property",
)?;
if !has {
return Ok(None);
}
let mut out = std::ptr::null_mut();
ok(
unsafe { napi_get_named_property(env, object, cname.as_ptr(), &mut out) },
"get property",
)?;
match type_of(env, out)? {
NAPI_UNDEFINED | NAPI_NULL => Ok(None),
_ => Ok(Some(out)),
}
}
pub fn type_of(env: napi_env, value: napi_value) -> Result<napi_valuetype> {
let mut out = 0;
ok(unsafe { napi_typeof(env, value, &mut out) }, "typeof")?;
Ok(out)
}
pub fn as_string(env: napi_env, value: napi_value) -> Result<String> {
let mut len = 0;
ok(
unsafe { napi_get_value_string_utf8(env, value, std::ptr::null_mut(), 0, &mut len) },
"string length",
)?;
let mut buffer = vec![0u8; len + 1];
let mut written = 0;
ok(
unsafe {
napi_get_value_string_utf8(
env,
value,
buffer.as_mut_ptr() as *mut c_char,
buffer.len(),
&mut written,
)
},
"string",
)?;
buffer.truncate(written);
String::from_utf8(buffer).map_err(|_| Thrown("a string was not valid UTF-8".into()))
}
pub fn as_bool(env: napi_env, value: napi_value) -> Result<bool> {
let mut out = false;
ok(unsafe { napi_get_value_bool(env, value, &mut out) }, "bool")?;
Ok(out)
}
pub fn as_f64(env: napi_env, value: napi_value) -> Result<f64> {
let mut out = 0.0;
ok(
unsafe { napi_get_value_double(env, value, &mut out) },
"number",
)?;
Ok(out)
}
pub fn as_bytes(env: napi_env, value: napi_value) -> Result<Vec<u8>> {
let mut is_typed = false;
ok(
unsafe { napi_is_typedarray(env, value, &mut is_typed) },
"is typed array",
)?;
if is_typed {
let (mut kind, mut len, mut data, mut buffer, mut offset) =
(0, 0, std::ptr::null_mut(), std::ptr::null_mut(), 0);
ok(
unsafe {
napi_get_typedarray_info(
env,
value,
&mut kind,
&mut len,
&mut data,
&mut buffer,
&mut offset,
)
},
"typed array",
)?;
const UINT8: i32 = 1;
const UINT8_CLAMPED: i32 = 2;
const INT8: i32 = 0;
if !matches!(kind, UINT8 | UINT8_CLAMPED | INT8) {
return Err(Thrown(
"a value must be a Uint8Array, an ArrayBuffer or an array of bytes; \
a wider typed array would need a byte order this cannot guess"
.into(),
));
}
if len == 0 {
return Ok(Vec::new());
}
return Ok(unsafe { std::slice::from_raw_parts(data as *const u8, len) }.to_vec());
}
let mut is_buffer = false;
ok(
unsafe { napi_is_arraybuffer(env, value, &mut is_buffer) },
"is ArrayBuffer",
)?;
if is_buffer {
let (mut data, mut len) = (std::ptr::null_mut(), 0);
ok(
unsafe { napi_get_arraybuffer_info(env, value, &mut data, &mut len) },
"ArrayBuffer",
)?;
if len == 0 {
return Ok(Vec::new());
}
return Ok(unsafe { std::slice::from_raw_parts(data as *const u8, len) }.to_vec());
}
let mut len = 0;
if unsafe { napi_get_array_length(env, value, &mut len) } == NAPI_OK {
let mut out = Vec::with_capacity(len as usize);
for i in 0..len {
let mut item = std::ptr::null_mut();
ok(
unsafe { napi_get_element(env, value, i, &mut item) },
"array element",
)?;
let n = as_f64(env, item)?;
if !(0.0..=255.0).contains(&n) || n.fract() != 0.0 {
return Err(Thrown(format!(
"{n} is not a byte; every element must be a whole number in 0..=255"
)));
}
out.push(n as u8);
}
return Ok(out);
}
Err(Thrown(
"expected bytes: a Uint8Array, an ArrayBuffer, or an array of numbers".into(),
))
}
pub fn throw(env: napi_env, message: &str) -> napi_value {
if let (Ok(text), Ok(undef)) = (string(env, message), undefined(env)) {
let mut error = std::ptr::null_mut();
if unsafe { napi_create_error(env, std::ptr::null_mut(), text, &mut error) } == NAPI_OK {
unsafe { napi_throw(env, error) };
}
return undef;
}
std::ptr::null_mut()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_failing_status_becomes_an_error_naming_the_call() {
let e = ok(7, "napi_create_string_utf8").unwrap_err();
assert!(e.0.contains("napi_create_string_utf8"), "{}", e.0);
assert!(e.0.contains('7'), "the status should be in the message");
assert!(ok(NAPI_OK, "anything").is_ok());
}
#[test]
fn a_property_name_with_a_nul_is_refused() {
assert!(CString::new("has\0nul").is_err());
assert!(CString::new("fine").is_ok());
}
}