Exposing Value::TypeOf

src/binding.cc

@@ -759,6 +759,10 @@ bool v8__Value__BooleanValue(const v8::Value& self, v8::Isolate* isolate) {
  return self.BooleanValue(isolate);
 }
 
+const v8::String* v8__Value__TypeOf(v8::Value& self, v8::Isolate* isolate) {
+ return local_to_ptr(self.TypeOf(isolate));
+}
+
 const v8::Primitive* v8__Null(v8::Isolate* isolate) {
  return local_to_ptr(v8::Null(isolate));
 }

src/value.rs

@@ -142,6 +142,10 @@ extern "C" {
  fn v8__Value__BooleanValue(this: *const Value, isolate: *mut Isolate)
  -> bool;
  fn v8__Value__GetHash(this: *const Value) -> int;
+ fn v8__Value__TypeOf(
+ this: *const Value,
+ isolate: *mut Isolate,
+ ) -> *const String;
 }
 
 impl Value {
@@ -702,4 +706,15 @@ impl Value {
  pub fn get_hash(&self) -> NonZeroI32 {
  unsafe { NonZeroI32::new_unchecked(v8__Value__GetHash(self)) }
  }
+
+ #[inline(always)]
+ pub fn type_of<'s>(
+ &self,
+ scope: &mut HandleScope<'s, ()>,
+ ) -> Local<'s, String> {
+ unsafe {
+ scope.cast_local(|sd| v8__Value__TypeOf(self, sd.get_isolate_ptr()))
+ }
+ .unwrap()
+ }
 }

tests/test_api.rs

@@ -4424,6 +4424,25 @@ fn shared_array_buffer() {
  }
 }
 
+#[test]
+fn typeof_checker() {
+ let _setup_guard = setup();
+
+ let isolate = &mut v8::Isolate::new(Default::default());
+ let scope = &mut v8::HandleScope::new(isolate);
+ let context = v8::Context::new(scope);
+ let scope = &mut v8::ContextScope::new(scope, context);
+
+ let value_1 = eval(scope, "").unwrap();
+ let type_of = value_1.type_of(scope);
+ let value_2 = eval(scope, "").unwrap();
+ let type_of_2 = value_2.type_of(scope);
+ assert_eq!(type_of, type_of_2);
+ let value_3 = eval(scope, "1").unwrap();
+ let type_of_3 = value_3.type_of(scope);
+ assert_ne!(type_of_2, type_of_3);
+}
+
 #[test]
 #[allow(clippy::cognitive_complexity)]
 #[allow(clippy::eq_op)]