@auto_js/napi 0.0.8 → 0.0.9

package/value/array_buffer.h.cc

@@ -1,6 +1,4 @@
 export module napi_js:array_buffer;
-import :bound_value;
-import :environment;
 import :object;
 import std;
 import v8;
@@ -8,93 +6,93 @@ import v8;
 namespace js::napi {
 
 // Data blocks
-class bound_value_for_data_block : public bound_value_next<data_block_tag> {
+class value_for_data_block : public value_next<data_block_tag> {
 	public:
-		using bound_value_next<data_block_tag>::bound_value_next;
+		using value_next<data_block_tag>::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 std::span<std::byte>() const;
 };
 
 // `ArrayBuffer`
-class bound_value_for_array_buffer : public bound_value_next<array_buffer_tag> {
+class value_for_array_buffer : public value_next<array_buffer_tag> {
 	public:
-		using bound_value_next<array_buffer_tag>::bound_value_next;
+		using value_next<array_buffer_tag>::value_next;
 		explicit operator js::array_buffer() const;
 };
 
 // `SharedArrayBuffer`
-class bound_value_for_shared_array_buffer : public bound_value_next<shared_array_buffer_tag> {
+class value_for_shared_array_buffer : public value_next<shared_array_buffer_tag> {
 	public:
-		using bound_value_next<shared_array_buffer_tag>::bound_value_next;
+		using value_next<shared_array_buffer_tag>::value_next;
 		explicit operator js::shared_array_buffer() const;
 };
 
 // `ArrayBufferView` (hidden superclass of `TypedArray` and `DataView`)
-class bound_value_for_array_buffer_view : public bound_value_next<array_buffer_view_tag> {
+class value_for_array_buffer_view : public value_next<array_buffer_view_tag> {
 	protected:
-		bound_value_for_array_buffer_view(
+		value_for_array_buffer_view(
 			napi_env env,
-			value_of<array_buffer_view_tag> typed_array,
-			std::tuple<value_of<data_block_tag>, std::size_t, std::size_t> array_buffer_info
+			local_of<array_buffer_view_tag> typed_array,
+			std::tuple<local_of<data_block_tag>, std::size_t, std::size_t> array_buffer_info
 		) :
-				bound_value_next<array_buffer_view_tag>{env, typed_array},
+				value_next<array_buffer_view_tag>{env, typed_array},
 				array_buffer_{std::get<0>(array_buffer_info)},
 				byte_offset_{std::get<1>(array_buffer_info)},
 				length_{std::get<2>(array_buffer_info)} {}
 
 	public:
-		[[nodiscard]] auto buffer() const -> value_of<data_block_tag> { return array_buffer_; }
+		[[nodiscard]] auto buffer() const -> local_of<data_block_tag> { return array_buffer_; }
 		[[nodiscard]] auto byte_offset() const -> std::size_t { return byte_offset_; }
 		[[nodiscard]] auto size() const -> std::size_t { return length_; }
 
 	private:
-		value_of<data_block_tag> array_buffer_;
+		local_of<data_block_tag> array_buffer_;
 		std::size_t byte_offset_;
 		std::size_t length_;
 };
 
 // `TypedArray`
-class value_for_typed_array : public value_next<typed_array_tag> {
+class local_for_typed_array : public local_next<typed_array_tag> {
 	protected:
-		static auto make(const environment& env, napi_typedarray_type type, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag>;
-		static auto make(const environment& env, napi_typedarray_type type, value_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag>;
+		static auto make(const environment& env, napi_typedarray_type type, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag>;
+		static auto make(const environment& env, napi_typedarray_type type, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag>;
 };
 
-class bound_value_for_typed_array : public bound_value_next<typed_array_tag> {
+class value_for_typed_array : public value_next<typed_array_tag> {
 	public:
-		using bound_value_next<typed_array_tag>::bound_value_next;
-		using any_bound_typed_array = std::variant<
-			bound_value<typed_array_tag_of<double>>,
-			bound_value<typed_array_tag_of<float>>,
-			bound_value<typed_array_tag_of<js::float16_t>>,
-			bound_value<typed_array_tag_of<js::uint8_clamped_t>>,
-			bound_value<typed_array_tag_of<std::int16_t>>,
-			bound_value<typed_array_tag_of<std::int32_t>>,
-			bound_value<typed_array_tag_of<std::int64_t>>,
-			bound_value<typed_array_tag_of<std::int8_t>>,
-			bound_value<typed_array_tag_of<std::uint16_t>>,
-			bound_value<typed_array_tag_of<std::uint32_t>>,
-			bound_value<typed_array_tag_of<std::uint64_t>>,
-			bound_value<typed_array_tag_of<std::uint8_t>>>;
-
-		static auto make_bound(const environment& env, value_of<typed_array_tag> typed_array) -> any_bound_typed_array;
+		using value_next<typed_array_tag>::value_next;
+		using any_value_typed_array = std::variant<
+			value_of<typed_array_tag_of<double>>,
+			value_of<typed_array_tag_of<float>>,
+			value_of<typed_array_tag_of<js::float16_t>>,
+			value_of<typed_array_tag_of<js::uint8_clamped_t>>,
+			value_of<typed_array_tag_of<std::int16_t>>,
+			value_of<typed_array_tag_of<std::int32_t>>,
+			value_of<typed_array_tag_of<std::int64_t>>,
+			value_of<typed_array_tag_of<std::int8_t>>,
+			value_of<typed_array_tag_of<std::uint16_t>>,
+			value_of<typed_array_tag_of<std::uint32_t>>,
+			value_of<typed_array_tag_of<std::uint64_t>>,
+			value_of<typed_array_tag_of<std::uint8_t>>>;
+
+		static auto make_bound(const environment& env, local_of<typed_array_tag> typed_array) -> any_value_typed_array;
 };
 
 template <class Type>
-class value_for_typed_array_of : public value_next<typed_array_tag_of<Type>> {
+class local_for_typed_array_of : public local_next<typed_array_tag_of<Type>> {
 	public:
-		using value_next<typed_array_tag_of<Type>>::value_next;
+		using local_next<typed_array_tag_of<Type>>::local_next;
 
-		static auto make(const environment& env, value_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
+		static auto make(const environment& env, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
 			if (napi::invoke(napi_is_arraybuffer, napi_env{env}, buffer)) {
-				return make(env, value_of<array_buffer_tag>::from(buffer), byte_offset, length);
+				return make(env, local_of<array_buffer_tag>::from(buffer), byte_offset, length);
 			} else {
-				return make(env, value_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
+				return make(env, local_of<shared_array_buffer_tag>::from(buffer), byte_offset, length);
 			}
 		}
 
-		static auto make(const environment& env, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<typed_array_tag_of<Type>> {
+		static auto make(const environment& env, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
 			constexpr auto type_tag = util::overloaded{
 				[](std::type_identity<double>) -> napi_typedarray_type { return napi_float64_array; },
 				[](std::type_identity<float>) -> napi_typedarray_type { return napi_float32_array; },
@@ -109,34 +107,34 @@ class value_for_typed_array_of : public value_next<typed_array_tag_of<Type>> {
 				[](std::type_identity<std::uint64_t>) -> napi_typedarray_type { return napi_biguint64_array; },
 				[](std::type_identity<std::uint8_t>) -> napi_typedarray_type { return napi_uint8_array; },
 			}(type<Type>);
-			return value_of<typed_array_tag_of<Type>>::from(value_for_typed_array::make(env, type_tag, buffer, byte_offset, length));
+			return local_of<typed_array_tag_of<Type>>::from(local_for_typed_array::make(env, type_tag, buffer, byte_offset, length));
 		}
 
 		// 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>> {
+		static auto make(const environment& /*env*/, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<typed_array_tag_of<Type>> {
 			return make_sab_typed_array_of<Type>(buffer, byte_offset, length);
 		}
 };
 
 template <class Type>
-class bound_value_for_typed_array_of : public bound_value_next<typed_array_tag_of<Type>> {
+class value_for_typed_array_of : public value_next<typed_array_tag_of<Type>> {
 	public:
-		using bound_value_next<typed_array_tag_of<Type>>::bound_value_next;
+		using value_next<typed_array_tag_of<Type>>::value_next;
 };
 
 // `DataView`
-class value_for_data_view : public value_next<data_view_tag> {
+class local_for_data_view : public local_next<data_view_tag> {
 	public:
-		using value_next<data_view_tag>::value_next;
+		using local_next<data_view_tag>::local_next;
 
-		static auto make(const environment& env, value_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag>;
-		static auto make(const environment& env, value_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> value_of<data_view_tag>;
-		static auto 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>;
+		static auto make(const environment& env, local_of<data_block_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
+		static auto make(const environment& env, local_of<array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
+		static auto make(const environment& env, local_of<shared_array_buffer_tag> buffer, std::size_t byte_offset, std::size_t length) -> local_of<data_view_tag>;
 };
 
-class bound_value_for_data_view : public bound_value_next<data_view_tag> {
+class value_for_data_view : public value_next<data_view_tag> {
 	public:
-		bound_value_for_data_view(napi_env env, value_of<data_view_tag> data_view);
+		value_for_data_view(napi_env env, local_of<data_view_tag> data_view);
 };
 
 } // namespace js::napi

package/value/class.cc

@@ -8,7 +8,7 @@ namespace js::napi {
 
 template <class Type>
 template <class... Args>
-auto value_for_class_of<Type>::construct(auto& env, Args&&... args) const -> value_of<object_tag>
+auto local_for_class_of<Type>::construct(auto& env, Args&&... args) const -> local_of<object_tag>
 	requires std::constructible_from<Type, Args...> {
 	// NOLINTNEXTLINE(readability-simplify-boolean-expr)
 	if (false) {
@@ -21,21 +21,20 @@ auto value_for_class_of<Type>::construct(auto& env, Args&&... args) const -> val
 
 template <class Type>
 template <class... HostArgs, class... RuntimeArgs>
-auto value_for_class_of<Type>::runtime_construct(
+auto local_for_class_of<Type>::runtime_construct(
 	auto& env,
 	std::tuple<HostArgs...> host_args,
 	std::tuple<RuntimeArgs...> runtime_args
-) const -> value_of<object_tag>
+) const -> local_of<object_tag>
 	requires std::constructible_from<Type, HostArgs...> {
 	const auto [... indices ] = util::sequence<sizeof...(HostArgs)>;
-	// NOLINTNEXTLINE(bugprone-use-after-move)
 	auto instance = std::make_unique<Type>(std::get<indices>(std::move(host_args))...);
 	return transfer_construct(env, std::move(instance), std::move(runtime_args));
 }
 
 template <class Type>
 template <class... Args>
-auto value_for_class_of<Type>::transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> value_of<object_tag> {
+auto local_for_class_of<Type>::transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> local_of<object_tag> {
 	using element_type = decltype(instance)::element_type;
 	auto construct = [ & ](napi_value this_arg) -> napi_value {
 		// Tag `this_arg`
@@ -51,16 +50,16 @@ auto value_for_class_of<Type>::transfer_construct(auto& env, auto instance, std:
 	// Now an external (of `internal_constructor`) gets passed to JavaScript for a moment and
 	// hopefully it jumps into `construct`
 	auto construct_ref = internal_constructor{construct};
-	auto* construct_external = napi_value{value_of<external_tag>::make(env, &construct_ref)};
+	auto* construct_external = napi_value{local_of<external_tag>::make(env, &construct_ref)};
 	auto [... runtime_arg_values ] = js::transfer_in_strict<std::array<napi_value, sizeof...(Args)>>(std::move(runtime_args), env);
 	auto arg_vector = std::array{construct_external, runtime_arg_values...};
 	auto* this_arg = napi::invoke(napi_new_instance, napi_env{env}, napi_value{*this}, arg_vector.size(), arg_vector.data());
-	return value_of<object_tag>::from(this_arg);
+	return local_of<object_tag>::from(this_arg);
 }
 
 template <class Type>
 template <class Environment>
-auto value_for_class_of<Type>::make(Environment& env, const auto& class_template) -> value_of<class_tag_of<Type>> {
+auto local_for_class_of<Type>::make(Environment& env, const auto& class_template) -> local_of<class_tag_of<Type>> {
 	// Make constructor callback
 	auto [ construct_ptr, constructor_data ] =
 		make_callback_storage(env, make_constructor_function<Environment, Type>(class_template.constructor.function));
@@ -132,7 +131,7 @@ auto value_for_class_of<Type>::make(Environment& env, const auto& class_template
 		property_descriptors.size(),
 		property_descriptors.data()
 	);
-	return js::napi::value_of<class_tag_of<Type>>::from(result);
+	return js::napi::local_of<class_tag_of<Type>>::from(result);
 }
 
 } // namespace js::napi

package/value/class.h.cc

@@ -5,23 +5,23 @@ import std;
 namespace js::napi {
 
 template <class Type>
-class value_for_class_of : public value_next<class_tag_of<Type>> {
+class local_for_class_of : public local_next<class_tag_of<Type>> {
 	public:
 		// Construct a new C++ instance & JavaScript value
 		template <class... Args>
-		auto construct(auto& env, Args&&... args) const -> value_of<object_tag>
+		auto construct(auto& env, Args&&... args) const -> local_of<object_tag>
 			requires std::constructible_from<Type, Args...>;
 
 		template <class... HostArgs, class... RuntimeArgs>
-		auto runtime_construct(auto& env, std::tuple<HostArgs...> host_args, std::tuple<RuntimeArgs...> runtime_args) const -> value_of<object_tag>
+		auto runtime_construct(auto& env, std::tuple<HostArgs...> host_args, std::tuple<RuntimeArgs...> runtime_args) const -> local_of<object_tag>
 			requires std::constructible_from<Type, HostArgs...>;
 
 		// Create a JavaScript value from an already-created instance smart pointer
 		template <class... Args>
-		auto transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> value_of<object_tag>;
+		auto transfer_construct(auto& env, auto instance, std::tuple<Args...> runtime_args) const -> local_of<object_tag>;
 
 		template <class Environment>
-		static auto make(Environment& env, const auto& class_template) -> value_of<class_tag_of<Type>>;
+		static auto make(Environment& env, const auto& class_template) -> local_of<class_tag_of<Type>>;
 };
 
 } // namespace js::napi

package/value/external.cc

@@ -1,24 +1,22 @@
 export module napi_js:external;
-import :api;
-import :bound_value;
 import :object;
 import std;
 
 namespace js::napi {
 
-class value_for_external : public value_next<external_tag> {
+class local_for_external : public local_next<external_tag> {
 	public:
 		// untagged
-		static auto make(auto& env, void* pointer) -> value_of<external_tag>;
+		static auto make(auto& env, void* pointer) -> local_of<external_tag>;
 
 		// tagged
 		template <class Type>
-		static auto make(auto& env, Type* pointer) -> value_of<external_tag>;
+		static auto make(auto& env, Type* pointer) -> local_of<external_tag>;
 };
 
-class bound_value_for_external : public bound_value_next<external_tag> {
+class value_for_external : public value_next<external_tag> {
 	public:
-		using bound_value_next<external_tag>::bound_value_next;
+		using value_next<external_tag>::value_next;
 
 		template <class Type>
 		[[nodiscard]] auto try_cast(std::type_identity<Type> /*type*/) const -> Type*;
@@ -26,20 +24,20 @@ class bound_value_for_external : public bound_value_next<external_tag> {
 
 // ---
 
-auto value_for_external::make(auto& env, void* pointer) -> value_of<external_tag> {
+auto local_for_external::make(auto& env, void* pointer) -> local_of<external_tag> {
 	auto* external = napi::invoke(napi_create_external, napi_env{env}, pointer, nullptr, nullptr);
-	return value_of<external_tag>::from(external);
+	return local_of<external_tag>::from(external);
 }
 
 template <class Type>
-auto value_for_external::make(auto& env, Type* pointer) -> value_of<external_tag> {
+auto local_for_external::make(auto& env, Type* pointer) -> local_of<external_tag> {
 	auto external = make(env, static_cast<void*>(pointer));
 	napi::invoke0(napi_type_tag_object, napi_env{env}, external, &type_tag_for<Type>);
 	return external;
 };
 
 template <class Type>
-auto bound_value_for_external::try_cast(std::type_identity<Type> /*type*/) const -> Type* {
+auto value_for_external::try_cast(std::type_identity<Type> /*type*/) const -> Type* {
 	if (napi::invoke(napi_check_object_type_tag, env(), napi_value{*this}, &type_tag_for<Type>)) {
 		return static_cast<Type*>(napi::invoke(napi_get_value_external, env(), napi_value{*this}));
 	} else {

package/value/function.cc

@@ -5,34 +5,34 @@ import std;
 namespace js::napi {
 
 template <class Result>
-auto value_for_function::apply(auto_environment auto& env, auto&& args) -> Result {
+auto local_for_function::apply(auto_environment auto& env, auto&& args) -> Result {
 	auto argv = js::transfer_in_strict<std::vector<napi_value>>(std::forward<decltype(args)>(args), env);
 	return invoke<Result>(env, std::span{argv});
 }
 
 template <class Result>
-auto value_for_function::call(auto_environment auto& env, auto&&... args) -> Result {
+auto local_for_function::call(auto_environment auto& env, auto&&... args) -> Result {
 	auto argv = js::transfer_in_strict<std::array<napi_value, sizeof...(args)>>(std::forward_as_tuple(args...), env);
 	return invoke<Result>(env, std::span{argv});
 }
 
 template <class Result>
-auto value_for_function::invoke(auto_environment auto& env, std::span<napi_value> args) -> Result {
+auto local_for_function::invoke(auto_environment auto& env, std::span<napi_value> args) -> Result {
 	auto undefined = js::transfer_in_strict<napi_value>(std::monostate{}, env);
 	auto* result = napi::invoke(napi_call_function, napi_env{env}, undefined, napi_value{*this}, args.size(), args.data());
 	return js::transfer_out<Result>(result, env);
 }
 
 template <auto_environment Environment>
-auto value_for_function::make(Environment& env, auto function) -> value_of<function_tag> {
+auto local_for_function::make(Environment& env, auto function) -> local_of<function_tag> {
 	auto [ callback, data ] = make_callback_storage(env, make_free_function<Environment>(std::move(function).callback));
-	auto make = [ & ](void* data) -> value_of<function_tag> {
-		return value_of<function_tag>::from(napi::invoke(napi_create_function, napi_env{env}, function.name.data(), function.name.length(), callback, data));
+	auto make = [ & ](void* data) -> local_of<function_tag> {
+		return local_of<function_tag>::from(napi::invoke(napi_create_function, napi_env{env}, function.name.data(), function.name.length(), callback, data));
 	};
 	if constexpr (requires { typename decltype(data)::element_type; }) {
 		// Function requires finalizer
 		auto function = make(data.get());
-		return apply_finalizer(std::move(data), [ & ](auto* data, napi_finalize finalize, void* hint) -> value_of<function_tag> {
+		return apply_finalizer(std::move(data), [ & ](auto* data, napi_finalize finalize, void* hint) -> local_of<function_tag> {
 			napi::invoke0(napi_add_finalizer, napi_env{env}, function, data, finalize, hint, nullptr);
 			return function;
 		});

package/value/function.h.cc

@@ -4,7 +4,7 @@ import std;
 
 namespace js::napi {
 
-class value_for_function : public value_next<function_tag> {
+class local_for_function : public local_next<function_tag> {
 	public:
 		template <class Result = std::monostate>
 		auto apply(auto_environment auto& env, auto&& args) -> Result;
@@ -13,7 +13,7 @@ class value_for_function : public value_next<function_tag> {
 		auto call(auto_environment auto& env, auto&&... args) -> Result;
 
 		template <auto_environment Environment>
-		static auto make(Environment& env, auto function) -> value_of<function_tag>;
+		static auto make(Environment& env, auto function) -> local_of<function_tag>;
 
 	private:
 		template <class Result>

package/value/object.cc

@@ -1,25 +1,22 @@
 module napi_js;
-import :api;
-import :bound_value;
-import :value_handle;
 
 namespace js::napi {
 
 // object
-auto bound_value_for_object::get(napi_value key) const -> value_of<value_tag> {
-	return value_of<value_tag>::from(napi::invoke(napi_get_property, env(), napi_value{*this}, key));
+auto value_for_object::get(napi_value key) const -> local_of<value_tag> {
+	return local_of<value_tag>::from(napi::invoke(napi_get_property, env(), napi_value{*this}, key));
 }
 
-auto bound_value_for_object::has(napi_value key) const -> bool {
+auto value_for_object::has(napi_value key) const -> bool {
 	return napi::invoke(napi_has_own_property, env(), napi_value{*this}, key);
 }
 
-auto bound_value_for_object::set(napi_value key, napi_value value) -> void {
+auto value_for_object::set(napi_value key, napi_value value) -> void {
 	napi::invoke0(napi_set_property, env(), napi_value{*this}, key, value);
 }
 
 // date
-bound_value_for_date::operator js_clock::time_point() const {
+value_for_date::operator js_clock::time_point() const {
 	return js_clock::time_point{js_clock::duration{napi::invoke(napi_get_date_value, env(), napi_value{*this})}};
 }
 

package/value/object.h.cc

@@ -1,42 +1,39 @@
 export module napi_js:object;
-import :api;
-import :bound_value;
-import :environment_fwd;
 import :primitive;
 import std;
 
 namespace js::napi {
 
 // object
-class value_for_object : public value_next<object_tag> {
+class local_for_object : public local_next<object_tag> {
 	public:
-		auto assign(this value_of<object_tag> self, auto_environment auto& env, auto source) -> void;
+		auto assign(auto_environment auto& env, auto source) const -> void;
 };
 
-class bound_value_for_object : public bound_value_next<object_tag> {
+class value_for_object : public value_next<object_tag> {
 	public:
-		using bound_value_next<object_tag>::bound_value_next;
+		using value_next<object_tag>::value_next;
 
 		template <class Type>
 		[[nodiscard]] auto try_cast(std::type_identity<Type> /*type*/) const -> Type*;
 
-		[[nodiscard]] auto get(napi_value key) const -> value_of<value_tag>;
+		[[nodiscard]] auto get(napi_value key) const -> local_of<value_tag>;
 		[[nodiscard]] auto has(napi_value key) const -> bool;
 
 		auto set(napi_value key, napi_value value) -> void;
 };
 
 // date
-class bound_value_for_date : public bound_value_next<date_tag> {
+class value_for_date : public value_next<date_tag> {
 	public:
-		using bound_value_next<date_tag>::bound_value_next;
+		using value_next<date_tag>::value_next;
 		[[nodiscard]] explicit operator js_clock::time_point() const;
 };
 
 // ---
 
 template <class Type>
-auto bound_value_for_object::try_cast(std::type_identity<Type> /*type*/) const -> Type* {
+auto value_for_object::try_cast(std::type_identity<Type> /*type*/) const -> Type* {
 	if (napi::invoke(napi_check_object_type_tag, env(), napi_value{*this}, &type_tag_for<Type>)) {
 		return static_cast<Type*>(napi::invoke(napi_unwrap, env(), napi_value{*this}));
 	} else {
@@ -44,8 +41,4 @@ auto bound_value_for_object::try_cast(std::type_identity<Type> /*type*/) const -
 	}
 }
 
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=125144
-template class bound_value_next<data_block_tag>;
-template class bound_value_next<array_buffer_view_tag>;
-
 } // namespace js::napi

package/value/primitive.cc

@@ -1,27 +1,24 @@
 module napi_js;
-import :api;
-import :bound_value;
-import :value_handle;
 import std;
 
 namespace js::napi {
 
 // boolean
-bound_value_for_boolean::operator bool() const {
+value_for_boolean::operator bool() const {
 	return napi::invoke(napi_get_value_bool, env(), napi_value{*this});
 }
 
 // number
-bound_value_for_number::operator double() const {
+value_for_number::operator double() const {
 	return napi::invoke(napi_get_value_double, env(), napi_value{*this});
 }
 
-bound_value_for_number::operator std::int32_t() const {
+value_for_number::operator std::int32_t() const {
 	return napi::invoke(napi_get_value_int32, env(), napi_value{*this});
 }
 
 // bigint
-bound_value_for_bigint::operator bigint() const {
+value_for_bigint::operator bigint() const {
 	js::bigint value;
 	auto one_word = std::uint64_t{};
 	auto length = std::size_t{1};
@@ -38,7 +35,7 @@ bound_value_for_bigint::operator bigint() const {
 	return value;
 }
 
-bound_value_for_bigint::operator std::int64_t() const {
+value_for_bigint::operator std::int64_t() const {
 	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
 	std::int64_t value;
 	// nb: `lossless` error not checked for consistency with `napi_get_value_int32`,
@@ -48,7 +45,7 @@ bound_value_for_bigint::operator std::int64_t() const {
 }
 
 // string
-bound_value_for_string::operator std::string() const {
+value_for_string::operator std::string() const {
 	std::string string;
 	auto length = napi::invoke(napi_get_value_string_latin1, env(), napi_value{*this}, nullptr, 0);
 	if (length > 0) {
@@ -60,7 +57,7 @@ bound_value_for_string::operator std::string() const {
 	return string;
 }
 
-bound_value_for_string::operator std::u16string() const {
+value_for_string::operator std::u16string() const {
 	// nb: napi requires that the returned string is null-terminated for some reason.
 	std::u16string string;
 	auto length = napi::invoke(napi_get_value_string_utf16, env(), napi_value{*this}, nullptr, 0);

package/value/primitive.h.cc

@@ -1,51 +1,51 @@
 export module napi_js:primitive;
 import :api;
-import :bound_value;
-import :environment_fwd;
-import :value_handle;
+import :environment;
+import :handle.local_of;
+import :handle.value_of;
 import std;
 
 namespace js::napi {
 
 // boolean
-class bound_value_for_boolean : public bound_value_next<boolean_tag> {
+class value_for_boolean : public value_next<boolean_tag> {
 	public:
-		using bound_value_next<boolean_tag>::bound_value_next;
+		using value_next<boolean_tag>::value_next;
 		[[nodiscard]] explicit operator bool() const;
 };
 
-class bound_value_for_false : public bound_value_next<false_tag> {
+class value_for_false : public value_next<false_tag> {
 	public:
-		using bound_value_next<false_tag>::bound_value_next;
+		using value_next<false_tag>::value_next;
 		[[nodiscard]] constexpr explicit operator bool() const { return false; }
 };
 
-class bound_value_for_true : public bound_value_next<true_tag> {
+class value_for_true : public value_next<true_tag> {
 	public:
-		using bound_value_next<true_tag>::bound_value_next;
+		using value_next<true_tag>::value_next;
 		[[nodiscard]] constexpr explicit operator bool() const { return true; }
 };
 
 // number
-class bound_value_for_number : public bound_value_next<number_tag> {
+class value_for_number : public value_next<number_tag> {
 	public:
-		using bound_value_next<number_tag>::bound_value_next;
+		using value_next<number_tag>::value_next;
 		[[nodiscard]] explicit operator double() const;
 		[[nodiscard]] explicit operator std::int32_t() const;
 };
 
 // bigint
-class bound_value_for_bigint : public bound_value_next<bigint_tag> {
+class value_for_bigint : public value_next<bigint_tag> {
 	public:
-		using bound_value_next<bigint_tag>::bound_value_next;
+		using value_next<bigint_tag>::value_next;
 		[[nodiscard]] explicit operator bigint() const;
 		[[nodiscard]] explicit operator std::int64_t() const;
 };
 
 // string
-class bound_value_for_string : public bound_value_next<string_tag> {
+class value_for_string : public value_next<string_tag> {
 	public:
-		using bound_value_next<string_tag>::bound_value_next;
+		using value_next<string_tag>::value_next;
 		[[nodiscard]] explicit operator std::string() const;
 		[[nodiscard]] explicit operator std::u16string() const;
 };