@auto_js/napi 0.0.1 → 0.0.4

package/value/primitive.h.cc

@@ -1,96 +1,38 @@
-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;
+import std;
 
 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;
+		[[nodiscard]] explicit operator std::int32_t() const;
+		[[nodiscard]] explicit operator std::int64_t() const;
+		[[nodiscard]] explicit operator std::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;
+		[[nodiscard]] explicit operator std::int64_t() const;
+		[[nodiscard]] explicit operator std::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;

package/value/record.cc

@@ -0,0 +1,38 @@
+module napi_js;
+import :api;
+import :array;
+import std;
+
+namespace js::napi {
+
+auto bound_value_for_record::into_range() const -> range_type {
+	return keys() | std::views::transform(iterator_transform{*this});
+}
+
+auto bound_value_for_record::size() const -> std::size_t {
+	return keys().size();
+}
+
+auto bound_value_for_record::keys() const -> const keys_type& {
+	if (napi_value{keys_} == nullptr) {
+		auto* property_names = napi::invoke(
+			napi_get_all_property_names,
+			env(),
+			*this,
+			napi_key_own_only,
+			static_cast<napi_key_filter>(napi_key_enumerable | napi_key_skip_symbols),
+			napi_key_keep_numbers
+		);
+		keys_ = keys_type{env(), js::napi::value_of<vector_tag>::from(property_names)};
+	}
+	return keys_;
+}
+
+bound_value_for_record::iterator_transform::iterator_transform(const bound_value_for_record& subject) :
+		subject_{&subject} {}
+
+auto bound_value_for_record::iterator_transform::operator()(value_of<value_tag> key) const -> value_type {
+	return std::pair{key_type::from(key), subject_->get(key)};
+}
+
+} // namespace js::napi

package/value/record.h.cc

@@ -0,0 +1,39 @@
+export module napi_js:record;
+import :array;
+import auto_js;
+import std;
+
+namespace js::napi {
+
+class bound_value_for_record : public bound_value_next<record_tag> {
+	public:
+		using bound_value_next<record_tag>::bound_value_next;
+		using keys_type = bound_value<vector_tag>;
+		using key_type = value_of<primitive_tag>;
+		using mapped_type = value_of<value_tag>;
+		using value_type = std::pair<key_type, mapped_type>;
+
+	private:
+		class iterator_transform {
+			public:
+				explicit iterator_transform(const bound_value_for_record& subject_);
+				auto operator()(value_of<value_tag> key) const -> value_type;
+
+			private:
+				const bound_value_for_record* subject_;
+		};
+
+	public:
+		using range_type = std::ranges::transform_view<std::views::all_t<const keys_type&>, iterator_transform>;
+		using iterator = std::ranges::iterator_t<range_type>;
+
+		[[nodiscard]] auto into_range() const -> range_type;
+		[[nodiscard]] auto size() const -> std::size_t;
+
+	private:
+		[[nodiscard]] auto keys() const -> const keys_type&;
+
+		mutable keys_type keys_;
+};
+
+} // namespace js::napi

package/value/value.cc

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

package/value/dictionary.cc

@@ -1,33 +0,0 @@
-module;
-#include <ranges>
-#include <utility>
-module napi_js;
-import :api;
-import :array;
-
-namespace js::napi {
-
-auto dictionary_like::into_range() const -> range_type {
-	return keys() | std::views::transform(iterator_transform{*this});
-}
-
-auto dictionary_like::size() const -> std::size_t {
-	return keys().size();
-}
-
-auto dictionary_like::keys() const -> const keys_type& {
-	if (napi_value{keys_} == nullptr) {
-		auto* property_names = napi::invoke(napi_get_property_names, env(), *this);
-		keys_ = keys_type{env(), js::napi::value<vector_tag>::from(property_names)};
-	}
-	return keys_;
-}
-
-dictionary_like::iterator_transform::iterator_transform(const dictionary_like& subject) :
-		subject_{&subject} {}
-
-auto dictionary_like::iterator_transform::operator()(value<value_tag> key) const -> value_type {
-	return std::pair{key_type::from(key), subject_->get(key)};
-}
-
-} // namespace js::napi

package/value/dictionary.h.cc

@@ -1,56 +0,0 @@
-module;
-#include <ranges>
-export module napi_js:dictionary;
-import :array;
-import :bound_value;
-import :object;
-import :value_handle;
-import auto_js;
-
-namespace js::napi {
-
-// Weird naming here because an object `{}` is a typeof "object", but lots of other things are
-// objects. Also, the object iterator is implemented as transformation on a property names vector
-// (which is also an object). So this needs to be its own class or it is a circular inheritance.
-class dictionary_like : public bound_value<object_tag> {
-	public:
-		using bound_value<object_tag>::bound_value;
-		using keys_type = bound_value<vector_tag>;
-		using key_type = value<primitive_tag>;
-		using mapped_type = value<value_tag>;
-		using value_type = std::pair<key_type, mapped_type>;
-
-	private:
-		class iterator_transform {
-			public:
-				explicit iterator_transform(const dictionary_like& subject_);
-				auto operator()(value<value_tag> key) const -> value_type;
-
-			private:
-				const dictionary_like* subject_;
-		};
-
-	public:
-		using range_type = std::ranges::transform_view<std::views::all_t<const keys_type&>, iterator_transform>;
-		using iterator = std::ranges::iterator_t<range_type>;
-
-		[[nodiscard]] auto into_range() const -> range_type;
-		[[nodiscard]] auto size() const -> std::size_t;
-
-	private:
-		[[nodiscard]] auto keys() const -> const keys_type&;
-
-		mutable keys_type keys_;
-};
-
-class bound_value_for_list : public dictionary_like {
-	public:
-		using dictionary_like::dictionary_like;
-};
-
-class bound_value_for_dictionary : public dictionary_like {
-	public:
-		using dictionary_like::dictionary_like;
-};
-
-} // namespace js::napi