add more v8 new api (#174)

toyobayashi · web-flow · commit d0d135629c08 · 2025-10-08T13:46:17.000+08:00
* add more v8 new api

* fix convert integer

* fix
diff --git a/packages/emnapi/CMakeLists.txt b/packages/emnapi/CMakeLists.txt
@@ -30,8 +30,10 @@ else()
 endif()
 
 set(V8_SRC
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/v8/array.cc"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/v8/external.cc"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/v8/exception.cc"
+  "${CMAKE_CURRENT_SOURCE_DIR}/src/v8/date.cc"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/v8/function.cc"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/v8/handle_scope.cc"
   "${CMAKE_CURRENT_SOURCE_DIR}/src/v8/internal.cc"
diff --git a/packages/emnapi/emnapi.gyp b/packages/emnapi/emnapi.gyp
@@ -142,8 +142,10 @@
       'target_name': 'v8',
       'type': 'static_library',
       'sources': [
+        'array.cc',
         'external.cc',
         'exception.cc',
+        'date.cc',
         'function.cc',
         'handle_scope.cc',
         'internal.cc',
diff --git a/packages/emnapi/src/v8/array.cc b/packages/emnapi/src/v8/array.cc
@@ -0,0 +1,14 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_array_new(Isolate* isolate, int length);
+}
+
+Local<Array> Array::New(Isolate* isolate, int length) {
+  auto n = _v8_array_new(isolate, length);
+  return v8impl::V8LocalValueFromAddress(n).As<Array>();
+}
+
+}
diff --git a/packages/emnapi/src/v8/array.ts b/packages/emnapi/src/v8/array.ts
@@ -0,0 +1,7 @@
+/**
+ * @__deps $emnapiCtx
+ * @__sig ppi
+ */
+export function _v8_array_new (context: Ptr, value: int): Ptr {
+  return emnapiCtx.napiValueFromJsValue(Array(value))
+}
diff --git a/packages/emnapi/src/v8/boolean.cc b/packages/emnapi/src/v8/boolean.cc
@@ -4,6 +4,7 @@ namespace v8 {
 
 extern "C" {
   V8_EXTERN bool _v8_boolean_value(const Boolean*);
+  V8_EXTERN internal::Address _v8_boolean_object_new(Isolate* isolate, int value);
 }
 
 void Boolean::CheckCast(v8::Data*) {}
@@ -12,4 +13,9 @@ bool Boolean::Value() const {
   return _v8_boolean_value(this);
 }
 
+Local<Value> BooleanObject::New(Isolate* isolate, bool value) {
+  auto n = _v8_boolean_object_new(isolate, static_cast<int>(value));
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
 }
diff --git a/packages/emnapi/src/v8/boolean.ts b/packages/emnapi/src/v8/boolean.ts
@@ -6,3 +6,12 @@ export function _v8_boolean_value (value: Ptr): number {
   const jsValue = emnapiCtx.jsValueFromNapiValue(value)
   return jsValue ? 1 : 0
 }
+
+/**
+ * @__deps $emnapiCtx
+ * @__sig ppi
+ */
+export function _v8_boolean_object_new (isolate: Ptr, value: number): Ptr {
+  // eslint-disable-next-line no-new-wrappers
+  return emnapiCtx.napiValueFromJsValue(new Boolean(value))
+}
diff --git a/packages/emnapi/src/v8/date.cc b/packages/emnapi/src/v8/date.cc
@@ -0,0 +1,15 @@
+#include "v8_impl.h"
+
+namespace v8 {
+
+extern "C" {
+  V8_EXTERN internal::Address _v8_date_new(Context* context, double value);
+}
+
+MaybeLocal<Value> Date::New(Local<Context> context, double time) {
+  auto n = _v8_date_new(*context, time);
+  if (!n) return MaybeLocal<Value>();
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
+}
diff --git a/packages/emnapi/src/v8/date.ts b/packages/emnapi/src/v8/date.ts
@@ -0,0 +1,7 @@
+/**
+ * @__deps $emnapiCtx
+ * @__sig ppd
+ */
+export function _v8_date_new (context: Ptr, value: double): Ptr {
+  return emnapiCtx.napiValueFromJsValue(new Date(value))
+}
diff --git a/packages/emnapi/src/v8/index.ts b/packages/emnapi/src/v8/index.ts
@@ -1,4 +1,6 @@
+export * from './array'
 export * from './boolean'
+export * from './date'
 export * from './exception'
 export * from './external'
 export * from './function'
diff --git a/packages/emnapi/src/v8/isolate.cc b/packages/emnapi/src/v8/isolate.cc
@@ -10,6 +10,10 @@ extern "C" {
 
 void Context::CheckCast(v8::Data*) {}
 
+Isolate* Context::GetIsolate() {
+  return v8::Isolate::GetCurrent();
+}
+
 Isolate* Isolate::GetCurrent() {
   static internal::Isolate current_isolate;
   return reinterpret_cast<Isolate*>(&current_isolate);
diff --git a/packages/emnapi/src/v8/number.cc b/packages/emnapi/src/v8/number.cc
@@ -10,6 +10,7 @@ extern "C" {
   V8_EXTERN void _v8_integer_value(const Integer*, int64_t*);
   V8_EXTERN uint32_t _v8_uint32_value(const Uint32*);
   V8_EXTERN int32_t _v8_int32_value(const Int32*);
+  V8_EXTERN internal::Address _v8_number_object_new(Isolate* isolate, double value);
 }
 
 void Number::CheckCast(v8::Data*) {}
@@ -53,4 +54,9 @@ Local<Integer> Integer::New(Isolate* isolate, int32_t value) {
   return v8impl::V8LocalValueFromAddress(number_value).As<Integer>();
 }
 
+Local<Value> NumberObject::New(Isolate* isolate, double value) {
+  auto n = _v8_number_object_new(isolate, value);
+  return v8impl::V8LocalValueFromAddress(n);
+}
+
 }
diff --git a/packages/emnapi/src/v8/number.ts b/packages/emnapi/src/v8/number.ts
@@ -67,3 +67,12 @@ export function _v8_integer_new (isolate: Ptr, value: number): Ptr {
 export function _v8_integer_new_from_unsigned (isolate: Ptr, value: number): Ptr {
   return emnapiCtx.napiValueFromJsValue(value >>> 0)
 }
+
+/**
+ * @__deps $emnapiCtx
+ * @__sig ppd
+ */
+export function _v8_number_object_new (isolate: Ptr, value: double): Ptr {
+  // eslint-disable-next-line no-new-wrappers
+  return emnapiCtx.napiValueFromJsValue(new Number(value))
+}
diff --git a/packages/emnapi/src/v8/script.cc b/packages/emnapi/src/v8/script.cc
@@ -18,6 +18,10 @@ class BackgroundDeserializeTask {};
 
 }
 
+void ScriptOrigin::VerifyHostDefinedOptions() const {
+
+}
+
 Local<Script> UnboundScript::BindToCurrentContext() {
   Local<Script> ret;
   internal::Address v = _v8_unbound_script_bind_to_current_context(this);
@@ -29,6 +33,14 @@ MaybeLocal<Value> Script::Run(Local<Context> context) {
   return v8impl::V8LocalValueFromAddress(_v8_script_run(this, *context));
 }
 
+MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context, Source* source, ScriptCompiler::CompileOptions options, v8::ScriptCompiler::NoCacheReason no_cache_reason) {
+  if (!source || source->source_string.IsEmpty()) return Local<Script>();
+  MaybeLocal<UnboundScript> unbound = CompileUnboundScript(
+    context->GetIsolate(), source, options, no_cache_reason);
+  if (unbound.IsEmpty()) return Local<Script>();
+  return unbound.ToLocalChecked()->BindToCurrentContext();
+}
+
 MaybeLocal<UnboundScript>
 ScriptCompiler::CompileUnboundScript(Isolate* isolate,
                                      ScriptCompiler::Source* source,
diff --git a/packages/emnapi/src/v8/string.cc b/packages/emnapi/src/v8/string.cc
@@ -4,9 +4,13 @@ namespace v8 {
 
 extern "C" {
   V8_EXTERN internal::Address _v8_string_new_from_utf8(Isolate* isolate, const char* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_from_one_byte(Isolate* isolate, const uint8_t* data, v8::NewStringType type, int length);
+  V8_EXTERN internal::Address _v8_string_new_from_two_byte(Isolate* isolate, const uint16_t* data, v8::NewStringType type, int length);
   V8_EXTERN int _v8_string_utf8_length(const String* self, Isolate* isolate);
   V8_EXTERN int _v8_string_length(const String* self);
   V8_EXTERN int _v8_string_write_utf8(const String* self, Isolate* isolate, char* buffer, int length, int* nchars_ref, int options);
+  V8_EXTERN internal::Address _v8_regex_new(Context* context, internal::Address pattern, int flags);
+  V8_EXTERN internal::Address _v8_string_object_new(Isolate* isolate, internal::Address value);
 }
 
 void String::CheckCast(v8::Data*) {}
@@ -17,6 +21,31 @@ MaybeLocal<String> String::NewFromUtf8(v8::Isolate* isolate, char const* data, v
   return v8impl::V8LocalValueFromAddress(str).As<String>();
 }
 
+MaybeLocal<String> String::NewFromOneByte(Isolate* isolate, const uint8_t* data, NewStringType type, int length) {
+  auto str = _v8_string_new_from_one_byte(isolate, reinterpret_cast<const uint8_t*>(data), type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<String> String::NewFromTwoByte(Isolate* isolate, const uint16_t* data, NewStringType type, int length) {
+  auto str = _v8_string_new_from_two_byte(isolate, data, type, length);
+  if (!str) return MaybeLocal<String>();
+  return v8impl::V8LocalValueFromAddress(str).As<String>();
+}
+
+MaybeLocal<RegExp> RegExp::New(Local<Context> context,
+                               Local<String> pattern,
+                               Flags flags) {
+  auto regex = _v8_regex_new(*context, v8impl::AddressFromV8LocalValue(pattern), flags);
+  if (!regex) return MaybeLocal<RegExp>();
+  return v8impl::V8LocalValueFromAddress(regex).As<RegExp>();
+}
+
+Local<Value> StringObject::New(Isolate* isolate, Local<String> value) {
+  auto str = _v8_string_object_new(isolate, v8impl::AddressFromV8LocalValue(value));
+  return v8impl::V8LocalValueFromAddress(str);
+}
+
 int String::Utf8Length(v8::Isolate* isolate) const {
   return _v8_string_utf8_length(this, isolate);
 }
diff --git a/packages/emnapi/src/v8/string.ts b/packages/emnapi/src/v8/string.ts
@@ -12,6 +12,56 @@ export function _v8_string_new_from_utf8 (isolate: Ptr, data: Ptr, type: number,
   return emnapiCtx.napiValueFromJsValue(str)
 }
 
+/**
+ * @__deps $emnapiCtx
+ * @__sig ppp
+ */
+export function _v8_string_object_new (isolate: Ptr, value: Ptr): Ptr {
+  // eslint-disable-next-line no-new-wrappers
+  return emnapiCtx.napiValueFromJsValue(new String(emnapiCtx.jsValueFromNapiValue(value)))
+}
+
+/**
+ * @__deps $emnapiCtx
+ * @__deps $emnapiString
+ * @__sig pppii
+ */
+export function _v8_string_new_from_one_byte (isolate: Ptr, data: Ptr, type: number, length: number): Ptr {
+  from64('data')
+  from64('length')
+  const str = emnapiString.encode(data as number, length === -1, length >>> 0, (c) => String.fromCharCode(c))
+  return emnapiCtx.napiValueFromJsValue(str)
+}
+
+/**
+ * @__deps $emnapiCtx
+ * @__deps $emnapiString
+ * @__sig pppii
+ */
+export function _v8_string_new_from_two_byte (isolate: Ptr, data: Ptr, type: number, length: number): Ptr {
+  from64('data')
+  from64('length')
+  const str = emnapiString.UTF16ToString(data as number, length)
+  return emnapiCtx.napiValueFromJsValue(str)
+}
+
+/**
+ * @__deps $emnapiCtx
+ * @__sig pppi
+ */
+export function _v8_regex_new (context: Ptr, pattern: Ptr, flags: number): Ptr {
+  from64('pattern')
+  const str = emnapiCtx.jsValueFromNapiValue(pattern)
+  let f = ''
+  if (flags & 1) f += 'g'
+  if (flags & 2) f += 'i'
+  if (flags & 4) f += 'm'
+  if (flags & 8) f += 'y'
+  if (flags & 16) f += 'u'
+  if (flags & 32) f += 's'
+  return emnapiCtx.napiValueFromJsValue(f ? new RegExp(str, f) : new RegExp(str))
+}
+
 /**
  * @__deps $emnapiCtx
  * @__deps $emnapiString
diff --git a/packages/emnapi/src/v8/value.ts b/packages/emnapi/src/v8/value.ts
@@ -55,7 +55,7 @@ export function _v8_value_to_object (value: Ptr, context: Ptr): Ptr {
  */
 export function _v8_value_to_integer (value: Ptr, context: Ptr): Ptr {
   const jsValue = emnapiCtx.jsValueFromNapiValue(value)
-  const intValue = Number(jsValue) | 0
+  const intValue = Math.trunc(Number(jsValue))
   return emnapiCtx.napiValueFromJsValue(intValue)
 }
 
diff --git a/packages/test/CMakeLists.txt b/packages/test/CMakeLists.txt
@@ -452,6 +452,7 @@ if(NOT IS_WASM32)
     add_test_v8("nan_json_stringify" "./nan/json-stringify.cpp" ON)
     add_test_v8("nan_maybe" "./nan/maybe.cpp" ON)
     add_test_v8("nan_methodswithdata" "./nan/methodswithdata.cpp" ON)
+    add_test_v8("nan_news" "./nan/news.cpp" ON)
     add_test_v8("nan_persistent" "./nan/persistent.cpp" ON)
     add_test_v8("nan_private" "./nan/private.cpp" ON)
     add_test_v8("nan_returnemptystring" "./nan/returnemptystring.cpp" ON)
diff --git a/packages/test/nan/news.cpp b/packages/test/nan/news.cpp
diff --git a/packages/test/nan/news.test.js b/packages/test/nan/news.test.js

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@ namespace v8 {`
`4`	`4`
`5`	`5`	`extern "C" {`
`6`	`6`	`V8_EXTERN bool _v8_boolean_value(const Boolean*);`
	`7`	`+ V8_EXTERN internal::Address _v8_boolean_object_new(Isolate* isolate, int value);`
`7`	`8`	`}`
`8`	`9`
`9`	`10`	`void Boolean::CheckCast(v8::Data*) {}`
`@@ -12,4 +13,9 @@ bool Boolean::Value() const {`
`12`	`13`	`return _v8_boolean_value(this);`
`13`	`14`	`}`
`14`	`15`
	`16`	`+Local<Value> BooleanObject::New(Isolate* isolate, bool value) {`
	`17`	`+ auto n = _v8_boolean_object_new(isolate, static_cast<int>(value));`
	`18`	`+ return v8impl::V8LocalValueFromAddress(n);`
	`19`	`+}`
	`20`	`+`
`15`	`21`	`}`