@auto_js/napi 0.0.1 → 0.0.2

package/handle/types.cc

@@ -4,7 +4,7 @@ import nodejs;
 
 namespace js::napi {
 
-// `value_handle` is the base class of `value<T>`, and `bound_value<T>`.
+// `value_handle` is the base class of `value_of<T>`, and `bound_value<T>`.
 class value_handle {
 	protected:
 		explicit value_handle(napi_value value) :
@@ -24,9 +24,9 @@ class value_handle {
 		napi_value value_{};
 };
 
-// `value` forward declarations
+// `value_of` forward declarations
 export template <class Tag = value_tag>
-class value;
+class value_of;
 
 template <class Tag>
 class value_next;
@@ -34,60 +34,52 @@ class value_next;
 template <class Type>
 class value_for_class_of;
 
+template <class Type>
+class value_for_typed_array_of;
+
 // `bound_value` forward declarations
-export template <class Tag>
+template <class Tag>
 class bound_value;
 
 template <class Tag>
 class bound_value_next;
 
-// Map of `value<Tag>` / `bound_value<Tag>` to concrete implementation classes.
+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_specialization {
+struct value_defaults {
 		using value_type = value_next<Tag>;
 		using bound_type = bound_value_next<Tag>;
 };
 
-// Typed specializations
-template <>
-struct value_specialization<undefined_tag> {
-		using value_type = class value_for_undefined;
-		using bound_type = bound_value_next<undefined_tag>;
-};
-
-template <>
-struct value_specialization<null_tag> {
-		using value_type = class value_for_null;
-		using bound_type = bound_value_next<null_tag>;
-};
+template <class Tag>
+struct value_specialization : value_defaults<Tag> {};
 
+// Typed specializations
 template <>
-struct value_specialization<boolean_tag> {
-		using value_type = class value_for_boolean;
+struct value_specialization<boolean_tag> : value_defaults<boolean_tag> {
 		using bound_type = class bound_value_for_boolean;
 };
 
 template <>
-struct value_specialization<number_tag> {
-		using value_type = class value_for_number;
+struct value_specialization<number_tag> : value_defaults<number_tag> {
 		using bound_type = class bound_value_for_number;
 };
 
 template <>
-struct value_specialization<bigint_tag> {
-		using value_type = class value_for_bigint;
+struct value_specialization<bigint_tag> : value_defaults<bigint_tag> {
 		using bound_type = class bound_value_for_bigint;
 };
 
 template <>
-struct value_specialization<string_tag> {
-		using value_type = class value_for_string;
+struct value_specialization<string_tag> : value_defaults<string_tag> {
 		using bound_type = class bound_value_for_string;
 };
 
 template <>
-struct value_specialization<date_tag> {
-		using value_type = class value_for_date;
+struct value_specialization<date_tag> : value_defaults<date_tag> {
 		using bound_type = class bound_value_for_date;
 };
 
@@ -98,39 +90,62 @@ struct value_specialization<object_tag> {
 };
 
 template <>
-struct value_specialization<function_tag> {
+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;
-		using bound_type = bound_value_next<function_tag>;
 };
 
-template <class Type>
-struct value_specialization<class_tag_of<Type>> {
-		using value_type = value_for_class_of<Type>;
-		using bound_type = bound_value_next<class_tag_of<Type>>;
+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<external_tag> {
-		using value_type = class value_for_external;
-		using bound_type = class bound_value_for_external;
+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<vector_tag> {
-		using value_type = value_next<vector_tag>;
-		using bound_type = class bound_value_for_vector;
+struct value_specialization<array_buffer_view_tag> : value_defaults<array_buffer_view_tag> {
+		using bound_type = class bound_value_for_array_buffer_view;
+};
+
+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<list_tag> {
-		using value_type = value_next<list_tag>;
-		using bound_type = class bound_value_for_list;
+struct value_specialization<external_tag> {
+		using value_type = class value_for_external;
+		using bound_type = class bound_value_for_external;
 };
 
 template <>
-struct value_specialization<dictionary_tag> {
-		using value_type = value_next<dictionary_tag>;
-		using bound_type = class bound_value_for_dictionary;
+struct value_specialization<vector_tag> : value_defaults<vector_tag> {
+		using bound_type = class bound_value_for_vector;
 };
 
 } // namespace js::napi

package/handle/value.cc

@@ -1,52 +1,50 @@
-module;
-#include <concepts>
-#include <type_traits>
 export module napi_js:value_handle;
 import :handle.types;
 import auto_js;
 import nodejs;
+import std;
 
 namespace js::napi {
 
 // Heirarchy:
-// value<object_tag> ->
+// value_of<object_tag> ->
 // value_for_object ->
 // value_next<object_tag> ->
-// value<value_tag> -> ...
+// value_of<value_tag> -> ...
 
-// Details applied to each level of the `value<T>` hierarchy.
+// Details applied to each level of the `value_of<T>` hierarchy.
 template <class Tag>
-class value_next : public value<typename Tag::tag_type> {
+class value_next : public value_of<typename Tag::tag_type> {
 	public:
-		using value<typename Tag::tag_type>::value;
+		using value_of<typename Tag::tag_type>::value_of;
 
 		// "Downcast" to a more specific tag. Potentially unsafe.
 		template <std::convertible_to<Tag> To>
-		auto cast(To /*tag*/) const -> value<To> { return value<To>::from(*this); }
+		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<Tag> { return value<Tag>{value_}; }
+		static auto from(napi_value value_) -> value_of<Tag> { return std::bit_cast<value_of<Tag>>(value_); }
 };
 
 // Tagged napi_value
 export template <class Tag>
-class value : public value_specialization<Tag>::value_type {
+class value_of : public value_specialization<Tag>::value_type {
 	public:
 		using value_specialization<Tag>::value_type::value_type;
 };
 
 // Sentinel instantiation
 template <>
-class value<void> : public value_handle {
+class value_of<void> : public value_handle {
 	public:
 		using value_handle::value_handle;
 };
 
 } // namespace js::napi
 
-// Specialize for `js::forward`. Makes `js::forward{napi::value<Tag>}` infer
+// Specialize for `js::forward`. Makes `js::forward{value_of<Tag>}` infer
 // `js::forward<Tag, ...>`.
 namespace js {
 template <class Tag>
-struct js::forward_tag_for<napi::value<Tag>> : std::type_identity<Tag> {};
+struct forward_tag_for<napi::value_of<Tag>> : std::type_identity<Tag> {};
 } // namespace js

package/package.json

@@ -1,16 +1,17 @@
 {
   "name": "@auto_js/napi",
-  "version": "0.0.1",
-  "description": "Automatic JavaScript to N-API bindings",
+  "version": "0.0.2",
   "author": "https://github.com/laverdet/",
+  "description": "Automatic JavaScript to N-API bindings",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/napi",
   "license": "ISC",
+  "dependencies": {
+    "@auto_js/js": "^0.0.2",
+    "@auto_js/v8_exports": "^0.0.2",
+    "@auto_js/napi_exports": "^0.0.2"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/laverdet/isolated-vm.git"
-  },
-  "dependencies": {
-    "@auto_js/js": "0.0.1",
-    "@auto_js/napi_exports": "0.0.1"
   }
 }

package/support/callback.cc

@@ -1,20 +1,10 @@
-module;
-#include <optional>
-#include <tuple>
-#include <type_traits>
-#include <utility>
 export module napi_js:callback;
 export import :callback_storage;
-import :api;
-import :bound_value;
-import :environment_fwd;
 import :error_scope;
-import :object;
-import :value_handle;
+import std;
 import util;
 
 namespace js::napi {
-namespace {
 
 // Unwrap `this` into the correct tagged external. Returns `std::nullopt` if there was a type error,
 // and there is a napi exception pending. `nullptr` will not be returned.
@@ -23,7 +13,7 @@ template <class Type>
 constexpr auto unwrap_member_this = [](auto_environment auto& env, napi_value this_arg) noexcept -> std::optional<tagged_external<Type>> {
 	return napi::invoke_maybe(napi_coerce_to_object, napi_env{env}, this_arg)
 		.and_then([ &env ](napi_value coerced_this_arg) -> std::optional<tagged_external<Type>> {
-			auto as_object = bound_value{env, value<object_tag>::from(coerced_this_arg)};
+			auto as_object = bound_value{env, value_of<object_tag>::from(coerced_this_arg)};
 			// Technically `try_cast` can throw but it should only be in catastrophic cases.
 			Type* unwrapped = as_object.try_cast(type<Type>);
 			if (unwrapped == nullptr) {
@@ -36,13 +26,11 @@ constexpr auto unwrap_member_this = [](auto_environment auto& env, napi_value th
 		});
 };
 
-} // namespace
-
 // Function type for internal host object construction
 using internal_constructor = util::function_ref<auto(napi_value)->napi_value>;
 
 // Make callback for plain free function
-export template <auto_environment Environment>
+template <auto_environment Environment>
 constexpr auto make_free_function(auto function) {
 	constexpr auto make_with_try_catch =
 		[]<class Env, class... Args, bool Nx, class Result>(
@@ -92,7 +80,7 @@ constexpr auto make_free_function(auto function) {
 }
 
 // Make callback for constructor invocations
-export template <auto_environment Environment, class Type>
+template <auto_environment Environment, class Type>
 constexpr auto make_constructor_function(auto constructor) {
 	// First, a lambda is created which will actually invoke the supplied constructor function.
 	constexpr auto make_invoke_runtime_constructor = util::overloaded{
@@ -128,7 +116,7 @@ constexpr auto make_constructor_function(auto constructor) {
 							auto instance = std::apply(
 								callback,
 								std::tuple_cat(
-									std::forward_as_tuple(env, value<object_tag>::from(info.this_arg())),
+									std::forward_as_tuple(env, value_of<object_tag>::from(info.this_arg())),
 									js::transfer_out<std::tuple<Args...>>(info.arguments(), env)
 								)
 							);
@@ -148,7 +136,7 @@ constexpr auto make_constructor_function(auto constructor) {
 				using callback_type = decltype(callback);
 				return util::bind{
 					[](callback_type& callback, Environment& env, const callback_info& info) noexcept -> napi_value {
-						return wrap(callback(env, value<object_tag>::from(info.this_arg())));
+						return wrap(callback(env, value_of<object_tag>::from(info.this_arg())));
 					},
 					std::move(callback),
 				};
@@ -206,7 +194,7 @@ constexpr auto make_constructor_function(auto constructor) {
 };
 
 // Make callback for method invocations
-export template <auto_environment Environment, class Type, class Method>
+template <auto_environment Environment, class Type, class Method>
 constexpr auto make_member_function(Method method) {
 	constexpr auto make_with_try_catch =
 		[]<class That, class Env, class... Args, bool Nx, class Result>(

package/support/callback_storage.cc

@@ -1,20 +1,15 @@
-module;
-#include <memory>
-#include <type_traits>
-#include <utility>
 export module napi_js:callback_storage;
 import :api;
 import :environment_fwd;
+import std;
 
 namespace js::napi {
 
-namespace {
 // Since napi runs each environment in its own thread we can store the environment data pointer
 // here. We could also go through `napi_get_instance_data` but there is no assurance that the
 // pointer type is the same. We assume the environment pointer will outlive the callback.
 template <auto_environment Environment>
-thread_local Environment* env_local = nullptr;
-} // namespace
+thread_local Environment* callback_env_local = nullptr;
 
 // Converts any invocable into a `napi_callback` and data pointer for use in napi API calls. The
 // result is a `std::tuple` with `{ callback_ptr, data_ptr, finalizer }`. Finalizer is either a
@@ -35,13 +30,13 @@ auto make_callback_storage(Environment& env, std::invocable<Environment&, const
 		} else if constexpr (sizeof(function_type) <= sizeof(void*)) {
 			// Trivial function type containing less than or equal to a pointer size. `data` is the
 			// function and environment is stored in a thread local.
-			env_local<Environment> = &env;
+			callback_env_local<Environment> = &env;
 			auto* data = reinterpret_cast<void*&>(function);
 			const auto callback = napi_callback{[](napi_env nenv, napi_callback_info info) -> napi_value {
 				const auto args = callback_info{nenv, info};
 				auto* data = args.data();
 				auto& invoke = reinterpret_cast<function_type&>(data);
-				auto& env = *env_local<Environment>;
+				auto& env = *callback_env_local<Environment>;
 				return invoke(env, args);
 			}};
 			return std::tuple{callback, data};

package/support/class_template_storage.cc

@@ -1,9 +1,7 @@
-module;
-#include <string> // IWYU pragma: keep
-#include <type_traits>
 export module napi_js:class_template_storage;
 import :reference;
 import auto_js;
+import std;
 import util;
 using namespace std::string_literals;
 
@@ -32,8 +30,8 @@ export template <const auto& Strings>
 class class_template_references {
 	public:
 		template <class Type>
-		auto class_template(this auto& self, std::type_identity<Type> /*type*/, const auto& class_template) -> napi::value<class_tag_of<Type>> {
-			constexpr auto name_sv = util::consteval_string_view{class_template.constructor.name};
+		auto class_template(this auto& self, std::type_identity<Type> /*type*/, const auto& class_template) -> value_of<class_tag_of<Type>> {
+			constexpr auto name_sv = util::make_consteval_string_view(class_template.constructor.name);
 			constexpr auto index = class_template_references_of<Strings>.lookup(name_sv);
 			if constexpr (!index) {
 				// nb: This fails while linking against STL for some reason. So the `constexpr` if works
@@ -45,7 +43,7 @@ class class_template_references {
 				static_assert(index, "Class template '"s + name_sv + "' is missing in storage"s);
 			}
 			auto& reference = self.class_template_references_.at(index).second;
-			using value_type = js::napi::value<class_tag_of<Type>>;
+			using value_type = js::napi::value_of<class_tag_of<Type>>;
 			if (reference) {
 				return value_type::from(reference.get(self));
 			} else {

package/support/container.cc

@@ -1,10 +1,7 @@
-module;
-#include <bit>
-#include <unordered_map>
 export module napi_js:container;
 import :environment;
-import :utility;
 import nodejs;
+import std;
 import util;
 
 namespace js::napi {
@@ -15,6 +12,7 @@ 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;
@@ -26,16 +24,16 @@ template <class Map>
 struct concrete_value_map final : virtual_value_map<typename Map::mapped_type> {
 	public:
 		using container_type = Map;
-		// nb: The iterator type between `std::unordered_map<int, int, left>` and
-		// `std::unordered_map<int, int, right>` are not technically compatible.
-		using iterator = virtual_value_map<typename Map::mapped_type>::iterator;
-		using mapped_type = container_type::mapped_type;
+		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));
 		}
 
@@ -58,6 +56,7 @@ class value_map {
 	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) :
@@ -68,8 +67,8 @@ class value_map {
 				} {}
 
 		auto end() const -> iterator { return map_->end(); }
-		auto find(napi_value key) const -> iterator { return map_->find(key); }
-		auto try_emplace(napi_value key, mapped_type value) -> std::pair<iterator, bool> { return map_->try_emplace(key, std::move(value)); }
+		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_;

package/support/environment.cc

@@ -1,5 +1,3 @@
-module;
-#include <stdexcept>
 module napi_js;
 import :api;
 import :utility;
@@ -7,27 +5,41 @@ import util;
 
 namespace js::napi {
 
-environment::environment(napi_env env) :
+environment::environment(napi_env env, bool uses_direct_handles) :
 		env_{env},
-		uses_direct_handles_{[ & ]() -> bool {
-			const auto direct_equal = direct_address_equal{};
-			const auto indirect_equal = indirect_address_equal{};
-			auto* array = napi::invoke(napi_create_array_with_length, env, 1);
-			napi::invoke0(napi_set_element, env, array, 0, array);
-			auto* result = napi::invoke(napi_get_element, env, array, 0);
-			if (direct_equal(array, result)) {
-				return true;
-			} else if (indirect_equal(array, result)) {
-				return false;
-			} else {
-				throw std::runtime_error{"Exotic napi handle behavior detected"};
-			}
-		}()} {
+		address_equal_{uses_direct_handles},
+		uses_direct_handles_{uses_direct_handles} {
 	scheduler().open(napi::invoke(napi_get_uv_event_loop, env));
+	// nb: `uv_async_t` is closed with an async hook, and not as the finalizer of
+	// `napi_set_instance_data`. `uv_close` is async and since nothing is keeping this shared library
+	// alive, the finalizer code can be unloaded.
+	auto finalizer = [](napi_async_cleanup_hook_handle handle, void* data) -> void {
+		auto& env = *static_cast<environment*>(data);
+		auto finalizer = util::fn<[](napi_async_cleanup_hook_handle handle) -> void {
+			napi::invoke0_noexcept(napi_remove_async_cleanup_hook, handle);
+		}>;
+		env.scheduler().close(util::function_ref{finalizer, handle});
+	};
+	napi::invoke0_noexcept(napi_add_async_cleanup_hook, env, finalizer, this, &cleanup_hook_handle_);
 }
 
-environment::~environment() {
-	scheduler().close();
-}
+environment::environment(napi_env env) :
+		environment{
+			env,
+			[ & ]() -> bool {
+				const auto direct_equal = direct_address_equal{};
+				const auto indirect_equal = indirect_address_equal{};
+				auto* array = napi::invoke(napi_create_array_with_length, env, 1);
+				napi::invoke0(napi_set_element, env, array, 0, array);
+				auto* result = napi::invoke(napi_get_element, env, array, 0);
+				if (direct_equal(array, result)) {
+					return true;
+				} else if (indirect_equal(array, result)) {
+					return false;
+				} else {
+					throw std::runtime_error{"Exotic napi handle behavior detected"};
+				}
+			}()
+		} {}
 
 } // namespace js::napi

package/support/environment.h.cc

@@ -1,36 +1,24 @@
-module;
-#include <functional>
-#include <memory>
 export module napi_js:environment;
 export import :environment_fwd;
 import :api;
+import :utility;
+import std;
 import util;
 
 namespace js::napi {
 
-// Internal holder for an environment pointer. Used as a common base class for `visit` & `accept`.
-// This could maybe become something similar to `realm_scope` if the need for it is more common.
-export template <auto_environment Type>
-class environment_scope {
-	public:
-		explicit environment_scope(Type& env) : env_{env} {}
-
-		explicit operator napi_env() const { return napi_env{env_.get()}; }
-		[[nodiscard]] auto environment() const -> Type& { return env_; }
-
-	private:
-		std::reference_wrapper<Type> env_;
-};
-
 // A reference to an environment is used as the lock witness. Generally, you should not have an
 // `environment&` unless you're in the napi thread and locked.
 export class environment : util::non_moveable, public uv_schedulable {
+	private:
+		environment(napi_env env, bool uses_direct_handles);
+
 	public:
 		explicit environment(napi_env env);
-		~environment();
 
 		// NOLINTNEXTLINE(google-explicit-constructor)
 		[[nodiscard]] operator napi_env() const { return env_; }
+		[[nodiscard]] auto address_equal() const -> const auto& { return address_equal_; }
 		[[nodiscard]] auto uses_direct_handles() const -> bool { return uses_direct_handles_; }
 
 		template <class Type>
@@ -50,6 +38,8 @@ export class environment : util::non_moveable, public uv_schedulable {
 
 	private:
 		napi_env env_;
+		napi_async_cleanup_hook_handle cleanup_hook_handle_{};
+		napi::address_equal address_equal_;
 		bool uses_direct_handles_;
 };
 

package/support/environment_fwd.cc

@@ -1,6 +1,5 @@
-module;
-#include <concepts>
 export module napi_js:environment_fwd;
+import std;
 
 namespace js::napi {
 

package/support/error_scope.cc

@@ -1,7 +1,5 @@
 export module napi_js:error_scope;
 import :accept;
-import :api;
-import :environment;
 
 namespace js::napi {
 

package/support/initialize.h.cc

@@ -1,10 +1,7 @@
-module;
-#include <cassert>
-#include <tuple>
 export module napi_js:initialize;
-import :environment;
 import :value;
 import nodejs;
+import std;
 import util;
 
 namespace js::napi {
@@ -37,7 +34,7 @@ class napi_js_module final : private detail::initialize_require {
 			const auto [... indices ] = util::sequence<sizeof...(Args)>;
 			auto& client_environment = environment::make_and_set_environment<Environment>(env, std::get<indices>(std::move(args_))...);
 			// assign export descriptor to napi-constructor namespace object
-			auto exports_local = napi::value<dictionary_tag>::from(exports);
+			auto exports_local = value_of<dictionary_tag>::from(exports);
 			exports_local.assign(client_environment, std::move(make_exports_)(client_environment));
 		}
 

package/support/promise.cc

@@ -1,18 +1,11 @@
-module;
-#include <concepts>
-#include <expected>
-#include <tuple>
-#include <utility>
 export module napi_js:promise;
-import :api;
-import :environment;
 import :value;
-import util;
+import std;
 
 namespace js::napi {
 
 // Resolver for `make_promise`
-export template <class Environment, class Dispatch>
+template <class Environment, class Dispatch>
 class resolver {
 	public:
 		resolver(Environment& env, napi_deferred deferred, Dispatch dispatch = {}) :
@@ -124,7 +117,7 @@ auto make_promise(Environment& env, auto... dispatch) {
 	auto resolve = resolver{env, deferred, std::move(dispatch)...};
 
 	// `[ promise, resolver ]`
-	return std::tuple{value<promise_tag>::from(promise), std::move(resolve)};
+	return std::tuple{value_of<promise_tag>::from(promise), std::move(resolve)};
 }
 
 } // namespace js::napi