@auto_js/napi 0.0.7 → 0.0.9

package/CMakeLists.txt

@@ -18,7 +18,6 @@ target_sources(${napi_js}
 		api/uv_dlib.cc
 		api/uv_scheduler.cc
 		support/environment.cc
-		support/host_shim.cc
 		support/host.cc
 		support/initialize.cc
 		transfer/accept.cc
@@ -39,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
@@ -69,3 +68,15 @@ target_sources(${napi_js}
 		value/record.h.cc
 		value/value.cc
 )
+
+# Enable "delay load" for win32 otherwise the dll will attempt to load node.exe from PATH as a
+# shared library and then start invoking functions from it.
+if(WIN32)
+	set(napi_js_delay_load ${napi_js}_delay_load)
+	add_library(${napi_js_delay_load} STATIC)
+	set_target_properties(${napi_js_delay_load} PROPERTIES CXX_VISIBILITY_PRESET default)
+	target_sources(${napi_js_delay_load} PUBLIC support/win32_delay_load_hook.cc)
+	target_link_libraries(${napi_js_delay_load} PUBLIC delayimp.lib)
+	target_link_libraries(${napi_js} PUBLIC ${napi_js_delay_load})
+	target_link_options(${napi_js_delay_load} PUBLIC "-Wl,/DELAYLOAD:node.exe")
+endif()

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,20 @@
 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.types;
 export import :initialize;
 export import :promise;
 export import :reference;
 export import :remote;
 export import :string_table;
 export import :utility;
-export import :value_handle;
+export import :handle.local_of;
+export import :handle.types;
+export import :handle.value_of;
 export import :value;
 export import :visit;

package/api/finalizer.cc

@@ -7,15 +7,14 @@ namespace js::napi {
 
 // Generic finalizer for basic `std::unique_ptr<T>`
 template <class Env, class Type, class Deleter>
-auto make_finalizer(std::type_identity<Env> /*type*/, std::unique_ptr<Type, Deleter>* unique) {
+auto make_finalizer(std::type_identity<Env> /*type*/, std::unique_ptr<Type, Deleter> unique) {
 	if constexpr (std::is_empty_v<Deleter>) {
 		// Finalizer uses a default-constructed deleter
 		auto finalize = [](Env /*env*/, void* data, void* /*hint*/) -> void {
 			Deleter deleter{};
 			deleter(static_cast<Type*>(data));
 		};
-		auto release = [ unique ] { unique->release(); };
-		return std::tuple{finalize, nullptr, release};
+		return std::tuple{finalize, nullptr, std::move(unique)};
 	} else {
 		static_assert(std::is_trivially_destructible_v<Deleter>);
 		static_assert(sizeof(Deleter) == sizeof(void*));
@@ -23,28 +22,26 @@ auto make_finalizer(std::type_identity<Env> /*type*/, std::unique_ptr<Type, Dele
 		auto finalize = [](Env /*env*/, void* data, void* hint) -> void {
 			std::bit_cast<Deleter>(hint)(static_cast<Type*>(data));
 		};
-		auto release = [ unique ] { unique->release(); };
-		return std::tuple{finalize, std::bit_cast<void*>(unique->get_deleter()), release};
+		return std::tuple{finalize, std::bit_cast<void*>(unique.get_deleter()), std::move(unique)};
 	}
 }
 
 // Generic finalizer for `std::shared_ptr<T>`
 template <class Env, class Type>
-auto make_finalizer(std::type_identity<Env> /*type*/, std::shared_ptr<Type>* shared) {
+auto make_finalizer(std::type_identity<Env> /*type*/, std::shared_ptr<Type> shared) {
 	// `shared_ptr<T>*` is passed as the finalizer hint
 	using shared_ptr_type = std::shared_ptr<Type>;
-	auto* ptr = shared->get();
-	auto ptr_ptr = std::make_unique<shared_ptr_type>(std::move(*shared));
+	auto* ptr = shared.get();
+	auto ptr_ptr = std::make_unique<shared_ptr_type>(std::move(shared));
 	auto finalize = [](Env /*env*/, void* /*data*/, void* hint) -> void {
 		delete static_cast<shared_ptr_type*>(hint);
 	};
-	auto release = [ ptr_ptr = std::move(ptr_ptr) ] mutable { ptr_ptr.release(); };
-	return std::tuple{finalize, ptr_ptr.get(), std::move(release)};
+	return std::tuple{finalize, ptr_ptr.get(), std::move(ptr_ptr)};
 }
 
 // Apply a finalizer to the given smart pointer type
 template <class Pointer, class Apply>
-auto apply_finalizer(Pointer unique, Apply apply) -> decltype(auto) {
+auto apply_finalizer(Pointer smart_ptr, Apply apply) -> decltype(auto) {
 	using element_type = Pointer::element_type;
 	constexpr auto napi_env_type = []() consteval -> auto {
 		if constexpr (std::invocable<Apply, element_type*, node_api_basic_finalize, void*>) {
@@ -54,11 +51,12 @@ auto apply_finalizer(Pointer unique, Apply apply) -> decltype(auto) {
 			return type<napi_env>;
 		}
 	}();
-	auto [ finalize, hint, release ] = make_finalizer(napi_env_type, &unique);
+	auto* pointer = smart_ptr.get();
+	auto [ finalize, hint, releasable ] = make_finalizer(napi_env_type, std::move(smart_ptr));
 	auto result = util::regular_return{[ & ] -> decltype(auto) {
-		return apply(unique.get(), finalize, hint);
+		return apply(pointer, finalize, hint);
 	}}();
-	release();
+	releasable.release();
 	return *std::move(result);
 }
 

package/api/napi_scheduler.cc

@@ -10,11 +10,11 @@ napi_scheduler::napi_scheduler(napi_env env) :
 	fn_.unref(env);
 }
 
-napi_scheduler::operator bool() const {
+napi_scheduler::operator bool() const noexcept {
 	return bool{fn_};
 }
 
-auto napi_scheduler::close(threadsafe_function_type::close_callback close) -> void {
+auto napi_scheduler::close(threadsafe_function_type::close_callback close) noexcept -> void {
 	fn_.close(close);
 }
 
@@ -32,7 +32,7 @@ auto napi_scheduler::increment_ref(node_api_basic_env env) const -> void {
 	}
 }
 
-auto napi_scheduler::storage::operator()(napi_env env, napi_value value, task_type& task) -> void {
+auto napi_scheduler::storage::operator()(napi_env env, napi_value value, task_type& task) noexcept -> void {
 	task(env, value);
 }
 

package/api/napi_scheduler.h.cc

@@ -10,21 +10,22 @@ namespace js::napi {
 export class napi_scheduler {
 	private:
 		struct storage;
-		using task_type = util::move_only_function<auto(napi_env, napi_value)->void>;
+		using task_type = util::move_only_function<auto(napi_env, napi_value) noexcept -> void>;
 		using threadsafe_function_type = threadsafe_function_of<storage, task_type>;
 
 	public:
+		napi_scheduler() = default;
 		explicit napi_scheduler(napi_env env);
-		auto operator()(auto task, auto&&... args) const -> bool;
-		explicit operator bool() const;
-		auto close(threadsafe_function_type::close_callback close) -> void;
+		auto operator()(auto task, auto&&... args) const noexcept -> bool;
+		explicit operator bool() const noexcept;
+		auto close(threadsafe_function_type::close_callback close) noexcept -> void;
 		auto decrement_ref(node_api_basic_env env) const -> void;
 		auto increment_ref(node_api_basic_env env) const -> void;
 
 	private:
 		struct storage {
 				storage() = default;
-				auto operator()(napi_env env, napi_value value, task_type& task) -> void;
+				auto operator()(napi_env env, napi_value value, task_type& task) noexcept -> void;
 				int refs{};
 		};
 
@@ -43,7 +44,7 @@ export class napi_schedulable {
 
 // ---
 
-auto napi_scheduler::operator()(auto task, auto&&... args) const -> bool {
+auto napi_scheduler::operator()(auto task, auto&&... args) const noexcept -> bool {
 	return fn_(
 		[ task = std::move(task),
 			... args = std::forward<decltype(args)>(args) ](

package/api/threadsafe_function.cc

@@ -13,6 +13,7 @@ class threadsafe_function_of : util::non_copyable {
 	public:
 		using close_callback = util::function_ref<auto()->void>;
 
+		threadsafe_function_of() = default;
 		explicit threadsafe_function_of(auto& env, napi_value value, auto&&... args);
 		threadsafe_function_of(const threadsafe_function_of&);
 		threadsafe_function_of(threadsafe_function_of&&) noexcept;
@@ -20,12 +21,12 @@ class threadsafe_function_of : util::non_copyable {
 		auto operator=(const threadsafe_function_of&) -> threadsafe_function_of& = delete;
 		auto operator=(threadsafe_function_of&&) -> threadsafe_function_of& = delete;
 
-		auto close(close_callback callback) -> void;
+		auto close(close_callback callback) noexcept -> void;
 		auto ref(node_api_basic_env env) const -> void;
 		auto unref(node_api_basic_env env) const -> void;
-		auto operator()(Message message) const -> bool;
-		auto operator*() const -> Context& { return get(); }
-		explicit operator bool() const { return tsfn_ != nullptr; }
+		auto operator()(Message message) const noexcept -> bool;
+		auto operator*() const noexcept -> Context& { return get(); }
+		explicit operator bool() const noexcept { return tsfn_ != nullptr; }
 
 	private:
 		struct storage : Context {
@@ -36,11 +37,11 @@ class threadsafe_function_of : util::non_copyable {
 			private:
 				close_callback close_hook_{[] -> void {}};
 		};
-		auto get() const -> storage&;
+		auto get() const noexcept -> storage&;
 
 		constexpr static auto trivial_message =
 			std::is_trivially_destructible_v<Message> && sizeof(Message) <= sizeof(void*);
-		mutable napi_threadsafe_function tsfn_;
+		mutable napi_threadsafe_function tsfn_{};
 };
 
 // ---
@@ -56,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)};
@@ -98,7 +97,7 @@ threadsafe_function_of<Context, Message>::~threadsafe_function_of() {
 }
 
 template <class Context, class Message>
-auto threadsafe_function_of<Context, Message>::close(close_callback callback) -> void {
+auto threadsafe_function_of<Context, Message>::close(close_callback callback) noexcept -> void {
 	get().close_hook_ = callback;
 	napi::invoke0_noexcept(napi_release_threadsafe_function, std::exchange(tsfn_, nullptr), napi_tsfn_abort);
 }
@@ -114,7 +113,7 @@ auto threadsafe_function_of<Context, Message>::unref(node_api_basic_env env) con
 }
 
 template <class Context, class Message>
-auto threadsafe_function_of<Context, Message>::operator()(Message message) const -> bool {
+auto threadsafe_function_of<Context, Message>::operator()(Message message) const noexcept -> bool {
 	auto check = [ & ](napi_status status) {
 		switch (status) {
 			case napi_ok:
@@ -133,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));
@@ -147,7 +145,7 @@ auto threadsafe_function_of<Context, Message>::operator()(Message message) const
 }
 
 template <class Context, class Message>
-auto threadsafe_function_of<Context, Message>::get() const -> storage& {
+auto threadsafe_function_of<Context, Message>::get() const noexcept -> storage& {
 	auto* context = napi::invoke_noexcept(napi_get_threadsafe_function_context, tsfn_);
 	return *reinterpret_cast<storage*>(context);
 }

package/api/uv_dlib.cc

@@ -1,13 +1,14 @@
 module napi_js;
 import :api.uv_dlib;
+import :support.host;
 import util;
 
 namespace js::napi {
 
 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 uv_dlib::uv_dlib(const std::string& filename) {
-	if (uv_dlopen(filename.c_str(), &lib_) != 0) {
-		throw js::runtime_error{util::transcode_string<char16_t>(std::string_view{uv_dlerror(&lib_)})};
+	if (host_uv_dlopen(filename.c_str(), &lib_) != 0) {
+		throw js::runtime_error{util::transcode_string<char16_t>(std::string_view{host_uv_dlerror(&lib_)})};
 	}
 }
 
@@ -20,7 +21,7 @@ auto uv_dlib::operator=(uv_dlib&& right) noexcept -> uv_dlib& {
 
 uv_dlib::~uv_dlib() {
 	if (lib_.handle != nullptr) {
-		uv_dlclose(&lib_);
+		host_uv_dlclose(&lib_);
 	}
 }
 

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 = value_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;
 
@@ -14,7 +14,7 @@ class reference_handle : util::non_copyable {
 				env_{env},
 				ref_{napi::invoke(napi_create_reference, env, value, 1)} {}
 
-		[[nodiscard]] auto env() const -> napi_env {
+		[[nodiscard]] auto env() const -> node_api_basic_env {
 			return env_;
 		}
 
@@ -64,7 +64,7 @@ class reference_handle : util::non_copyable {
 		explicit operator bool() const { return ref_ != nullptr; }
 
 	private:
-		napi_env env_{};
+		node_api_basic_env env_{};
 		napi_ref ref_{};
 };
 
@@ -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

@@ -23,14 +23,15 @@ class remote : protected reference_handle {
 	public:
 		using unique_remote = std::unique_ptr<remote, util::function_constant<expire>>;
 
-		remote(private_constructor /*private*/, const environment& env, value_of<Tag> value, napi_scheduler scheduler) :
+		remote() = default;
+		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_;
@@ -44,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);
 }
 
@@ -67,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()}};
 }