@auto_js/napi 0.0.5 → 0.0.7

package/transfer/visit.cc

@@ -1,5 +1,5 @@
 export module napi_js:visit;
-import :container;
+import :utility;
 import :value;
 import std;
 import util;
@@ -10,7 +10,7 @@ namespace js::napi {
 // Instantiated in the acceptor that corresponds to a napi visitor
 struct reference_map_type {
 		template <class Type>
-		using type = napi::value_map<Type>;
+		using type = napi::unordered_value_map<Type>;
 };
 
 // Visitor which may visit only property names. `symbol` should probably be rethought since they are
@@ -104,7 +104,6 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		using reference_map_t<Reference, reference_map_type>::lookup_or_visit;
 
 		visit_value(auto* /*transfer*/, Environment& env) :
-				reference_map_t<Reference, reference_map_type>{env},
 				env_{env} {}
 
 		// If the private `immediate` operation is defined: this public operation will first
@@ -135,7 +134,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 
 		template <class Accept>
 		auto operator()(value_of<number_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (std::bit_cast<v8::Local<v8::Number>>(subject)->IsInt32()) {
+			if (maybe_fast_is_number_int32(subject).value_or(false)) {
 				return immediate(value_of<number_tag_of<std::int32_t>>::from(subject), accept);
 			} else {
 				return immediate(value_of<number_tag_of<double>>::from(subject), accept);
@@ -153,81 +152,87 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 
 			// Check the reference map, and lookup type via napi
 			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
-				auto v8_subject = std::bit_cast<v8::Local<v8::Value>>(subject);
-				return util::template_traverse(
-					accept_tags_of_v<Accept>,
-					util::overloaded{
-						// Fast paths
-						[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsUndefined() ? (*this)(value_of<undefined_tag>::from(subject), accept) : next();
-						},
-						[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsNull() ? (*this)(value_of<null_tag>::from(subject), accept) : next();
-						},
-						[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsBoolean() ? (*this)(value_of<boolean_tag>::from(subject), accept) : next();
-						},
-						[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsNumber() ? (*this)(value_of<number_tag>::from(subject), accept) : next();
-						},
-						[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsString() ? immediate(value_of<string_tag>::from(subject), accept) : next();
-						},
-						[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsBigInt() ? immediate(value_of<bigint_tag>::from(subject), accept) : next();
-						},
-						[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsDate() ? immediate(value_of<date_tag>::from(subject), accept) : next();
-						},
-						[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsArray() ? immediate(value_of<list_tag>::from(subject), accept) : next();
-						},
-						[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
-							// checks. We don't really want to accept those types here, I don't think..
-							return v8_subject->IsObject() ? immediate(value_of<object_tag>::from(subject), accept) : next();
-						},
-						[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
-							return v8_subject->IsFunction() ? immediate(value_of<function_tag>::from(subject), accept) : next();
-						},
-
-						// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
-						// differentiate between.
-						[]<class Type>(number_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-						[]<class Type>(string_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-
-						// Unknown tag
-						[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
-
-						// Slow path
-						[ & ]() -> accept_target_t<Accept> {
-							auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
-							switch (type_of) {
-								case napi_undefined:
-									return (*this)(value_of<undefined_tag>::from(subject), accept);
-								case napi_null:
-									return (*this)(value_of<null_tag>::from(subject), accept);
-								case napi_boolean:
-									return (*this)(value_of<boolean_tag>::from(subject), accept);
-								case napi_number:
-									return (*this)(value_of<number_tag>::from(subject), accept);
-								case napi_string:
-									return immediate(value_of<string_tag>::from(subject), accept);
-								case napi_symbol:
-									return immediate(value_of<symbol_tag>::from(subject), accept);
-								case napi_object:
-									return immediate(value_of<object_tag>::from(subject), accept);
-								case napi_function:
-									return immediate(value_of<function_tag>::from(subject), accept);
-								case napi_external:
-									return immediate(value_of<external_tag>::from(subject), accept);
-								case napi_bigint:
-									return immediate(value_of<bigint_tag>::from(subject), accept);
-							}
-							std::unreachable();
-						},
+				// This is the pure-napi implementation
+				auto slow_path = [ & ]() -> accept_target_t<Accept> {
+					auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
+					switch (type_of) {
+						case napi_undefined:
+							return (*this)(value_of<undefined_tag>::from(subject), accept);
+						case napi_null:
+							return (*this)(value_of<null_tag>::from(subject), accept);
+						case napi_boolean:
+							return (*this)(value_of<boolean_tag>::from(subject), accept);
+						case napi_number:
+							return (*this)(value_of<number_tag>::from(subject), accept);
+						case napi_string:
+							return immediate(value_of<string_tag>::from(subject), accept);
+						case napi_symbol:
+							return immediate(value_of<symbol_tag>::from(subject), accept);
+						case napi_object:
+							return immediate(value_of<object_tag>::from(subject), accept);
+						case napi_function:
+							return immediate(value_of<function_tag>::from(subject), accept);
+						case napi_external:
+							return immediate(value_of<external_tag>::from(subject), accept);
+						case napi_bigint:
+							return immediate(value_of<bigint_tag>::from(subject), accept);
 					}
-				);
+					std::unreachable();
+				};
+
+				if (has_fast_is_functions) {
+					return util::template_traverse(
+						accept_tags_of_v<Accept>,
+						util::overloaded{
+							// Fast paths
+							[ & ](undefined_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_undefined(subject) ? (*this)(value_of<undefined_tag>::from(subject), accept) : next();
+							},
+							[ & ](null_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_null(subject) ? (*this)(value_of<null_tag>::from(subject), accept) : next();
+							},
+							[ & ](boolean_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_boolean(subject) ? (*this)(value_of<boolean_tag>::from(subject), accept) : next();
+							},
+							[ & ](number_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_number(subject) ? (*this)(value_of<number_tag>::from(subject), accept) : next();
+							},
+							[ & ](string_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_string(subject) ? immediate(value_of<string_tag>::from(subject), accept) : next();
+							},
+							[ & ](bigint_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_bigint(subject) ? immediate(value_of<bigint_tag>::from(subject), accept) : next();
+							},
+							[ & ](date_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return napi::invoke(napi_is_date, napi_env{*this}, subject) ? immediate(value_of<date_tag>::from(subject), accept) : next();
+							},
+							[ & ](list_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_array(subject) ? immediate(value_of<list_tag>::from(subject), accept) : next();
+							},
+							[ & ](object_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								// nb: You can't really skip the subsequent is promise, is date, is arraybuffer, etc
+								// checks. We don't really want to accept those types here, I don't think..
+								return fast_is_object(subject) ? immediate(value_of<object_tag>::from(subject), accept) : next();
+							},
+							[ & ](function_tag /*tag*/, auto next) -> accept_target_t<Accept> {
+								return fast_is_function(subject) ? immediate(value_of<function_tag>::from(subject), accept) : next();
+							},
+
+							// Skip these, otherwise `number_tag` and `string_tag` are invoked twice, which we don't
+							// differentiate between.
+							[]<class Type>(number_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+							[]<class Type>(string_tag_of<Type> /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+
+							// Unknown tag
+							[](auto /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
+
+							// Slow path
+							slow_path,
+						}
+					);
+				} else {
+					return slow_path();
+				}
 			});
 		}
 
@@ -267,10 +272,10 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		// strings
 		template <class Accept>
 		auto immediate(value_of<string_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			if (std::bit_cast<v8::Local<v8::String>>(subject)->IsOneByte()) {
-				return accept_tagged(value_of<string_tag_of<char16_t>>::from(subject), accept);
-			} else {
+			if (maybe_fast_is_string_one_byte(subject).value_or(false)) {
 				return accept_tagged(value_of<string_tag_of<char>>::from(subject), accept);
+			} else {
+				return accept_tagged(value_of<string_tag_of<char16_t>>::from(subject), accept);
 			}
 		}
 
@@ -291,7 +296,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 				return immediate(value_of<typed_array_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_dataview, napi_env{*this}, subject)) {
 				return immediate(value_of<data_view_tag>::from(subject), accept);
-			} else if (std::bit_cast<v8::Local<v8::Object>>(subject)->IsSharedArrayBuffer()) {
+			} else if (maybe_is_shared_array_buffer(env_.get(), subject).value_or(false)) {
 				return immediate(value_of<shared_array_buffer_tag>::from(subject), accept);
 			} else if (napi::invoke(napi_is_arraybuffer, napi_env{*this}, subject)) {
 				return immediate(value_of<array_buffer_tag>::from(subject), accept);

package/value/array_buffer.cc

@@ -1,6 +1,7 @@
 module napi_js;
 import :api;
 import :array_buffer;
+import :support.host;
 import std;
 import v8;
 
@@ -8,18 +9,6 @@ namespace js::napi {
 
 // `bound_value_for_data_block`
 bound_value_for_data_block::operator std::span<std::byte>() const {
-	auto local = std::bit_cast<v8::Local<v8::ArrayBuffer>>(napi_value{*this});
-	auto* data = reinterpret_cast<std::byte*>(local->Data());
-	auto byte_length = local->ByteLength();
-	return std::span{data, byte_length};
-}
-
-// `bound_value_for_array_buffer`
-bound_value_for_array_buffer::operator js::array_buffer() const {
-	return js::array_buffer{std::span<std::byte>{*this}};
-}
-
-bound_value_for_array_buffer::operator std::span<std::byte>() const {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	void* bytes;
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
@@ -28,6 +17,11 @@ bound_value_for_array_buffer::operator std::span<std::byte>() const {
 	return std::span{reinterpret_cast<std::byte*>(bytes), byte_length};
 }
 
+// `bound_value_for_array_buffer`
+bound_value_for_array_buffer::operator js::array_buffer() const {
+	return js::array_buffer{std::span<std::byte>{*this}};
+}
+
 // `bound_value_for_shared_array_buffer`
 bound_value_for_shared_array_buffer::operator js::shared_array_buffer() const {
 	auto local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{*this});
@@ -37,11 +31,6 @@ bound_value_for_shared_array_buffer::operator js::shared_array_buffer() const {
 	return js::shared_array_buffer{local->ByteLength(), std::move(data_shared_ptr)};
 }
 
-bound_value_for_shared_array_buffer::operator std::span<std::byte>() const {
-	auto local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{*this});
-	return std::span{reinterpret_cast<std::byte*>(local->Data()), local->ByteLength()};
-}
-
 // `value_for_typed_array`
 auto value_for_typed_array::make(const environment& env, napi_typedarray_type type_tag, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag> {
 	return value_of<typed_array_tag>::from(napi::invoke(napi_create_typedarray, napi_env{env}, type_tag, length, napi_value{buffer}, byte_offset));
@@ -92,9 +81,7 @@ auto value_for_data_view::make(const environment& env, value_of<array_buffer_tag
 }
 
 auto value_for_data_view::make(const environment& /*env*/, value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag> {
-	auto buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
-	auto view_local = v8::DataView::New(buffer_local, byte_offset, length);
-	return value_of<data_view_tag>::from(std::bit_cast<napi_value>(view_local));
+	return make_sab_data_view(buffer, byte_offset, length);
 }
 
 // `bound_value_for_data_view`

package/value/array_buffer.h.cc

@@ -20,20 +20,14 @@ class bound_value_for_data_block : public bound_value_next<data_block_tag> {
 class bound_value_for_array_buffer : public bound_value_next<array_buffer_tag> {
 	public:
 		using bound_value_next<array_buffer_tag>::bound_value_next;
-		[[nodiscard]] constexpr auto byte_length() const -> std::size_t { return std::span<std::byte>{*this}.size(); }
-		[[nodiscard]] constexpr auto data() const -> const std::byte* { return std::span<std::byte>{*this}.data(); }
 		explicit operator js::array_buffer() const;
-		explicit operator std::span<std::byte>() const;
 };
 
 // `SharedArrayBuffer`
 class bound_value_for_shared_array_buffer : public bound_value_next<shared_array_buffer_tag> {
 	public:
 		using bound_value_next<shared_array_buffer_tag>::bound_value_next;
-		[[nodiscard]] constexpr auto byte_length() const -> std::size_t { return std::span<std::byte>{*this}.size(); }
-		[[nodiscard]] constexpr auto data() const -> const std::byte* { return std::span<std::byte>{*this}.data(); }
 		explicit operator js::shared_array_buffer() const;
-		explicit operator std::span<std::byte>() const;
 };
 
 // `ArrayBufferView` (hidden superclass of `TypedArray` and `DataView`)
@@ -120,23 +114,7 @@ class value_for_typed_array_of : public value_next<typed_array_tag_of<Type>> {
 
 		// napi doesn't provide a way to make a typed array view on a shared array buffer
 		static auto make(const environment& /*env*/, value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
-			using constructor_type = type_t<util::overloaded{
-				[](std::type_identity<double>) -> std::type_identity<v8::Float64Array> { return {}; },
-				[](std::type_identity<float>) -> std::type_identity<v8::Float32Array> { return {}; },
-				[](std::type_identity<js::float16_t>) -> std::type_identity<v8::Float16Array> { return {}; },
-				[](std::type_identity<js::uint8_clamped_t>) -> std::type_identity<v8::Uint8ClampedArray> { return {}; },
-				[](std::type_identity<std::int16_t>) -> std::type_identity<v8::Int16Array> { return {}; },
-				[](std::type_identity<std::int32_t>) -> std::type_identity<v8::Int32Array> { return {}; },
-				[](std::type_identity<std::int64_t>) -> std::type_identity<v8::BigInt64Array> { return {}; },
-				[](std::type_identity<std::int8_t>) -> std::type_identity<v8::Int8Array> { return {}; },
-				[](std::type_identity<std::uint16_t>) -> std::type_identity<v8::Uint16Array> { return {}; },
-				[](std::type_identity<std::uint32_t>) -> std::type_identity<v8::Uint32Array> { return {}; },
-				[](std::type_identity<std::uint64_t>) -> std::type_identity<v8::BigUint64Array> { return {}; },
-				[](std::type_identity<std::uint8_t>) -> std::type_identity<v8::Uint8Array> { return {}; },
-			}(type<Type>)>;
-			auto buffer_local = std::bit_cast<v8::Local<v8::SharedArrayBuffer>>(napi_value{buffer});
-			auto view_local = constructor_type::New(buffer_local, byte_offset, length);
-			return value_of<typed_array_tag_of<Type>>::from(std::bit_cast<napi_value>(view_local));
+			return make_sab_typed_array_of<Type>(buffer, byte_offset, length);
 		}
 };
 

package/value/class.cc

@@ -42,7 +42,7 @@ auto value_for_class_of<Type>::transfer_construct(auto& env, auto instance, std:
 		napi::invoke0(napi_type_tag_object, napi_env{env}, this_arg, &type_tag_for<element_type>);
 
 		// Wrap w/ finalizer
-		return apply_finalizer(std::move(instance), [ & ](element_type* instance, napi_finalize finalize, void* hint) -> napi_value {
+		return apply_finalizer(std::move(instance), [ & ](element_type* instance, node_api_basic_finalize finalize, void* hint) -> napi_value {
 			napi::invoke0(napi_wrap, napi_env{env}, this_arg, instance, finalize, hint, nullptr);
 			return this_arg;
 		});

package/support/container.cc

@@ -1,77 +0,0 @@
-export module napi_js:container;
-import :environment;
-import nodejs;
-import std;
-import util;
-
-namespace js::napi {
-
-// Map container for napi values
-template <class Type>
-struct virtual_value_map {
-	public:
-		using container_type = std::unordered_map<napi_value, Type>;
-		using iterator = container_type::iterator;
-		using key_type = container_type::key_type;
-		using mapped_type = container_type::mapped_type;
-
-		virtual auto end() const -> iterator = 0;
-		virtual auto find(napi_value key) const -> iterator = 0;
-		virtual auto try_emplace(napi_value key, Type value) -> std::pair<iterator, bool> = 0;
-};
-
-template <class Map>
-struct concrete_value_map final : virtual_value_map<typename Map::mapped_type> {
-	public:
-		using container_type = Map;
-		using typename virtual_value_map<typename Map::mapped_type>::mapped_type;
-		using typename virtual_value_map<typename Map::mapped_type>::iterator;
-
-		virtual auto end() const -> iterator {
-			return std::bit_cast<iterator>(map_.end());
-		}
-
-		virtual auto find(napi_value key) const -> iterator {
-			// nb: The iterator type between `std::unordered_map<int, int, left>` and
-			// `std::unordered_map<int, int, right>` are not technically compatible.
-			return std::bit_cast<iterator>(map_.find(key));
-		}
-
-		virtual auto try_emplace(napi_value key, mapped_type value) -> std::pair<iterator, bool> {
-			auto [ it, inserted ] = map_.try_emplace(key, std::move(value));
-			return std::pair{std::bit_cast<iterator>(it), inserted};
-		}
-
-	private:
-		container_type map_;
-};
-
-export template <class Type>
-class value_map {
-	private:
-		using direct_map_type = concrete_value_map<std::unordered_map<napi_value, Type, direct_address_hash, direct_address_equal>>;
-		using indirect_map_type = concrete_value_map<std::unordered_map<napi_value, Type, indirect_address_hash, indirect_address_equal>>;
-		using virtual_map_type = util::covariant_value<virtual_value_map<Type>, direct_map_type, indirect_map_type>;
-
-	public:
-		using container_type = virtual_value_map<Type>;
-		using iterator = container_type::iterator;
-		using key_type = container_type::key_type;
-		using mapped_type = container_type::mapped_type;
-
-		explicit value_map(const environment& env) :
-				map_{
-					env.uses_direct_handles()
-						? virtual_map_type{direct_map_type{}}
-						: virtual_map_type{indirect_map_type{}}
-				} {}
-
-		auto end() const -> iterator { return map_->end(); }
-		auto find(key_type key) const -> iterator { return map_->find(key); }
-		auto try_emplace(key_type key, mapped_type value) -> std::pair<iterator, bool> { return map_->try_emplace(key, std::move(value)); }
-
-	private:
-		virtual_map_type map_;
-};
-
-} // namespace js::napi