@auto_js/napi 0.0.1 → 0.0.4

package/CMakeLists.txt

@@ -1,20 +1,24 @@
 find_package_from_npm(@auto_js/js)
 find_package_from_npm(@auto_js/napi_exports)
+find_package_from_npm(@auto_js/v8_exports)
 
 add_library(napi_js OBJECT)
 target_compile_features(napi_js PUBLIC cxx_std_23)
 target_include_directories(napi_js INTERFACE include)
-target_link_libraries(napi_js PRIVATE auto_js nodejs utility_js)
+target_link_libraries(napi_js PRIVATE auto_js nodejs nodejs_v8 utility_js)
 
 target_sources(napi_js
 	PRIVATE
+		api/uv_dlib.cc
 		api/uv_scheduler.cc
 		support/environment.cc
 		support/initialize.cc
+		transfer/accept.cc
+		value/array_buffer.cc
 		value/array.cc
-		value/dictionary.cc
 		value/object.cc
 		value/primitive.cc
+		value/record.cc
 	PUBLIC FILE_SET CXX_MODULES FILES
 		_module.cc
 		api/api.cc
@@ -22,6 +26,7 @@ target_sources(napi_js
 		api/finalizer.cc
 		api/handle_scope.cc
 		api/invoke.cc
+		api/uv_dlib.h.cc
 		api/uv_handle.cc
 		api/uv_scheduler.h.cc
 		handle/bound_value.cc
@@ -40,16 +45,17 @@ target_sources(napi_js
 		support/promise.cc
 		support/string_table.cc
 		support/utility.cc
-		transfer/accept.cc
+		transfer/accept.h.cc
 		transfer/visit.cc
+		value/array_buffer.h.cc
 		value/array.h.cc
 		value/class.cc
 		value/class.h.cc
-		value/dictionary.h.cc
 		value/external.cc
 		value/function.cc
 		value/function.h.cc
 		value/object.h.cc
 		value/primitive.h.cc
+		value/record.h.cc
 		value/value.cc
 )

package/README.md

@@ -5,10 +5,14 @@
 `@auto_js` -- Automatic C++ bindings for JavaScript
 ===================================================
 
-<img align="right" width="33%" height="33%" src="upload/macro.jpg">
+<img align="right" width="33%" height="33%" src="https://github.com/laverdet/isolated-vm/raw/experimental/packages/auto_js/napi/upload/macro.jpg">
 
 I made this C++ template thing that converts JavaScript functions and values automatically.
 
+It requires at least clang 21 to build. I think gcc 16, when it is released, would also be able to
+compile it. C++23 modules are used which requires a modern toolchain. It doesn't use reflection but
+it does use C++26 variadic structured bindings which is only recently getting compiler support.
+
 ```c++
 auto log(std::string message) -> void {
 	std::print("{}", message);
@@ -25,6 +29,29 @@ js::napi::napi_js_module module_namespace{
 };
 ```
 
+## Example module
+
+An example module is located at: [packages/auto_js/example](https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/example).
+
+Instructions for building the demo on macOS:
+
+```
+# all this nonsense is just checking out the example subdirectory
+git clone --branch=experimental --no-checkout --depth=1 https://github.com/laverdet/isolated-vm.git
+cd isolated-vm
+git sparse-checkout set packages/auto_js/example
+git checkout
+cd packages/auto_js/example
+
+# install llvm, npm, configure, then build
+brew install llvm
+npm install
+CXX=$(brew --prefix llvm)/bin/clang npm run configure
+npm run build
+node main.mjs
+```
+
+
 ## It's better than what you're writing by hand
 
 ```c++
@@ -247,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<>>;
-		static auto class_template(environment& env) -> js::napi::value<class_tag_of<database>> {
+		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>> {
 			// incomplete
 		}
 };

package/_module.cc

@@ -1,19 +1,21 @@
 export module napi_js;
-// nb: These must come first, for some reason
-import :accept;
-import :visit;
-// Before these:
-export import :api; // should be removed
+export import :accept;
+export import :api;
+export import :bound_value;
+export import :callback;
+export import :class_definitions;
 export import :class_template_storage;
+export import :container;
 export import :environment;
-export import :external;
-export import :function;
+export import :error_scope;
+export import :function_definitions;
+export import :handle.types;
 export import :initialize;
-export import :object;
 export import :promise;
 export import :reference;
 export import :remote;
 export import :string_table;
+export import :utility;
+export import :value_handle;
 export import :value;
-import :class_definitions;
-import :function_definitions;
+export import :visit;

package/api/api.cc

@@ -1,10 +1,11 @@
 export module napi_js:api;
 // Internal nodejs API utilities which have no dependencies on anything else in `napi_js`
-export import :api.callback_info;
-export import :api.finalizer;
-export import :api.handle_scope;
-export import :api.invoke;
-export import :api.uv_handle;
-export import :api.uv_scheduler;
-export import auto_js;
 export import nodejs;
+export import auto_js;
+export import :api.uv_scheduler;
+export import :api.uv_handle;
+export import :api.uv_dlib;
+export import :api.invoke;
+export import :api.handle_scope;
+export import :api.finalizer;
+export import :api.callback_info;

package/api/callback_info.cc

@@ -1,13 +1,7 @@
-module;
-#include <array>
-#include <span>
-#if _LIBCPP_VERSION
-// clang 22.1.0: Without this I get a big horrible ICE in this file
-#include <new>
-#endif
 export module napi_js:api.callback_info;
 import :api.invoke;
 import auto_js;
+import std;
 import util;
 
 namespace js::napi {

package/api/finalizer.cc

@@ -1,9 +1,6 @@
-module;
-#include <concepts>
-#include <memory>
-#include <type_traits>
 export module napi_js:api.finalizer;
 import nodejs;
+import std;
 import util;
 
 namespace js::napi {

package/api/invoke.cc

@@ -1,11 +1,6 @@
-module;
-#include <concepts>
-#include <exception>
-#include <optional>
-#include <stdexcept>
-#include <type_traits>
 export module napi_js:api.invoke;
 export import nodejs;
+import std;
 import util;
 
 namespace js::napi {
@@ -69,7 +64,7 @@ using napi_invoke_out_t = type_t<napi_invoke_out(type<Params>...)>;
 
 // Invoke the given napi function and throw if it fails.
 export template <class... Params>
-auto invoke(auto(function)(Params...)->napi_status, auto&&... args)
+auto invoke(auto(function)(Params...)->napi_status, auto&&... args) -> napi_invoke_out_t<Params...>
 	requires std::invocable<decltype(function), decltype(args)..., napi_invoke_out_t<Params...>*> {
 	napi_invoke_out_t<Params...> out_arg;
 	napi::invoke0(function, std::forward<decltype(args)>(args)..., &out_arg);
@@ -78,7 +73,7 @@ auto invoke(auto(function)(Params...)->napi_status, auto&&... args)
 
 // Invoke the given napi function and return `optional<T>` indicating failure.
 export template <class... Params>
-auto invoke_maybe(auto(function)(Params...)->napi_status, auto&&... args)
+auto invoke_maybe(auto(function)(Params...)->napi_status, auto&&... args) -> std::optional<napi_invoke_out_t<Params...>>
 	requires std::invocable<decltype(function), decltype(args)..., napi_invoke_out_t<Params...>*> {
 	using out_type = napi_invoke_out_t<Params...>;
 	out_type out_arg;
@@ -89,7 +84,7 @@ auto invoke_maybe(auto(function)(Params...)->napi_status, auto&&... args)
 
 // Invoke the given napi function and terminate if it fails.
 export template <class... Params>
-auto invoke_noexcept(auto(function)(Params...)->napi_status, auto&&... args) noexcept
+auto invoke_noexcept(auto(function)(Params...)->napi_status, auto&&... args) noexcept -> napi_invoke_out_t<Params...>
 	requires std::invocable<decltype(function), decltype(args)..., napi_invoke_out_t<Params...>*> {
 	napi_invoke_out_t<Params...> out_arg;
 	napi::invoke0_noexcept(function, std::forward<decltype(args)>(args)..., &out_arg);

package/api/uv_dlib.cc

@@ -0,0 +1,27 @@
+module napi_js;
+import :api.uv_dlib;
+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_)})};
+	}
+}
+
+uv_dlib::uv_dlib(uv_dlib&& right) noexcept : lib_{std::exchange(right.lib_, {})} {}
+
+auto uv_dlib::operator=(uv_dlib&& right) noexcept -> uv_dlib& {
+	lib_ = std::exchange(right.lib_, {});
+	return *this;
+}
+
+uv_dlib::~uv_dlib() {
+	if (lib_.handle != nullptr) {
+		uv_dlclose(&lib_);
+	}
+}
+
+} // namespace js::napi

package/api/uv_dlib.h.cc

@@ -0,0 +1,21 @@
+export module napi_js:api.uv_dlib;
+import nodejs;
+import std;
+
+namespace js::napi {
+
+export class uv_dlib {
+	public:
+		// Constructor must take `std::string` because it needs to be null-terminated.
+		explicit uv_dlib(const std::string& filename);
+		uv_dlib(const uv_dlib&) = delete;
+		uv_dlib(uv_dlib&&) noexcept;
+		auto operator=(const uv_dlib&) -> uv_dlib& = delete;
+		auto operator=(uv_dlib&&) noexcept -> uv_dlib&;
+		~uv_dlib();
+
+	private:
+		uv_lib_t lib_;
+};
+
+} // namespace js::napi

package/api/uv_handle.cc

@@ -1,10 +1,6 @@
-module;
-#include <memory>
-#include <stdexcept>
-#include <type_traits>
-#include <utility>
 export module napi_js:api.uv_handle;
 import nodejs;
+import std;
 import util;
 
 namespace js::napi {
@@ -35,7 +31,7 @@ class uv_typed_handle {
 
 // `uv_handle_t` subtype wrapper with uv-owned shared memory. An open handle must be closed before
 // the handle is destroyed or it is UB.
-export template <class Handle, class Type>
+template <class Handle, class Type>
 class uv_handle_of : public util::pointer_facade {
 	private:
 		struct private_constructor {
@@ -59,7 +55,7 @@ class uv_handle_of : public util::pointer_facade {
 		auto operator=(const uv_handle_of&) -> uv_handle_of& = delete;
 
 		auto operator*() -> auto& { return value_; }
-		auto close() -> void;
+		auto close(util::function_ref<auto()->void> close_hook) -> void;
 		auto handle() -> auto& { return handle_; }
 		auto open(const auto& init, uv_loop_t* loop, auto&&... args) -> void;
 
@@ -68,6 +64,7 @@ class uv_handle_of : public util::pointer_facade {
 
 	private:
 		uv_typed_handle<Handle, shared_or_weak_ptr> handle_;
+		util::function_ref<auto()->void> close_hook_{[] -> void {}};
 		Type value_;
 };
 
@@ -79,9 +76,12 @@ uv_handle_of<Handle, Type>::~uv_handle_of() {
 }
 
 template <class Handle, class Type>
-auto uv_handle_of<Handle, Type>::close() -> void {
+auto uv_handle_of<Handle, Type>::close(util::function_ref<auto()->void> close_hook) -> void {
+	close_hook_ = close_hook;
 	uv_close(handle(), [](uv_handle_t* handle) -> void {
-		delete static_cast<shared_ptr_type*>(std::exchange(handle->data, nullptr));
+		auto self = std::unique_ptr<shared_ptr_type>(static_cast<shared_ptr_type*>(std::exchange(handle->data, nullptr)));
+		auto& handle_of = **self;
+		handle_of.close_hook_();
 	});
 }
 

package/api/uv_scheduler.cc

@@ -1,26 +1,20 @@
 module;
 #include <cassert>
-#include <functional>
-#include <thread>
-#include <utility>
 module napi_js;
+import std;
 
 namespace js::napi {
 
-auto uv_scheduler::close() -> void {
-	// nb: It's not safe to dereference `auto& async` like the functions because `.close()` deletes
-	// the underlying memory and would cause a dangling reference. I think `uv_close` is probably
-	// always async but I'm not sure of it.
-	assert((*async_)->thread_id == std::this_thread::get_id());
-	[[maybe_unused]] auto abandoned_tasks =
-		std::invoke([ & ]() -> auto {
-			assert((*async_)->thread_id == std::this_thread::get_id());
-			auto lock = (*async_)->shared.write();
-			lock->is_open = false;
-			auto tasks = std::exchange(lock->tasks, {});
-			async_->close();
-			return tasks;
-		});
+auto uv_scheduler::close(util::function_ref<auto()->void> close_hook) -> void {
+	auto& async = *async_;
+	assert(async->thread_id == std::this_thread::get_id());
+	std::ignore = [ & ] -> auto {
+		auto lock = async->shared.write();
+		lock->is_open = false;
+		auto tasks = std::exchange(lock->tasks, {});
+		async.close(close_hook);
+		return tasks;
+	}();
 }
 
 auto uv_scheduler::decrement_ref() -> void {

package/api/uv_scheduler.h.cc

@@ -1,9 +1,6 @@
-module;
-#include <memory>
-#include <thread>
-#include <vector>
 export module napi_js:api.uv_scheduler;
 import :api.uv_handle;
+import std;
 import util;
 
 #if _LIBCPP_VERSION
@@ -11,7 +8,7 @@ import util;
 // /usr/lib/llvm-22/bin/../include/c++/v1/__new/allocate.h:39:30: error: no matching function for call to 'operator new'
 //    39 |     return static_cast<_Tp*>(__builtin_operator_new(__size, static_cast<align_val_t>(__align)));
 export {
-  using ::operator new;
+	using ::operator new;
 }
 #endif
 
@@ -23,7 +20,7 @@ export class uv_scheduler {
 		using task_type = util::maybe_move_only_function<auto()->void>;
 
 	public:
-		auto close() -> void;
+		auto close(util::function_ref<auto()->void> close_hook) -> void;
 		auto decrement_ref() -> void;
 		auto increment_ref() -> void;
 		auto open(uv_loop_t* loop) -> void;

package/handle/bound_value.cc

@@ -1,5 +1,3 @@
-module;
-#include <concepts>
 export module napi_js:bound_value;
 import :handle.types;
 import nodejs;
@@ -12,17 +10,16 @@ class bound_value_next : public bound_value<typename Tag::tag_type> {
 	public:
 		using bound_value<typename Tag::tag_type>::bound_value;
 		bound_value_next() = default;
-		bound_value_next(napi_env env, value<Tag> value) :
+		bound_value_next(napi_env env, value_of<Tag> value) :
 				bound_value<typename Tag::tag_type>{env, napi_value{value}} {}
 
-		template <std::constructible_from<Tag> To>
 		// NOLINTNEXTLINE(google-explicit-constructor)
-		operator value<To>() const { return value<To>::from(napi_value{*this}); }
+		operator value_of<Tag>() const { return value_of<Tag>::from(napi_value{*this}); }
 };
 
 // Member & method implementation for stateful objects. Used internally in visitors. I think it
 // might make sense to have the environment specified by a template parameter. Then you would use
-// `bound_value<T>` or something instead of passing the environment to each `value<T>` method.
+// `bound_value<T>` or something instead of passing the environment to each `value_of<T>` method.
 template <class Tag>
 class bound_value : public value_specialization<Tag>::bound_type {
 	public:
@@ -30,7 +27,7 @@ class bound_value : public value_specialization<Tag>::bound_type {
 };
 
 template <class Tag>
-bound_value(auto, value<Tag>) -> bound_value<Tag>;
+bound_value(auto, value_of<Tag>) -> bound_value<Tag>;
 
 template <>
 class bound_value<void> : public value_handle {

package/handle/reference.cc

@@ -1,9 +1,7 @@
-module;
-#include <stdexcept>
-#include <utility>
 export module napi_js:reference;
 import :api;
 import :value_handle;
+import std;
 import util;
 
 namespace js::napi {
@@ -36,9 +34,15 @@ class reference_handle : util::non_copyable {
 		}
 
 	public:
+#if __GNUC__ > 14
+		constexpr reference_handle(const reference_handle& /*right*/) {
+			// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=125008
+		};
+#else
 		consteval reference_handle(const reference_handle& /*right*/) {
 			// consteval no-op!
 		};
+#endif
 
 		constexpr reference_handle(reference_handle&& right) noexcept :
 				env_{right.env_},
@@ -68,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<Tag>;
+		using value_type = value_of<Tag>;
 		using reference<typename Tag::tag_type>::reference;
 
 		reference() = default;
@@ -82,7 +86,7 @@ class reference : public reference<typename Tag::tag_type> {
 };
 
 template <class Tag>
-reference(auto, value<Tag>) -> reference<Tag>;
+reference(auto, value_of<Tag>) -> reference<Tag>;
 
 // nb: Protected inheritance so that `remote<T> is not comparable to `reference<T>`.
 template <>

package/handle/remote.cc

@@ -1,13 +1,7 @@
-module;
-#include <cassert>
-#include <memory>
-#include <type_traits>
-#include <utility>
 export module napi_js:remote;
-import :api;
 import :environment;
 import :reference;
-import :value_handle;
+import std;
 import util;
 
 namespace js::napi {
@@ -29,14 +23,14 @@ 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<Tag> value, uv_scheduler scheduler) :
+		remote(private_constructor /*private*/, const environment& env, value_of<Tag> value, uv_scheduler scheduler) :
 				reference_handle{napi_env{env}, napi_value{value}},
 				scheduler_{std::move(scheduler)} {}
 
-		auto deref(const environment& env) const -> value<Tag>;
+		auto deref(const environment& env) const -> value_of<Tag>;
 
-		static auto make_shared(remote_handle_environment auto& env, value<Tag> value) -> std::shared_ptr<remote>;
-		static auto make_unique(remote_handle_environment auto& env, value<Tag> value) -> unique_remote;
+		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;
 
 	private:
 		uv_scheduler scheduler_;
@@ -50,12 +44,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<Tag> value) -> shared_remote<Tag> {
+auto make_shared_remote(remote_handle_environment auto& env, value_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<Tag> value) -> unique_remote<Tag> {
+auto make_unique_remote(remote_handle_environment auto& env, value_of<Tag> value) -> unique_remote<Tag> {
 	return remote<Tag>::make_unique(env, value);
 }
 
@@ -75,17 +69,17 @@ auto remote<Tag>::expire(remote* ptr) -> void {
 }
 
 template <class Tag>
-auto remote<Tag>::deref(const environment& env) const -> value<Tag> {
-	return value<Tag>::from(get_value(napi_env{env}));
+auto remote<Tag>::deref(const environment& env) const -> value_of<Tag> {
+	return value_of<Tag>::from(get_value(napi_env{env}));
 }
 
 template <class Tag>
-auto remote<Tag>::make_shared(remote_handle_environment auto& env, value<Tag> value) -> std::shared_ptr<remote> {
+auto remote<Tag>::make_shared(remote_handle_environment auto& env, value_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<Tag> value) -> unique_remote {
+auto remote<Tag>::make_unique(remote_handle_environment auto& env, value_of<Tag> value) -> unique_remote {
 	return unique_remote{new remote{private_constructor{}, env, value, env.scheduler()}};
 }