Move presentational role conflict resolution down to Role.from

packages/alfa-aria/src/feature.ts

@@ -57,11 +57,7 @@ export class Feature<N extends string = string> {
 }
 
 export namespace Feature {
-  export type Aspect<T, A extends Array<unknown> = []> = Mapper<
-    Element,
-    T,
-    A
-  >;
+  export type Aspect<T, A extends Array<unknown> = []> = Mapper<Element, T, A>;
 
   export interface Status {
     readonly obsolete: boolean;
@@ -71,7 +67,7 @@ export namespace Feature {
     /**
      * @internal
      */
-    readonly allowPresentational?: boolean;
+    readonly allowPresentational: boolean;
   }
 
   const features = Cache.empty<Namespace, Cache<string, Feature>>();
@@ -309,9 +305,10 @@ Feature.register(
 
 Feature.register(
   Namespace.HTML,
-  Feature.of("img", (element, { allowPresentational = true }) =>
+  Feature.of("img", (element, { allowPresentational }) =>
     Option.of(
-      allowPresentational && element.attribute("alt").some((alt) => alt.value === "")
+      allowPresentational &&
+        element.attribute("alt").some((alt) => alt.value === "")
         ? "presentation"
         : "img"
     )

packages/alfa-aria/src/node.ts

@@ -233,23 +233,10 @@ export namespace Node {
         } else {
           accessibleNode = Role.from(node)
             .flatMap((role) => {
-              // If the element has a presentational role, but is not allowed to
-              // be presentational, we fall back to its implicit role by not
-              // considering its explicit role.
-              if (
-                role.some(isPresentational) &&
-                !isAllowedPresentational(node)
-              ) {
-                return Role.from(node, {
-                  explicit: false,
-                  allowPresentational: false,
-                });
-              }
-
               return Branched.of(role);
             })
             .flatMap<Node>((role) => {
-              if (role.some(isPresentational)) {
+              if (role.some(Role.isPresentational)) {
                 return Branched.of(Container.of(node));
               }
 
@@ -323,29 +310,3 @@ export namespace Node {
     });
   }
 }
-
-const isPresentational: Predicate<Role> = property(
-  "name",
-  equals("presentation", "none")
-);
-
-/**
- * Determine if an element is allowed to be presentational.
- *
- * @see https://w3c.github.io/aria/#conflict_resolution_presentation_none
- */
-const isAllowedPresentational: Predicate<dom.Element> = (element) => {
-  if (element.tabIndex().isSome()) {
-    return false;
-  }
-
-  return Role.lookup("roletype").some((role) => {
-    for (const attribute of role.characteristics.supports) {
-      if (element.attribute(attribute).isSome()) {
-        return false;
-      }
-    }
-
-    return true;
-  });
-};

packages/alfa-aria/src/role.ts

@@ -12,7 +12,7 @@ import { Feature } from "./feature";
 import { Attribute } from "./attribute";
 
 const { some } = Iterable;
-const { equals, or } = Predicate;
+const { equals, or, not, property, test } = Predicate;
 
 export class Role<N extends string = string> implements Equatable {
   public static of<N extends string>(
@@ -129,6 +129,7 @@ export namespace Role {
   /**
    * @see https://www.w3.org/TR/wai-aria/#roles_categorization
    */
+
   export enum Category {
     /**
      * @see https://www.w3.org/TR/wai-aria/#abstract_roles
@@ -233,6 +234,8 @@ export namespace Role {
   ): Branched<Option<Role>, Browser> {
     const role = element.attribute("role").map((attr) => attr.value.trim());
 
+    const allowedPresentational = options.allowPresentational ?? isAllowedPresentational(element);
+
     return (
       Branched.of<Option<string>, Browser>(
         role.map((role) => role.toLowerCase())
@@ -251,15 +254,22 @@ export namespace Role {
                   const role = Role.lookup(name);
 
                   if (
+                    // If the role is not abstract…
                     role.some(
                       (role) => role.category !== Role.Category.Abstract
+                    ) &&
+                    // …and it's not a presentational role in a forbidden context…
+                    !(
+                      role.some(Role.isPresentational) &&
+                      !isAllowedPresentational
                     )
                   ) {
+                    // …then we got ourselves a valid explicit role…
                     return role;
                   }
                 }
               }
-
+              // …otherwise, default to implicit role computation.
               return None;
             })
             .orElse(() => {
@@ -270,7 +280,8 @@ export namespace Role {
                   return feature.flatMap((feature) =>
                     feature
                       .role(element, {
-                        allowPresentational: options.allowPresentational,
+                        allowPresentational:
+                          allowedPresentational,
                       })
                       .flatMap(Role.lookup)
                   );
@@ -284,12 +295,14 @@ export namespace Role {
   }
 
   export namespace from {
-    export interface Options extends Feature.RoleOptions {
+    export interface Options extends Partial<Feature.RoleOptions> {
       readonly explicit?: boolean;
       readonly implicit?: boolean;
     }
   }
 
+  export const isPresentational = hasName("presentation", "none");
+
   export function hasName(predicate: Predicate<string>): Predicate<Role>;
 
   export function hasName(
@@ -313,6 +326,27 @@ export namespace Role {
   }
 }
 
+/**
+ * Determine if an element is allowed to be presentational.
+ *
+ * @see https://w3c.github.io/aria/#conflict_resolution_presentation_none
+ */
+const isAllowedPresentational: Predicate<Element> = (element) => {
+  if (element.tabIndex().isSome()) {
+    return false;
+  }
+
+  return Role.lookup("roletype").some((role) => {
+    for (const attribute of role.characteristics.supports) {
+      if (element.attribute(attribute).isSome()) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+};
+
 import "./role/separator";
 
 import "./role/abstract/command";