aria-ease 3.0.2 → 4.0.0

package/dist/index.js

@@ -9208,6 +9208,164 @@ function updateAccordionTriggerAriaAttributes(accordionId, accordionTriggersClas
   });
 }
 
+// src/accordion/src/makeAccordionAccessible/makeAccordionAccessible.ts
+function makeAccordionAccessible({ accordionId, triggersClass, panelsClass, allowMultiple = false }) {
+  const accordionContainer = document.querySelector(`#${accordionId}`);
+  if (!accordionContainer) {
+    console.error(`[aria-ease] Element with id="${accordionId}" not found. Make sure the accordion container exists before calling makeAccordionAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  const triggers = Array.from(accordionContainer.querySelectorAll(`.${triggersClass}`));
+  if (triggers.length === 0) {
+    console.error(`[aria-ease] No elements with class="${triggersClass}" found. Make sure accordion triggers exist before calling makeAccordionAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  const panels = Array.from(accordionContainer.querySelectorAll(`.${panelsClass}`));
+  if (panels.length === 0) {
+    console.error(`[aria-ease] No elements with class="${panelsClass}" found. Make sure accordion panels exist before calling makeAccordionAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  if (triggers.length !== panels.length) {
+    console.error(`[aria-ease] Accordion trigger/panel mismatch: found ${triggers.length} triggers but ${panels.length} panels.`);
+    return { cleanup: () => {
+    } };
+  }
+  const handlerMap = /* @__PURE__ */ new WeakMap();
+  const clickHandlerMap = /* @__PURE__ */ new WeakMap();
+  function initialize() {
+    triggers.forEach((trigger, index) => {
+      const panel = panels[index];
+      if (!trigger.id) {
+        trigger.id = `${accordionId}-trigger-${index}`;
+      }
+      if (!panel.id) {
+        panel.id = `${accordionId}-panel-${index}`;
+      }
+      trigger.setAttribute("aria-controls", panel.id);
+      trigger.setAttribute("aria-expanded", "false");
+      panel.setAttribute("role", "region");
+      panel.setAttribute("aria-labelledby", trigger.id);
+      panel.style.display = "none";
+    });
+  }
+  function expandItem(index) {
+    if (index < 0 || index >= triggers.length) {
+      console.error(`[aria-ease] Invalid accordion index: ${index}`);
+      return;
+    }
+    const trigger = triggers[index];
+    const panel = panels[index];
+    trigger.setAttribute("aria-expanded", "true");
+    panel.style.display = "block";
+  }
+  function collapseItem(index) {
+    if (index < 0 || index >= triggers.length) {
+      console.error(`[aria-ease] Invalid accordion index: ${index}`);
+      return;
+    }
+    const trigger = triggers[index];
+    const panel = panels[index];
+    trigger.setAttribute("aria-expanded", "false");
+    panel.style.display = "none";
+  }
+  function toggleItem(index) {
+    const trigger = triggers[index];
+    const isExpanded = trigger.getAttribute("aria-expanded") === "true";
+    if (isExpanded) {
+      collapseItem(index);
+    } else {
+      if (!allowMultiple) {
+        triggers.forEach((_, i) => {
+          if (i !== index) {
+            collapseItem(i);
+          }
+        });
+      }
+      expandItem(index);
+    }
+  }
+  function handleTriggerClick(index) {
+    return () => {
+      toggleItem(index);
+    };
+  }
+  function handleTriggerKeydown(index) {
+    return (event) => {
+      const { key } = event;
+      switch (key) {
+        case "Enter":
+        case " ":
+          event.preventDefault();
+          toggleItem(index);
+          break;
+        case "ArrowDown":
+          event.preventDefault();
+          {
+            const nextIndex = (index + 1) % triggers.length;
+            triggers[nextIndex].focus();
+          }
+          break;
+        case "ArrowUp":
+          event.preventDefault();
+          {
+            const prevIndex = (index - 1 + triggers.length) % triggers.length;
+            triggers[prevIndex].focus();
+          }
+          break;
+        case "Home":
+          event.preventDefault();
+          triggers[0].focus();
+          break;
+        case "End":
+          event.preventDefault();
+          triggers[triggers.length - 1].focus();
+          break;
+      }
+    };
+  }
+  function addListeners() {
+    triggers.forEach((trigger, index) => {
+      const clickHandler = handleTriggerClick(index);
+      const keydownHandler = handleTriggerKeydown(index);
+      trigger.addEventListener("click", clickHandler);
+      trigger.addEventListener("keydown", keydownHandler);
+      handlerMap.set(trigger, keydownHandler);
+      clickHandlerMap.set(trigger, clickHandler);
+    });
+  }
+  function removeListeners() {
+    triggers.forEach((trigger) => {
+      const keydownHandler = handlerMap.get(trigger);
+      const clickHandler = clickHandlerMap.get(trigger);
+      if (keydownHandler) {
+        trigger.removeEventListener("keydown", keydownHandler);
+        handlerMap.delete(trigger);
+      }
+      if (clickHandler) {
+        trigger.removeEventListener("click", clickHandler);
+        clickHandlerMap.delete(trigger);
+      }
+    });
+  }
+  function cleanup() {
+    removeListeners();
+    triggers.forEach((_, index) => {
+      collapseItem(index);
+    });
+  }
+  initialize();
+  addListeners();
+  return {
+    expandItem,
+    collapseItem,
+    toggleItem,
+    cleanup
+  };
+}
+
 // src/utils/handleKeyPress/handleKeyPress.ts
 function isTextInput(el) {
   if (el.tagName !== "INPUT") return false;
@@ -9331,7 +9489,7 @@ function handleKeyPress(event, elementItems, elementItemIndex, menuElementDiv, t
 }
 
 // src/block/src/makeBlockAccessible/makeBlockAccessible.ts
-function makeBlockAccessible(blockId, blockItemsClass) {
+function makeBlockAccessible({ blockId, blockItemsClass }) {
   const blockDiv = document.querySelector(`#${blockId}`);
   if (!blockDiv) {
     console.error(`[aria-ease] Element with id="${blockId}" not found. Make sure the block element exists before calling makeBlockAccessible.`);
@@ -9410,6 +9568,134 @@ function updateCheckboxAriaAttributes(checkboxId, checkboxesClass, checkboxState
   });
 }
 
+// src/checkbox/src/makeCheckboxAccessible/makeCheckboxAccessible.ts
+function makeCheckboxAccessible({ checkboxGroupId, checkboxesClass }) {
+  const checkboxGroup = document.querySelector(`#${checkboxGroupId}`);
+  if (!checkboxGroup) {
+    console.error(`[aria-ease] Element with id="${checkboxGroupId}" not found. Make sure the checkbox group container exists before calling makeCheckboxAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  const checkboxes = Array.from(checkboxGroup.querySelectorAll(`.${checkboxesClass}`));
+  if (checkboxes.length === 0) {
+    console.error(`[aria-ease] No elements with class="${checkboxesClass}" found. Make sure checkboxes exist before calling makeCheckboxAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  const handlerMap = /* @__PURE__ */ new WeakMap();
+  const clickHandlerMap = /* @__PURE__ */ new WeakMap();
+  function initialize() {
+    if (!checkboxGroup.getAttribute("role")) {
+      checkboxGroup.setAttribute("role", "group");
+    }
+    checkboxes.forEach((checkbox) => {
+      checkbox.setAttribute("role", "checkbox");
+      if (!checkbox.hasAttribute("aria-checked")) {
+        checkbox.setAttribute("aria-checked", "false");
+      }
+      if (!checkbox.hasAttribute("tabindex")) {
+        checkbox.setAttribute("tabindex", "0");
+      }
+    });
+  }
+  function toggleCheckbox(index) {
+    if (index < 0 || index >= checkboxes.length) {
+      console.error(`[aria-ease] Invalid checkbox index: ${index}`);
+      return;
+    }
+    const checkbox = checkboxes[index];
+    const isChecked = checkbox.getAttribute("aria-checked") === "true";
+    checkbox.setAttribute("aria-checked", isChecked ? "false" : "true");
+  }
+  function setCheckboxState(index, checked) {
+    if (index < 0 || index >= checkboxes.length) {
+      console.error(`[aria-ease] Invalid checkbox index: ${index}`);
+      return;
+    }
+    checkboxes[index].setAttribute("aria-checked", checked ? "true" : "false");
+  }
+  function handleCheckboxClick(index) {
+    return () => {
+      toggleCheckbox(index);
+    };
+  }
+  function handleCheckboxKeydown(index) {
+    return (event) => {
+      const { key } = event;
+      switch (key) {
+        case " ":
+          event.preventDefault();
+          toggleCheckbox(index);
+          break;
+        case "ArrowDown":
+          event.preventDefault();
+          {
+            const nextIndex = (index + 1) % checkboxes.length;
+            checkboxes[nextIndex].focus();
+          }
+          break;
+        case "ArrowUp":
+          event.preventDefault();
+          {
+            const prevIndex = (index - 1 + checkboxes.length) % checkboxes.length;
+            checkboxes[prevIndex].focus();
+          }
+          break;
+        case "Home":
+          event.preventDefault();
+          checkboxes[0].focus();
+          break;
+        case "End":
+          event.preventDefault();
+          checkboxes[checkboxes.length - 1].focus();
+          break;
+      }
+    };
+  }
+  function addListeners() {
+    checkboxes.forEach((checkbox, index) => {
+      const clickHandler = handleCheckboxClick(index);
+      const keydownHandler = handleCheckboxKeydown(index);
+      checkbox.addEventListener("click", clickHandler);
+      checkbox.addEventListener("keydown", keydownHandler);
+      handlerMap.set(checkbox, keydownHandler);
+      clickHandlerMap.set(checkbox, clickHandler);
+    });
+  }
+  function removeListeners() {
+    checkboxes.forEach((checkbox) => {
+      const keydownHandler = handlerMap.get(checkbox);
+      const clickHandler = clickHandlerMap.get(checkbox);
+      if (keydownHandler) {
+        checkbox.removeEventListener("keydown", keydownHandler);
+        handlerMap.delete(checkbox);
+      }
+      if (clickHandler) {
+        checkbox.removeEventListener("click", clickHandler);
+        clickHandlerMap.delete(checkbox);
+      }
+    });
+  }
+  function cleanup() {
+    removeListeners();
+  }
+  function getCheckedStates() {
+    return checkboxes.map((checkbox) => checkbox.getAttribute("aria-checked") === "true");
+  }
+  function getCheckedIndices() {
+    return checkboxes.map((checkbox, index) => checkbox.getAttribute("aria-checked") === "true" ? index : -1).filter((index) => index !== -1);
+  }
+  initialize();
+  addListeners();
+  return {
+    toggleCheckbox,
+    setCheckboxState,
+    getCheckedStates,
+    getCheckedIndices,
+    cleanup
+  };
+}
+
 // src/menu/src/makeMenuAccessible/makeMenuAccessible.ts
 function makeMenuAccessible({ menuId, menuItemsClass, triggerId }) {
   const menuDiv = document.querySelector(`#${menuId}`);
@@ -9440,7 +9726,6 @@ function makeMenuAccessible({ menuId, menuItemsClass, triggerId }) {
   triggerButton.setAttribute("aria-expanded", "false");
   menuDiv.setAttribute("role", "menu");
   menuDiv.setAttribute("aria-labelledby", triggerId);
-  menuDiv.style.display = "none";
   const handlerMap = /* @__PURE__ */ new WeakMap();
   const submenuInstances = /* @__PURE__ */ new Map();
   let cachedItems = null;
@@ -9576,41 +9861,40 @@ function makeMenuAccessible({ menuId, menuItemsClass, triggerId }) {
       item.setAttribute("role", "menuitem");
     });
   }
+  intializeMenuItems();
   function handleTriggerKeydown(event) {
-    const key = event.key;
-    if (key === "Enter" || key === " ") {
+    if (event.key === "Enter" || event.key === " ") {
       event.preventDefault();
-      const isExpanded = triggerButton.getAttribute("aria-expanded") === "true";
-      if (isExpanded) {
+      const isOpen = menuDiv.style.display !== "none";
+      if (isOpen) {
         closeMenu();
       } else {
         openMenu();
       }
     }
   }
-  let isTransitioning = false;
   function handleTriggerClick() {
-    if (isTransitioning) return;
-    const isExpanded = triggerButton.getAttribute("aria-expanded") === "true";
-    isTransitioning = true;
-    if (isExpanded) {
+    const isOpen = menuDiv.style.display !== "none";
+    if (isOpen) {
       closeMenu();
     } else {
       openMenu();
     }
-    setTimeout(() => {
-      isTransitioning = false;
-    }, 100);
   }
-  intializeMenuItems();
+  function handleClickOutside(event) {
+    if (menuDiv && triggerButton && !menuDiv.contains(event.target) && !triggerButton.contains(event.target) && getComputedStyle(menuDiv).display !== "none" && triggerButton.getAttribute("aria-expanded") === "true") {
+      closeMenu();
+    }
+  }
   triggerButton.addEventListener("keydown", handleTriggerKeydown);
   triggerButton.addEventListener("click", handleTriggerClick);
+  document.addEventListener("click", handleClickOutside);
   triggerButton.setAttribute("data-menu-initialized", "true");
   function cleanup() {
     removeListeners();
     triggerButton.removeEventListener("keydown", handleTriggerKeydown);
     triggerButton.removeEventListener("click", handleTriggerClick);
-    triggerButton.removeAttribute("data-menu-initialized");
+    document.removeEventListener("click", handleClickOutside);
     menuDiv.style.display = "none";
     setAria(false);
     submenuInstances.forEach((instance) => instance.cleanup());
@@ -9653,6 +9937,127 @@ function updateRadioAriaAttributes(radioId, radiosClass, radioStates, currentPre
   });
 }
 
+// src/radio/src/makeRadioAccessible/makeRadioAccessible.ts
+function makeRadioAccessible({ radioGroupId, radiosClass, defaultSelectedIndex = 0 }) {
+  const radioGroup = document.querySelector(`#${radioGroupId}`);
+  if (!radioGroup) {
+    console.error(`[aria-ease] Element with id="${radioGroupId}" not found. Make sure the radio group container exists before calling makeRadioAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  const radios = Array.from(radioGroup.querySelectorAll(`.${radiosClass}`));
+  if (radios.length === 0) {
+    console.error(`[aria-ease] No elements with class="${radiosClass}" found. Make sure radio buttons exist before calling makeRadioAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  const handlerMap = /* @__PURE__ */ new WeakMap();
+  const clickHandlerMap = /* @__PURE__ */ new WeakMap();
+  let currentSelectedIndex = defaultSelectedIndex;
+  function initialize() {
+    if (!radioGroup.getAttribute("role")) {
+      radioGroup.setAttribute("role", "radiogroup");
+    }
+    radios.forEach((radio, index) => {
+      radio.setAttribute("role", "radio");
+      radio.setAttribute("tabindex", index === currentSelectedIndex ? "0" : "-1");
+      if (index === currentSelectedIndex) {
+        radio.setAttribute("aria-checked", "true");
+      } else {
+        radio.setAttribute("aria-checked", "false");
+      }
+    });
+  }
+  function selectRadio(index) {
+    if (index < 0 || index >= radios.length) {
+      console.error(`[aria-ease] Invalid radio index: ${index}`);
+      return;
+    }
+    if (currentSelectedIndex >= 0 && currentSelectedIndex < radios.length) {
+      radios[currentSelectedIndex].setAttribute("aria-checked", "false");
+      radios[currentSelectedIndex].setAttribute("tabindex", "-1");
+    }
+    radios[index].setAttribute("aria-checked", "true");
+    radios[index].setAttribute("tabindex", "0");
+    radios[index].focus();
+    currentSelectedIndex = index;
+  }
+  function handleRadioClick(index) {
+    return () => {
+      selectRadio(index);
+    };
+  }
+  function handleRadioKeydown(index) {
+    return (event) => {
+      const { key } = event;
+      let nextIndex = index;
+      switch (key) {
+        case "ArrowDown":
+        case "ArrowRight":
+          event.preventDefault();
+          nextIndex = (index + 1) % radios.length;
+          selectRadio(nextIndex);
+          break;
+        case "ArrowUp":
+        case "ArrowLeft":
+          event.preventDefault();
+          nextIndex = (index - 1 + radios.length) % radios.length;
+          selectRadio(nextIndex);
+          break;
+        case " ":
+          event.preventDefault();
+          selectRadio(index);
+          break;
+        case "Home":
+          event.preventDefault();
+          selectRadio(0);
+          break;
+        case "End":
+          event.preventDefault();
+          selectRadio(radios.length - 1);
+          break;
+      }
+    };
+  }
+  function addListeners() {
+    radios.forEach((radio, index) => {
+      const clickHandler = handleRadioClick(index);
+      const keydownHandler = handleRadioKeydown(index);
+      radio.addEventListener("click", clickHandler);
+      radio.addEventListener("keydown", keydownHandler);
+      handlerMap.set(radio, keydownHandler);
+      clickHandlerMap.set(radio, clickHandler);
+    });
+  }
+  function removeListeners() {
+    radios.forEach((radio) => {
+      const keydownHandler = handlerMap.get(radio);
+      const clickHandler = clickHandlerMap.get(radio);
+      if (keydownHandler) {
+        radio.removeEventListener("keydown", keydownHandler);
+        handlerMap.delete(radio);
+      }
+      if (clickHandler) {
+        radio.removeEventListener("click", clickHandler);
+        clickHandlerMap.delete(radio);
+      }
+    });
+  }
+  function cleanup() {
+    removeListeners();
+  }
+  function getSelectedIndex() {
+    return currentSelectedIndex;
+  }
+  initialize();
+  addListeners();
+  return {
+    selectRadio,
+    getSelectedIndex,
+    cleanup
+  };
+}
+
 // src/toggle/src/updateToggleAriaAttribute/updateToggleAriaAttribute.ts
 function updateToggleAriaAttribute(toggleId, togglesClass, toggleStates, currentPressedToggleIndex) {
   const toggleDiv = document.querySelector(`#${toggleId}`);
@@ -9680,6 +10085,150 @@ function updateToggleAriaAttribute(toggleId, togglesClass, toggleStates, current
   });
 }
 
+// src/toggle/src/makeTogggleAccessible/makeToggleAccessible.ts
+function makeToggleAccessible({ toggleId, togglesClass, isSingleToggle = true }) {
+  const toggleContainer = document.querySelector(`#${toggleId}`);
+  if (!toggleContainer) {
+    console.error(`[aria-ease] Element with id="${toggleId}" not found. Make sure the toggle element exists before calling makeToggleAccessible.`);
+    return { cleanup: () => {
+    } };
+  }
+  let toggles;
+  if (isSingleToggle) {
+    toggles = [toggleContainer];
+  } else {
+    if (!togglesClass) {
+      console.error(`[aria-ease] togglesClass is required when isSingleToggle is false.`);
+      return { cleanup: () => {
+      } };
+    }
+    toggles = Array.from(toggleContainer.querySelectorAll(`.${togglesClass}`));
+    if (toggles.length === 0) {
+      console.error(`[aria-ease] No elements with class="${togglesClass}" found. Make sure toggle buttons exist before calling makeToggleAccessible.`);
+      return { cleanup: () => {
+      } };
+    }
+  }
+  const handlerMap = /* @__PURE__ */ new WeakMap();
+  const clickHandlerMap = /* @__PURE__ */ new WeakMap();
+  function initialize() {
+    toggles.forEach((toggle) => {
+      if (toggle.tagName.toLowerCase() !== "button" && !toggle.getAttribute("role")) {
+        toggle.setAttribute("role", "button");
+      }
+      if (!toggle.hasAttribute("aria-pressed")) {
+        toggle.setAttribute("aria-pressed", "false");
+      }
+      if (!toggle.hasAttribute("tabindex")) {
+        toggle.setAttribute("tabindex", "0");
+      }
+    });
+  }
+  function toggleButton(index) {
+    if (index < 0 || index >= toggles.length) {
+      console.error(`[aria-ease] Invalid toggle index: ${index}`);
+      return;
+    }
+    const toggle = toggles[index];
+    const isPressed = toggle.getAttribute("aria-pressed") === "true";
+    toggle.setAttribute("aria-pressed", isPressed ? "false" : "true");
+  }
+  function setPressed(index, pressed) {
+    if (index < 0 || index >= toggles.length) {
+      console.error(`[aria-ease] Invalid toggle index: ${index}`);
+      return;
+    }
+    toggles[index].setAttribute("aria-pressed", pressed ? "true" : "false");
+  }
+  function handleToggleClick(index) {
+    return () => {
+      toggleButton(index);
+    };
+  }
+  function handleToggleKeydown(index) {
+    return (event) => {
+      const { key } = event;
+      switch (key) {
+        case "Enter":
+        case " ":
+          event.preventDefault();
+          toggleButton(index);
+          break;
+        case "ArrowDown":
+        case "ArrowRight":
+          if (!isSingleToggle && toggles.length > 1) {
+            event.preventDefault();
+            const nextIndex = (index + 1) % toggles.length;
+            toggles[nextIndex].focus();
+          }
+          break;
+        case "ArrowUp":
+        case "ArrowLeft":
+          if (!isSingleToggle && toggles.length > 1) {
+            event.preventDefault();
+            const prevIndex = (index - 1 + toggles.length) % toggles.length;
+            toggles[prevIndex].focus();
+          }
+          break;
+        case "Home":
+          if (!isSingleToggle && toggles.length > 1) {
+            event.preventDefault();
+            toggles[0].focus();
+          }
+          break;
+        case "End":
+          if (!isSingleToggle && toggles.length > 1) {
+            event.preventDefault();
+            toggles[toggles.length - 1].focus();
+          }
+          break;
+      }
+    };
+  }
+  function addListeners() {
+    toggles.forEach((toggle, index) => {
+      const clickHandler = handleToggleClick(index);
+      const keydownHandler = handleToggleKeydown(index);
+      toggle.addEventListener("click", clickHandler);
+      toggle.addEventListener("keydown", keydownHandler);
+      handlerMap.set(toggle, keydownHandler);
+      clickHandlerMap.set(toggle, clickHandler);
+    });
+  }
+  function removeListeners() {
+    toggles.forEach((toggle) => {
+      const keydownHandler = handlerMap.get(toggle);
+      const clickHandler = clickHandlerMap.get(toggle);
+      if (keydownHandler) {
+        toggle.removeEventListener("keydown", keydownHandler);
+        handlerMap.delete(toggle);
+      }
+      if (clickHandler) {
+        toggle.removeEventListener("click", clickHandler);
+        clickHandlerMap.delete(toggle);
+      }
+    });
+  }
+  function cleanup() {
+    removeListeners();
+  }
+  function getPressedStates() {
+    return toggles.map((toggle) => toggle.getAttribute("aria-pressed") === "true");
+  }
+  function getPressedIndices() {
+    return toggles.map((toggle, index) => toggle.getAttribute("aria-pressed") === "true" ? index : -1).filter((index) => index !== -1);
+  }
+  initialize();
+  addListeners();
+  return {
+    toggleButton,
+    setPressed,
+    getPressedStates,
+    getPressedIndices,
+    cleanup
+  };
+}
+
 // src/combobox/src/makeComboBoxAccessible.ts
 function makeComboboxAccessible({ comboboxInputId, comboboxButtonId, listBoxId, listBoxItemsClass, config: config2 }) {
   const comboboxInput = document.getElementById(`${comboboxInputId}`);
@@ -13479,20 +14028,54 @@ async function runContractTests(componentName, component) {
   const staticFailed = 0;
   reporter.reportStatic(staticPassed, staticFailed);
   reporter.summary(failures);
-  return { passes, failures };
+  return { passes, failures, skipped };
 }
 
 // src/utils/test/src/test.ts
 async function testUiComponent(componentName, component, url) {
-  const results = await axe(component);
+  if (!componentName || typeof componentName !== "string") {
+    throw new Error("\u274C testUiComponent requires a valid componentName (string)");
+  }
+  if (!component || !(component instanceof HTMLElement)) {
+    throw new Error("\u274C testUiComponent requires a valid component (HTMLElement)");
+  }
+  if (url && typeof url !== "string") {
+    throw new Error("\u274C testUiComponent url parameter must be a string");
+  }
+  let results;
+  try {
+    results = await axe(component);
+  } catch (error) {
+    throw new Error(
+      `\u274C Axe accessibility scan failed
+Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
   let contract;
-  if (url) {
-    console.log(`\u{1F3AD} Running Playwright E2E tests on ${url}`);
-    const { runContractTestsPlaywright } = await import("./contractTestRunnerPlaywright-7U2O33SR.js");
-    contract = await runContractTestsPlaywright(componentName, url);
-  } else {
-    console.log(`\u{1F9EA} Running jsdom tests (limited event handling)`);
-    contract = await runContractTests(componentName, component);
+  try {
+    if (url) {
+      console.log(`\u{1F3AD} Running Playwright E2E tests on ${url}`);
+      try {
+        new URL(url);
+      } catch {
+        throw new Error(
+          `\u274C Invalid URL format: "${url}"
+URL must include protocol (e.g., "http://localhost:5173/test")`
+        );
+      }
+      const { runContractTestsPlaywright } = await import("./contractTestRunnerPlaywright-UQQI5MYS.js");
+      contract = await runContractTestsPlaywright(componentName, url);
+    } else {
+      console.log(`\u{1F9EA} Running jsdom tests (limited event handling)`);
+      console.log(`Some tests may be skipped or yield false positives/negatives.
+For full coverage, run with a URL to enable Playwright E2E tests.`);
+      contract = await runContractTests(componentName, component);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      throw error;
+    }
+    throw new Error(`\u274C Contract test execution failed: ${String(error)}`);
   }
   const result = {
     violations: results.violations,
@@ -13503,10 +14086,11 @@ async function testUiComponent(componentName, component, url) {
     const mode = url ? "Playwright" : "jsdom";
     throw new Error(
       `
-\u274C ${contract.failures.length} assertion${contract.failures.length > 1 ? "s" : ""} failed (${mode} mode)
-\u2705 ${contract.passes.length} assertion${contract.passes.length > 1 ? "s" : ""} passed
+\u274C ${contract.failures.length} accessibility contract test${contract.failures.length > 1 ? "s" : ""} failed (${mode} mode)
+\u2705 ${contract.passes.length} test${contract.passes.length > 1 ? "s" : ""} passed
 
-\u{1F4CB} Review the detailed test report above for specific failures.`
+\u{1F4CB} Review the detailed test report above for specific failures.
+\u{1F4A1} Contract tests validate ARIA attributes and keyboard interactions per W3C APG guidelines.`
     );
   }
   if (results.violations.length > 0) {
@@ -13553,9 +14137,13 @@ if (typeof window === "undefined") {
   };
 }
 export {
+  makeAccordionAccessible,
   makeBlockAccessible,
+  makeCheckboxAccessible,
   makeComboboxAccessible,
   makeMenuAccessible,
+  makeRadioAccessible,
+  makeToggleAccessible,
   testUiComponent,
   updateAccordionTriggerAriaAttributes,
   updateCheckboxAriaAttributes,