@auto_js/napi 0.0.1

package/api/uv_scheduler.cc

@@ -0,0 +1,56 @@
+module;
+#include <cassert>
+#include <functional>
+#include <thread>
+#include <utility>
+module napi_js;
+
+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::decrement_ref() -> void {
+	auto& async = *async_;
+	assert(async->thread_id == std::this_thread::get_id());
+	if (--async->refs == 0) {
+		uv_unref(async.handle());
+	}
+}
+
+auto uv_scheduler::increment_ref() -> void {
+	auto& async = *async_;
+	assert(async->thread_id == std::this_thread::get_id());
+	if (++async->refs == 1) {
+		uv_ref(async.handle());
+	}
+}
+
+auto uv_scheduler::open(uv_loop_t* loop) -> void {
+	auto& async = *async_;
+	assert(async->thread_id == std::this_thread::get_id());
+	async->shared.write()->is_open = true;
+	async.open(uv_async_init, loop, [](uv_async_t* async_handle) -> void {
+		auto& async = *handle_type::unwrap(async_handle);
+		auto tasks = std::exchange(async->shared.write()->tasks, {});
+		for (auto& task : tasks) {
+			task();
+		}
+	});
+	uv_unref(async.handle());
+}
+
+} // namespace js::napi

package/api/uv_scheduler.h.cc

@@ -0,0 +1,73 @@
+module;
+#include <memory>
+#include <thread>
+#include <vector>
+export module napi_js:api.uv_scheduler;
+import :api.uv_handle;
+import util;
+
+#if _LIBCPP_VERSION
+// clang 22.1.0
+// /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;
+}
+#endif
+
+namespace js::napi {
+
+// Shareable libuv scheduler
+export class uv_scheduler {
+	private:
+		using task_type = util::maybe_move_only_function<auto()->void>;
+
+	public:
+		auto close() -> void;
+		auto decrement_ref() -> void;
+		auto increment_ref() -> void;
+		auto open(uv_loop_t* loop) -> void;
+		auto operator()(auto task, auto&&... args) const -> void;
+		explicit operator bool() const { return bool{async_}; }
+
+	private:
+		struct locked_storage {
+				std::vector<task_type> tasks;
+				bool is_open{};
+		};
+		struct storage {
+				storage() = default;
+				util::lockable<locked_storage> shared;
+				std::thread::id thread_id{std::this_thread::get_id()};
+				int refs{};
+		};
+		using handle_type = uv_handle_of<uv_async_t, storage>;
+		std::shared_ptr<handle_type> async_{handle_type::make()};
+};
+
+// An environment with an uv loop and scheduler
+export class uv_schedulable {
+	public:
+		auto scheduler(this auto& self) -> auto& { return self.uv_scheduler_; }
+
+	private:
+		uv_scheduler uv_scheduler_;
+};
+
+// ---
+
+auto uv_scheduler::operator()(auto task, auto&&... args) const -> void {
+	auto& async = *async_;
+	auto shared = async->shared.write();
+	if (shared->is_open) {
+		shared->tasks.push_back(
+			[ task = std::move(task),
+				... args = std::forward<decltype(args)>(args) ]() mutable -> void {
+				task(std::move(args)...);
+			}
+		);
+		uv_async_send(async.handle());
+	}
+}
+
+} // namespace js::napi

package/handle/bound_value.cc

@@ -0,0 +1,49 @@
+module;
+#include <concepts>
+export module napi_js:bound_value;
+import :handle.types;
+import nodejs;
+
+namespace js::napi {
+
+// Details applied to each level of the `bound_value<T>` hierarchy.
+template <class Tag>
+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<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}); }
+};
+
+// 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.
+template <class Tag>
+class bound_value : public value_specialization<Tag>::bound_type {
+	public:
+		using value_specialization<Tag>::bound_type::bound_type;
+};
+
+template <class Tag>
+bound_value(auto, value<Tag>) -> bound_value<Tag>;
+
+template <>
+class bound_value<void> : public value_handle {
+	protected:
+		bound_value() = default;
+		bound_value(napi_env env, napi_value value) :
+				value_handle{value},
+				env_{env} {}
+
+		[[nodiscard]] auto env() const -> napi_env { return env_; }
+
+	private:
+		napi_env env_{};
+};
+
+} // namespace js::napi

package/handle/reference.cc

@@ -0,0 +1,93 @@
+module;
+#include <stdexcept>
+#include <utility>
+export module napi_js:reference;
+import :api;
+import :value_handle;
+import util;
+
+namespace js::napi {
+
+// Base class of reference & remote values
+class reference_handle : util::non_copyable {
+	protected:
+		reference_handle() = default;
+		reference_handle(napi_env env, napi_value value) :
+				env_{env},
+				ref_{napi::invoke(napi_create_reference, env, value, 1)} {}
+
+		[[nodiscard]] auto env() const -> napi_env {
+			return env_;
+		}
+
+		[[nodiscard]] auto get_value(napi_env env) const -> napi_value {
+			return napi::invoke(napi_get_reference_value, env, ref_);
+		}
+
+		auto reset(napi_env env, napi_value value) -> void {
+			if (ref_ != nullptr) {
+				if (env != env_) {
+					throw std::logic_error{"Environment mismatch"};
+				}
+				napi::invoke0(napi_delete_reference, env, std::exchange(ref_, nullptr));
+			}
+			env_ = env;
+			ref_ = napi::invoke(napi_create_reference, env, value, 1);
+		}
+
+	public:
+		consteval reference_handle(const reference_handle& /*right*/) {
+			// consteval no-op!
+		};
+
+		constexpr reference_handle(reference_handle&& right) noexcept :
+				env_{right.env_},
+				ref_{std::exchange(right.ref_, nullptr)} {}
+
+		constexpr ~reference_handle() {
+			if (ref_ != nullptr) {
+				napi::invoke0_noexcept(napi_delete_reference, env_, ref_);
+			}
+		}
+
+		auto operator=(const reference_handle&) = delete;
+		auto operator=(reference_handle&& right) noexcept -> reference_handle& {
+			env_ = right.env_;
+			ref_ = std::exchange(right.ref_, nullptr);
+			return *this;
+		};
+
+		explicit operator bool() const { return ref_ != nullptr; }
+
+	private:
+		napi_env env_{};
+		napi_ref ref_{};
+};
+
+// A not-thread safe persistent value reference.
+export template <class Tag>
+class reference : public reference<typename Tag::tag_type> {
+	public:
+		using value_type = value<Tag>;
+		using reference<typename Tag::tag_type>::reference;
+
+		reference() = default;
+		reference(napi_env env, value_type value) :
+				reference<typename Tag::tag_type>{env, napi_value{value}} {}
+
+		explicit operator bool() const { return reference_handle::operator bool(); }
+		[[nodiscard]] auto get(napi_env env) const -> value_type { return value_type::from(this->get_value(env)); }
+
+		auto reset(napi_env env, value_type value) -> void { reference_handle::reset(env, napi_value{value}); }
+};
+
+template <class Tag>
+reference(auto, value<Tag>) -> reference<Tag>;
+
+// nb: Protected inheritance so that `remote<T> is not comparable to `reference<T>`.
+template <>
+class reference<void> : protected reference_handle {
+		using reference_handle::reference_handle;
+};
+
+} // namespace js::napi

package/handle/remote.cc

@@ -0,0 +1,92 @@
+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 util;
+
+namespace js::napi {
+
+template <class Type>
+concept remote_handle_environment =
+	std::is_base_of_v<environment, Type> &&
+	std::is_base_of_v<uv_schedulable, Type>;
+
+// Thread safe persistent value reference
+export template <class Tag>
+class remote : protected reference_handle {
+	private:
+		struct private_constructor {
+				explicit private_constructor() = default;
+		};
+		static auto expire(remote* ptr) -> void;
+
+	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) :
+				reference_handle{napi_env{env}, napi_value{value}},
+				scheduler_{std::move(scheduler)} {}
+
+		auto deref(const environment& env) const -> value<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;
+
+	private:
+		uv_scheduler scheduler_;
+};
+
+// Convenience helpers
+export template <class Type>
+using shared_remote = std::shared_ptr<remote<Type>>;
+
+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> {
+	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> {
+	return remote<Tag>::make_unique(env, value);
+}
+
+// ---
+
+template <class Tag>
+auto remote<Tag>::expire(remote* ptr) -> void {
+	std::unique_ptr<remote> self{ptr};
+	ptr->scheduler_(
+		util::make_indirect_moveable_function(
+			[ self = std::move(self) ] mutable -> auto {
+				const auto scope = handle_scope{self->env()};
+				self.reset();
+			}
+		)
+	);
+}
+
+template <class Tag>
+auto remote<Tag>::deref(const environment& env) const -> value<Tag> {
+	return value<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> {
+	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 {
+	return unique_remote{new remote{private_constructor{}, env, value, env.scheduler()}};
+}
+
+} // namespace js::napi

package/handle/types.cc

@@ -0,0 +1,136 @@
+export module napi_js:handle.types;
+import auto_js;
+import nodejs;
+
+namespace js::napi {
+
+// `value_handle` is the base class of `value<T>`, and `bound_value<T>`.
+class value_handle {
+	protected:
+		explicit value_handle(napi_value value) :
+				value_{value} {}
+
+	public:
+		value_handle() = default;
+
+		// Implicit cast back to a `napi_value`
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		operator napi_value() const { return value_; }
+
+		// Check empty value
+		explicit operator bool() const { return value_ != nullptr; }
+
+	private:
+		napi_value value_{};
+};
+
+// `value` forward declarations
+export template <class Tag = value_tag>
+class value;
+
+template <class Tag>
+class value_next;
+
+template <class Type>
+class value_for_class_of;
+
+// `bound_value` forward declarations
+export 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 Tag>
+struct value_specialization {
+		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 <>
+struct value_specialization<boolean_tag> {
+		using value_type = class value_for_boolean;
+		using bound_type = class bound_value_for_boolean;
+};
+
+template <>
+struct value_specialization<number_tag> {
+		using value_type = class value_for_number;
+		using bound_type = class bound_value_for_number;
+};
+
+template <>
+struct value_specialization<bigint_tag> {
+		using value_type = class value_for_bigint;
+		using bound_type = class bound_value_for_bigint;
+};
+
+template <>
+struct value_specialization<string_tag> {
+		using value_type = class value_for_string;
+		using bound_type = class bound_value_for_string;
+};
+
+template <>
+struct value_specialization<date_tag> {
+		using value_type = class value_for_date;
+		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<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<external_tag> {
+		using value_type = class value_for_external;
+		using bound_type = class bound_value_for_external;
+};
+
+template <>
+struct value_specialization<vector_tag> {
+		using value_type = value_next<vector_tag>;
+		using bound_type = class bound_value_for_vector;
+};
+
+template <>
+struct value_specialization<list_tag> {
+		using value_type = value_next<list_tag>;
+		using bound_type = class bound_value_for_list;
+};
+
+template <>
+struct value_specialization<dictionary_tag> {
+		using value_type = value_next<dictionary_tag>;
+		using bound_type = class bound_value_for_dictionary;
+};
+
+} // namespace js::napi

package/handle/value.cc

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

package/include/napi_js_initialize.h

@@ -0,0 +1,7 @@
+#include <node_api.h>
+import napi_js;
+
+NAPI_MODULE_INIT(/*napi_env env, napi_value exports*/) {
+	js::napi::detail::initialize_require::initialize(env, exports);
+	return exports;
+}

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@auto_js/napi",
+  "version": "0.0.1",
+  "description": "Automatic JavaScript to N-API bindings",
+  "author": "https://github.com/laverdet/",
+  "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/auto_js/napi",
+  "license": "ISC",
+  "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"
+  }
+}