@sit-onyx/headless 1.0.0-beta.1 → 1.0.0-beta.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sit-onyx/headless",
   "description": "Headless composables for Vue",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.2",
   "type": "module",
   "author": "Schwarz IT KG",
   "license": "Apache-2.0",

package/src/composables/menuButton/TestMenuButton.ct.tsx

@@ -9,6 +9,6 @@ test("menuButton", async ({ mount, page }) => {
     page,
     button: page.getByRole("button"),
     menu: page.locator("ul"),
-    menuItems: await page.locator("li").all(),
+    menuItems: page.getByRole("menuitem"),
   });
 });

package/src/composables/menuButton/TestMenuButton.vue

@@ -8,18 +8,19 @@ const items = Array.from({ length: 10 }, (_, index) => {
 });
 
 const activeItem = ref<string>();
+const isExpanded = ref(false);
+const onToggle = () => (isExpanded.value = !isExpanded.value);
 
 const {
-  elements: { button, menu, menuItem, listItem, flyout },
-  state: { isExpanded },
-} = createMenuButton();
+  elements: { root, button, menu, menuItem, listItem },
+} = createMenuButton({ isExpanded, onToggle });
 </script>
 
 <template>
-  <button v-bind="button">Toggle nav menu</button>
-  <div v-bind="flyout">
+  <div v-bind="root">
+    <button v-bind="button">Toggle nav menu</button>
     <ul v-show="isExpanded" v-bind="menu">
-      <li v-for="item in items" v-bind="listItem" :key="item.value" title="item">
+      <li v-for="item in items" v-bind="listItem" :key="item.value">
         <a v-bind="menuItem({ active: activeItem === item.value })" href="#">{{ item.label }}</a>
       </li>
     </ul>

package/src/composables/menuButton/createMenuButton.testing.ts

@@ -17,7 +17,7 @@ export type MenuButtonTestingOptions = {
   /**
    * List items (at least 3).
    */
-  menuItems: Locator[];
+  menuItems: Locator;
 };
 
 /**
@@ -45,25 +45,26 @@ export const menuButtonTesting = async ({
   await expect(button).toBeVisible();
 
   // ensure correct navigation menu aria attributes
-  await expect(
-    button,
-    'flyout menu must have an "aria-expanded" attribute set to false',
-  ).toHaveAttribute("aria-expanded", "false");
-
-  button.hover();
-
-  await expect(
-    button,
-    'flyout menu must have an "aria-expanded" attribute set to true',
-  ).toHaveAttribute("aria-expanded", "true");
-
-  const firstItem = menuItems[0].getByRole("menuitem");
-  const secondItem = menuItems[1].getByRole("menuitem");
-  const lastItem = menuItems[menuItems.length - 1].getByRole("menuitem");
+  await expect(button, "button must have arial-controls attribute").toHaveAttribute(
+    "aria-controls",
+  );
+  await expect(button, "button must have aria-expanded attribute").toHaveAttribute(
+    "aria-expanded",
+    "false",
+  );
 
   await page.keyboard.press("Tab");
   await expect(button, "Button should be focused when pressing tab key").toBeFocused();
 
+  const firstItem = menuItems.first();
+  const secondItem = menuItems.nth(1);
+  const lastItem = menuItems.last();
+
+  await page.keyboard.press("Enter");
+  await expect(button, "button must have aria-expanded attribute").toHaveAttribute(
+    "aria-expanded",
+    "true",
+  );
   await button.press("ArrowDown");
   await expect(
     firstItem,

package/src/composables/menuButton/createMenuButton.ts

@@ -1,123 +1,141 @@
-import { computed, ref } from "vue";
+import { computed, ref, type Ref } from "vue";
 import { createBuilder } from "../../utils/builder";
 import { createId } from "../../utils/id";
 import { debounce } from "../../utils/timer";
+import { useGlobalEventListener } from "../helpers/useGlobalListener";
+
+type CreateMenuButtonOptions = {
+  isExpanded: Ref<boolean>;
+  onToggle: () => void;
+};
 
 /**
  * Based on https://www.w3.org/WAI/ARIA/apg/patterns/disclosure/examples/disclosure-navigation/
  */
-export const createMenuButton = createBuilder(() => {
-  const menuId = createId("menu");
-  const buttonId = createId("menu-button");
-  const isExpanded = ref(false);
+export const createMenuButton = createBuilder(
+  ({ isExpanded, onToggle }: CreateMenuButtonOptions) => {
+    const rootId = createId("menu-button-root");
+    const menuId = createId("menu-button-list");
+    const menuRef = ref<HTMLElement>();
+    const buttonId = createId("menu-button-button");
 
-  /**
-   * Debounced expanded state that will only be toggled after a given timeout.
-   */
-  const updateDebouncedExpanded = debounce(
-    (expanded: boolean) => (isExpanded.value = expanded),
-    200,
-  );
+    useGlobalEventListener({
+      type: "keydown",
+      listener: (e) => e.key === "Escape" && isExpanded.value && onToggle(),
+      disabled: computed(() => !isExpanded.value),
+    });
 
-  const hoverEvents = computed(() => {
-    return {
-      onMouseover: () => updateDebouncedExpanded(true),
-      onMouseout: () => updateDebouncedExpanded(false),
-      onFocusin: () => (isExpanded.value = true),
-      onFocusout: () => (isExpanded.value = false),
-    };
-  });
+    /**
+     * Debounced expanded state that will only be toggled after a given timeout.
+     */
+    const updateDebouncedExpanded = debounce(
+      (expanded: boolean) => isExpanded.value !== expanded && onToggle(),
+      200,
+    );
 
-  const focusRelativeItem = (next: "next" | "prev" | "first" | "last") => {
-    const currentMenuItem = document.activeElement as HTMLElement;
+    const focusRelativeItem = (next: "next" | "prev" | "first" | "last") => {
+      const currentMenuItem = document.activeElement as HTMLElement;
 
-    // Either the current focus is on a "menuitem", then we can just get the parent menu.
-    // Or the current focus is on the button, then we can get the connected menu using the menuId
-    const currentMenu =
-      currentMenuItem?.closest('[role="menu"]') || document.getElementById(menuId);
-    if (!currentMenu) return;
+      // Either the current focus is on a "menuitem", then we can just get the parent menu.
+      // Or the current focus is on the button, then we can get the connected menu using the menuId
+      const currentMenu = currentMenuItem?.closest('[role="menu"]') || menuRef.value;
+      if (!currentMenu) return;
 
-    const menuItems = [...currentMenu.querySelectorAll<HTMLElement>('[role="menuitem"]')];
-    let nextIndex = 0;
+      const menuItems = [...currentMenu.querySelectorAll<HTMLElement>('[role="menuitem"]')];
+      let nextIndex = 0;
 
-    if (currentMenuItem) {
-      const currentIndex = menuItems.indexOf(currentMenuItem);
-      switch (next) {
-        case "next":
-          nextIndex = currentIndex + 1;
+      if (currentMenuItem) {
+        const currentIndex = menuItems.indexOf(currentMenuItem);
+        switch (next) {
+          case "next":
+            nextIndex = currentIndex + 1;
+            break;
+          case "prev":
+            nextIndex = currentIndex - 1;
+            break;
+          case "first":
+            nextIndex = 0;
+            break;
+          case "last":
+            nextIndex = menuItems.length - 1;
+            break;
+        }
+      }
+
+      const nextMenuItem = menuItems[nextIndex];
+      nextMenuItem?.focus();
+    };
+
+    const handleKeydown = (event: KeyboardEvent) => {
+      switch (event.key) {
+        case "ArrowDown":
+        case "ArrowRight":
+          event.preventDefault();
+          focusRelativeItem("next");
+          break;
+        case "ArrowUp":
+        case "ArrowLeft":
+          event.preventDefault();
+          focusRelativeItem("prev");
+          break;
+        case "Home":
+          event.preventDefault();
+          focusRelativeItem("first");
           break;
-        case "prev":
-          nextIndex = currentIndex - 1;
+        case "End":
+          event.preventDefault();
+          focusRelativeItem("last");
           break;
-        case "first":
-          nextIndex = 0;
+        case " ":
+          event.preventDefault();
+          (event.target as HTMLElement).click();
           break;
-        case "last":
-          nextIndex = menuItems.length - 1;
+        case "Escape":
+          event.preventDefault();
+          isExpanded.value && onToggle();
           break;
       }
-    }
-
-    const nextMenuItem = menuItems[nextIndex];
-    nextMenuItem?.focus();
-  };
-
-  const handleKeydown = (event: KeyboardEvent) => {
-    switch (event.key) {
-      case "ArrowDown":
-      case "ArrowRight":
-        event.preventDefault();
-        focusRelativeItem("next");
-        break;
-      case "ArrowUp":
-      case "ArrowLeft":
-        event.preventDefault();
-        focusRelativeItem("prev");
-        break;
-      case "Home":
-        event.preventDefault();
-        focusRelativeItem("first");
-        break;
-      case "End":
-        event.preventDefault();
-        focusRelativeItem("last");
-        break;
-      case " ":
-        event.preventDefault();
-        (event.target as HTMLElement).click();
-        break;
-    }
-  };
+    };
 
-  return {
-    state: { isExpanded },
-    elements: {
-      button: computed(
-        () =>
-          ({
-            "aria-controls": menuId,
-            "aria-expanded": isExpanded.value,
-            "aria-haspopup": true,
-            id: buttonId,
-            ...hoverEvents.value,
-            onKeydown: handleKeydown,
-          }) as const,
-      ),
-      flyout: {
-        ...hoverEvents.value,
-      },
-      menu: {
-        id: menuId,
-        role: "menu",
-        "aria-labelledby": buttonId,
-        onKeydown: handleKeydown,
+    return {
+      elements: {
+        root: {
+          id: rootId,
+          onKeydown: handleKeydown,
+          onMouseover: () => updateDebouncedExpanded(true),
+          onMouseout: () => updateDebouncedExpanded(false),
+          onFocusout: (event) => {
+            // if focus receiving element is not part of the menu button, then close
+            if (document.getElementById(rootId)?.contains(event.relatedTarget as HTMLElement)) {
+              return;
+            }
+            isExpanded.value && onToggle();
+          },
+        },
+        button: computed(
+          () =>
+            ({
+              "aria-controls": menuId,
+              "aria-expanded": isExpanded.value,
+              "aria-haspopup": true,
+              onFocus: () => !isExpanded.value && onToggle(),
+              id: buttonId,
+            }) as const,
+        ),
+        menu: {
+          id: menuId,
+          ref: menuRef,
+          role: "menu",
+          "aria-labelledby": buttonId,
+          onClick: () => isExpanded.value && onToggle(),
+        },
+        ...createMenuItems().elements,
       },
-      ...createMenuItem().elements,
-    },
-  };
-});
+    };
+  },
+);
 
-export const createMenuItem = createBuilder(() => {
+export const createMenuItems = createBuilder(() => {
   return {
     elements: {
       listItem: {

package/src/composables/navigationMenu/TestMenu.ct.tsx

@@ -0,0 +1,12 @@
+import { test } from "@playwright/experimental-ct-vue";
+import { navigationTesting } from "./createMenu.testing";
+import TestMenu from "./TestMenu.vue";
+
+test("navigationMenu", async ({ mount, page }) => {
+  await mount(<TestMenu />);
+
+  await navigationTesting({
+    buttons: page.getByRole("button"),
+    nav: page.getByRole("navigation"),
+  });
+});

package/src/composables/navigationMenu/TestMenu.vue

@@ -0,0 +1,16 @@
+<script lang="ts" setup>
+import TestMenuButton from "../menuButton/TestMenuButton.vue";
+import { createNavigationMenu } from "./createMenu";
+
+const {
+  elements: { nav },
+} = createNavigationMenu({ navigationName: "test menu" });
+</script>
+
+<template>
+  <nav v-bind="nav">
+    <TestMenuButton />
+    <TestMenuButton />
+    <TestMenuButton />
+  </nav>
+</template>

package/src/composables/navigationMenu/createMenu.testing.ts

@@ -0,0 +1,48 @@
+import { expect } from "@playwright/experimental-ct-vue";
+import type { Locator } from "@playwright/test";
+
+export type NavigationMenuTestingOptions = {
+  /**
+   * Locator for the navigation landmark.
+   */
+  nav: Locator;
+  /**
+   * Locator for the button elements.
+   */
+  buttons: Locator;
+};
+
+/**
+ * Playwright utility for executing accessibility testing for a navigation menu.
+ * Will check aria attributes and keyboard shortcuts as defined in https://www.w3.org/WAI/ARIA/apg/patterns/disclosure/examples/disclosure-navigation/
+ */
+export const navigationTesting = async ({ nav, buttons }: NavigationMenuTestingOptions) => {
+  /**
+   * Navigation landmark should have label
+   */
+  await expect(nav).toHaveRole("navigation");
+  await expect(nav).toHaveAttribute("aria-label");
+  /**
+   * Disclosure buttons should have aria attributes
+   */
+  for (const button of await buttons.all()) {
+    await expect(button, "button must have arial-controls attribute").toHaveAttribute(
+      "aria-controls",
+    );
+    await expect(button, "button must have aria-expanded attribute").toHaveAttribute(
+      "aria-expanded",
+    );
+  }
+  /**
+   * Focus first button
+   */
+  await nav.press("Tab");
+  await expect(buttons.nth(0)).toBeFocused();
+  /**
+   * Move keyboard focus among top-level buttons using arrow keys
+   */
+  await nav.press("ArrowRight");
+  await expect(buttons.nth(1)).toBeFocused();
+  await nav.press("ArrowLeft");
+  await expect(buttons.nth(0)).toBeFocused();
+};

package/src/composables/navigationMenu/createMenu.ts

@@ -0,0 +1,56 @@
+import { unref, type MaybeRef } from "vue";
+import { createId } from "../..";
+import { createBuilder } from "../../utils/builder";
+import { MathUtils } from "../../utils/math";
+
+type CreateNavigationMenu = {
+  /**
+   * Name of the navigation landmark.
+   * Usually this is the name of the website.
+   */
+  navigationName?: MaybeRef<string | undefined>;
+};
+
+/**
+ * Based on https://www.w3.org/WAI/ARIA/apg/patterns/disclosure/examples/disclosure-navigation/
+ */
+export const createNavigationMenu = createBuilder(({ navigationName }: CreateNavigationMenu) => {
+  const navId = createId("nav");
+
+  const getMenuButtons = () => {
+    const nav = document.getElementById(navId);
+    if (!nav) return [];
+    return [...nav.querySelectorAll<HTMLElement>("button[aria-expanded][aria-controls]")];
+  };
+
+  const focusRelative = (trigger: HTMLElement, next: "next" | "previous") => {
+    const menuButtons = getMenuButtons();
+    const index = menuButtons.indexOf(trigger);
+    if (index === -1) return;
+    const nextIndex = MathUtils.clamp(
+      index + (next === "next" ? 1 : -1),
+      0,
+      menuButtons.length - 1,
+    );
+    menuButtons[nextIndex].focus();
+  };
+
+  return {
+    elements: {
+      nav: {
+        "aria-label": unref(navigationName),
+        id: navId,
+        onKeydown: (event) => {
+          switch (event.key) {
+            case "ArrowRight":
+              focusRelative(event.target as HTMLElement, "next");
+              break;
+            case "ArrowLeft":
+              focusRelative(event.target as HTMLElement, "previous");
+              break;
+          }
+        },
+      },
+    },
+  };
+});

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from "./composables/comboBox/createComboBox";
 export * from "./composables/listbox/createListbox";
 export * from "./composables/menuButton/createMenuButton";
+export * from "./composables/navigationMenu/createMenu";
 export * from "./composables/tooltip/createTooltip";
 export { createId } from "./utils/id";
 export { isPrintableCharacter, wasKeyPressed } from "./utils/keyboard";