aria-ease 6.8.0 → 6.9.1

package/bin/{test-WRIJHN6H.js → test-OND56UUL.js}

@@ -5,7 +5,7 @@ import {
   normalizeLevel,
   normalizeStrictness,
   resolveEnforcement
-} from "./chunk-2TOYEY5L.js";
+} from "./chunk-XERMSYEH.js";
 import "./chunk-I2KLQ2HA.js";
 
 // src/utils/test/src/test.ts
@@ -24,7 +24,7 @@ async function runContractTests(componentName, component, strictness) {
   const resolvedPath = new URL(contractPath, import.meta.url).pathname;
   const contractData = await fs.readFile(resolvedPath, "utf-8");
   const componentContract = JSON.parse(contractData);
-  const totalTests = componentContract.static[0].assertions.length + componentContract.dynamic.length;
+  const totalTests = (componentContract.relationships?.length || 0) + (componentContract.static[0]?.assertions.length || 0) + componentContract.dynamic.length;
   reporter.start(componentName, totalTests);
   const failures = [];
   const passes = [];
@@ -48,6 +48,82 @@ async function runContractTests(componentName, component, strictness) {
   let staticPassed = 0;
   let staticFailed = 0;
   let staticWarnings = 0;
+  for (const rel of componentContract.relationships || []) {
+    const relationshipLevel = normalizeLevel(rel.level);
+    if (rel.type === "aria-reference") {
+      const fromSelector = componentContract.selectors[rel.from];
+      const toSelector = componentContract.selectors[rel.to];
+      const relDescription = `${rel.from}.${rel.attribute} references ${rel.to}`;
+      if (!fromSelector || !toSelector) {
+        const outcome = classifyFailure(`Relationship selector missing: from="${rel.from}" or to="${rel.to}" not found in selectors.`, rel.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
+        continue;
+      }
+      const fromTarget = component.querySelector(fromSelector);
+      const toTarget = component.querySelector(toSelector);
+      if (!fromTarget || !toTarget) {
+        const outcome = classifyFailure(`Relationship target not found: ${!fromTarget ? rel.from : rel.to}.`, rel.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
+        continue;
+      }
+      const toId = toTarget.getAttribute("id");
+      const attrValue = fromTarget.getAttribute(rel.attribute) || "";
+      if (!toId) {
+        const outcome = classifyFailure(`Relationship target "${rel.to}" must have an id for ${rel.attribute} validation.`, rel.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
+        continue;
+      }
+      const references = attrValue.split(/\s+/).filter(Boolean);
+      if (!references.includes(toId)) {
+        const outcome = classifyFailure(`Expected ${rel.from} ${rel.attribute} to reference id "${toId}", found "${attrValue}".`, rel.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
+        continue;
+      }
+      passes.push(`Relationship valid: ${rel.from}.${rel.attribute} -> ${rel.to} (id=${toId}).`);
+      staticPassed += 1;
+      reporter.reportStaticTest(relDescription, "pass", void 0, relationshipLevel);
+      continue;
+    }
+    if (rel.type === "contains") {
+      const parentSelector = componentContract.selectors[rel.parent];
+      const childSelector = componentContract.selectors[rel.child];
+      const relDescription = `${rel.parent} contains ${rel.child}`;
+      if (!parentSelector || !childSelector) {
+        const outcome = classifyFailure(`Relationship selector missing: parent="${rel.parent}" or child="${rel.child}" not found in selectors.`, rel.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
+        continue;
+      }
+      const parentTarget = component.querySelector(parentSelector);
+      if (!parentTarget) {
+        const outcome = classifyFailure(`Relationship parent target not found: ${rel.parent}.`, rel.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
+        continue;
+      }
+      const nestedChild = parentTarget.querySelector(childSelector);
+      if (!nestedChild) {
+        const outcome = classifyFailure(`Expected ${rel.parent} to contain descendant matching selector for ${rel.child}.`, rel.level);
+        if (outcome.status === "fail") staticFailed += 1;
+        if (outcome.status === "warn") staticWarnings += 1;
+        reporter.reportStaticTest(relDescription, outcome.status, outcome.detail, outcome.level);
+        continue;
+      }
+      passes.push(`Relationship valid: ${rel.parent} contains ${rel.child}.`);
+      staticPassed += 1;
+      reporter.reportStaticTest(relDescription, "pass", void 0, relationshipLevel);
+    }
+  }
   for (const test of componentContract.static[0].assertions) {
     if (test.target !== "relative") {
       const staticLevel = normalizeLevel(test.level);
@@ -103,6 +179,7 @@ async function runContractTests(componentName, component, strictness) {
 }
 
 // src/utils/test/src/test.ts
+import path from "path";
 async function testUiComponent(componentName, component, url, options = {}) {
   if (!componentName || typeof componentName !== "string") {
     throw new Error("\u274C testUiComponent requires a valid componentName (string)");
@@ -141,14 +218,24 @@ Error: ${error instanceof Error ? error.message : String(error)}`
     return null;
   }
   let strictness = normalizeStrictness(options.strictness);
-  if (options.strictness === void 0 && typeof window === "undefined") {
+  let config = {};
+  let configBaseDir = typeof process !== "undefined" ? process.cwd() : "";
+  if (typeof process !== "undefined" && typeof process.cwd === "function") {
     try {
-      const { loadConfig } = await import("./configLoader-XRF6VM4J.js");
-      const { config } = await loadConfig(process.cwd());
-      const componentStrictness = config.test?.components?.find((comp) => comp?.name === componentName)?.strictness;
-      strictness = normalizeStrictness(componentStrictness ?? config.test?.strictness);
+      const { loadConfig } = await import("./configLoader-Q6A4JLKW.js");
+      const result2 = await loadConfig(process.cwd());
+      config = result2.config;
+      if (result2.configPath) {
+        configBaseDir = path.dirname(result2.configPath);
+      }
+      if (options.strictness === void 0) {
+        const componentStrictness = config.test?.components?.find((comp) => comp?.name === componentName)?.strictness;
+        strictness = normalizeStrictness(componentStrictness ?? config.test?.strictness);
+      }
     } catch {
-      strictness = "balanced";
+      if (options.strictness === void 0) {
+        strictness = "balanced";
+      }
     }
   }
   let contract;
@@ -157,8 +244,8 @@ Error: ${error instanceof Error ? error.message : String(error)}`
       const devServerUrl = await checkDevServer(url);
       if (devServerUrl) {
         console.log(`\u{1F3AD} Running Playwright tests on ${devServerUrl}`);
-        const { runContractTestsPlaywright } = await import("./contractTestRunnerPlaywright-UAOFNS7Z.js");
-        contract = await runContractTestsPlaywright(componentName, devServerUrl, strictness);
+        const { runContractTestsPlaywright } = await import("./contractTestRunnerPlaywright-ZZNWDUYP.js");
+        contract = await runContractTestsPlaywright(componentName, devServerUrl, strictness, config, configBaseDir);
       } else {
         throw new Error(
           `\u274C Dev server not running at ${url}

package/dist/AccordionComponentStrategy-4ZEIQ2V6.js

@@ -0,0 +1,42 @@
+import {
+  test_exports
+} from "./chunk-PK5L2SAF.js";
+import "./chunk-I2KLQ2HA.js";
+
+// src/utils/test/src/component-strategies/AccordionComponentStrategy.ts
+var AccordionComponentStrategy = class {
+  constructor(mainSelector, selectors, actionTimeoutMs = 400, assertionTimeoutMs = 400) {
+    this.mainSelector = mainSelector;
+    this.selectors = selectors;
+    this.actionTimeoutMs = actionTimeoutMs;
+    this.assertionTimeoutMs = assertionTimeoutMs;
+  }
+  async resetState(page) {
+    if (!this.selectors.panel || !this.selectors.trigger || this.selectors.popup) {
+      return;
+    }
+    const triggerSelector = this.selectors.trigger;
+    const panelSelector = this.selectors.panel;
+    if (!triggerSelector || !panelSelector) return;
+    const allTriggers = await page.locator(triggerSelector).all();
+    for (const trigger of allTriggers) {
+      const isExpanded = await trigger.getAttribute("aria-expanded") === "true";
+      const triggerPanel = await trigger.getAttribute("aria-controls");
+      if (isExpanded && triggerPanel) {
+        await trigger.click({ timeout: this.actionTimeoutMs });
+        const panel = page.locator(`#${triggerPanel}`);
+        await (0, test_exports.expect)(panel).toBeHidden({ timeout: this.assertionTimeoutMs }).catch(() => {
+        });
+      }
+    }
+  }
+  async shouldSkipTest() {
+    return false;
+  }
+  getMainSelector() {
+    return this.mainSelector;
+  }
+};
+export {
+  AccordionComponentStrategy
+};

package/dist/ComboboxComponentStrategy-OGRVZXAF.js

@@ -0,0 +1,64 @@
+import {
+  test_exports
+} from "./chunk-PK5L2SAF.js";
+import "./chunk-I2KLQ2HA.js";
+
+// src/utils/test/src/component-strategies/ComboboxComponentStrategy.ts
+var ComboboxComponentStrategy = class {
+  constructor(mainSelector, selectors, actionTimeoutMs = 400, assertionTimeoutMs = 400) {
+    this.mainSelector = mainSelector;
+    this.selectors = selectors;
+    this.actionTimeoutMs = actionTimeoutMs;
+    this.assertionTimeoutMs = assertionTimeoutMs;
+  }
+  async resetState(page) {
+    if (!this.selectors.popup) return;
+    const popupSelector = this.selectors.popup;
+    const popupElement = page.locator(popupSelector).first();
+    const isPopupVisible = await popupElement.isVisible().catch(() => false);
+    if (!isPopupVisible) return;
+    let listBoxClosed = false;
+    let closeSelector = this.selectors.input;
+    if (!closeSelector && this.selectors.focusable) {
+      closeSelector = this.selectors.focusable;
+    } else if (!closeSelector) {
+      closeSelector = this.selectors.button;
+    }
+    if (closeSelector) {
+      const closeElement = page.locator(closeSelector).first();
+      await closeElement.focus();
+      await page.keyboard.press("Escape");
+      listBoxClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: this.assertionTimeoutMs }).then(() => true).catch(() => false);
+    }
+    if (!listBoxClosed && this.selectors.button) {
+      const buttonElement = page.locator(this.selectors.button).first();
+      await buttonElement.click({ timeout: this.actionTimeoutMs });
+      listBoxClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: this.assertionTimeoutMs }).then(() => true).catch(() => false);
+    }
+    if (!listBoxClosed) {
+      await page.mouse.click(10, 10);
+      listBoxClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: this.assertionTimeoutMs }).then(() => true).catch(() => false);
+    }
+    if (!listBoxClosed) {
+      throw new Error(
+        `\u274C FATAL: Cannot close combobox popup between tests. Popup remains visible after trying:
+  1. Escape key
+  2. Clicking button
+  3. Clicking outside
+This indicates a problem with the combobox component's close functionality.`
+      );
+    }
+    if (this.selectors.input) {
+      await page.locator(this.selectors.input).first().clear();
+    }
+  }
+  async shouldSkipTest() {
+    return false;
+  }
+  getMainSelector() {
+    return this.mainSelector;
+  }
+};
+export {
+  ComboboxComponentStrategy
+};

package/dist/MenuComponentStrategy-JAMTCSNF.js

@@ -0,0 +1,81 @@
+import {
+  test_exports
+} from "./chunk-PK5L2SAF.js";
+import "./chunk-I2KLQ2HA.js";
+
+// src/utils/test/src/component-strategies/MenuComponentStrategy.ts
+var MenuComponentStrategy = class {
+  constructor(mainSelector, selectors, actionTimeoutMs = 400, assertionTimeoutMs = 400) {
+    this.mainSelector = mainSelector;
+    this.selectors = selectors;
+    this.actionTimeoutMs = actionTimeoutMs;
+    this.assertionTimeoutMs = assertionTimeoutMs;
+  }
+  async resetState(page) {
+    if (!this.selectors.popup) return;
+    const popupSelector = this.selectors.popup;
+    const popupElement = page.locator(popupSelector).first();
+    const isPopupVisible = await popupElement.isVisible().catch(() => false);
+    if (!isPopupVisible) return;
+    let menuClosed = false;
+    let closeSelector = this.selectors.input;
+    if (!closeSelector && this.selectors.focusable) {
+      closeSelector = this.selectors.focusable;
+    } else if (!closeSelector) {
+      closeSelector = this.selectors.trigger;
+    }
+    if (closeSelector) {
+      const closeElement = page.locator(closeSelector).first();
+      await closeElement.focus();
+      await page.keyboard.press("Escape");
+      menuClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: this.assertionTimeoutMs }).then(() => true).catch(() => false);
+    }
+    if (!menuClosed && this.selectors.trigger) {
+      const triggerElement = page.locator(this.selectors.trigger).first();
+      await triggerElement.click({ timeout: this.actionTimeoutMs });
+      menuClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: this.assertionTimeoutMs }).then(() => true).catch(() => false);
+    }
+    if (!menuClosed) {
+      await page.mouse.click(10, 10);
+      menuClosed = await (0, test_exports.expect)(popupElement).toBeHidden({ timeout: this.assertionTimeoutMs }).then(() => true).catch(() => false);
+    }
+    if (!menuClosed) {
+      throw new Error(
+        `\u274C FATAL: Cannot close menu between tests. Menu remains visible after trying:
+  1. Escape key
+  2. Clicking trigger
+  3. Clicking outside
+This indicates a problem with the menu component's close functionality.`
+      );
+    }
+    if (this.selectors.input) {
+      await page.locator(this.selectors.input).first().clear();
+    }
+    if (this.selectors.trigger) {
+      const triggerElement = page.locator(this.selectors.trigger).first();
+      await triggerElement.focus();
+    }
+  }
+  async shouldSkipTest(test, page) {
+    const requiresSubmenu = test.action.some(
+      (act) => act.target === "submenu" || act.target === "submenuTrigger" || act.target === "submenuItems"
+    ) || test.assertions.some(
+      (assertion) => assertion.target === "submenu" || assertion.target === "submenuTrigger" || assertion.target === "submenuItems"
+    );
+    if (!requiresSubmenu) {
+      return false;
+    }
+    const submenuTriggerSelector = this.selectors.submenuTrigger;
+    if (!submenuTriggerSelector) {
+      return true;
+    }
+    const submenuTriggerCount = await page.locator(submenuTriggerSelector).count();
+    return submenuTriggerCount === 0;
+  }
+  getMainSelector() {
+    return this.mainSelector;
+  }
+};
+export {
+  MenuComponentStrategy
+};

package/dist/TabsComponentStrategy-3SQURPMX.js

@@ -0,0 +1,29 @@
+import "./chunk-I2KLQ2HA.js";
+
+// src/utils/test/src/component-strategies/TabsComponentStrategy.ts
+var TabsComponentStrategy = class {
+  constructor(mainSelector, selectors) {
+    this.mainSelector = mainSelector;
+    this.selectors = selectors;
+  }
+  async resetState() {
+  }
+  async shouldSkipTest(test, page) {
+    if (test.isVertical !== void 0 && this.selectors.tablist) {
+      const tablistSelector = this.selectors.tablist;
+      const tablist = page.locator(tablistSelector).first();
+      const orientation = await tablist.getAttribute("aria-orientation");
+      const isVertical = orientation === "vertical";
+      if (test.isVertical !== isVertical) {
+        return true;
+      }
+    }
+    return false;
+  }
+  getMainSelector() {
+    return this.mainSelector;
+  }
+};
+export {
+  TabsComponentStrategy
+};

package/dist/chunk-PK5L2SAF.js

@@ -0,0 +1,17 @@
+import {
+  __export,
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// node_modules/@playwright/test/index.mjs
+var test_exports = {};
+__export(test_exports, {
+  default: () => default2
+});
+__reExport(test_exports, test_star);
+import * as test_star from "playwright/test";
+import { default as default2 } from "playwright/test";
+
+export {
+  test_exports
+};

package/dist/{chunk-2TOYEY5L.js → chunk-XERMSYEH.js}

@@ -30,11 +30,13 @@ var ContractReporter = class {
   skipped = 0;
   warnings = 0;
   isPlaywright = false;
+  isCustomContract = false;
   apgUrl = "https://www.w3.org/WAI/ARIA/apg/";
   hasPrintedStaticSection = false;
   hasPrintedDynamicSection = false;
-  constructor(isPlaywright = false) {
+  constructor(isPlaywright = false, isCustomContract = false) {
     this.isPlaywright = isPlaywright;
+    this.isCustomContract = isCustomContract;
   }
   log(message) {
     process.stderr.write(message + "\n");
@@ -195,6 +197,13 @@ ${"\u2500".repeat(60)}`);
     const totalPasses = this.staticPasses + dynamicPasses;
     const totalFailures = this.staticFailures + dynamicFailures;
     const totalRun = totalPasses + totalFailures + this.warnings;
+    const getComponentMessage = () => {
+      const componentDisplayName = `${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)}`;
+      if (this.isCustomContract) {
+        return `${componentDisplayName} component validates against your custom accessibility policy \u2713`;
+      }
+      return `${componentDisplayName} component meets Aria-Ease baseline WAI-ARIA expectations \u2713`;
+    };
     if (failures.length > 0) {
       this.reportFailures(failures);
     }
@@ -206,7 +215,7 @@ ${"\u2550".repeat(60)}`);
 `);
     if (totalFailures === 0 && this.skipped === 0 && this.warnings === 0) {
       this.log(`\u2705 All ${totalRun} tests passed!`);
-      this.log(`   ${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)} component meets WAI-ARIA expectations for Roles, States, Properties, and Keyboard Interactions \u2713`);
+      this.log(`   ${getComponentMessage()}`);
     } else if (totalFailures === 0) {
       this.log(`\u2705 ${totalPasses}/${totalRun} tests passed`);
       if (this.skipped > 0) {
@@ -215,7 +224,7 @@ ${"\u2550".repeat(60)}`);
       if (this.warnings > 0) {
         this.log(`\u26A0\uFE0F ${this.warnings} warning${this.warnings > 1 ? "s" : ""}`);
       }
-      this.log(`   ${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)} component meets WAI-ARIA expectations for Roles, States, Properties, and Keyboard Interactions \u2713`);
+      this.log(`   ${getComponentMessage()}`);
     } else {
       this.log(`\u274C ${totalFailures} test${totalFailures > 1 ? "s" : ""} failed`);
       this.log(`\u2705 ${totalPasses} test${totalPasses > 1 ? "s" : ""} passed`);

package/dist/{configLoader-IT4PWCJB.js → configLoader-WTGJAP4Z.js}

@@ -56,6 +56,9 @@ function validateConfig(config) {
               if (comp.path !== void 0 && typeof comp.path !== "string") {
                 errors.push(`test.components[${idx}].path must be a string when provided`);
               }
+              if (comp.strategyPath !== void 0 && typeof comp.strategyPath !== "string") {
+                errors.push(`test.components[${idx}].strategyPath must be a string when provided`);
+              }
               if (comp.strictness !== void 0 && !["minimal", "balanced", "strict", "paranoid"].includes(comp.strictness)) {
                 errors.push(`test.components[${idx}].strictness must be one of: minimal, balanced, strict, paranoid`);
               }
@@ -70,6 +73,24 @@ function validateConfig(config) {
       }
     }
   }
+  if (cfg.contracts !== void 0) {
+    if (!Array.isArray(cfg.contracts)) {
+      errors.push("contracts must be an array");
+    } else {
+      cfg.contracts.forEach((contract, idx) => {
+        if (typeof contract !== "object" || contract === null) {
+          errors.push(`contracts[${idx}] must be an object`);
+        } else {
+          if (typeof contract.src !== "string") {
+            errors.push(`contracts[${idx}].src is required and must be a string`);
+          }
+          if (contract.out !== void 0 && typeof contract.out !== "string") {
+            errors.push(`contracts[${idx}].out must be a string`);
+          }
+        }
+      });
+    }
+  }
   return { valid: errors.length === 0, errors };
 }
 async function loadConfigFile(filePath) {