@auto_js/v8 0.0.2 → 0.0.4

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@auto_js/v8",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "author": "https://github.com/laverdet/",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/v8",
   "license": "ISC",
   "dependencies": {
-    "@auto_js/js": "^0.0.2",
+    "@auto_js/js": "^0.0.4",
     "@auto_js/v8_exports": "^0.0.2"
   },
   "repository": {

package/transfer/accept.h.cc

@@ -105,6 +105,7 @@ struct accept_v8_primitive {
 struct accept_v8_value : accept_v8_primitive {
 	public:
 		using accept_type = accept_v8_primitive;
+		using accept_target_type = v8::Local<v8::Value>;
 		explicit accept_v8_value(auto* transfer, context_lock_witness lock) :
 				accept_type{transfer, lock},
 				context_{lock.context()} {}
@@ -177,6 +178,40 @@ struct accept_v8_value : accept_v8_primitive {
 			};
 		}
 
+		// vectors
+		auto operator()(this const auto& self, vector_tag /*tag*/, auto& visit, auto&& subject)
+			-> js::deferred_receiver<v8::Local<v8::Array>, decltype(self), decltype(visit), decltype(subject)> {
+			auto [... size ] = util::maybe_range_size(subject);
+			return {
+				v8::Array::New(self.isolate(), size...),
+				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
+				[](v8::Local<v8::Array> array, auto& self, auto& visit, auto /*&&*/ subject) -> void {
+					std::uint32_t ii = 0;
+					auto&& range = util::into_range(std::forward<decltype(subject)>(subject));
+					for (auto&& subject : util::forward_range(std::forward<decltype(range)>(range))) {
+						auto element = visit(std::forward<decltype(subject)>(subject), self);
+						unmaybe(array->Set(self.context_, ii++, element));
+					}
+				},
+			};
+		}
+
+		template <std::size_t Size>
+		auto operator()(this const auto& self, tuple_tag<Size> /*tag*/, auto& visit, auto&& subject)
+			-> js::deferred_receiver<v8::Local<v8::Array>, decltype(self), decltype(visit), decltype(subject)> {
+			return {
+				v8::Array::New(self.isolate(), Size),
+				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
+				[](v8::Local<v8::Array> array, auto& self, auto& visit, auto /*&&*/ tuple) -> void {
+					const auto [... indices ] = util::sequence<Size>;
+					(..., [ & ]() -> void {
+						auto element = visit(indices, std::forward<decltype(tuple)>(tuple), self);
+						unmaybe(array->Set(self.context_, indices, element));
+					}());
+				}
+			};
+		}
+
 		// object
 		auto operator()(this const auto& self, dictionary_tag /*tag*/, auto& visit, auto&& subject)
 			-> js::deferred_receiver<v8::Local<v8::Object>, decltype(self), decltype(visit), decltype(subject)> {
@@ -236,7 +271,7 @@ struct accept_v8_value : accept_v8_primitive {
 		auto operator()(this const auto& self, struct_tag<Size> /*tag*/, auto& visit, auto&& subject)
 			-> js::deferred_receiver<v8::Local<v8::Object>, decltype(self), decltype(visit), decltype(subject)> {
 			return {
-				v8::Local<v8::Object>::New(self.isolate()),
+				v8::Object::New(self.isolate()),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
 				[](v8::Local<v8::Object> object, auto& self, auto& visit, auto /*&&*/ subject) -> void {
 					self.template accept_entry_pair_struct<Size>(visit, object, std::forward<decltype(subject)>(subject));
@@ -315,6 +350,27 @@ struct accept_v8_template : accept_v8_primitive {
 		std::reference_wrapper<const Lock> lock_;
 };
 
+// object key lookup (struct_template, etc)
+template <class Meta, auto Key, class Type>
+struct accept_v8_property_value {
+	public:
+		explicit constexpr accept_v8_property_value(auto* transfer) :
+				first{transfer},
+				second{transfer} {}
+
+		auto operator()(dictionary_tag /*tag*/, auto& visit, const auto& subject) const -> Type {
+			if (auto local = first(std::type_identity<void>{}, visit.first); subject.has(local)) {
+				return visit.second(subject.get(local), second);
+			} else {
+				return second(undefined_in_tag{}, visit.second, std::monostate{});
+			}
+		}
+
+	private:
+		mutable visit_key_literal<Key, v8::Local<v8::Object>> first;
+		accept_value<Meta, Type> second;
+};
+
 // `return_into(...)`
 struct return_into_marker {};
 
@@ -360,8 +416,9 @@ struct accept_v8_return_into : accept_v8_value_with<Lock> {
 		}
 
 		auto operator()(auto tag, auto& visit, auto&& subject) const -> return_into_marker
-			requires std::invocable<const accept_type&, decltype(visit), decltype(tag), decltype(subject)> {
-			return_value_.Set(util::invoke_as<accept_type>(*this, tag, visit, std::forward<decltype(subject)>(subject)));
+			requires std::invocable<const accept_type&, decltype(tag), decltype(visit), decltype(subject)> {
+			auto value = util::invoke_as<accept_type>(*this, tag, visit, std::forward<decltype(subject)>(subject));
+			return_value_.Set(js::dispatch_referenceable(std::move(value)));
 			return {};
 		}
 
@@ -403,6 +460,9 @@ struct accept_v8_object_assign {
 
 namespace js {
 
+template <class Type>
+struct accept_property_subject<v8::Local<Type>> : std::type_identity<v8::Local<v8::Object>> {};
+
 // primitives
 template <class Meta, class Type>
 	requires std::is_base_of_v<v8::Primitive, Type>
@@ -441,7 +501,16 @@ struct accept<Meta, v8::MaybeLocal<Type>> : accept<Meta, v8::Local<Type>> {
 		}
 };
 
+// object key lookup (struct_template, etc)
+template <class Meta, auto Key, class Type>
+struct accept_property_value<Meta, Key, Type, v8::Local<v8::Object>> : iv8::accept_v8_property_value<Meta, Key, Type> {
+		using iv8::accept_v8_property_value<Meta, Key, Type>::accept_v8_property_value;
+};
+
 // return_into
+template <>
+struct accept_property_subject<iv8::return_into_marker> : accept_property_subject<v8::Local<v8::Value>> {};
+
 template <class Meta>
 struct accept<Meta, iv8::return_into_marker> : iv8::accept_v8_return_into<typename Meta::accept_context_type> {
 		using iv8::accept_v8_return_into<typename Meta::accept_context_type>::accept_v8_return_into;

package/transfer/visit.cc

@@ -51,6 +51,35 @@ struct visit_property_name {
 		std::reference_wrapper<Visit> visit_;
 };
 
+// `visit_key_literal` instantiation for v8
+template <auto Key>
+struct visit_v8_key_literal {
+		explicit constexpr visit_v8_key_literal(auto* /*transfer*/) {}
+
+		auto operator()(const auto& /*anything*/, const auto& accept_or_visit) -> v8::Local<v8::Name> {
+			const auto make = util::overloaded{
+				[](v8::Isolate* isolate, std::string_view subject) -> v8::Local<v8::String> {
+					const auto* data = reinterpret_cast<const std::uint8_t*>(subject.data());
+					auto size = static_cast<int>(subject.size());
+					return unmaybe(v8::String::NewFromOneByte(isolate, data, v8::NewStringType::kInternalized, size));
+				},
+				[](v8::Isolate* isolate, std::u16string_view subject) -> v8::Local<v8::String> {
+					const auto* data = reinterpret_cast<const std::uint16_t*>(subject.data());
+					auto size = static_cast<int>(subject.size());
+					return unmaybe(v8::String::NewFromTwoByte(isolate, data, v8::NewStringType::kInternalized, size));
+				},
+			};
+			if (local_key_.IsEmpty()) {
+				constexpr auto key = util::make_consteval_string_view(Key);
+				local_key_ = make(accept_or_visit.witness().isolate(), key);
+			}
+			return local_key_;
+		}
+
+	private:
+		v8::Local<v8::String> local_key_;
+};
+
 // Implements `Visit`'s non-caching `immediate()` function as a caching visit operation.
 template <class Visit>
 struct visit_cached_immediate : Visit {
@@ -434,4 +463,10 @@ struct visit<Meta, v8::FunctionCallbackInfo<v8::Value>> : visit<Meta, v8::Local<
 		}
 };
 
+// Object key maker for v8 objects
+template <auto Key>
+struct visit_key_literal<Key, v8::Local<v8::Object>> : iv8::visit_v8_key_literal<Key> {
+		using iv8::visit_v8_key_literal<Key>::visit_v8_key_literal;
+};
+
 } // namespace js

package/value/object.cc

@@ -8,6 +8,24 @@ import v8;
 
 namespace js::iv8 {
 
+constexpr auto has_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Name> key) -> bool {
+	return iv8::unmaybe(object->HasRealNamedProperty(context, key));
+}
+
+constexpr auto has_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Number> key) -> bool {
+	return iv8::unmaybe(object->HasRealIndexedProperty(context, key.As<v8::Uint32>()->Value()));
+}
+
+constexpr auto has_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Primitive> key) -> bool {
+	// Weird `if` here since there is a "quick" `IsString()` internally, but not for name, number, or
+	// symbol.
+	if (key->IsString() || !key->IsNumber()) {
+		return has_property(context, object, key.As<v8::Name>());
+	} else {
+		return has_property(context, object, key.As<v8::Number>());
+	}
+}
+
 constexpr auto get_property(v8::Local<v8::Context> context, v8::Local<v8::Object> object, v8::Local<v8::Name> key) -> v8::Local<v8::Value> {
 	// Maybe I'm misunderstanding the "without causing side effects" part of `GetRealNamedProperty`'s
 	// documentation, but it definitely invokes getters.
@@ -42,15 +60,27 @@ auto value_for_object::keys() const -> const value_for_array& {
 	return keys_;
 }
 
-auto value_for_object::get(v8::Local<v8::Name> key) -> v8::Local<v8::Value> {
+auto value_for_object::has(v8::Local<v8::Name> key) const -> bool {
+	return has_property(context(), util::slice(*this), key);
+}
+
+auto value_for_object::has(v8::Local<v8::Number> key) const -> bool {
+	return has_property(context(), util::slice(*this), key);
+}
+
+auto value_for_object::has(v8::Local<v8::Primitive> key) const -> bool {
+	return has_property(context(), util::slice(*this), key);
+}
+
+auto value_for_object::get(v8::Local<v8::Name> key) const -> v8::Local<v8::Value> {
 	return get_property(context(), util::slice(*this), key);
 }
 
-auto value_for_object::get(v8::Local<v8::Number> key) -> v8::Local<v8::Value> {
+auto value_for_object::get(v8::Local<v8::Number> key) const -> v8::Local<v8::Value> {
 	return get_property(context(), util::slice(*this), key);
 }
 
-auto value_for_object::get(v8::Local<v8::Primitive> key) -> v8::Local<v8::Value> {
+auto value_for_object::get(v8::Local<v8::Primitive> key) const -> v8::Local<v8::Value> {
 	return get_property(context(), util::slice(*this), key);
 }
 

package/value/object.h.cc

@@ -33,9 +33,12 @@ class value_for_object : public handle_with_context<v8::Object> {
 		using range_type = std::ranges::transform_view<std::views::all_t<const value_for_array&>, iterator_transform>;
 		using iterator = std::ranges::iterator_t<range_type>;
 
-		[[nodiscard]] auto get(v8::Local<v8::Name> key) -> v8::Local<v8::Value>;
-		[[nodiscard]] auto get(v8::Local<v8::Number> key) -> v8::Local<v8::Value>;
-		[[nodiscard]] auto get(v8::Local<v8::Primitive> key) -> v8::Local<v8::Value>;
+		[[nodiscard]] auto get(v8::Local<v8::Name> key) const -> v8::Local<v8::Value>;
+		[[nodiscard]] auto get(v8::Local<v8::Number> key) const -> v8::Local<v8::Value>;
+		[[nodiscard]] auto get(v8::Local<v8::Primitive> key) const -> v8::Local<v8::Value>;
+		[[nodiscard]] auto has(v8::Local<v8::Name> key) const -> bool;
+		[[nodiscard]] auto has(v8::Local<v8::Number> key) const -> bool;
+		[[nodiscard]] auto has(v8::Local<v8::Primitive> key) const -> bool;
 		[[nodiscard]] auto into_range() -> range_type;
 		[[nodiscard]] auto size() const -> std::size_t;