@auto_js/napi 0.0.8 → 0.0.10

package/value/record.cc

@@ -1,19 +1,17 @@
 module napi_js;
-import :api;
-import :array;
 import std;
 
 namespace js::napi {
 
-auto bound_value_for_record::into_range() const -> range_type {
+auto 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 {
+auto value_for_record::size() const -> std::size_t {
 	return keys().size();
 }
 
-auto bound_value_for_record::keys() const -> const keys_type& {
+auto value_for_record::keys() const -> const keys_type& {
 	if (napi_value{keys_} == nullptr) {
 		auto* property_names = napi::invoke(
 			napi_get_all_property_names,
@@ -23,15 +21,15 @@ auto bound_value_for_record::keys() const -> const keys_type& {
 			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)};
+		keys_ = keys_type{env(), js::napi::local_of<vector_tag>::from(property_names)};
 	}
 	return keys_;
 }
 
-bound_value_for_record::iterator_transform::iterator_transform(const bound_value_for_record& subject) :
+value_for_record::iterator_transform::iterator_transform(const value_for_record& subject) :
 		subject_{&subject} {}
 
-auto bound_value_for_record::iterator_transform::operator()(value_of<value_tag> key) const -> value_type {
+auto value_for_record::iterator_transform::operator()(local_of<value_tag> key) const -> value_type {
 	return std::pair{key_type::from(key), subject_->get(key)};
 }
 

package/value/record.h.cc

@@ -5,22 +5,22 @@ import std;
 
 namespace js::napi {
 
-class bound_value_for_record : public bound_value_next<record_tag> {
+class value_for_record : public 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_next<record_tag>::value_next;
+		using keys_type = value_of<vector_tag>;
+		using key_type = local_of<primitive_tag>;
+		using mapped_type = local_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;
+				explicit iterator_transform(const value_for_record& subject_);
+				auto operator()(local_of<value_tag> key) const -> value_type;
 
 			private:
-				const bound_value_for_record* subject_;
+				const value_for_record* subject_;
 		};
 
 	public:

package/value/value.cc

@@ -4,7 +4,9 @@ export import :array;
 export import :class_;
 export import :external;
 export import :function;
+export import :handle.local_of;
+export import :handle.types;
+export import :handle.value_of;
 export import :object;
 export import :primitive;
 export import :record;
-export import :value_handle;

package/handle/bound_value.cc

@@ -1,47 +0,0 @@
-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 tag_type = Tag;
-		using bound_value<typename Tag::tag_type>::bound_value;
-		bound_value_next() = default;
-		bound_value_next(napi_env env, value_of<Tag> value) :
-				bound_value<typename Tag::tag_type>{env, napi_value{value}} {}
-
-		// NOLINTNEXTLINE(google-explicit-constructor)
-		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_of<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_of<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