chore: code suggestions

crates/rome_aria/src/lib.rs

@@ -7,7 +7,7 @@ pub mod roles;
 pub use properties::AriaProperties;
 pub(crate) use roles::AriaRoleDefinition;
 pub use roles::AriaRoles;
-use rome_aria_metadata::{AriaPropertiesEnum, AriaPropertyTypeEnum};
+pub use rome_aria_metadata::{AriaPropertiesEnum, AriaPropertyTypeEnum};
 
 /// It checks if an ARIA property is valid
 ///

crates/rome_aria/src/macros.rs

@@ -14,11 +14,11 @@ macro_rules! define_role {
         }
 
         impl $crate::AriaRoleDefinition for $id {
-            fn properties<'a>(&self) -> std::slice::Iter<'a, (&str, bool)> {
+            fn properties(&self) -> std::slice::Iter<(&str, bool)> {
                 $id::PROPS.iter()
             }
 
-            fn roles<'a>(&self) -> std::slice::Iter<'a, &str> {
+            fn roles(&self) -> std::slice::Iter<&str> {
                 $id::ROLES.iter()
             }
         }
@@ -40,11 +40,11 @@ macro_rules! define_property {
         }
 
         impl AriaPropertyDefinition for $id {
-            fn values<'a>(&self) -> std::slice::Iter<'a, &str> {
+            fn values(&self) -> std::slice::Iter<&'static str> {
                 $id::VALUES.iter()
             }
 
-            fn property_type<'a>(&self) -> $crate::AriaPropertyTypeEnum {
+            fn property_type(&self) -> $crate::AriaPropertyTypeEnum {
                 // SAFETY: PROPERTY_TYPE is internal and should not contain extraneous properties
                 $crate::AriaPropertyTypeEnum::from_str($id::PROPERTY_TYPE).unwrap()
             }

crates/rome_aria/src/properties.rs

@@ -97,7 +97,7 @@ define_property! {
 
 define_property! {
     AriaDropeffect {
-        PROPERTY_TYPE: "id",
+        PROPERTY_TYPE: "tokenlist",
         VALUES: ["copy", "execute", "link", "move", "none", "popup"],
     }
 }
@@ -342,7 +342,7 @@ define_property! {
 pub struct AriaProperties;
 
 impl AriaProperties {
-    pub fn get_property(&self, property_name: &str) -> Option<&dyn AriaPropertyDefinition> {
+    pub fn get_property<'a>(&self, property_name: &str) -> Option<&'a dyn AriaPropertyDefinition> {
         Some(match property_name {
             "aria-activedescendant" => &AriaActivedescendant as &dyn AriaPropertyDefinition,
             "aria-autocomplete" => &AriaAutocomplete as &dyn AriaPropertyDefinition,
@@ -398,7 +398,7 @@ impl AriaProperties {
 
 pub trait AriaPropertyDefinition: Debug {
     /// Returns the allowed values by this property
-    fn values<'a>(&self) -> Iter<'a, &str>;
+    fn values(&self) -> Iter<&str>;
 
     /// Returns the property type
     fn property_type(&self) -> AriaPropertyTypeEnum;

crates/rome_aria/src/roles.rs

@@ -18,10 +18,10 @@ pub trait AriaRoleDefinition: Debug {
     /// let properties = checkbox_role.properties();
     /// assert_eq!(properties.len(), 2);
     /// ```
-    fn properties<'a>(&self) -> Iter<'a, (&str, bool)>;
+    fn properties(&self) -> Iter<(&str, bool)>;
 
     /// It returns an iterator over the possible roles of this definition
-    fn roles<'a>(&self) -> Iter<'a, &str>;
+    fn roles(&self) -> Iter<&str>;
 
     /// Given a [aria property](ARIA_PROPERTIES) as input, it checks if it's required
     /// for the current role.
@@ -45,7 +45,7 @@ pub trait AriaRoleDefinition: Debug {
         if is_aria_property_valid(property_to_check) {
             let property_to_check = AriaPropertiesEnum::from_str(property_to_check);
             if let Ok(property_to_check) = property_to_check {
-                for (property, required) in self.properties().as_ref() {
+                for (property, required) in self.properties() {
                     let property = AriaPropertiesEnum::from_str(property).unwrap();
                     if property == property_to_check {
                         return *required;

crates/rome_js_analyze/src/aria_analyzers/nursery/use_aria_prop_types.rs

@@ -1,12 +1,14 @@
 use crate::aria_services::Aria;
 use rome_analyze::context::RuleContext;
 use rome_analyze::{declare_rule, Rule, RuleDiagnostic};
+use rome_aria::AriaPropertyTypeEnum;
 use rome_console::markup;
 use rome_js_syntax::{
     AnyJsExpression, AnyJsLiteralExpression, AnyJsxAttributeValue, JsSyntaxToken, JsxAttribute,
     TextRange,
 };
 use rome_rowan::{AstNode, AstNodeList};
+use std::slice::Iter;
 
 declare_rule! {
     /// Enforce that ARIA state and property values are valid.
@@ -24,6 +26,14 @@ declare_rule! {
     /// <span aria-labelledby="" >some text</span>
     /// ```
     ///
+    /// ```jsx, expect_diagnostic
+    /// <span aria-valuemax="hey">some text</span>
+    /// ```
+    ///
+    /// ```jsx, expect_diagnostic
+    /// <span aria-orientation="hey">some text</span>
+    /// ```
+    ///
     /// ### Valid
     ///
     /// ```jsx
@@ -48,8 +58,9 @@ declare_rule! {
 
 pub(crate) struct UseAriaProptypesState {
     attribute_value_range: TextRange,
-    allowed_values: Vec<String>,
+    allowed_values: Iter<'static, &'static str>,
     attribute_name: JsSyntaxToken,
+    property_type: AriaPropertyTypeEnum,
 }
 
 impl Rule for UseAriaPropTypes {
@@ -76,15 +87,21 @@ impl Rule for UseAriaPropTypes {
                                 // Early error, the template literal is empty
                                 return Some(UseAriaProptypesState {
                                     attribute_value_range,
-                                    allowed_values: aria_property
-                                        .values()
-                                        .map(|value| value.to_string())
-                                        .collect::<Vec<_>>(),
+                                    allowed_values: aria_property.values(),
                                     attribute_name,
+                                    property_type: aria_property.property_type(),
                                 });
-                            } else {
-                                None
                             }
+                            template
+                                .elements()
+                                .iter()
+                                .next()
+                                .and_then(|chunk| {
+                                    chunk
+                                        .as_js_template_chunk_element()
+                                        .and_then(|t| t.template_chunk_token().ok())
+                                })
+                                .map(|t| t.token_text_trimmed())
                         }
                         AnyJsExpression::AnyJsLiteralExpression(
                             AnyJsLiteralExpression::JsStringLiteralExpression(string),
@@ -98,11 +115,9 @@ impl Rule for UseAriaPropTypes {
             if !aria_property.contains_correct_value(attribute_text.text()) {
                 return Some(UseAriaProptypesState {
                     attribute_value_range,
-                    allowed_values: aria_property
-                        .values()
-                        .map(|value| value.to_string())
-                        .collect::<Vec<_>>(),
+                    allowed_values: aria_property.values(),
                     attribute_name,
+                    property_type: aria_property.property_type(),
                 });
             }
         }
@@ -112,19 +127,73 @@ impl Rule for UseAriaPropTypes {
 
     fn diagnostic(_ctx: &RuleContext<Self>, state: &Self::State) -> Option<RuleDiagnostic> {
         let attribute_name = state.attribute_name.text_trimmed();
-        Some(
-            RuleDiagnostic::new(
-                rule_category!(),
-                state.attribute_value_range,
-                markup! {
+        let diagnostic = RuleDiagnostic::new(
+            rule_category!(),
+            state.attribute_value_range,
+            markup! {
                 "The value of the ARIA attribute "<Emphasis>{attribute_name}</Emphasis>" is not correct."
             },
-            ).footer_list(
-        markup!{
-                    "The supported values for the "<Emphasis>{attribute_name}</Emphasis>" attribute are:"
+        );
+
+        let diagnostic = match state.property_type {
+            AriaPropertyTypeEnum::Boolean => {
+                diagnostic.footer_list(
+                    markup!{
+                        "The only supported values for the "<Emphasis>{attribute_name}</Emphasis>" is one of the following:"
+                    },
+                    &["true", "false"]
+                )
+            }
+            AriaPropertyTypeEnum::Integer => {
+                diagnostic.note(
+                    markup!{
+                        "The only value supported is a number without fractional components."
+                    }
+                )
+            }
+            AriaPropertyTypeEnum::Id |
+            AriaPropertyTypeEnum::Idlist |
+            AriaPropertyTypeEnum::String => {
+                diagnostic.note(
+                    markup!{
+                        "The only supported value is text."
+                    }
+                )
+            }
+
+            AriaPropertyTypeEnum::Number => {
+                diagnostic.note(
+                    markup!{
+                        "The only supported value is number."
+                    }
+                )
+            }
+            AriaPropertyTypeEnum::Token => {
+                diagnostic.footer_list(
+                    markup!{
+                    "The only supported value for the "<Emphasis>{attribute_name}</Emphasis>" is one of the following:"
                 },
-            &state.allowed_values
-            )
-        )
+                    state.allowed_values.as_slice()
+                )
+            }
+            AriaPropertyTypeEnum::Tokenlist => {
+                diagnostic.footer_list(
+                    markup!{
+                    "The values supported for "<Emphasis>{attribute_name}</Emphasis>" are one or more of the following:"
+                },
+                    state.allowed_values.as_slice()
+                )
+            }
+            AriaPropertyTypeEnum::Tristate => {
+                diagnostic.footer_list(
+                    markup!{
+                        "The only supported value for the "<Emphasis>{attribute_name}</Emphasis>" one of the following:"
+                    },
+                    &["true", "false", "mixed"]
+                )
+            }
+        };
+
+        Some(diagnostic)
     }
 }

crates/rome_js_analyze/src/lib.rs

@@ -226,17 +226,13 @@ mod tests {
             String::from_utf8(buffer).unwrap()
         }
 
-        const SOURCE: &str = r#"something.forEach((Element, index) => {
-    return <List
-        ><div key={index}>foo</div>
-    </List>;
-})"#;
+        const SOURCE: &str = r#"<span aria-labelledby={``} ></span>"#;
 
         let parsed = parse(SOURCE, FileId::zero(), SourceType::jsx());
 
         let mut error_ranges: Vec<TextRange> = Vec::new();
         let options = AnalyzerOptions::default();
-        let rule_filter = RuleFilter::Rule("suspicious", "noArrayIndexKey");
+        let rule_filter = RuleFilter::Rule("nursery", "useAriaPropTypes");
         analyze(
             FileId::zero(),
             &parsed.tree(),

crates/rome_js_analyze/tests/specs/nursery/useAriaPropTypes/invalid.jsx

@@ -1,8 +1,15 @@
 var a = <span role="checkbox" aria-checked="test" ></span>;
 var a = <span aria-autocomplete="test" ></span>;
 var a = <span aria-invalid="foo"></span>;
+var a = <span aria-invalid={`foo`} ></span>;
+var a = <span aria-invalid={"foo"} ></span>;
 var a = <span aria-errormessage="" ></span>;
 var a = <span aria-relevant="fancy" ></span>;
 var a = <span aria-labelledby="" ></span>;
 var a = <span aria-labelledby={``} ></span>;
+var a = <span aria-labelledby={""} ></span>;
 var a = <span aria-details=""></span>;
+var a = <span aria-setsize="hey"></span>;
+var a = <span aria-valuemax="hey"></span>;
+var a = <span aria-dropeffect="hey"></span>;
+var a = <span aria-orientation="hey"></span>;