@auto_js/napi 0.0.8 → 0.0.10

package/CMakeLists.txt

@@ -38,7 +38,7 @@ target_sources(${napi_js}
 		api/uv_dlib.h.cc
 		api/uv_handle.cc
 		api/uv_scheduler.h.cc
-		handle/bound_value.cc
+		handle/local.cc
 		handle/reference.cc
 		handle/remote.cc
 		handle/types.cc

package/README.md

@@ -181,20 +181,20 @@ struct enum_values<enum_test> {
 
 ## Variants
 
-`std::variant<std::u16string, double>` could be used to accept *either* a string or a number value.
-You can mix and match types as needed.
+`std::variant<std::u16string, std::string, double, std::int32_t>` could be used to accept *either* a
+string or a number value. You can mix and match types as needed. If you use one of the covariant
+types then you must also use its alternative. `std::u16string, std::string`, `double, std::int32_t`,
+and `std::int64_t, js::bigint`.
 
 
 ## Covariants
 
 `std::variant<double, int32_t>` can be used to accept *either* a floating point or a signed integer.
 Note that this uses runtime function calls to resolve the covariance. In v8 it will invoke
-`value->IsInt32()` to discover what to return. Napi does not support this, so a `double` will always
-be returned.
+`value->IsInt32()` to discover what to return.
 
-`std::variant<std::string, std::u16string>` can be used in a similar way to accept either a UTF-16
+`std::variant<std::u16string, std::string>` can be used in a similar way to accept either a UTF-16
 string or the optimized ASCII string. This uses `value->IsOneByte()` to resolve the covariance.
-Again, in napi a UTF-16 string will always be returned.
 
 
 ## Structures
@@ -274,8 +274,8 @@ export class database {
 		using transfer_type = js::tagged_external<database>;
 
 		auto query(environment& env, std::string query) -> std::string;
-		static auto connect(environment& env, std::string uri) -> js::forward<js::napi::value_of<>>;
-		static auto class_template(environment& env) -> js::napi::value_of<class_tag_of<database>> {
+		static auto connect(environment& env, std::string uri) -> js::forward<js::napi::local_of<>>;
+		static auto class_template(environment& env) -> js::napi::local_of<class_tag_of<database>> {
 			// incomplete
 		}
 };

package/_module.cc

@@ -1,20 +1,21 @@
 export module napi_js;
 export import :accept;
 export import :api;
-export import :bound_value;
 export import :callback;
 export import :class_definitions;
 export import :class_template_storage;
 export import :environment;
 export import :error_scope;
 export import :function_definitions;
+export import :handle.local_of;
 export import :handle.types;
+export import :handle.value_of;
 export import :initialize;
 export import :promise;
 export import :reference;
 export import :remote;
 export import :string_table;
+export import :support.host;
 export import :utility;
-export import :value_handle;
 export import :value;
 export import :visit;

package/api/finalizer.cc

@@ -43,7 +43,7 @@ auto make_finalizer(std::type_identity<Env> /*type*/, std::shared_ptr<Type> shar
 template <class Pointer, class Apply>
 auto apply_finalizer(Pointer smart_ptr, Apply apply) -> decltype(auto) {
 	using element_type = Pointer::element_type;
-	constexpr auto napi_env_type = []() consteval -> auto {
+	constexpr auto napi_env_type = [] consteval -> auto {
 		if constexpr (std::invocable<Apply, element_type*, node_api_basic_finalize, void*>) {
 			return type<node_api_basic_env>;
 		} else {

package/api/threadsafe_function.cc

@@ -48,7 +48,7 @@ class threadsafe_function_of : util::non_copyable {
 
 template <class Context, class Message>
 threadsafe_function_of<Context, Message>::threadsafe_function_of(auto& env, napi_value value, auto&&... args) :
-		tsfn_{[ & ]() -> auto {
+		tsfn_{[ & ] -> auto {
 			constexpr auto name = util::make_consteval_string_view(util::cw<"threadsafe_function_of">);
 			auto resource_name = napi::invoke(napi_create_string_latin1, env, name.data(), name.size());
 			auto context = std::make_unique<storage>(std::forward<decltype(args)>(args)...);
@@ -57,9 +57,7 @@ threadsafe_function_of<Context, Message>::threadsafe_function_of(auto& env, napi
 				auto& context = *static_cast<storage*>(context_ptr);
 				if constexpr (trivial_message) {
 					if (env != nullptr) {
-						auto message = Message{};
-						std::memcpy(&message, &data, sizeof(Message));
-						context(env, value, message);
+						context(env, value, util::bit_truncation_cast<Message>(data));
 					}
 				} else {
 					auto message = std::unique_ptr<Message>{static_cast<Message*>(data)};
@@ -134,8 +132,7 @@ auto threadsafe_function_of<Context, Message>::operator()(Message message) const
 		}
 	};
 	if constexpr (trivial_message) {
-		void* data{};
-		std::memcpy(&data, &message, sizeof(Message));
+		auto* data = util::bit_padding_cast<void*>(message);
 		return check(napi_call_threadsafe_function(tsfn_, data, napi_tsfn_nonblocking));
 	} else {
 		auto message_ptr = std::make_unique<Message>(std::move(message));

package/api/uv_scheduler.h.cc

@@ -50,7 +50,7 @@ auto uv_scheduler::operator()(auto task, auto&&... args) const -> void {
 	if (shared->is_open) {
 		shared->tasks.emplace_back(
 			[ task = std::move(task),
-				... args = std::forward<decltype(args)>(args) ]() mutable -> void {
+				... args = std::forward<decltype(args)>(args) ] mutable -> void {
 				task(std::move(args)...);
 			}
 		);

package/handle/local.cc

@@ -0,0 +1,112 @@
+export module napi_js:handle.local_of;
+import :handle.types;
+import auto_js;
+import nodejs;
+import std;
+import util;
+
+namespace js::napi {
+
+// Map of `local_of<Tag>` to its concrete implementation class
+template <class Tag>
+struct local_specialization;
+
+// Tagged napi_value. Each `local_of<T>` inherits from the tag before it which makes overloading
+// acceptor functions naturally hierarchical.
+export template <class Tag>
+class local_of : public local_of<typename Tag::tag_type> {
+	protected:
+		using local_type = local_specialization<Tag>::type;
+		explicit local_of(napi_value value) : local_of<typename Tag::tag_type>{value} {}
+
+	public:
+		local_of() = default;
+		using tag_type = Tag;
+
+		// Constructor from tagged `runtime_handle` flavors
+		explicit local_of(local_type value)
+			requires(type<local_type> != type<runtime_handle>) :
+				local_of{napi_value{value}} {}
+
+		// "Downcast" to a more specific tag. Potentially unsafe.
+		template <std::convertible_to<Tag> To>
+		auto cast(To /*tag*/) const -> local_of<To> { return local_of<To>::from(*this); }
+
+		// Construct from any `napi_value`. Potentially unsafe.
+		static auto from(napi_value value_) -> local_of<Tag> { return std::bit_cast<local_of<Tag>>(value_); }
+
+		// Forward `make` to specialization
+		static auto make(auto&&... args) -> local_of<Tag> { return local_type::make(std::forward<decltype(args)>(args)...); }
+
+		// Dereference operators
+		auto operator*() const -> local_type { return std::bit_cast<local_type>(napi_value{*this}); }
+		auto operator->() const -> auto { return util::pointer_delegate{**this}; }
+};
+
+// Sentinel instantiation
+template <>
+class local_of<void> : public runtime_handle {
+	public:
+		using runtime_handle::runtime_handle;
+};
+
+// Deduction guide
+template <class Type>
+local_of(Type value) -> local_of<typename Type::tag_type>;
+
+// Details applied to each level of the `local_of<T>` hierarchy.
+template <class Tag>
+struct local_next : local_specialization<typename Tag::tag_type>::type {
+		using local_specialization<typename Tag::tag_type>::type::type;
+		using tag_type = Tag;
+};
+
+// `local_of<Tag>` implementation specializations. The default specialization selects the nearest
+// specialization, or simply `runtime_handle` as the base class.
+template <class Type> class local_for_class_of;
+template <class Type> class local_for_typed_array_of;
+
+template <class Tag>
+struct local_specialization
+		: local_specialization<typename Tag::tag_type> {};
+
+template <>
+struct local_specialization<void>
+		: std::type_identity<runtime_handle> {};
+
+template <>
+struct local_specialization<object_tag>
+		: std::type_identity<class local_for_object> {};
+
+template <>
+struct local_specialization<function_tag>
+		: std::type_identity<class local_for_function> {};
+
+template <>
+struct local_specialization<typed_array_tag>
+		: std::type_identity<class local_for_typed_array> {};
+
+template <class Type>
+struct local_specialization<typed_array_tag_of<Type>>
+		: std::type_identity<class local_for_typed_array_of<Type>> {};
+
+template <>
+struct local_specialization<data_view_tag>
+		: std::type_identity<class local_for_data_view> {};
+
+template <class Type>
+struct local_specialization<class_tag_of<Type>>
+		: std::type_identity<class local_for_class_of<Type>> {};
+
+template <>
+struct local_specialization<external_tag>
+		: std::type_identity<class local_for_external> {};
+
+} // namespace js::napi
+
+// Specialize for `js::forward`. Makes `js::forward{local_of<Tag>}` infer
+// `js::forward<Tag, ...>`.
+namespace js {
+template <class Tag>
+struct forward_tag_for<napi::local_of<Tag>> : std::type_identity<Tag> {};
+} // namespace js

package/handle/reference.cc

@@ -1,6 +1,6 @@
 export module napi_js:reference;
 import :api;
-import :value_handle;
+import :handle.local_of;
 import std;
 import util;
 
@@ -72,7 +72,7 @@ class reference_handle : util::non_copyable {
 export template <class Tag>
 class reference : public reference<typename Tag::tag_type> {
 	public:
-		using value_type = value_of<Tag>;
+		using value_type = local_of<Tag>;
 		using reference<typename Tag::tag_type>::reference;
 
 		reference() = default;
@@ -86,7 +86,7 @@ class reference : public reference<typename Tag::tag_type> {
 };
 
 template <class Tag>
-reference(auto, value_of<Tag>) -> reference<Tag>;
+reference(auto, local_of<Tag>) -> reference<Tag>;
 
 // nb: Protected inheritance so that `remote<T> is not comparable to `reference<T>`.
 template <>

package/handle/remote.cc

@@ -24,14 +24,14 @@ class remote : protected reference_handle {
 		using unique_remote = std::unique_ptr<remote, util::function_constant<expire>>;
 
 		remote() = default;
-		remote(private_constructor /*private*/, const environment& env, value_of<Tag> value, napi_scheduler scheduler) :
+		remote(private_constructor /*private*/, const environment& env, local_of<Tag> value, napi_scheduler scheduler) :
 				reference_handle{napi_env{env}, napi_value{value}},
 				scheduler_{std::move(scheduler)} {}
 
-		auto deref(const environment& env) const -> value_of<Tag>;
+		auto deref(const environment& env) const -> local_of<Tag>;
 
-		static auto make_shared(remote_handle_environment auto& env, value_of<Tag> value) -> std::shared_ptr<remote>;
-		static auto make_unique(remote_handle_environment auto& env, value_of<Tag> value) -> unique_remote;
+		static auto make_shared(remote_handle_environment auto& env, local_of<Tag> value) -> std::shared_ptr<remote>;
+		static auto make_unique(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote;
 
 	private:
 		napi_scheduler scheduler_;
@@ -45,12 +45,12 @@ export template <class Type>
 using unique_remote = remote<Type>::unique_remote;
 
 export template <class Tag>
-auto make_shared_remote(remote_handle_environment auto& env, value_of<Tag> value) -> shared_remote<Tag> {
+auto make_shared_remote(remote_handle_environment auto& env, local_of<Tag> value) -> shared_remote<Tag> {
 	return remote<Tag>::make_shared(env, value);
 }
 
 export template <class Tag>
-auto make_unique_remote(remote_handle_environment auto& env, value_of<Tag> value) -> unique_remote<Tag> {
+auto make_unique_remote(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote<Tag> {
 	return remote<Tag>::make_unique(env, value);
 }
 
@@ -68,17 +68,17 @@ auto remote<Tag>::expire(remote* ptr) -> void {
 }
 
 template <class Tag>
-auto remote<Tag>::deref(const environment& env) const -> value_of<Tag> {
-	return value_of<Tag>::from(get_value(napi_env{env}));
+auto remote<Tag>::deref(const environment& env) const -> local_of<Tag> {
+	return local_of<Tag>::from(get_value(napi_env{env}));
 }
 
 template <class Tag>
-auto remote<Tag>::make_shared(remote_handle_environment auto& env, value_of<Tag> value) -> std::shared_ptr<remote> {
+auto remote<Tag>::make_shared(remote_handle_environment auto& env, local_of<Tag> value) -> std::shared_ptr<remote> {
 	return std::shared_ptr<remote>{new remote{private_constructor{}, env, value, env.scheduler()}, expire};
 }
 
 template <class Tag>
-auto remote<Tag>::make_unique(remote_handle_environment auto& env, value_of<Tag> value) -> unique_remote {
+auto remote<Tag>::make_unique(remote_handle_environment auto& env, local_of<Tag> value) -> unique_remote {
 	return unique_remote{new remote{private_constructor{}, env, value, env.scheduler()}};
 }
 

package/handle/types.cc

@@ -4,14 +4,13 @@ import nodejs;
 
 namespace js::napi {
 
-// `value_handle` is the base class of `value_of<T>`, and `bound_value<T>`.
-class value_handle {
+// `runtime_handle` is the base class of `local_of<T>` and `value_of<T>` member types.
+class runtime_handle {
 	protected:
-		explicit value_handle(napi_value value) :
-				value_{value} {}
-
 	public:
-		value_handle() = default;
+		explicit runtime_handle(int, napi_value value) : value_{value} {}
+		explicit runtime_handle(napi_value value) : value_{value} {}
+		runtime_handle() = default;
 
 		// Implicit cast back to a `napi_value`
 		// NOLINTNEXTLINE(google-explicit-constructor)
@@ -24,143 +23,11 @@ class value_handle {
 		napi_value value_{};
 };
 
-// `value_of` forward declarations
+// Forward declarations for handle types which declare template deduction guides on each other.
 export template <class Tag = value_tag>
-class value_of;
-
-template <class Tag>
-class value_next;
-
-template <class Type>
-class value_for_class_of;
-
-template <class Type>
-class value_for_typed_array_of;
-
-// `bound_value` forward declarations
-template <class Tag>
-class bound_value;
-
-template <class Tag>
-class bound_value_next;
-
-template <class Type>
-class bound_value_for_typed_array_of;
-
-// Map of `value_of<Tag>` / `bound_value<Tag>` to concrete implementation classes.
-template <class Tag>
-struct value_defaults {
-		using value_type = value_next<Tag>;
-		using bound_type = bound_value_next<Tag>;
-};
-
-template <class Tag>
-struct value_specialization : value_defaults<Tag> {};
-
-// Typed specializations
-template <>
-struct value_specialization<boolean_tag> : value_defaults<boolean_tag> {
-		using bound_type = class bound_value_for_boolean;
-};
-
-template <>
-struct value_specialization<false_tag> : value_defaults<false_tag> {
-		using bound_type = class bound_value_for_false;
-};
-
-template <>
-struct value_specialization<true_tag> : value_defaults<true_tag> {
-		using bound_type = class bound_value_for_true;
-};
-
-template <>
-struct value_specialization<number_tag> : value_defaults<number_tag> {
-		using bound_type = class bound_value_for_number;
-};
-
-template <>
-struct value_specialization<bigint_tag> : value_defaults<bigint_tag> {
-		using bound_type = class bound_value_for_bigint;
-};
-
-template <>
-struct value_specialization<string_tag> : value_defaults<string_tag> {
-		using bound_type = class bound_value_for_string;
-};
-
-template <>
-struct value_specialization<date_tag> : value_defaults<date_tag> {
-		using bound_type = class bound_value_for_date;
-};
-
-template <>
-struct value_specialization<object_tag> {
-		using value_type = class value_for_object;
-		using bound_type = class bound_value_for_object;
-};
-
-template <>
-struct value_specialization<record_tag> : value_defaults<record_tag> {
-		using bound_type = class bound_value_for_record;
-};
-
-template <>
-struct value_specialization<function_tag> : value_defaults<function_tag> {
-		using value_type = class value_for_function;
-};
-
-template <>
-struct value_specialization<data_block_tag> : value_defaults<data_block_tag> {
-		using bound_type = class bound_value_for_data_block;
-};
-
-template <>
-struct value_specialization<array_buffer_tag> : value_defaults<array_buffer_tag> {
-		using bound_type = class bound_value_for_array_buffer;
-};
-
-template <>
-struct value_specialization<shared_array_buffer_tag> : value_defaults<shared_array_buffer_tag> {
-		using bound_type = class bound_value_for_shared_array_buffer;
-};
-
-template <>
-struct value_specialization<array_buffer_view_tag> : value_defaults<array_buffer_view_tag> {
-		using bound_type = class bound_value_for_array_buffer_view;
-};
+class local_of;
 
-template <>
-struct value_specialization<typed_array_tag> {
-		using value_type = class value_for_typed_array;
-		using bound_type = class bound_value_for_typed_array;
-};
-
-template <class Type>
-struct value_specialization<typed_array_tag_of<Type>> {
-		using value_type = value_for_typed_array_of<Type>;
-		using bound_type = bound_value_for_typed_array_of<Type>;
-};
-
-template <>
-struct value_specialization<data_view_tag> {
-		using value_type = class value_for_data_view;
-		using bound_type = class bound_value_for_data_view;
-};
-
-template <class Type>
-struct value_specialization<class_tag_of<Type>> : value_defaults<class_tag_of<Type>> {
-		using value_type = value_for_class_of<Type>;
-};
-
-template <>
-struct value_specialization<external_tag> {
-		using value_type = class value_for_external;
-		using bound_type = class bound_value_for_external;
-};
-
-template <>
-struct value_specialization<vector_tag> : value_defaults<vector_tag> {
-		using bound_type = class bound_value_for_vector;
-};
+export template <class Tag = value_tag>
+class value_of;
 
 } // namespace js::napi

package/handle/value.cc

@@ -1,55 +1,147 @@
-export module napi_js:value_handle;
+export module napi_js:handle.value_of;
 import :handle.types;
-import auto_js;
 import nodejs;
 import std;
 
 namespace js::napi {
 
-// Heirarchy:
-// value_of<object_tag> ->
+// Map of `value_of<Tag>` to concrete implementation classes.
+template <class Tag>
+struct value_specialization;
+
+// Heirarchy (for example):
+// value_of<record_tag>
+// value_for_record ->
+// value_next<record_tag> ->
 // value_for_object ->
 // value_next<object_tag> ->
-// value_of<value_tag> -> ...
+// value_next<value_tag> ->
+// value_next<datum_tag> ->
+// value_of<void>
 
 // Details applied to each level of the `value_of<T>` hierarchy.
 template <class Tag>
 class value_next : public value_of<typename Tag::tag_type> {
 	public:
-		using value_of<typename Tag::tag_type>::value_of;
+		using tag_type = Tag;
+		value_next() = default;
+		value_next(auto&& env, local_of<Tag> value, auto&&... rest) :
+				value_of<typename Tag::tag_type>{std::forward<decltype(env)>(env), value, std::forward<decltype(rest)>(rest)...} {}
 
-		// "Downcast" to a more specific tag. Potentially unsafe.
-		template <std::convertible_to<Tag> To>
-		auto cast(To /*tag*/) const -> value_of<To> { return value_of<To>::from(*this); }
-
-		// Construct from any `napi_value`. Potentially unsafe.
-		static auto from(napi_value value_) -> value_of<Tag> { return std::bit_cast<value_of<Tag>>(value_); }
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		operator local_of<Tag>() const { return local_of<Tag>::from(napi_value{*this}); }
 };
 
-// Deduction guide for `value_of{bound_value}`
-template <class Type>
-	requires requires { typename Type::tag_type; }
-value_of(Type value) -> value_of<typename Type::tag_type>;
-
-// Tagged napi_value
-export template <class Tag>
-class value_of : public value_specialization<Tag>::value_type {
+// Member & method implementation for value semantics objects. It holds the type-erased environment
+// and is used for common operations like casting & iteration.
+template <class Tag>
+class value_of : public value_specialization<Tag>::type {
 	public:
-		using value_specialization<Tag>::value_type::value_type;
+		using value_type = value_specialization<Tag>::type;
+		using value_type::value_type;
 };
 
 // Sentinel instantiation
 template <>
-class value_of<void> : public value_handle {
-	public:
-		using value_handle::value_handle;
+class value_of<void> : public runtime_handle {
+	protected:
+		value_of() = default;
+		value_of(napi_env env, napi_value value) :
+				runtime_handle{value},
+				env_{env} {}
+
+		[[nodiscard]] auto env() const -> napi_env { return env_; }
+
+	private:
+		napi_env env_{};
 };
 
-} // namespace js::napi
+// Deduction guide
+template <class Tag>
+value_of(auto, local_of<Tag>) -> value_of<Tag>;
+
+// `value_of<Tag>` specializations. The default specialization selects `value_next` for the
+// immediate parent tag, instantiating it for each tag unconditionally.
+template <class Type> class value_for_typed_array_of;
 
-// Specialize for `js::forward`. Makes `js::forward{value_of<Tag>}` infer
-// `js::forward<Tag, ...>`.
-namespace js {
 template <class Tag>
-struct forward_tag_for<napi::value_of<Tag>> : std::type_identity<Tag> {};
-} // namespace js
+struct value_specialization
+		: std::type_identity<value_next<Tag>> {};
+
+template <>
+struct value_specialization<void>
+		: std::type_identity<value_of<void>> {};
+
+template <>
+struct value_specialization<boolean_tag>
+		: std::type_identity<class value_for_boolean> {};
+
+template <>
+struct value_specialization<false_tag>
+		: std::type_identity<class value_for_false> {};
+
+template <>
+struct value_specialization<true_tag>
+		: std::type_identity<class value_for_true> {};
+
+template <>
+struct value_specialization<number_tag>
+		: std::type_identity<class value_for_number> {};
+
+template <>
+struct value_specialization<bigint_tag>
+		: std::type_identity<class value_for_bigint> {};
+
+template <>
+struct value_specialization<string_tag>
+		: std::type_identity<class value_for_string> {};
+
+template <>
+struct value_specialization<object_tag>
+		: std::type_identity<class value_for_object> {};
+
+template <>
+struct value_specialization<date_tag>
+		: std::type_identity<class value_for_date> {};
+
+template <>
+struct value_specialization<record_tag>
+		: std::type_identity<class value_for_record> {};
+
+template <>
+struct value_specialization<data_block_tag>
+		: std::type_identity<class value_for_data_block> {};
+
+template <>
+struct value_specialization<array_buffer_tag>
+		: std::type_identity<class value_for_array_buffer> {};
+
+template <>
+struct value_specialization<shared_array_buffer_tag>
+		: std::type_identity<class value_for_shared_array_buffer> {};
+
+template <>
+struct value_specialization<array_buffer_view_tag>
+		: std::type_identity<class value_for_array_buffer_view> {};
+
+template <>
+struct value_specialization<typed_array_tag>
+		: std::type_identity<class value_for_typed_array> {};
+
+template <class Type>
+struct value_specialization<typed_array_tag_of<Type>>
+		: std::type_identity<value_for_typed_array_of<Type>> {};
+
+template <>
+struct value_specialization<data_view_tag>
+		: std::type_identity<class value_for_data_view> {};
+
+template <>
+struct value_specialization<external_tag>
+		: std::type_identity<class value_for_external> {};
+
+template <>
+struct value_specialization<vector_tag>
+		: std::type_identity<class value_for_vector> {};
+
+} // namespace js::napi