aria-ease 6.4.8 → 6.5.0

package/dist/contractTestRunnerPlaywright-7F756CFB.js

@@ -0,0 +1,984 @@
+import {
+  ContractReporter,
+  contract_default,
+  createTestPage
+} from "./chunk-AUJAN4RK.js";
+import {
+  __export,
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// src/utils/test/src/contractTestRunnerPlaywright.ts
+import { readFileSync as readFileSync2 } from "fs";
+
+// 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";
+
+// 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 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 combobox popup between tests. Popup remains visible after trying:
+  1. Escape key
+  2. Clicking trigger
+  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;
+  }
+};
+
+// 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;
+  }
+};
+
+// 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) {
+    for (const act of test.action) {
+      if (act.type === "keypress" && (act.target === "submenuTrigger" || act.target === "submenu")) {
+        const submenuSelector = this.selectors[act.target];
+        if (submenuSelector) {
+          const submenuCount = await page.locator(submenuSelector).count();
+          if (submenuCount === 0) {
+            return true;
+          }
+        }
+      }
+    }
+    for (const assertion of test.assertions) {
+      if (assertion.target === "submenu" || assertion.target === "submenuTrigger") {
+        const submenuSelector = this.selectors[assertion.target];
+        if (submenuSelector) {
+          const submenuCount = await page.locator(submenuSelector).count();
+          if (submenuCount === 0) {
+            return true;
+          }
+        }
+      }
+    }
+    return false;
+  }
+  getMainSelector() {
+    return this.mainSelector;
+  }
+};
+
+// 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;
+  }
+};
+
+// src/utils/test/src/ComponentDetector.ts
+import { readFileSync } from "fs";
+var ComponentDetector = class {
+  static detect(componentName, actionTimeoutMs = 400, assertionTimeoutMs = 400) {
+    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 selectors = componentContract.selectors;
+    if (componentName.includes("combobox")) {
+      const mainSelector = selectors.input || selectors.container;
+      return new ComboboxComponentStrategy(mainSelector, selectors, actionTimeoutMs, assertionTimeoutMs);
+    }
+    if (componentName === "accordion") {
+      const mainSelector = selectors.trigger || selectors.container;
+      return new AccordionComponentStrategy(mainSelector, selectors, actionTimeoutMs, assertionTimeoutMs);
+    }
+    if (componentName === "menu") {
+      const mainSelector = selectors.trigger || selectors.container;
+      return new MenuComponentStrategy(mainSelector, selectors, actionTimeoutMs, assertionTimeoutMs);
+    }
+    if (componentName === "tabs") {
+      const mainSelector = selectors.tablist || selectors.tab;
+      return new TabsComponentStrategy(mainSelector, selectors);
+    }
+    return null;
+  }
+};
+
+// src/utils/test/src/RelativeTargetResolver.ts
+var RelativeTargetResolver = class {
+  /**
+   * Resolve a relative target like "first", "second", "last", "next", "previous"
+   * @param page Playwright page instance
+   * @param selector Base selector to find elements
+   * @param relative Relative position (first, second, last, next, previous)
+   * @returns The resolved Locator or null if not found
+   */
+  static async resolve(page, 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;
+    }
+  }
+};
+
+// src/utils/test/src/ActionExecutor.ts
+var ActionExecutor = class {
+  constructor(page, selectors, timeoutMs = 400) {
+    this.page = page;
+    this.selectors = selectors;
+    this.timeoutMs = timeoutMs;
+  }
+  /**
+   * Check if error is due to browser/page being closed
+   */
+  isBrowserClosedError(error) {
+    return error instanceof Error && error.message.includes("Target page, context or browser has been closed");
+  }
+  /**
+   * Execute focus action
+   */
+  async focus(target) {
+    try {
+      const selector = this.selectors[target];
+      if (!selector) {
+        return { success: false, error: `Selector for focus target ${target} not found.` };
+      }
+      await this.page.locator(selector).first().focus({ timeout: this.timeoutMs });
+      return { success: true };
+    } catch (error) {
+      if (this.isBrowserClosedError(error)) {
+        return {
+          success: false,
+          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
+          shouldBreak: true
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to focus ${target}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Execute type/fill action
+   */
+  async type(target, value) {
+    try {
+      const selector = this.selectors[target];
+      if (!selector) {
+        return { success: false, error: `Selector for type target ${target} not found.` };
+      }
+      await this.page.locator(selector).first().fill(value, { timeout: this.timeoutMs });
+      return { success: true };
+    } catch (error) {
+      if (this.isBrowserClosedError(error)) {
+        return {
+          success: false,
+          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
+          shouldBreak: true
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to type into ${target}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Execute click action
+   */
+  async click(target, relativeTarget) {
+    try {
+      if (target === "document") {
+        await this.page.mouse.click(10, 10);
+        return { success: true };
+      }
+      if (target === "relative" && relativeTarget) {
+        const relativeSelector = this.selectors.relative;
+        if (!relativeSelector) {
+          return { success: false, error: `Relative selector not defined for click action.` };
+        }
+        const element = await RelativeTargetResolver.resolve(this.page, relativeSelector, relativeTarget);
+        if (!element) {
+          return { success: false, error: `Could not resolve relative target ${relativeTarget} for click.` };
+        }
+        await element.click({ timeout: this.timeoutMs });
+        return { success: true };
+      }
+      const selector = this.selectors[target];
+      if (!selector) {
+        return { success: false, error: `Selector for action target ${target} not found.` };
+      }
+      await this.page.locator(selector).first().click({ timeout: this.timeoutMs });
+      return { success: true };
+    } catch (error) {
+      if (this.isBrowserClosedError(error)) {
+        return {
+          success: false,
+          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
+          shouldBreak: true
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to click ${target}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Execute keypress action
+   */
+  async keypress(target, key) {
+    try {
+      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[key] || key;
+      if (keyValue === "Space") {
+        keyValue = " ";
+      } else if (keyValue.includes(" ")) {
+        keyValue = keyValue.replace(/ /g, "");
+      }
+      if (target === "focusable" && ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Escape"].includes(keyValue)) {
+        await this.page.keyboard.press(keyValue);
+        return { success: true };
+      }
+      const selector = this.selectors[target];
+      if (!selector) {
+        return { success: false, error: `Selector for keypress target ${target} not found.` };
+      }
+      const locator = this.page.locator(selector).first();
+      const elementCount = await locator.count();
+      if (elementCount === 0) {
+        return {
+          success: false,
+          error: `${target} element not found (optional submenu test)`,
+          shouldBreak: true
+          // Signal to skip this test
+        };
+      }
+      await locator.press(keyValue, { timeout: this.timeoutMs });
+      return { success: true };
+    } catch (error) {
+      if (this.isBrowserClosedError(error)) {
+        return {
+          success: false,
+          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
+          shouldBreak: true
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to press ${key} on ${target}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Execute hover action
+   */
+  async hover(target, relativeTarget) {
+    try {
+      if (target === "relative" && relativeTarget) {
+        const relativeSelector = this.selectors.relative;
+        if (!relativeSelector) {
+          return { success: false, error: `Relative selector not defined for hover action.` };
+        }
+        const element = await RelativeTargetResolver.resolve(this.page, relativeSelector, relativeTarget);
+        if (!element) {
+          return { success: false, error: `Could not resolve relative target ${relativeTarget} for hover.` };
+        }
+        await element.hover({ timeout: this.timeoutMs });
+        return { success: true };
+      }
+      const selector = this.selectors[target];
+      if (!selector) {
+        return { success: false, error: `Selector for hover target ${target} not found.` };
+      }
+      await this.page.locator(selector).first().hover({ timeout: this.timeoutMs });
+      return { success: true };
+    } catch (error) {
+      if (this.isBrowserClosedError(error)) {
+        return {
+          success: false,
+          error: `CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`,
+          shouldBreak: true
+        };
+      }
+      return {
+        success: false,
+        error: `Failed to hover ${target}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+};
+
+// src/utils/test/src/AssertionRunner.ts
+var AssertionRunner = class {
+  constructor(page, selectors, timeoutMs = 400) {
+    this.page = page;
+    this.selectors = selectors;
+    this.timeoutMs = timeoutMs;
+  }
+  /**
+   * Resolve the target element for an assertion
+   */
+  async resolveTarget(targetName, relativeTarget) {
+    try {
+      if (targetName === "relative") {
+        const relativeSelector = this.selectors.relative;
+        if (!relativeSelector) {
+          return { target: null, error: "Relative selector is not defined in the contract." };
+        }
+        if (!relativeTarget) {
+          return { target: null, error: "Relative target or expected value is not defined." };
+        }
+        const target = await RelativeTargetResolver.resolve(this.page, relativeSelector, relativeTarget);
+        if (!target) {
+          return { target: null, error: `Target ${targetName} not found.` };
+        }
+        return { target };
+      }
+      const selector = this.selectors[targetName];
+      if (!selector) {
+        return { target: null, error: `Selector for assertion target ${targetName} not found.` };
+      }
+      return { target: this.page.locator(selector).first() };
+    } catch (error) {
+      return {
+        target: null,
+        error: `Failed to resolve target ${targetName}: ${error instanceof Error ? error.message : String(error)}`
+      };
+    }
+  }
+  /**
+   * Validate visibility assertion
+   */
+  async validateVisibility(target, targetName, expectedVisible, failureMessage, testDescription) {
+    try {
+      if (expectedVisible) {
+        await (0, test_exports.expect)(target).toBeVisible({ timeout: this.timeoutMs });
+        return {
+          success: true,
+          passMessage: `${targetName} is visible as expected. Test: "${testDescription}".`
+        };
+      } else {
+        await (0, test_exports.expect)(target).toBeHidden({ timeout: this.timeoutMs });
+        return {
+          success: true,
+          passMessage: `${targetName} is not visible as expected. Test: "${testDescription}".`
+        };
+      }
+    } catch {
+      const selector = this.selectors[targetName] || "";
+      const debugState = await this.page.evaluate((sel) => {
+        const el = sel ? document.querySelector(sel) : null;
+        if (!el) return "element not found";
+        const styles = window.getComputedStyle(el);
+        return `display:${styles.display}, visibility:${styles.visibility}, opacity:${styles.opacity}`;
+      }, selector);
+      if (expectedVisible) {
+        return {
+          success: false,
+          failMessage: `${failureMessage} (actual: ${debugState})`
+        };
+      } else {
+        return {
+          success: false,
+          failMessage: `${failureMessage} ${targetName} is still visible (actual: ${debugState}).`
+        };
+      }
+    }
+  }
+  /**
+   * Validate attribute assertion
+   */
+  async validateAttribute(target, targetName, attribute, expectedValue, failureMessage, testDescription) {
+    if (expectedValue === "!empty") {
+      const attributeValue2 = await target.getAttribute(attribute);
+      if (attributeValue2 && attributeValue2.trim() !== "") {
+        return {
+          success: true,
+          passMessage: `${targetName} has non-empty "${attribute}". Test: "${testDescription}".`
+        };
+      } else {
+        return {
+          success: false,
+          failMessage: `${failureMessage} ${targetName} "${attribute}" should not be empty, found "${attributeValue2}".`
+        };
+      }
+    }
+    const expectedValues = expectedValue.split(" | ").map((v) => v.trim());
+    const attributeValue = await target.getAttribute(attribute);
+    if (attributeValue !== null && expectedValues.includes(attributeValue)) {
+      return {
+        success: true,
+        passMessage: `${targetName} has expected "${attribute}". Test: "${testDescription}".`
+      };
+    } else {
+      return {
+        success: false,
+        failMessage: `${failureMessage} ${targetName} "${attribute}" should be "${expectedValue}", found "${attributeValue}".`
+      };
+    }
+  }
+  /**
+   * Validate input value assertion
+   */
+  async validateValue(target, targetName, expectedValue, failureMessage, testDescription) {
+    const inputValue = await target.inputValue().catch(() => "");
+    if (expectedValue === "!empty") {
+      if (inputValue && inputValue.trim() !== "") {
+        return {
+          success: true,
+          passMessage: `${targetName} has non-empty value. Test: "${testDescription}".`
+        };
+      } else {
+        return {
+          success: false,
+          failMessage: `${failureMessage} ${targetName} value should not be empty, found "${inputValue}".`
+        };
+      }
+    }
+    if (expectedValue === "") {
+      if (inputValue === "") {
+        return {
+          success: true,
+          passMessage: `${targetName} has empty value. Test: "${testDescription}".`
+        };
+      } else {
+        return {
+          success: false,
+          failMessage: `${failureMessage} ${targetName} value should be empty, found "${inputValue}".`
+        };
+      }
+    }
+    if (inputValue === expectedValue) {
+      return {
+        success: true,
+        passMessage: `${targetName} has expected value. Test: "${testDescription}".`
+      };
+    } else {
+      return {
+        success: false,
+        failMessage: `${failureMessage} ${targetName} value should be "${expectedValue}", found "${inputValue}".`
+      };
+    }
+  }
+  /**
+   * Validate focus assertion
+   */
+  async validateFocus(target, targetName, failureMessage, testDescription) {
+    try {
+      await (0, test_exports.expect)(target).toBeFocused({ timeout: this.timeoutMs });
+      return {
+        success: true,
+        passMessage: `${targetName} has focus as expected. Test: "${testDescription}".`
+      };
+    } catch {
+      const actualFocus = await this.page.evaluate(() => {
+        const focused = document.activeElement;
+        return focused ? `${focused.tagName}#${focused.id || "no-id"}.${focused.className || "no-class"}` : "no element focused";
+      });
+      return {
+        success: false,
+        failMessage: `${failureMessage} (actual focus: ${actualFocus})`
+      };
+    }
+  }
+  /**
+   * Validate role assertion
+   */
+  async validateRole(target, targetName, expectedRole, failureMessage, testDescription) {
+    const roleValue = await target.getAttribute("role");
+    if (roleValue === expectedRole) {
+      return {
+        success: true,
+        passMessage: `${targetName} has role "${expectedRole}". Test: "${testDescription}".`
+      };
+    } else {
+      return {
+        success: false,
+        failMessage: `${failureMessage} Expected role "${expectedRole}", found "${roleValue}".`
+      };
+    }
+  }
+  /**
+   * Main validation method - routes to specific validators
+   */
+  async validate(assertion, testDescription) {
+    if (this.page.isClosed()) {
+      return {
+        success: false,
+        failMessage: `CRITICAL: Browser/page closed before completing all tests. Increase test timeout or reduce test complexity.`
+      };
+    }
+    const { target, error } = await this.resolveTarget(assertion.target, assertion.relativeTarget || assertion.expectedValue);
+    if (error || !target) {
+      return { success: false, failMessage: error || `Target ${assertion.target} not found.`, target: null };
+    }
+    switch (assertion.assertion) {
+      case "toBeVisible":
+        return this.validateVisibility(target, assertion.target, true, assertion.failureMessage || "", testDescription);
+      case "notToBeVisible":
+        return this.validateVisibility(target, assertion.target, false, assertion.failureMessage || "", testDescription);
+      case "toHaveAttribute":
+        if (assertion.attribute && assertion.expectedValue !== void 0) {
+          return this.validateAttribute(
+            target,
+            assertion.target,
+            assertion.attribute,
+            assertion.expectedValue,
+            assertion.failureMessage || "",
+            testDescription
+          );
+        }
+        return { success: false, failMessage: "Missing attribute or expectedValue for toHaveAttribute assertion" };
+      case "toHaveValue":
+        if (assertion.expectedValue !== void 0) {
+          return this.validateValue(target, assertion.target, assertion.expectedValue, assertion.failureMessage || "", testDescription);
+        }
+        return { success: false, failMessage: "Missing expectedValue for toHaveValue assertion" };
+      case "toHaveFocus":
+        return this.validateFocus(target, assertion.target, assertion.failureMessage || "", testDescription);
+      case "toHaveRole":
+        if (assertion.expectedValue !== void 0) {
+          return this.validateRole(target, assertion.target, assertion.expectedValue, assertion.failureMessage || "", testDescription);
+        }
+        return { success: false, failMessage: "Missing expectedValue for toHaveRole assertion" };
+      default:
+        return { success: false, failMessage: `Unknown assertion type: ${assertion.assertion}` };
+    }
+  }
+};
+
+// src/utils/test/src/contractTestRunnerPlaywright.ts
+async function runContractTestsPlaywright(componentName, url) {
+  const reporter = new ContractReporter(true);
+  const actionTimeoutMs = 400;
+  const assertionTimeoutMs = 400;
+  const contractTyped = contract_default;
+  const contractPath = contractTyped[componentName]?.path;
+  const resolvedPath = new URL(contractPath, import.meta.url).pathname;
+  const contractData = readFileSync2(resolvedPath, "utf-8");
+  const componentContract = JSON.parse(contractData);
+  const totalTests = componentContract.static[0].assertions.length + componentContract.dynamic.length;
+  const apgUrl = componentContract.meta?.source?.apg;
+  const failures = [];
+  const passes = [];
+  const skipped = [];
+  let page = null;
+  try {
+    page = await createTestPage();
+    if (url) {
+      try {
+        await page.goto(url, {
+          waitUntil: "domcontentloaded",
+          timeout: 3e4
+        });
+      } catch (error) {
+        throw new Error(
+          `Failed to navigate to ${url}. Ensure dev server is running and accessible. Original error: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      await page.addStyleTag({ content: `* { transition: none !important; animation: none !important; }` });
+    }
+    const strategy = ComponentDetector.detect(componentName, actionTimeoutMs, assertionTimeoutMs);
+    if (!strategy) {
+      throw new Error(`Unsupported component: ${componentName}`);
+    }
+    const mainSelector = strategy.getMainSelector();
+    if (!mainSelector) {
+      throw new Error(`CRITICAL: No selector found in contract for ${componentName}`);
+    }
+    try {
+      await page.locator(mainSelector).first().waitFor({ state: "attached", timeout: 3e4 });
+    } catch (error) {
+      throw new Error(
+        `
+\u274C CRITICAL: Component not found on page!
+This usually means:
+  - The component didn't render
+  - The URL is incorrect
+  - The component selector '${mainSelector}' in the contract is wrong
+  - Original error: ${error}`
+      );
+    }
+    reporter.start(componentName, totalTests, apgUrl);
+    if (componentName === "menu" && componentContract.selectors.trigger) {
+      await page.locator(componentContract.selectors.trigger).first().waitFor({
+        state: "attached",
+        timeout: 5e3
+      }).catch(() => {
+      });
+    }
+    const failuresBeforeStatic = failures.length;
+    const staticAssertionRunner = new AssertionRunner(page, componentContract.selectors, assertionTimeoutMs);
+    for (const test of componentContract.static[0]?.assertions || []) {
+      if (test.target === "relative") continue;
+      const staticDescription = `${test.target}${test.attribute ? ` (${test.attribute})` : ""}`;
+      const targetSelector = componentContract.selectors[test.target];
+      if (!targetSelector) {
+        const failure = `Selector for target ${test.target} not found.`;
+        failures.push(failure);
+        reporter.reportStaticTest(staticDescription, false, failure);
+        continue;
+      }
+      const target = page.locator(targetSelector).first();
+      const exists = await target.count() > 0;
+      if (!exists) {
+        const failure = `Target ${test.target} not found.`;
+        failures.push(failure);
+        reporter.reportStaticTest(staticDescription, false, failure);
+        continue;
+      }
+      const isRedundantCheck = (selector, attrName, expectedVal) => {
+        const attrPattern = new RegExp(`\\[${attrName}(?:=["']?([^\\]"']+)["']?)?\\]`);
+        const match = selector.match(attrPattern);
+        if (!match) return false;
+        if (!expectedVal) return true;
+        const selectorValue = match[1];
+        if (selectorValue) {
+          const expectedValues = expectedVal.split(" | ");
+          return expectedValues.includes(selectorValue);
+        }
+        return false;
+      };
+      if (!test.expectedValue) {
+        const attributes = test.attribute.split(" | ");
+        let hasAny = false;
+        let allRedundant = true;
+        for (const attr of attributes) {
+          const attrTrimmed = attr.trim();
+          if (isRedundantCheck(targetSelector, attrTrimmed)) {
+            passes.push(`${attrTrimmed} on ${test.target} verified by selector (already present in: ${targetSelector}).`);
+            hasAny = true;
+            continue;
+          }
+          allRedundant = false;
+          const value = await target.getAttribute(attrTrimmed);
+          if (value !== null) {
+            hasAny = true;
+            break;
+          }
+        }
+        if (!hasAny && !allRedundant) {
+          const failure = test.failureMessage + ` None of the attributes "${test.attribute}" are present.`;
+          failures.push(failure);
+          reporter.reportStaticTest(staticDescription, false, failure);
+        } else if (!allRedundant && hasAny) {
+          passes.push(`At least one of the attributes "${test.attribute}" exists on the element.`);
+          reporter.reportStaticTest(staticDescription, true);
+        } else {
+          reporter.reportStaticTest(staticDescription, true);
+        }
+      } else {
+        if (isRedundantCheck(targetSelector, test.attribute, test.expectedValue)) {
+          passes.push(`${test.attribute}="${test.expectedValue}" on ${test.target} verified by selector (already present in: ${targetSelector}).`);
+          reporter.reportStaticTest(staticDescription, true);
+        } else {
+          const result = await staticAssertionRunner.validateAttribute(
+            target,
+            test.target,
+            test.attribute,
+            test.expectedValue,
+            test.failureMessage,
+            "Static ARIA Test"
+          );
+          if (result.success && result.passMessage) {
+            passes.push(result.passMessage);
+            reporter.reportStaticTest(staticDescription, true);
+          } else if (!result.success && result.failMessage) {
+            failures.push(result.failMessage);
+            reporter.reportStaticTest(staticDescription, false, result.failMessage);
+          }
+        }
+      }
+    }
+    for (const dynamicTest of componentContract.dynamic || []) {
+      if (!page || page.isClosed()) {
+        console.warn(`
+\u26A0\uFE0F  Browser closed - skipping remaining ${componentContract.dynamic.length - componentContract.dynamic.indexOf(dynamicTest)} tests
+`);
+        failures.push(`CRITICAL: Browser/page closed before completing all tests. ${componentContract.dynamic.length - componentContract.dynamic.indexOf(dynamicTest)} tests skipped.`);
+        break;
+      }
+      const { action, assertions } = dynamicTest;
+      const failuresBeforeTest = failures.length;
+      try {
+        await strategy.resetState(page);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        reporter.error(errorMessage);
+        throw error;
+      }
+      const shouldSkipTest = await strategy.shouldSkipTest(dynamicTest, page);
+      if (shouldSkipTest) {
+        reporter.reportTest(dynamicTest, "skip", `Skipping test - component-specific conditions not met`);
+        continue;
+      }
+      const actionExecutor = new ActionExecutor(page, componentContract.selectors, actionTimeoutMs);
+      const assertionRunner = new AssertionRunner(page, componentContract.selectors, assertionTimeoutMs);
+      for (const act of action) {
+        if (!page || page.isClosed()) {
+          failures.push(`CRITICAL: Browser/page closed during test execution. Remaining actions skipped.`);
+          break;
+        }
+        let result;
+        if (act.type === "focus") {
+          result = await actionExecutor.focus(act.target);
+        } else if (act.type === "type" && act.value) {
+          result = await actionExecutor.type(act.target, act.value);
+        } else if (act.type === "click") {
+          result = await actionExecutor.click(act.target, act.relativeTarget);
+        } else if (act.type === "keypress" && act.key) {
+          result = await actionExecutor.keypress(act.target, act.key);
+        } else if (act.type === "hover") {
+          result = await actionExecutor.hover(act.target, act.relativeTarget);
+        } else {
+          continue;
+        }
+        if (!result.success) {
+          if (result.error) {
+            failures.push(result.error);
+          }
+          if (result.shouldBreak) {
+            if (result.error?.includes("optional submenu test")) {
+              reporter.reportTest(dynamicTest, "skip", result.error);
+            }
+            break;
+          }
+          continue;
+        }
+      }
+      for (const assertion of assertions) {
+        const result = await assertionRunner.validate(assertion, dynamicTest.description);
+        if (result.success && result.passMessage) {
+          passes.push(result.passMessage);
+        } else if (!result.success && result.failMessage) {
+          failures.push(result.failMessage);
+        }
+      }
+      const failuresAfterTest = failures.length;
+      const testPassed = failuresAfterTest === failuresBeforeTest;
+      const failureMessage = testPassed ? void 0 : failures[failures.length - 1];
+      if (dynamicTest.isOptional === true && !testPassed) {
+        failures.pop();
+        reporter.reportTest(dynamicTest, "optional-fail", failureMessage);
+      } else {
+        reporter.reportTest(dynamicTest, testPassed ? "pass" : "fail", failureMessage);
+      }
+    }
+    const staticTotal = componentContract.static[0].assertions.length;
+    const staticFailed = failures.length - failuresBeforeStatic;
+    const staticPassed = Math.max(0, staticTotal - staticFailed);
+    reporter.reportStatic(staticPassed, staticFailed);
+    reporter.summary(failures);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.message.includes("Executable doesn't exist") || error.message.includes("browserType.launch")) {
+        throw new Error("\n\u274C CRITICAL: Playwright browsers not found!\n\u{1F4E6} Run: npx playwright install chromium");
+      } else if (error.message.includes("net::ERR_CONNECTION_REFUSED") || error.message.includes("NS_ERROR_CONNECTION_REFUSED")) {
+        throw new Error(`
+\u274C CRITICAL: Cannot connect to dev server!
+Make sure your dev server is running at ${url}`);
+      } else if (error.message.includes("Timeout") && error.message.includes("waitFor")) {
+        throw new Error(
+          "\n\u274C CRITICAL: Component not found on page!\nThe component selector could not be found within 30 seconds.\nThis usually means:\n  - The component didn't render\n  - The URL is incorrect\n  - The component selector was not provided to the component utility, or a wrong selector was used\n"
+        );
+      } else if (error.message.includes("Target page, context or browser has been closed")) {
+        throw new Error(
+          "\n\u274C CRITICAL: Browser/page was closed unexpectedly!\nThis usually means:\n  - The test timeout was too short\n  - The browser crashed\n  - An external process killed the browser"
+        );
+      } else {
+        throw error;
+      }
+    }
+  } finally {
+    if (page) await page.close();
+  }
+  return { passes, failures, skipped };
+}
+export {
+  runContractTestsPlaywright
+};