@auto_js/napi 0.0.1

package/value/function.cc

@@ -0,0 +1,52 @@
+module;
+#include <array>
+#include <span>
+#include <tuple>
+#include <variant>
+#include <vector>
+export module napi_js:function_definitions;
+import :api;
+import :callback;
+import :function;
+
+namespace js::napi {
+
+template <class Result>
+auto value_for_function::apply(auto_environment auto& env, auto&& args) -> Result {
+	auto arg_values = js::transfer_in_strict<std::vector<napi_value>>(std::forward<decltype(args)>(args), env);
+	return invoke<Result>(env, std::span{arg_values});
+}
+
+template <class Result>
+auto value_for_function::call(auto_environment auto& env, auto&&... args) -> Result {
+	auto arg_values = js::transfer_in_strict<std::array<napi_value, sizeof...(args)>>(std::forward_as_tuple(args...), env);
+	return invoke<Result>(env, std::span{arg_values});
+}
+
+template <class Result>
+auto value_for_function::invoke(auto_environment auto& env, std::span<napi_value> args) -> Result {
+	auto undefined = js::transfer_in_strict<napi_value>(std::monostate{}, env);
+	auto* result = napi::invoke(napi_call_function, napi_env{env}, undefined, napi_value{*this}, args.size(), args.data());
+	return js::transfer_out<Result>(result, env);
+}
+
+template <auto_environment Environment>
+auto value_for_function::make(Environment& env, auto function) -> value<function_tag> {
+	auto [ callback, data ] = make_callback_storage(env, make_free_function<Environment>(std::move(function).callback));
+	auto make = [ & ](void* data) -> value<function_tag> {
+		return value<function_tag>::from(napi::invoke(napi_create_function, napi_env{env}, function.name.data(), function.name.length(), callback, data));
+	};
+	if constexpr (requires { typename decltype(data)::element_type; }) {
+		// Function requires finalizer
+		auto function = make(data.get());
+		return apply_finalizer(std::move(data), [ & ](auto* data, napi_finalize finalize, void* hint) -> value<function_tag> {
+			napi::invoke0(napi_add_finalizer, napi_env{env}, function, data, finalize, hint, nullptr);
+			return function;
+		});
+	} else {
+		// No finalizer needed
+		return make(data);
+	}
+}
+
+} // namespace js::napi

package/value/function.h.cc

@@ -0,0 +1,30 @@
+module;
+#include <span>
+#include <variant>
+export module napi_js:function;
+import :environment_fwd;
+import :primitive;
+import :value_handle;
+import util;
+
+namespace js::napi {
+
+class value_for_function : public value_next<function_tag> {
+	public:
+		using value_next<function_tag>::value_next;
+
+		template <class Result = std::monostate>
+		auto apply(auto_environment auto& env, auto&& args) -> Result;
+
+		template <class Result = std::monostate>
+		auto call(auto_environment auto& env, auto&&... args) -> Result;
+
+		template <auto_environment Environment>
+		static auto make(Environment& env, auto function) -> value<function_tag>;
+
+	private:
+		template <class Result>
+		auto invoke(auto_environment auto& env, std::span<napi_value> args) -> Result;
+};
+
+} // namespace js::napi

package/value/object.cc

@@ -0,0 +1,30 @@
+module napi_js;
+import :api;
+import :bound_value;
+import :value_handle;
+
+namespace js::napi {
+
+// object
+auto bound_value_for_object::get(napi_value key) const -> value<value_tag> {
+	return value<value_tag>::from(napi::invoke(napi_get_property, env(), napi_value{*this}, key));
+}
+
+auto bound_value_for_object::has(napi_value key) const -> bool {
+	return napi::invoke(napi_has_own_property, env(), napi_value{*this}, key);
+}
+
+auto bound_value_for_object::set(napi_value key, napi_value value) -> void {
+	napi::invoke0(napi_set_property, env(), napi_value{*this}, key, value);
+}
+
+// date
+auto value_for_date::make(const environment& env, js_clock::time_point date) -> value<date_tag> {
+	return value<date_tag>::from(napi::invoke(napi_create_date, napi_env{env}, date.time_since_epoch().count()));
+}
+
+bound_value_for_date::operator js_clock::time_point() const {
+	return js_clock::time_point{js_clock::duration{napi::invoke(napi_get_date_value, env(), napi_value{*this})}};
+}
+
+} // namespace js::napi

package/value/object.h.cc

@@ -0,0 +1,59 @@
+module;
+#include <array>
+#include <tuple>
+#include <utility>
+export module napi_js:object;
+import :api;
+import :bound_value;
+import :environment_fwd;
+import :primitive;
+import :value_handle;
+
+namespace js::napi {
+
+// object
+class value_for_object : public value_next<object_tag> {
+	public:
+		using value_next<object_tag>::value_next;
+
+		auto assign(this value<object_tag> self, auto_environment auto& env, auto source) -> void;
+};
+
+class bound_value_for_object : public bound_value_next<object_tag> {
+	public:
+		using bound_value_next<object_tag>::bound_value_next;
+
+		template <class Type>
+		[[nodiscard]] auto try_cast(std::type_identity<Type> /*type*/) const -> Type*;
+
+		[[nodiscard]] auto get(napi_value key) const -> value<value_tag>;
+		[[nodiscard]] auto has(napi_value key) const -> bool;
+
+		auto set(napi_value key, napi_value value) -> void;
+};
+
+// date
+class value_for_date : public value_next<date_tag> {
+	public:
+		using value_next<date_tag>::value_next;
+		static auto make(const environment& env, js_clock::time_point date) -> value<date_tag>;
+};
+
+class bound_value_for_date : public bound_value_next<date_tag> {
+	public:
+		using bound_value_next<date_tag>::bound_value_next;
+		[[nodiscard]] explicit operator js_clock::time_point() const;
+};
+
+// ---
+
+template <class Type>
+auto bound_value_for_object::try_cast(std::type_identity<Type> /*type*/) const -> Type* {
+	if (napi::invoke(napi_check_object_type_tag, env(), napi_value{*this}, &type_tag_for<Type>)) {
+		return static_cast<Type*>(napi::invoke(napi_unwrap, env(), napi_value{*this}));
+	} else {
+		return nullptr;
+	}
+}
+
+} // namespace js::napi

package/value/primitive.cc

@@ -0,0 +1,160 @@
+module;
+#include <cstdint>
+#include <string>
+#include <string_view>
+module napi_js;
+import :api;
+import :bound_value;
+import :value_handle;
+
+namespace js::napi {
+
+// undefined
+auto value_for_undefined::make(const environment& env) -> value<undefined_tag> {
+	return value<undefined_tag>::from(napi::invoke(napi_get_undefined, napi_env{env}));
+}
+
+// null
+auto value_for_null::make(const environment& env) -> value<null_tag> {
+	return value<null_tag>::from(napi::invoke(napi_get_null, napi_env{env}));
+}
+
+// boolean
+auto value_for_boolean::make(const environment& env, bool boolean) -> value<boolean_tag> {
+	return value<boolean_tag>::from(napi::invoke(napi_get_boolean, napi_env{env}, boolean));
+}
+
+bound_value_for_boolean::operator bool() const {
+	return napi::invoke(napi_get_value_bool, env(), napi_value{*this});
+}
+
+// number
+auto value_for_number::make(const environment& env, double number) -> value<number_tag> {
+	return value<number_tag>::from(napi::invoke(napi_create_double, napi_env{env}, number));
+}
+
+auto value_for_number::make(const environment& env, int32_t number) -> value<number_tag> {
+	return value<number_tag>::from(napi::invoke(napi_create_int32, napi_env{env}, number));
+}
+
+auto value_for_number::make(const environment& env, int64_t number) -> value<number_tag> {
+	return value<number_tag>::from(napi::invoke(napi_create_int64, napi_env{env}, number));
+}
+
+auto value_for_number::make(const environment& env, uint32_t number) -> value<number_tag> {
+	return value<number_tag>::from(napi::invoke(napi_create_uint32, napi_env{env}, number));
+}
+
+bound_value_for_number::operator double() const {
+	return napi::invoke(napi_get_value_double, env(), napi_value{*this});
+}
+
+bound_value_for_number::operator int32_t() const {
+	return napi::invoke(napi_get_value_int32, env(), napi_value{*this});
+}
+
+bound_value_for_number::operator int64_t() const {
+	return napi::invoke(napi_get_value_int64, env(), napi_value{*this});
+}
+
+bound_value_for_number::operator uint32_t() const {
+	return napi::invoke(napi_get_value_uint32, env(), napi_value{*this});
+}
+
+// bigint
+auto value_for_bigint::make(const environment& env, const bigint& number) -> value<bigint_tag> {
+	return value<bigint_tag>::from(napi::invoke(napi_create_bigint_words, napi_env{env}, number.sign_bit(), number.size(), number.data()));
+}
+
+auto value_for_bigint::make(const environment& env, int64_t number) -> value<bigint_tag> {
+	return value<bigint_tag>::from(napi::invoke(napi_create_bigint_int64, napi_env{env}, number));
+}
+
+auto value_for_bigint::make(const environment& env, uint64_t number) -> value<bigint_tag> {
+	return value<bigint_tag>::from(napi::invoke(napi_create_bigint_uint64, napi_env{env}, number));
+}
+
+bound_value_for_bigint::operator bigint() const {
+	js::bigint value;
+	auto one_word = uint64_t{};
+	auto length = size_t{1};
+	napi::invoke0(napi_get_value_bigint_words, env(), napi_value{*this}, &value.sign_bit(), &length, &one_word);
+	if (value.sign_bit() == 0 && length == 1) {
+		return js::bigint{one_word};
+	}
+	value.resize_and_overwrite(length, [ & ](auto* words, auto length) noexcept {
+		if (length > 0) {
+			napi::invoke0_noexcept(napi_get_value_bigint_words, env(), napi_value{*this}, &value.sign_bit(), &length, words);
+		}
+		return length;
+	});
+	return value;
+}
+
+bound_value_for_bigint::operator int64_t() const {
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	int64_t value;
+	// nb: `lossless` error not checked for consistency with `napi_get_value_int32`,
+	// `napi_get_value_string_latin1`, etc which don't return any errors.
+	napi::invoke(napi_get_value_bigint_int64, env(), napi_value{*this}, &value);
+	return value;
+}
+
+bound_value_for_bigint::operator uint64_t() const {
+	// NOLINTNEXTLINE(cppcoreguidelines-init-variables)
+	uint64_t value;
+	napi::invoke(napi_get_value_bigint_uint64, env(), napi_value{*this}, &value);
+	return value;
+}
+
+// string
+auto value_for_string::make(const environment& env, std::string_view string) -> value<string_tag> {
+	return value<string_tag>::from(napi::invoke(napi_create_string_latin1, napi_env{env}, string.data(), string.length()));
+}
+
+auto value_for_string::make(const environment& env, std::u8string_view string) -> value<string_tag> {
+	return value<string_tag>::from(napi::invoke(napi_create_string_utf8, napi_env{env}, reinterpret_cast<const char*>(string.data()), string.length()));
+}
+
+auto value_for_string::make(const environment& env, std::u16string_view string) -> value<string_tag> {
+	return value<string_tag>::from(napi::invoke(napi_create_string_utf16, napi_env{env}, string.data(), string.length()));
+}
+
+auto value_for_string::make_property_name(const environment& env, std::string_view string) -> value<string_tag> {
+	return value<string_tag>::from(napi::invoke(node_api_create_property_key_latin1, napi_env{env}, reinterpret_cast<const char*>(string.data()), string.length()));
+}
+
+auto value_for_string::make_property_name(const environment& env, std::u8string_view string) -> value<string_tag> {
+	return value<string_tag>::from(napi::invoke(node_api_create_property_key_utf8, napi_env{env}, reinterpret_cast<const char*>(string.data()), string.length()));
+}
+
+auto value_for_string::make_property_name(const environment& env, std::u16string_view string) -> value<string_tag> {
+	return value<string_tag>::from(napi::invoke(node_api_create_property_key_utf16, napi_env{env}, string.data(), string.length()));
+}
+
+bound_value_for_string::operator std::string() const {
+	std::string string;
+	auto length = napi::invoke(napi_get_value_string_latin1, env(), napi_value{*this}, nullptr, 0);
+	if (length > 0) {
+		string.resize_and_overwrite(length + 1, [ this ](char* data, size_t length) noexcept -> size_t {
+			napi::invoke_noexcept(napi_get_value_string_latin1, env(), napi_value{*this}, data, length);
+			return length - 1;
+		});
+	}
+	return string;
+}
+
+bound_value_for_string::operator std::u16string() const {
+	// nb: napi requires that the returned string is null-terminated for some reason.
+	std::u16string string;
+	auto length = napi::invoke(napi_get_value_string_utf16, env(), napi_value{*this}, nullptr, 0);
+	if (length > 0) {
+		string.resize_and_overwrite(length + 1, [ this ](char16_t* data, size_t length) noexcept -> size_t {
+			napi::invoke_noexcept(napi_get_value_string_utf16, env(), napi_value{*this}, data, length);
+			return length - 1;
+		});
+	}
+	return string;
+}
+
+} // namespace js::napi

package/value/primitive.h.cc

@@ -0,0 +1,101 @@
+module;
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <string_view>
+#include <variant>
+export module napi_js:primitive;
+import :api;
+import :bound_value;
+import :environment_fwd;
+import :value_handle;
+
+namespace js::napi {
+
+// undefined
+class value_for_undefined : public value_next<undefined_tag> {
+	public:
+		using value_next<undefined_tag>::value_next;
+		static auto make(const environment& env) -> value<undefined_tag>;
+		static auto make(const environment& env, std::monostate /*undefined*/) -> value<undefined_tag> { return make(env); }
+};
+
+// null
+class value_for_null : public value_next<null_tag> {
+	public:
+		using value_next<null_tag>::value_next;
+		static auto make(const environment& env) -> value<null_tag>;
+		static auto make(const environment& env, std::nullptr_t /*null*/) -> value<null_tag> { return make(env); }
+};
+
+// boolean
+class value_for_boolean : public value_next<boolean_tag> {
+	public:
+		using value_next<boolean_tag>::value_next;
+		static auto make(const environment& env, bool boolean) -> value<boolean_tag>;
+};
+
+class bound_value_for_boolean : public bound_value_next<boolean_tag> {
+	public:
+		using bound_value_next<boolean_tag>::bound_value_next;
+		[[nodiscard]] explicit operator bool() const;
+};
+
+// number
+class value_for_number : public value_next<number_tag> {
+	public:
+		using value_next<number_tag>::value_next;
+		static auto make(const environment& env, double number) -> value<number_tag>;
+		static auto make(const environment& env, int32_t number) -> value<number_tag>;
+		static auto make(const environment& env, int64_t number) -> value<number_tag>;
+		static auto make(const environment& env, uint32_t number) -> value<number_tag>;
+
+		static auto make_property_name(const environment& env, int32_t number) -> value<number_tag> { return make(env, number); }
+};
+
+class bound_value_for_number : public bound_value_next<number_tag> {
+	public:
+		using bound_value_next<number_tag>::bound_value_next;
+		[[nodiscard]] explicit operator double() const;
+		[[nodiscard]] explicit operator int32_t() const;
+		[[nodiscard]] explicit operator int64_t() const;
+		[[nodiscard]] explicit operator uint32_t() const;
+};
+
+// bigint
+class value_for_bigint : public value_next<bigint_tag> {
+	public:
+		using value_next<bigint_tag>::value_next;
+		static auto make(const environment& env, const bigint& number) -> value<bigint_tag>;
+		static auto make(const environment& env, int64_t number) -> value<bigint_tag>;
+		static auto make(const environment& env, uint64_t number) -> value<bigint_tag>;
+};
+
+class bound_value_for_bigint : public bound_value_next<bigint_tag> {
+	public:
+		using bound_value_next<bigint_tag>::bound_value_next;
+		[[nodiscard]] explicit operator bigint() const;
+		[[nodiscard]] explicit operator int64_t() const;
+		[[nodiscard]] explicit operator uint64_t() const;
+};
+
+// string
+class value_for_string : public value_next<string_tag> {
+	public:
+		using value_next<string_tag>::value_next;
+		static auto make(const environment& env, std::string_view string) -> value<string_tag>;
+		static auto make(const environment& env, std::u8string_view string) -> value<string_tag>;
+		static auto make(const environment& env, std::u16string_view string) -> value<string_tag>;
+		static auto make_property_name(const environment& env, std::string_view string) -> value<string_tag>;
+		static auto make_property_name(const environment& env, std::u8string_view string) -> value<string_tag>;
+		static auto make_property_name(const environment& env, std::u16string_view string) -> value<string_tag>;
+};
+
+class bound_value_for_string : public bound_value_next<string_tag> {
+	public:
+		using bound_value_next<string_tag>::bound_value_next;
+		[[nodiscard]] explicit operator std::string() const;
+		[[nodiscard]] explicit operator std::u16string() const;
+};
+
+} // namespace js::napi

package/value/value.cc

@@ -0,0 +1,10 @@
+export module napi_js:value;
+export import :value_handle;
+import :array;
+import :bound_value;
+import :class_;
+import :dictionary;
+import :external;
+import :function;
+import :object;
+import :primitive;