aria-ease 2.8.2 → 2.8.4

package/dist/{contractTestRunnerPlaywright-YNHMLHQ2.js → contractTestRunnerPlaywright-7O2T4JES.js}

@@ -25,8 +25,11 @@ async function runContractTestsPlaywright(componentName, url) {
     browser = await chromium.launch({ headless: true });
     const context = await browser.newContext();
     const page = await context.newPage();
-    await page.goto(url, { waitUntil: "networkidle" });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 3e4 });
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: 6e4
+    });
+    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {

package/dist/{contractTestRunnerPlaywright-ZY2T4UTV.js → contractTestRunnerPlaywright-AJ2DOOJT.js}

@@ -25,8 +25,11 @@ async function runContractTestsPlaywright(componentName, url) {
     browser = await chromium.launch({ headless: true });
     const context = await browser.newContext();
     const page = await context.newPage();
-    await page.goto(url, { waitUntil: "networkidle" });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 9e4 });
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: 6e4
+    });
+    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {
@@ -148,6 +151,11 @@ async function runContractTestsPlaywright(componentName, url) {
               continue;
             }
             const target = page.locator(keypressSelector).first();
+            const elementCount = await target.count();
+            if (elementCount === 0) {
+              reporter.reportTest(dynamicTest, "skip", `Skipping test - ${act.target} element not found (optional submenu test)`);
+              break;
+            }
             await target.press(keyValue);
           }
         }

package/dist/index.cjs

@@ -9419,8 +9419,11 @@ async function runContractTestsPlaywright(componentName, url) {
     browser = await import_playwright.chromium.launch({ headless: true });
     const context = await browser.newContext();
     const page = await context.newPage();
-    await page.goto(url, { waitUntil: "networkidle" });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 3e4 });
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: 6e4
+    });
+    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {
@@ -9542,6 +9545,11 @@ async function runContractTestsPlaywright(componentName, url) {
               continue;
             }
             const target = page.locator(keypressSelector).first();
+            const elementCount = await target.count();
+            if (elementCount === 0) {
+              reporter.reportTest(dynamicTest, "skip", `Skipping test - ${act.target} element not found (optional submenu test)`);
+              break;
+            }
             await target.press(keyValue);
           }
         }

package/dist/index.js

@@ -13171,7 +13171,7 @@ async function testUiComponent(componentName, component, url) {
   let contract;
   if (url) {
     console.log(`\u{1F3AD} Running Playwright E2E tests on ${url}`);
-    const { runContractTestsPlaywright } = await import("./contractTestRunnerPlaywright-YNHMLHQ2.js");
+    const { runContractTestsPlaywright } = await import("./contractTestRunnerPlaywright-AJ2DOOJT.js");
     contract = await runContractTestsPlaywright(componentName, url);
   } else {
     console.log(`\u{1F9EA} Running jsdom tests (limited event handling)`);

package/dist/src/utils/test/{contractTestRunnerPlaywright-I36Y2NHA.js → contractTestRunnerPlaywright-7O2T4JES.js}

@@ -21,8 +21,11 @@ async function runContractTestsPlaywright(componentName, url) {
     browser = await chromium.launch({ headless: true });
     const context = await browser.newContext();
     const page = await context.newPage();
-    await page.goto(url, { waitUntil: "networkidle" });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 5e3 });
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: 6e4
+    });
+    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {

package/dist/src/utils/test/{contractTestRunnerPlaywright-YNHMLHQ2.js → contractTestRunnerPlaywright-AJ2DOOJT.js}

@@ -21,8 +21,11 @@ async function runContractTestsPlaywright(componentName, url) {
     browser = await chromium.launch({ headless: true });
     const context = await browser.newContext();
     const page = await context.newPage();
-    await page.goto(url, { waitUntil: "networkidle" });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 3e4 });
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: 6e4
+    });
+    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {
@@ -144,6 +147,11 @@ async function runContractTestsPlaywright(componentName, url) {
               continue;
             }
             const target = page.locator(keypressSelector).first();
+            const elementCount = await target.count();
+            if (elementCount === 0) {
+              reporter.reportTest(dynamicTest, "skip", `Skipping test - ${act.target} element not found (optional submenu test)`);
+              break;
+            }
             await target.press(keyValue);
           }
         }

package/dist/src/utils/test/index.cjs

@@ -9257,8 +9257,11 @@ async function runContractTestsPlaywright(componentName, url) {
     browser = await playwright.chromium.launch({ headless: true });
     const context = await browser.newContext();
     const page = await context.newPage();
-    await page.goto(url, { waitUntil: "networkidle" });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 3e4 });
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: 6e4
+    });
+    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {
@@ -9380,6 +9383,11 @@ async function runContractTestsPlaywright(componentName, url) {
               continue;
             }
             const target = page.locator(keypressSelector).first();
+            const elementCount = await target.count();
+            if (elementCount === 0) {
+              reporter.reportTest(dynamicTest, "skip", `Skipping test - ${act.target} element not found (optional submenu test)`);
+              break;
+            }
             await target.press(keyValue);
           }
         }

package/dist/src/utils/test/index.js

@@ -12524,7 +12524,7 @@ async function testUiComponent(componentName, component, url) {
   let contract;
   if (url) {
     console.log(`\u{1F3AD} Running Playwright E2E tests on ${url}`);
-    const { runContractTestsPlaywright } = await import('./contractTestRunnerPlaywright-YNHMLHQ2.js');
+    const { runContractTestsPlaywright } = await import('./contractTestRunnerPlaywright-AJ2DOOJT.js');
     contract = await runContractTestsPlaywright(componentName, url);
   } else {
     console.log(`\u{1F9EA} Running jsdom tests (limited event handling)`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-ease",
-  "version": "2.8.2",
+  "version": "2.8.4",
   "description": "Out-of-the-box accessibility utility package to develop production ready applications.",
   "main": "dist/index.cjs",
   "type": "module",
@@ -107,6 +107,7 @@
   },
   "files": [
     "dist",
+    "bin",
     "README.md",
     "LICENSE"
   ],

package/dist/src/utils/test/contractTestRunnerPlaywright-ZY2T4UTV.js

@@ -1,249 +0,0 @@
-import { ContractReporter, contract_default } from './chunk-SSBW5VAA.js';
-import { chromium } from 'playwright';
-import { readFileSync } from 'fs';
-
-async function runContractTestsPlaywright(componentName, url) {
-  const reporter = new ContractReporter(true);
-  const contractTyped = contract_default;
-  const contractPath = contractTyped[componentName]?.path;
-  if (!contractPath) {
-    throw new Error(`Contract path not found for component: ${componentName}`);
-  }
-  const resolvedPath = new URL(contractPath, import.meta.url).pathname;
-  const contractData = readFileSync(resolvedPath, "utf-8");
-  const componentContract = JSON.parse(contractData);
-  const totalTests = componentContract.static[0].assertions.length + componentContract.dynamic.length;
-  reporter.start(componentName, totalTests);
-  const failures = [];
-  const passes = [];
-  let browser = null;
-  try {
-    browser = await chromium.launch({ headless: true });
-    const context = await browser.newContext();
-    const page = await context.newPage();
-    await page.goto(url, { waitUntil: "networkidle" });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 9e4 });
-    async function resolveRelativeTarget(selector, relative) {
-      const items = await page.locator(selector).all();
-      switch (relative) {
-        case "first":
-          return items[0];
-        case "second":
-          return items[1];
-        case "last":
-          return items[items.length - 1];
-        case "next": {
-          const currentIndex = await page.evaluate(([sel]) => {
-            const items2 = Array.from(document.querySelectorAll(sel));
-            return items2.indexOf(document.activeElement);
-          }, [selector]);
-          const nextIndex = (currentIndex + 1) % items.length;
-          return items[nextIndex];
-        }
-        case "previous": {
-          const currentIndex = await page.evaluate(([sel]) => {
-            const items2 = Array.from(document.querySelectorAll(sel));
-            return items2.indexOf(document.activeElement);
-          }, [selector]);
-          const prevIndex = (currentIndex - 1 + items.length) % items.length;
-          return items[prevIndex];
-        }
-        default:
-          return null;
-      }
-    }
-    for (const test of componentContract.static[0]?.assertions || []) {
-      if (test.target === "relative") continue;
-      const targetSelector = componentContract.selectors[test.target];
-      if (!targetSelector) {
-        failures.push(`Selector for target ${test.target} not found.`);
-        continue;
-      }
-      const target = page.locator(targetSelector).first();
-      const exists = await target.count() > 0;
-      if (!exists) {
-        failures.push(`Target ${test.target} not found.`);
-        continue;
-      }
-      if (!test.expectedValue) {
-        const attributes = test.attribute.split(" | ");
-        let hasAny = false;
-        for (const attr of attributes) {
-          const value = await target.getAttribute(attr.trim());
-          if (value !== null) {
-            hasAny = true;
-            break;
-          }
-        }
-        if (!hasAny) {
-          failures.push(test.failureMessage + ` None of the attributes "${test.attribute}" are present.`);
-        } else {
-          passes.push(`At least one of the attributes "${test.attribute}" exists on the element.`);
-        }
-      } else {
-        const attributeValue = await target.getAttribute(test.attribute);
-        const expectedValues = test.expectedValue.split(" | ");
-        if (!attributeValue || !expectedValues.includes(attributeValue)) {
-          failures.push(test.failureMessage + ` Attribute value does not match expected value. Expected: ${test.expectedValue}, Found: ${attributeValue}`);
-        } else {
-          passes.push(`Attribute value matches expected value. Expected: ${test.expectedValue}, Found: ${attributeValue}`);
-        }
-      }
-    }
-    for (const dynamicTest of componentContract.dynamic || []) {
-      const { action, assertions } = dynamicTest;
-      const failuresBeforeTest = failures.length;
-      const containerElement = page.locator(componentContract.selectors.container).first();
-      const triggerElement = page.locator(componentContract.selectors.trigger).first();
-      const isContainerVisible = await containerElement.isVisible();
-      if (isContainerVisible) {
-        await triggerElement.click();
-        await page.waitForTimeout(50);
-      }
-      for (const act of action) {
-        if (act.type === "click") {
-          if (act.target === "document") {
-            await page.mouse.click(10, 10);
-          } else {
-            const actionSelector = componentContract.selectors[act.target];
-            if (!actionSelector) {
-              failures.push(`Selector for action target ${act.target} not found.`);
-              continue;
-            }
-            await page.locator(actionSelector).first().click();
-            await page.waitForTimeout(200);
-          }
-        }
-        if (act.type === "keypress" && act.key) {
-          const keyMap = {
-            "Space": "Space",
-            "Enter": "Enter",
-            "Escape": "Escape",
-            "Arrow Up": "ArrowUp",
-            "Arrow Down": "ArrowDown",
-            "Arrow Left": "ArrowLeft",
-            "Arrow Right": "ArrowRight",
-            "Home": "Home",
-            "End": "End",
-            "Tab": "Tab"
-          };
-          let keyValue = keyMap[act.key] || act.key;
-          if (keyValue === "Space") {
-            keyValue = " ";
-          } else if (keyValue.includes(" ")) {
-            keyValue = keyValue.replace(/ /g, "");
-          }
-          if (act.target === "focusable" && ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Escape"].includes(keyValue)) {
-            await page.waitForTimeout(100);
-            await page.keyboard.press(keyValue);
-            await page.waitForTimeout(50);
-          } else {
-            const keypressSelector = componentContract.selectors[act.target];
-            if (!keypressSelector) {
-              failures.push(`Selector for keypress target ${act.target} not found.`);
-              continue;
-            }
-            const target = page.locator(keypressSelector).first();
-            await target.press(keyValue);
-          }
-        }
-        await page.waitForTimeout(100);
-      }
-      for (const assertion of assertions) {
-        let target;
-        if (assertion.target === "relative") {
-          const relativeSelector = componentContract.selectors.relative;
-          if (!relativeSelector) {
-            failures.push("Relative selector is not defined in the contract.");
-            continue;
-          }
-          if (!assertion.expectedValue) {
-            failures.push("Expected value for relative target is not defined.");
-            continue;
-          }
-          target = await resolveRelativeTarget(relativeSelector, assertion.expectedValue);
-        } else {
-          const assertionSelector = componentContract.selectors[assertion.target];
-          if (!assertionSelector) {
-            failures.push(`Selector for assertion target ${assertion.target} not found.`);
-            continue;
-          }
-          target = page.locator(assertionSelector).first();
-        }
-        if (!target) {
-          failures.push(`Target ${assertion.target} not found.`);
-          continue;
-        }
-        if (assertion.assertion === "toBeVisible") {
-          const isVisible = await target.isVisible();
-          if (isVisible) {
-            passes.push(`${assertion.target} is visible as expected. Test: "${dynamicTest.description}".`);
-          } else {
-            failures.push(`${assertion.failureMessage}`);
-          }
-        }
-        if (assertion.assertion === "notToBeVisible") {
-          const isVisible = await target.isVisible();
-          if (!isVisible) {
-            passes.push(`${assertion.target} is not visible as expected. Test: "${dynamicTest.description}".`);
-          } else {
-            failures.push(assertion.failureMessage + ` ${assertion.target} is still visible.`);
-          }
-        }
-        if (assertion.assertion === "toHaveAttribute" && assertion.attribute && assertion.expectedValue) {
-          const attributeValue = await target.getAttribute(assertion.attribute);
-          if (attributeValue === assertion.expectedValue) {
-            passes.push(`${assertion.target} has expected "${assertion.attribute}". Test: "${dynamicTest.description}".`);
-          } else {
-            failures.push(assertion.failureMessage + ` ${assertion.target} "${assertion.attribute}" should be "${assertion.expectedValue}", found "${attributeValue}".`);
-          }
-        }
-        if (assertion.assertion === "toHaveFocus") {
-          const hasFocus = await target.evaluate((el) => el === document.activeElement);
-          if (hasFocus) {
-            passes.push(`${assertion.target} has focus as expected. Test: "${dynamicTest.description}".`);
-          } else {
-            failures.push(`${assertion.failureMessage}`);
-          }
-        }
-        if (assertion.assertion === "toHaveRole" && assertion.expectedValue) {
-          const roleValue = await target.getAttribute("role");
-          if (roleValue === assertion.expectedValue) {
-            passes.push(`${assertion.target} has role "${assertion.expectedValue}". Test: "${dynamicTest.description}".`);
-          } else {
-            failures.push(assertion.failureMessage + ` Expected role "${assertion.expectedValue}", found "${roleValue}".`);
-          }
-        }
-      }
-      const failuresAfterTest = failures.length;
-      const testPassed = failuresAfterTest === failuresBeforeTest;
-      const failureMessage = testPassed ? void 0 : failures[failures.length - 1];
-      reporter.reportTest(dynamicTest, testPassed ? "pass" : "fail", failureMessage);
-    }
-    const staticPassed = componentContract.static[0].assertions.length;
-    const staticFailed = 0;
-    reporter.reportStatic(staticPassed, staticFailed);
-    reporter.summary(failures);
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Executable doesn't exist")) {
-        console.error("\n\u274C Playwright browsers not found!\n");
-        console.log("\u{1F4E6} Run: npx playwright install chromium\n");
-        failures.push("Playwright browser not installed. Run: npx playwright install chromium");
-      } else if (error.message.includes("net::ERR_CONNECTION_REFUSED")) {
-        console.error("\n\u274C Cannot connect to dev server!\n");
-        console.log(`   Make sure your dev server is running at ${url}
-`);
-        failures.push(`Dev server not running at ${url}`);
-      } else {
-        console.error("\u274C Playwright test error:", error.message);
-        failures.push(`Test error: ${error.message}`);
-      }
-    }
-  } finally {
-    if (browser) await browser.close();
-  }
-  return { passes, failures };
-}
-
-export { runContractTestsPlaywright };