@auto_js/napi 0.0.9 → 0.0.11

package/_module.cc

@@ -7,14 +7,15 @@ 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 :handle.local_of;
-export import :handle.types;
-export import :handle.value_of;
 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)...);

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

@@ -13,7 +13,7 @@ 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>
+export template <class Tag>
 class local_of : public local_of<typename Tag::tag_type> {
 	protected:
 		using local_type = local_specialization<Tag>::type;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@auto_js/napi",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "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/v8_exports": "^0.0.7",
-    "@auto_js/js": "^0.0.9",
-    "@auto_js/napi_exports": "^0.0.9"
+    "@auto_js/js": "^0.0.11",
+    "@auto_js/napi_exports": "^0.0.10",
+    "@auto_js/v8_exports": "^0.0.8"
   },
   "repository": {
     "type": "git",

package/support/callback.cc

@@ -40,8 +40,8 @@ constexpr auto make_free_function(auto function) {
 		using callback_type = decltype(callback);
 		return util::bind{
 			[](callback_type& callback, Environment& env, const callback_info& info) noexcept(Nx) -> napi_value {
-				return invoke_internal_error_scope(env, [ & ]() -> napi_value {
-					auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				return invoke_internal_error_scope(env, [ & ] -> napi_value {
+					auto run = util::regular_return{[ & ] -> decltype(auto) {
 						return std::apply(
 							callback,
 							std::tuple_cat(
@@ -65,7 +65,7 @@ constexpr auto make_free_function(auto function) {
 		using callback_type = decltype(callback);
 		return util::bind{
 			[](callback_type& callback, Environment& env, const callback_info& /*info*/) noexcept -> napi_value {
-				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				auto run = util::regular_return{[ & ] -> decltype(auto) {
 					return callback(env);
 				}};
 				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);
@@ -112,7 +112,7 @@ constexpr auto make_constructor_function(auto constructor) {
 				using callback_type = decltype(callback);
 				return util::bind{
 					[](callback_type& callback, wrap_type& wrap, Environment& env, const callback_info& info) noexcept(Nx) -> napi_value {
-						return invoke_internal_error_scope(env, [ & ]() -> napi_value {
+						return invoke_internal_error_scope(env, [ & ] -> napi_value {
 							auto instance = std::apply(
 								callback,
 								std::tuple_cat(
@@ -159,7 +159,7 @@ constexpr auto make_constructor_function(auto constructor) {
 		[](runtime_constructor_type& constructor, Environment& env, const callback_info& info) -> napi_value {
 			auto arguments = info.arguments();
 			if (!arguments.empty()) {
-				auto maybe_constructor = [ & ]() -> std::optional<internal_constructor*> {
+				auto maybe_constructor = [ & ] -> std::optional<internal_constructor*> {
 					try {
 						// Check truthiness since null or undefined causes `napi_coerce_to_object` to throw
 						auto* arg0 = util::at(arguments, 0);
@@ -181,7 +181,7 @@ constexpr auto make_constructor_function(auto constructor) {
 				}
 				if (*maybe_constructor != nullptr) {
 					const auto& constructor = **maybe_constructor;
-					return invoke_internal_error_scope(env, [ & ]() -> napi_value {
+					return invoke_internal_error_scope(env, [ & ] -> napi_value {
 						return constructor(info.this_arg());
 					});
 				}
@@ -208,8 +208,8 @@ constexpr auto make_member_function(Method method) {
 				if (!maybe_that) {
 					return nullptr;
 				}
-				return invoke_internal_error_scope(env, [ & ]() -> napi_value {
-					auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				return invoke_internal_error_scope(env, [ & ] -> napi_value {
+					auto run = util::regular_return{[ & ] -> decltype(auto) {
 						return std::apply(
 							callback,
 							std::tuple_cat(
@@ -237,7 +237,7 @@ constexpr auto make_member_function(Method method) {
 				if (!maybe_that) {
 					return nullptr;
 				}
-				auto run = util::regular_return{[ & ]() -> decltype(auto) {
+				auto run = util::regular_return{[ & ] -> decltype(auto) {
 					return callback(**maybe_that, env);
 				}};
 				return js::transfer_in_strict<napi_value>(run().value_or(std::monostate{}), env);

package/support/class_template_storage.cc

@@ -10,7 +10,7 @@ namespace js::napi {
 // Given a pack of strings it returns a static reference to a `util::sealed_map` of napi object
 // references.
 template <const auto& Strings>
-constexpr auto class_template_references_of = []() -> auto {
+constexpr auto class_template_references_of = [] consteval -> auto {
 	const auto [... strings ] = Strings;
 	return util::sealed_map{std::type_identity<napi::reference<class_tag>>{}, strings...};
 }();

package/support/host.cc

@@ -123,7 +123,7 @@ constexpr auto unknown_maybe_is = [](auto...) -> std::optional<bool> { return st
 
 // 'SharedArrayBuffer' functions
 auto v8_make_shared_array_buffer(js::shared_array_buffer::shared_pointer_type data, std::size_t byte_length) -> local_of<shared_array_buffer_tag> {
-	auto backing_store = [ & ]() -> auto {
+	auto backing_store = [ & ] -> auto {
 		// v8 does not call the deleter `byte_length` is zero. So the heap-allocated shared_ptr trick
 		// does not work in that case.
 		if (byte_length == 0) {
@@ -233,7 +233,7 @@ auto initialize_host_environment(napi_env env) -> void {
 			}
 
 			// Get `globalThis.process`
-			auto* process_global = [ & ]() -> napi_value {
+			auto* process_global = [ & ] -> napi_value {
 				auto* global = napi::invoke(napi_get_global, env);
 				constexpr auto process_cw = util::make_consteval_string_view(util::cw<"process">);
 				auto* process_str = napi::invoke(node_api_create_property_key_latin1, env, process_cw.data(), process_cw.length());
@@ -246,7 +246,7 @@ auto initialize_host_environment(napi_env env) -> void {
 			}();
 
 			// Detect bun via `process.isBun`
-			auto is_bun = process_global == nullptr ? false : [ & ]() -> bool {
+			auto is_bun = process_global == nullptr ? false : [ & ] -> bool {
 				constexpr auto is_bun_cw = util::make_consteval_string_view(util::cw<"isBun">);
 				auto* is_bun_str = napi::invoke(node_api_create_property_key_latin1, env, is_bun_cw.data(), is_bun_cw.length());
 				auto* is_bun = napi::invoke(napi_get_property, env, process_global, is_bun_str);
@@ -255,7 +255,7 @@ auto initialize_host_environment(napi_env env) -> void {
 			}();
 
 			// Detect deno via `process.versions.deno`
-			auto is_deno = process_global == nullptr ? false : [ & ]() -> bool {
+			auto is_deno = process_global == nullptr ? false : [ & ] -> bool {
 				constexpr auto versions_cw = util::make_consteval_string_view(util::cw<"versions">);
 				auto* versions_str = napi::invoke(node_api_create_property_key_latin1, env, versions_cw.data(), versions_cw.length());
 				auto* versions = napi::invoke(napi_get_property, env, process_global, versions_str);

package/support/initialize.h.cc

@@ -31,7 +31,7 @@ class napi_js_module final : private detail::initialize_require {
 	private:
 		auto operator()(napi_env env, napi_value exports) -> void override {
 			// construct environment, set napi instance data w/ finalizer
-			const auto [... indices ] = util::sequence<sizeof...(Args)>;
+			constexpr 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 = local_of<dictionary_tag>::from(exports);

package/support/string_table.cc

@@ -10,7 +10,7 @@ namespace js::napi {
 // Given a pack of strings it returns a static reference to a `util::sealed_map` of napi string
 // references.
 template <const auto& Strings>
-constexpr auto string_table_of = []() -> auto {
+constexpr auto string_table_of = [] consteval -> auto {
 	const auto [... strings ] = Strings;
 	return util::sealed_map{std::type_identity<napi::reference<string_tag>>{}, strings...};
 }();

package/transfer/accept.h.cc

@@ -51,6 +51,12 @@ struct accept_basic_napi_value {
 			return (*this)(number_tag_of<double>{}, visit, double{std::forward<decltype(subject)>(subject)});
 		}
 
+		template <class Type>
+		auto operator()(number_tag_of<Type> tag, visit_holder visit, Type subject) const -> local_of<number_tag_of<Type>> {
+			auto value = (*this)(tag, visit, std::int32_t{std::forward<decltype(subject)>(subject)});
+			return local_of<number_tag_of<Type>>::from(value);
+		}
+
 		template <class Type>
 		auto operator()(number_tag_of<Type> tag, visit_holder visit, auto&& subject) const -> local_of<number_tag_of<Type>> {
 			return (*this)(tag, visit, Type{std::forward<decltype(subject)>(subject)});
@@ -190,8 +196,8 @@ struct accept_napi_value : accept_basic_napi_value {
 				local_of<vector_tag>::from(napi::invoke(napi_create_array_with_length, napi_env{self}, Size)),
 				std::forward_as_tuple(self, visit, std::forward<decltype(subject)>(subject)),
 				[](local_of<vector_tag> array, auto& self, auto& visit, auto /*&&*/ tuple) -> void {
-					const auto [... indices ] = util::sequence<Size>;
-					(..., [ & ]() -> void {
+					constexpr auto [... indices ] = util::sequence<Size>;
+					(..., [ & ] -> void {
 						// nb: This is forwarded to *each* visitor. The visitor should be aware and only lvalue
 						// reference members one at a time.
 						auto* element = napi_value{visit(indices, std::forward<decltype(tuple)>(tuple), self)};
@@ -267,8 +273,8 @@ struct accept_napi_value : accept_basic_napi_value {
 		auto accept_entry_pair_struct(this const auto& self, auto& visit, local_of<object_tag> target, auto&& subject) -> void {
 			// NOLINTNEXTLINE(cppcoreguidelines-pro-type-member-init)
 			std::array<napi_property_descriptor, Size> properties;
-			const auto [... indices ] = util::sequence<Size>;
-			(..., [ & ]() -> void {
+			constexpr auto [... indices ] = util::sequence<Size>;
+			(..., [ & ] -> void {
 				// nb: This is forwarded to *each* visitor. The visitor should be aware and only lvalue
 				// reference members one at a time.
 				auto accept_entry = accept_entry_pair<decltype(self), decltype(self)>{self};

package/transfer/visit.cc

@@ -22,7 +22,7 @@ struct visit_property_name {
 
 		template <class Accept>
 		auto operator()(napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
-			return visit_.get().lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return visit_.get().lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				auto accept_as = [ & ]<class Tag>(Tag tag) -> auto {
 					auto value = value_of{napi_env{visit_.get()}, local_of<Tag>::from(subject)};
 					return accept(tag, *this, value);
@@ -111,7 +111,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		template <class Tag, class Accept>
 		auto operator()(local_of<Tag> subject, const Accept& accept) -> accept_target_t<Accept>
 			requires requires { immediate(subject, accept); } {
-			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				return immediate(subject, accept);
 			});
 		}
@@ -151,10 +151,10 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 		auto operator()(napi_value subject, const Accept& accept) -> accept_target_t<Accept> {
 
 			// Check the reference map, and lookup type via napi
-			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				// This is the pure-napi implementation
 				auto slow_path = util::overloaded{
-					[ & ]() -> accept_target_t<Accept> {
+					[ & ] -> accept_target_t<Accept> {
 						auto type_of = napi::invoke(napi_typeof, napi_env{*this}, subject);
 						switch (type_of) {
 							case napi_undefined:
@@ -247,7 +247,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 
 		template <class Accept>
 		auto operator()(local_of<data_block_tag> subject, const Accept& accept) -> accept_target_t<Accept> {
-			return lookup_or_visit(subject, [ & ]() -> accept_target_t<Accept> {
+			return lookup_or_visit(subject, [ & ] -> accept_target_t<Accept> {
 				return util::template_traverse(
 					accept_tags_of_v<Accept>,
 					util::overloaded{
@@ -257,7 +257,7 @@ struct visit_value : reference_map_t<Reference, reference_map_type> {
 						[ & ](shared_array_buffer_tag /*tag*/, auto next) -> accept_target_t<Accept> { return next(); },
 
 						// Slow path
-						[ & ]() -> accept_target_t<Accept> {
+						[ & ] -> accept_target_t<Accept> {
 							return immediate(subject, accept);
 						}
 					}

package/value/class.cc

@@ -27,7 +27,7 @@ auto local_for_class_of<Type>::runtime_construct(
 	std::tuple<RuntimeArgs...> runtime_args
 ) const -> local_of<object_tag>
 	requires std::constructible_from<Type, HostArgs...> {
-	const auto [... indices ] = util::sequence<sizeof...(HostArgs)>;
+	constexpr auto [... indices ] = util::sequence<sizeof...(HostArgs)>;
 	auto instance = std::make_unique<Type>(std::get<indices>(std::move(host_args))...);
 	return transfer_construct(env, std::move(instance), std::move(runtime_args));
 }