aria-ease 2.8.4 → 2.9.0

package/bin/{audit-XABLAI36.js → audit-XZJXMUPL.js}

@@ -1,6 +1,6 @@
 import "./chunk-JSBRDJBE.js";
 
-// src/utils/audit/src/audit/audit.js
+// src/utils/audit/src/audit/audit.ts
 import AxeBuilder from "@axe-core/playwright";
 import { chromium } from "playwright";
 async function runAudit(url, options) {
@@ -38,8 +38,7 @@ async function runAudit(url, options) {
     }
     throw error;
   } finally {
-    if (browser)
-      await browser.close();
+    if (browser) await browser.close();
   }
 }
 export {

package/bin/{chunk-JGKPHTSR.js → chunk-5Z7PR3VC.js}

@@ -3,6 +3,10 @@ var contract_default = {
   menu: {
     path: "./contracts/MenuContract.json",
     component: "menu"
+  },
+  combobox: {
+    path: "./contracts/ComboboxContract.json",
+    component: "combobox"
   }
 };
 

package/bin/cli.cjs

@@ -33,7 +33,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/utils/audit/src/audit/audit.js
+// src/utils/audit/src/audit/audit.ts
 var audit_exports = {};
 __export(audit_exports, {
   runAudit: () => runAudit
@@ -73,20 +73,19 @@ async function runAudit(url, options) {
     }
     throw error;
   } finally {
-    if (browser)
-      await browser.close();
+    if (browser) await browser.close();
   }
 }
 var import_playwright, import_playwright2;
 var init_audit = __esm({
-  "src/utils/audit/src/audit/audit.js"() {
+  "src/utils/audit/src/audit/audit.ts"() {
     "use strict";
     import_playwright = __toESM(require("@axe-core/playwright"), 1);
     import_playwright2 = require("playwright");
   }
 });
 
-// src/utils/audit/src/formatters/formatters.js
+// src/utils/audit/src/formatters/formatters.ts
 var formatters_exports = {};
 __export(formatters_exports, {
   formatResults: () => formatResults
@@ -94,14 +93,22 @@ __export(formatters_exports, {
 function formatResults(allResults, format2) {
   switch (format2) {
     case "json":
-      return JSON.stringify(allResults.flatMap(({ url, result }) => result ? result.violations.flatMap((v) => v.nodes.map((n) => ({
-        URL: url,
-        Rule: v.id,
-        Impact: v.impact,
-        Description: v.description,
-        Target: n.target,
-        FailureSummary: n.failureSummary
-      }))) : []), null, 2);
+      return JSON.stringify(
+        allResults.flatMap(
+          ({ url, result }) => result ? result.violations.flatMap(
+            (v) => v.nodes.map((n) => ({
+              URL: url,
+              Rule: v.id,
+              Impact: v.impact,
+              Description: v.description,
+              Target: n.target,
+              FailureSummary: n.failureSummary
+            }))
+          ) : []
+        ),
+        null,
+        2
+      );
     case "csv":
       return toCSV(allResults);
     case "html":
@@ -116,7 +123,9 @@ function toCSV(allResults) {
     if (result) {
       result.violations.forEach((v) => {
         v.nodes.forEach((n) => {
-          rows.push(escapeCSV(url) + "," + escapeCSV(v.id) + "," + escapeCSV(v.impact) + "," + escapeCSV(v.description) + "," + escapeCSV(Array.isArray(n.target) ? n.target.join("; ") : String(n.target)) + "," + escapeCSV(n.failureSummary ?? ""));
+          rows.push(
+            escapeCSV(url) + "," + escapeCSV(v.id) + "," + escapeCSV(v.impact) + "," + escapeCSV(v.description) + "," + escapeCSV(Array.isArray(n.target) ? n.target.join("; ") : String(n.target)) + "," + escapeCSV(n.failureSummary ?? "")
+          );
         });
       });
     }
@@ -136,8 +145,7 @@ function toHTML(allResults) {
     impactCounts: /* @__PURE__ */ new Map()
   };
   allResults.forEach(({ result }) => {
-    if (!result)
-      return;
+    if (!result) return;
     summary.pagesAudited++;
     const pageViolations = result.violations.reduce((acc, v) => {
       const nodesCount = (v.nodes || []).length;
@@ -150,13 +158,11 @@ function toHTML(allResults) {
       }
       return acc;
     }, 0);
-    if (pageViolations > 0)
-      summary.pagesWithViolations++;
+    if (pageViolations > 0) summary.pagesWithViolations++;
   });
   const rows = [];
   allResults.forEach(({ url, result }) => {
-    if (!result)
-      return;
+    if (!result) return;
     result.violations.forEach((v) => {
       v.nodes.forEach((n) => {
         const target = Array.isArray(n.target) ? n.target.join("; ") : String(n.target);
@@ -262,7 +268,7 @@ function escapeClass(s) {
   return String(s ?? "").toLowerCase().replace(/[^a-z0-9]+/g, "-");
 }
 var init_formatters = __esm({
-  "src/utils/audit/src/formatters/formatters.js"() {
+  "src/utils/audit/src/formatters/formatters.ts"() {
     "use strict";
   }
 });
@@ -275,6 +281,10 @@ var init_contract = __esm({
       menu: {
         path: "./contracts/MenuContract.json",
         component: "menu"
+      },
+      combobox: {
+        path: "./contracts/ComboboxContract.json",
+        component: "combobox"
       }
     };
   }
@@ -13018,7 +13028,12 @@ async function runContractTests(componentName, component) {
   const skipped = [];
   for (const test of componentContract.static[0].assertions) {
     if (test.target !== "relative") {
-      const target = component.querySelector(componentContract.selectors[test.target]);
+      const selector = componentContract.selectors[test.target];
+      if (!selector) {
+        failures.push(`Selector for target ${test.target} not found.`);
+        continue;
+      }
+      const target = component.querySelector(selector);
       if (!target) {
         failures.push(`Target ${test.target} not found.`);
         continue;
@@ -13076,13 +13091,17 @@ async function runContractTests(componentName, component) {
     }
     const { action, assertions } = dynamicTest;
     const failuresBeforeTest = failures.length;
-    const containerElement = component.querySelector(componentContract.selectors.container);
-    const triggerElement = component.querySelector(componentContract.selectors.trigger);
-    if (containerElement && triggerElement) {
-      const isContainerVisible = containerElement.style.display !== "none";
-      if (isContainerVisible) {
-        fireEvent.click(triggerElement);
-        await new Promise((resolve) => setTimeout(resolve, 50));
+    const containerSelector = componentContract.selectors.container;
+    const triggerSelector = componentContract.selectors.trigger;
+    if (containerSelector && triggerSelector) {
+      const containerElement = component.querySelector(containerSelector);
+      const triggerElement = component.querySelector(triggerSelector);
+      if (containerElement && triggerElement) {
+        const isContainerVisible = containerElement.style.display !== "none";
+        if (isContainerVisible) {
+          fireEvent.click(triggerElement);
+          await new Promise((resolve) => setTimeout(resolve, 50));
+        }
       }
     }
     const preActionExpectedTargets = /* @__PURE__ */ new Map();
@@ -13099,7 +13118,12 @@ async function runContractTests(componentName, component) {
         if (act.target === "document") {
           fireEvent.click(document.body);
         } else {
-          const target = component.querySelector(componentContract.selectors[act.target]);
+          const selector = componentContract.selectors[act.target];
+          if (!selector) {
+            failures.push(`Selector for action target ${act.target} not found.`);
+            continue;
+          }
+          const target = component.querySelector(selector);
           if (target instanceof HTMLElement) {
             target.focus();
             fireEvent.click(target);
@@ -13113,16 +13137,27 @@ async function runContractTests(componentName, component) {
         let target;
         if (act.target === "focusable" && ["Arrow Up", "Arrow Down", "Arrow Left", "Arrow Right", "Escape"].includes(act.key || "")) {
           const activeElement = document.activeElement;
-          const containerElement2 = component.querySelector(componentContract.selectors.container);
-          const focusableItems = containerElement2?.querySelectorAll(componentContract.selectors.focusable);
+          const containerSelector2 = componentContract.selectors.container;
+          const focusableSelector = componentContract.selectors.focusable;
+          if (!containerSelector2 || !focusableSelector) {
+            failures.push(`Container or focusable selector not found.`);
+            continue;
+          }
+          const containerElement = component.querySelector(containerSelector2);
+          const focusableItems = containerElement?.querySelectorAll(focusableSelector);
           if (focusableItems && focusableItems.length > 0) {
             const focusedItem = Array.from(focusableItems).find((item) => item === activeElement);
             target = focusedItem || focusableItems[0];
           } else {
-            target = containerElement2;
+            target = containerElement;
           }
         } else {
-          target = component.querySelector(componentContract.selectors[act.target]);
+          const selector = componentContract.selectors[act.target];
+          if (!selector) {
+            failures.push(`Selector for keypress target ${act.target} not found.`);
+            continue;
+          }
+          target = component.querySelector(selector);
         }
         if (target) {
           target.focus();
@@ -13164,7 +13199,12 @@ async function runContractTests(componentName, component) {
         }
         target = resolveRelativeTarget(component, relativeSelector, assertion.expectedValue);
       } else {
-        target = component.querySelector(componentContract.selectors[assertion.target]);
+        const selector = componentContract.selectors[assertion.target];
+        if (!selector) {
+          failures.push(`Selector for assertion target ${assertion.target} not found.`);
+          continue;
+        }
+        target = component.querySelector(selector);
       }
       if (!target) {
         failures.push(`Target ${assertion.target} not found.`);
@@ -13262,7 +13302,11 @@ async function runContractTestsPlaywright(componentName, url) {
       waitUntil: "domcontentloaded",
       timeout: 6e4
     });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
+    const mainSelector = componentContract.selectors.trigger || componentContract.selectors.input || componentContract.selectors.container;
+    if (!mainSelector) {
+      throw new Error(`No main selector (trigger, input, or container) found in contract for ${componentName}`);
+    }
+    await page.waitForSelector(mainSelector, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {
@@ -13333,17 +13377,61 @@ async function runContractTestsPlaywright(componentName, url) {
     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);
+      if (componentContract.selectors.listbox || componentContract.selectors.container) {
+        const popupSelector = componentContract.selectors.listbox || componentContract.selectors.container;
+        if (!popupSelector) continue;
+        const popupElement = page.locator(popupSelector).first();
+        const isPopupVisible = await popupElement.isVisible();
+        if (isPopupVisible) {
+          const closeSelector = componentContract.selectors.input || componentContract.selectors.trigger;
+          if (closeSelector) {
+            const closeElement = page.locator(closeSelector).first();
+            await closeElement.focus();
+            await page.keyboard.press("Escape");
+            await page.waitForTimeout(200);
+            if (componentContract.selectors.input) {
+              const inputElement = page.locator(componentContract.selectors.input).first();
+              await inputElement.clear();
+              await page.waitForTimeout(50);
+            }
+          }
+        }
       }
       for (const act of action) {
+        if (act.type === "focus") {
+          const focusSelector = componentContract.selectors[act.target];
+          if (!focusSelector) {
+            failures.push(`Selector for focus target ${act.target} not found.`);
+            continue;
+          }
+          await page.locator(focusSelector).first().focus();
+          await page.waitForTimeout(50);
+        }
+        if (act.type === "type" && act.value) {
+          const typeSelector = componentContract.selectors[act.target];
+          if (!typeSelector) {
+            failures.push(`Selector for type target ${act.target} not found.`);
+            continue;
+          }
+          await page.locator(typeSelector).first().fill(act.value);
+          await page.waitForTimeout(50);
+        }
         if (act.type === "click") {
           if (act.target === "document") {
             await page.mouse.click(10, 10);
+          } else if (act.target === "relative" && act.relativeTarget) {
+            const relativeSelector = componentContract.selectors.relative;
+            if (!relativeSelector) {
+              failures.push(`Relative selector not defined for click action.`);
+              continue;
+            }
+            const relativeElement = await resolveRelativeTarget(relativeSelector, act.relativeTarget);
+            if (!relativeElement) {
+              failures.push(`Could not resolve relative target ${act.relativeTarget} for click.`);
+              continue;
+            }
+            await relativeElement.click();
+            await page.waitForTimeout(200);
           } else {
             const actionSelector = componentContract.selectors[act.target];
             if (!actionSelector) {
@@ -13392,6 +13480,30 @@ async function runContractTestsPlaywright(componentName, url) {
             await target.press(keyValue);
           }
         }
+        if (act.type === "hover") {
+          if (act.target === "relative" && act.relativeTarget) {
+            const relativeSelector = componentContract.selectors.relative;
+            if (!relativeSelector) {
+              failures.push(`Relative selector not defined for hover action.`);
+              continue;
+            }
+            const relativeElement = await resolveRelativeTarget(relativeSelector, act.relativeTarget);
+            if (!relativeElement) {
+              failures.push(`Could not resolve relative target ${act.relativeTarget} for hover.`);
+              continue;
+            }
+            await relativeElement.hover();
+            await page.waitForTimeout(50);
+          } else {
+            const hoverSelector = componentContract.selectors[act.target];
+            if (!hoverSelector) {
+              failures.push(`Selector for hover target ${act.target} not found.`);
+              continue;
+            }
+            await page.locator(hoverSelector).first().hover();
+            await page.waitForTimeout(50);
+          }
+        }
         await page.waitForTimeout(100);
       }
       for (const assertion of assertions) {
@@ -13402,11 +13514,12 @@ async function runContractTestsPlaywright(componentName, url) {
             failures.push("Relative selector is not defined in the contract.");
             continue;
           }
-          if (!assertion.expectedValue) {
-            failures.push("Expected value for relative target is not defined.");
+          const relativeTargetValue = assertion.relativeTarget || assertion.expectedValue;
+          if (!relativeTargetValue) {
+            failures.push("Relative target or expected value is not defined.");
             continue;
           }
-          target = await resolveRelativeTarget(relativeSelector, assertion.expectedValue);
+          target = await resolveRelativeTarget(relativeSelector, relativeTargetValue);
         } else {
           const assertionSelector = componentContract.selectors[assertion.target];
           if (!assertionSelector) {
@@ -13437,12 +13550,38 @@ async function runContractTestsPlaywright(componentName, url) {
         }
         if (assertion.assertion === "toHaveAttribute" && assertion.attribute && assertion.expectedValue) {
           const attributeValue = await target.getAttribute(assertion.attribute);
-          if (attributeValue === assertion.expectedValue) {
+          if (assertion.expectedValue === "!empty") {
+            if (attributeValue && attributeValue.trim() !== "") {
+              passes.push(`${assertion.target} has non-empty "${assertion.attribute}". Test: "${dynamicTest.description}".`);
+            } else {
+              failures.push(assertion.failureMessage + ` ${assertion.target} "${assertion.attribute}" should not be empty, found "${attributeValue}".`);
+            }
+          } else 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 === "toHaveValue") {
+          const inputValue = await target.inputValue().catch(() => "");
+          if (assertion.expectedValue === "!empty") {
+            if (inputValue && inputValue.trim() !== "") {
+              passes.push(`${assertion.target} has non-empty value. Test: "${dynamicTest.description}".`);
+            } else {
+              failures.push(assertion.failureMessage + ` ${assertion.target} value should not be empty, found "${inputValue}".`);
+            }
+          } else if (assertion.expectedValue === "") {
+            if (inputValue === "") {
+              passes.push(`${assertion.target} has empty value. Test: "${dynamicTest.description}".`);
+            } else {
+              failures.push(assertion.failureMessage + ` ${assertion.target} value should be empty, found "${inputValue}".`);
+            }
+          } else if (inputValue === assertion.expectedValue) {
+            passes.push(`${assertion.target} has expected value. Test: "${dynamicTest.description}".`);
+          } else {
+            failures.push(assertion.failureMessage + ` ${assertion.target} value should be "${assertion.expectedValue}", found "${inputValue}".`);
+          }
+        }
         if (assertion.assertion === "toHaveFocus") {
           const hasFocus = await target.evaluate((el) => el === document.activeElement);
           if (hasFocus) {
@@ -13531,11 +13670,19 @@ async function testUiComponent(componentName, component, url) {
   }
   if (results.violations.length > 0) {
     const violationCount = results.violations.length;
+    const violationDetails = results.violations.map(
+      (v) => `
+  - ${v.id}: ${v.description}
+    Impact: ${v.impact}
+    Affected elements: ${v.nodes.length}
+    Help: ${v.helpUrl}`
+    ).join("\n");
     throw new Error(
       `
 \u274C ${violationCount} axe accessibility violation${violationCount > 1 ? "s" : ""} detected
+${violationDetails}
 
-\u{1F4CB} Check result.violations for details`
+\u{1F4CB} Full details available in result.violations`
     );
   }
   return result;
@@ -13573,14 +13720,14 @@ var init_test = __esm({
   }
 });
 
-// src/utils/test/index.js
+// src/utils/test/index.ts
 var test_exports = {};
 __export(test_exports, {
   runTest: () => runTest,
   testUiComponent: () => testUiComponent
 });
 var init_test2 = __esm({
-  "src/utils/test/index.js"() {
+  "src/utils/test/index.ts"() {
     "use strict";
     init_test();
   }
@@ -13592,7 +13739,7 @@ var import_chalk = __toESM(require("chalk"), 1);
 var import_path2 = __toESM(require("path"), 1);
 var import_fs_extra2 = __toESM(require("fs-extra"), 1);
 
-// src/utils/cli/configLoader.js
+// src/utils/cli/configLoader.ts
 var import_path = __toESM(require("path"), 1);
 var import_fs_extra = __toESM(require("fs-extra"), 1);
 function validateConfig(config2) {

package/bin/cli.js

@@ -7,7 +7,7 @@ import chalk from "chalk";
 import path2 from "path";
 import fs2 from "fs-extra";
 
-// src/utils/cli/configLoader.js
+// src/utils/cli/configLoader.ts
 import path from "path";
 import fs from "fs-extra";
 function validateConfig(config) {
@@ -128,8 +128,8 @@ var program = new Command();
 program.name("aria-ease").description("Run accessibility tests and audits").version("2.2.3");
 program.command("audit").description("Run axe-core powered accessibility audit on webpages").option("-u, --url <url>", "Single URL to audit").option("-f, --format <format>", "Output format for the audit report: json | csv | html | all", "all").option("-o, --out <path>", "Directory to save the audit report", "./accessibility-reports/audit").action(async (opts) => {
   console.log(chalk.cyanBright("\u{1F680} Starting accessibility audit...\n"));
-  const { runAudit } = await import("./audit-XABLAI36.js");
-  const { formatResults } = await import("./formatters-2RPHPXW2.js");
+  const { runAudit } = await import("./audit-XZJXMUPL.js");
+  const { formatResults } = await import("./formatters-U4E5EVPL.js");
   const { config, configPath, errors } = await loadConfig(process.cwd());
   if (configPath) {
     console.log(chalk.green(`\u2705 Loaded config from ${path2.basename(configPath)}
@@ -204,7 +204,7 @@ program.command("audit").description("Run axe-core powered accessibility audit o
   console.log(chalk.green("\n\u{1F389} All audits completed."));
 });
 program.command("test").description("Run core a11y accessibility standard tests on UI components").action(async () => {
-  const { runTest } = await import("./test-S2U633GD.js");
+  const { runTest } = await import("./test-PK5MBHIN.js");
   runTest();
 });
 program.command("help").description("Display help information").action(() => {

package/bin/{contractTestRunnerPlaywright-VDTXMVK5.js → contractTestRunnerPlaywright-62LXHK7K.js}

@@ -1,7 +1,7 @@
 import {
   ContractReporter,
   contract_default
-} from "./chunk-JGKPHTSR.js";
+} from "./chunk-5Z7PR3VC.js";
 import "./chunk-JSBRDJBE.js";
 
 // src/utils/test/contract/contractTestRunnerPlaywright.ts
@@ -30,7 +30,11 @@ async function runContractTestsPlaywright(componentName, url) {
       waitUntil: "domcontentloaded",
       timeout: 6e4
     });
-    await page.waitForSelector(componentContract.selectors.trigger, { timeout: 6e4 });
+    const mainSelector = componentContract.selectors.trigger || componentContract.selectors.input || componentContract.selectors.container;
+    if (!mainSelector) {
+      throw new Error(`No main selector (trigger, input, or container) found in contract for ${componentName}`);
+    }
+    await page.waitForSelector(mainSelector, { timeout: 6e4 });
     async function resolveRelativeTarget(selector, relative) {
       const items = await page.locator(selector).all();
       switch (relative) {
@@ -101,17 +105,61 @@ async function runContractTestsPlaywright(componentName, url) {
     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);
+      if (componentContract.selectors.listbox || componentContract.selectors.container) {
+        const popupSelector = componentContract.selectors.listbox || componentContract.selectors.container;
+        if (!popupSelector) continue;
+        const popupElement = page.locator(popupSelector).first();
+        const isPopupVisible = await popupElement.isVisible();
+        if (isPopupVisible) {
+          const closeSelector = componentContract.selectors.input || componentContract.selectors.trigger;
+          if (closeSelector) {
+            const closeElement = page.locator(closeSelector).first();
+            await closeElement.focus();
+            await page.keyboard.press("Escape");
+            await page.waitForTimeout(200);
+            if (componentContract.selectors.input) {
+              const inputElement = page.locator(componentContract.selectors.input).first();
+              await inputElement.clear();
+              await page.waitForTimeout(50);
+            }
+          }
+        }
       }
       for (const act of action) {
+        if (act.type === "focus") {
+          const focusSelector = componentContract.selectors[act.target];
+          if (!focusSelector) {
+            failures.push(`Selector for focus target ${act.target} not found.`);
+            continue;
+          }
+          await page.locator(focusSelector).first().focus();
+          await page.waitForTimeout(50);
+        }
+        if (act.type === "type" && act.value) {
+          const typeSelector = componentContract.selectors[act.target];
+          if (!typeSelector) {
+            failures.push(`Selector for type target ${act.target} not found.`);
+            continue;
+          }
+          await page.locator(typeSelector).first().fill(act.value);
+          await page.waitForTimeout(50);
+        }
         if (act.type === "click") {
           if (act.target === "document") {
             await page.mouse.click(10, 10);
+          } else if (act.target === "relative" && act.relativeTarget) {
+            const relativeSelector = componentContract.selectors.relative;
+            if (!relativeSelector) {
+              failures.push(`Relative selector not defined for click action.`);
+              continue;
+            }
+            const relativeElement = await resolveRelativeTarget(relativeSelector, act.relativeTarget);
+            if (!relativeElement) {
+              failures.push(`Could not resolve relative target ${act.relativeTarget} for click.`);
+              continue;
+            }
+            await relativeElement.click();
+            await page.waitForTimeout(200);
           } else {
             const actionSelector = componentContract.selectors[act.target];
             if (!actionSelector) {
@@ -160,6 +208,30 @@ async function runContractTestsPlaywright(componentName, url) {
             await target.press(keyValue);
           }
         }
+        if (act.type === "hover") {
+          if (act.target === "relative" && act.relativeTarget) {
+            const relativeSelector = componentContract.selectors.relative;
+            if (!relativeSelector) {
+              failures.push(`Relative selector not defined for hover action.`);
+              continue;
+            }
+            const relativeElement = await resolveRelativeTarget(relativeSelector, act.relativeTarget);
+            if (!relativeElement) {
+              failures.push(`Could not resolve relative target ${act.relativeTarget} for hover.`);
+              continue;
+            }
+            await relativeElement.hover();
+            await page.waitForTimeout(50);
+          } else {
+            const hoverSelector = componentContract.selectors[act.target];
+            if (!hoverSelector) {
+              failures.push(`Selector for hover target ${act.target} not found.`);
+              continue;
+            }
+            await page.locator(hoverSelector).first().hover();
+            await page.waitForTimeout(50);
+          }
+        }
         await page.waitForTimeout(100);
       }
       for (const assertion of assertions) {
@@ -170,11 +242,12 @@ async function runContractTestsPlaywright(componentName, url) {
             failures.push("Relative selector is not defined in the contract.");
             continue;
           }
-          if (!assertion.expectedValue) {
-            failures.push("Expected value for relative target is not defined.");
+          const relativeTargetValue = assertion.relativeTarget || assertion.expectedValue;
+          if (!relativeTargetValue) {
+            failures.push("Relative target or expected value is not defined.");
             continue;
           }
-          target = await resolveRelativeTarget(relativeSelector, assertion.expectedValue);
+          target = await resolveRelativeTarget(relativeSelector, relativeTargetValue);
         } else {
           const assertionSelector = componentContract.selectors[assertion.target];
           if (!assertionSelector) {
@@ -205,12 +278,38 @@ async function runContractTestsPlaywright(componentName, url) {
         }
         if (assertion.assertion === "toHaveAttribute" && assertion.attribute && assertion.expectedValue) {
           const attributeValue = await target.getAttribute(assertion.attribute);
-          if (attributeValue === assertion.expectedValue) {
+          if (assertion.expectedValue === "!empty") {
+            if (attributeValue && attributeValue.trim() !== "") {
+              passes.push(`${assertion.target} has non-empty "${assertion.attribute}". Test: "${dynamicTest.description}".`);
+            } else {
+              failures.push(assertion.failureMessage + ` ${assertion.target} "${assertion.attribute}" should not be empty, found "${attributeValue}".`);
+            }
+          } else 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 === "toHaveValue") {
+          const inputValue = await target.inputValue().catch(() => "");
+          if (assertion.expectedValue === "!empty") {
+            if (inputValue && inputValue.trim() !== "") {
+              passes.push(`${assertion.target} has non-empty value. Test: "${dynamicTest.description}".`);
+            } else {
+              failures.push(assertion.failureMessage + ` ${assertion.target} value should not be empty, found "${inputValue}".`);
+            }
+          } else if (assertion.expectedValue === "") {
+            if (inputValue === "") {
+              passes.push(`${assertion.target} has empty value. Test: "${dynamicTest.description}".`);
+            } else {
+              failures.push(assertion.failureMessage + ` ${assertion.target} value should be empty, found "${inputValue}".`);
+            }
+          } else if (inputValue === assertion.expectedValue) {
+            passes.push(`${assertion.target} has expected value. Test: "${dynamicTest.description}".`);
+          } else {
+            failures.push(assertion.failureMessage + ` ${assertion.target} value should be "${assertion.expectedValue}", found "${inputValue}".`);
+          }
+        }
         if (assertion.assertion === "toHaveFocus") {
           const hasFocus = await target.evaluate((el) => el === document.activeElement);
           if (hasFocus) {