aria-ease 6.10.0 → 6.12.0

package/dist/index.cjs

@@ -31,31 +31,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/utils/test/contract/contract.json
-var contract_default;
-var init_contract = __esm({
-  "src/utils/test/contract/contract.json"() {
-    contract_default = {
-      menu: {
-        path: "./aria-contracts/menu/menu.contract.json",
-        component: "menu"
-      },
-      "combobox.listbox": {
-        path: "./aria-contracts/combobox/combobox.listbox.contract.json",
-        component: "combobox.listbox"
-      },
-      accordion: {
-        path: "./aria-contracts/accordion/accordion.contract.json",
-        component: "accordion"
-      },
-      tabs: {
-        path: "./aria-contracts/tabs/tabs.contract.json",
-        component: "tabs"
-      }
-    };
-  }
-});
-
 // src/utils/test/src/ContractReporter.ts
 var ContractReporter;
 var init_ContractReporter = __esm({
@@ -480,8 +455,8 @@ function validateConfig(config) {
               if (typeof comp.name !== "string") {
                 errors.push(`test.components[${idx}].name must be a string`);
               }
-              if (comp.path !== void 0 && typeof comp.path !== "string") {
-                errors.push(`test.components[${idx}].path must be a string when provided`);
+              if (comp.contractPath !== void 0 && typeof comp.contractPath !== "string") {
+                errors.push(`test.components[${idx}].contractPath 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`);
@@ -885,12 +860,6 @@ var init_StrategyRegistry = __esm({
             (m) => m.TabsComponentStrategy
           )
         );
-        this.builtInStrategies.set(
-          "combobox.listbox",
-          () => Promise.resolve().then(() => (init_ComboboxComponentStrategy(), ComboboxComponentStrategy_exports)).then(
-            (m) => m.ComboboxComponentStrategy
-          )
-        );
       }
       /**
        * Load a strategy - either from custom path or built-in registry
@@ -937,15 +906,14 @@ var init_StrategyRegistry = __esm({
 });
 
 // src/utils/test/src/ComponentDetector.ts
-var import_fs, import_path3, import_meta2, ComponentDetector;
+var import_fs, import_path3, import_meta, ComponentDetector;
 var init_ComponentDetector = __esm({
   "src/utils/test/src/ComponentDetector.ts"() {
     "use strict";
     import_fs = require("fs");
     import_path3 = __toESM(require("path"), 1);
-    init_contract();
     init_StrategyRegistry();
-    import_meta2 = {};
+    import_meta = {};
     ComponentDetector = class {
       static strategyRegistry = new StrategyRegistry();
       static isComponentConfig(value) {
@@ -965,11 +933,7 @@ var init_ComponentDetector = __esm({
        */
       static async detect(componentName, componentConfig, actionTimeoutMs = 400, assertionTimeoutMs = 400, configBaseDir) {
         const typedComponentConfig = this.isComponentConfig(componentConfig) ? componentConfig : void 0;
-        let contractPath = typedComponentConfig?.path;
-        if (!contractPath) {
-          const contractTyped = contract_default;
-          contractPath = contractTyped[componentName]?.path;
-        }
+        const contractPath = typedComponentConfig?.contractPath;
         if (!contractPath) {
           throw new Error(`Contract path not found for component: ${componentName}`);
         }
@@ -988,7 +952,7 @@ var init_ComponentDetector = __esm({
             (0, import_fs.readFileSync)(cwdResolved, "utf-8");
             return cwdResolved;
           } catch {
-            return new URL(contractPath, import_meta2.url).pathname;
+            return new URL(contractPath, import_meta.url).pathname;
           }
         })();
         const contractData = (0, import_fs.readFileSync)(resolvedPath, "utf-8");
@@ -1002,7 +966,7 @@ var init_ComponentDetector = __esm({
         if (!strategyClass) {
           return null;
         }
-        const mainSelector = selectors.trigger || selectors.input || selectors.tablist || selectors.container;
+        const mainSelector = selectors.main;
         if (componentName === "tabs") {
           return new strategyClass(mainSelector, selectors);
         }
@@ -1577,7 +1541,7 @@ __export(contractTestRunnerPlaywright_exports, {
 });
 async function runContractTestsPlaywright(componentName, url, strictness, config, configBaseDir) {
   const componentConfig = config?.test?.components?.find((c) => c.name === componentName);
-  const isCustomContract = !!componentConfig?.path;
+  const isCustomContract = !!componentConfig?.contractPath;
   const reporter = new ContractReporter(true, isCustomContract);
   const defaultTimeouts = {
     actionTimeoutMs: 400,
@@ -1617,11 +1581,7 @@ async function runContractTestsPlaywright(componentName, url, strictness, config
     defaultTimeouts.componentReadyTimeoutMs
   );
   const strictnessMode = normalizeStrictness(strictness);
-  let contractPath = componentConfig?.path;
-  if (!contractPath) {
-    const contractTyped = contract_default;
-    contractPath = contractTyped[componentName]?.path;
-  }
+  const contractPath = componentConfig?.contractPath;
   if (!contractPath) {
     throw new Error(`Contract path not found for component: ${componentName}`);
   }
@@ -1640,7 +1600,7 @@ async function runContractTestsPlaywright(componentName, url, strictness, config
       (0, import_fs2.readFileSync)(cwdResolved, "utf-8");
       return cwdResolved;
     } catch {
-      return new URL(contractPath, import_meta3.url).pathname;
+      return new URL(contractPath, import_meta2.url).pathname;
     }
   })();
   const contractData = (0, import_fs2.readFileSync)(resolvedPath, "utf-8");
@@ -2112,20 +2072,19 @@ This usually means:
   }
   return { passes, failures, skipped, warnings };
 }
-var import_fs2, import_path4, import_meta3;
+var import_fs2, import_path4, import_meta2;
 var init_contractTestRunnerPlaywright = __esm({
   "src/utils/test/src/contractTestRunnerPlaywright.ts"() {
     "use strict";
     import_fs2 = require("fs");
     import_path4 = __toESM(require("path"), 1);
-    init_contract();
     init_playwrightTestHarness();
     init_ComponentDetector();
     init_ContractReporter();
     init_ActionExecutor();
     init_AssertionRunner();
     init_strictness();
-    import_meta3 = {};
+    import_meta2 = {};
   }
 });
 
@@ -3761,90 +3720,141 @@ function makeTabsAccessible({ tabListId, tabsClass, tabPanelsClass, orientation
 }
 
 // src/utils/test/dsl/src/state-packs/comboboxStatePack.ts
+function hasCapabilities(ctx, requiredCaps) {
+  return requiredCaps.some((cap) => ctx.capabilities.includes(cap));
+}
+function resolveSetup(setup, ctx) {
+  if (Array.isArray(setup) && setup.length && !setup[0].when) {
+    setup = [{ when: ["keyboard"], steps: () => setup }];
+  }
+  for (const strat of setup) {
+    if (hasCapabilities(ctx, strat.when)) {
+      return strat.steps(ctx);
+    }
+  }
+  throw new Error(
+    `No setup strategy matches capabilities: ${ctx.capabilities.join(", ")}`
+  );
+}
 var COMBOBOX_STATES = {
   "listbox.open": {
-    setup: openCombobox(),
-    assertion: isComboboxOpen()
+    setup: [
+      {
+        when: ["keyboard", "textInput"],
+        steps: () => [
+          { type: "keypress", target: "input", key: "ArrowDown" }
+        ]
+      },
+      {
+        when: ["pointer"],
+        steps: () => [
+          { type: "click", target: "button" }
+        ]
+      }
+    ],
+    assertion: isComboboxOpen
   },
   "listbox.closed": {
-    setup: closeCombobox(),
-    assertion: isComboboxClosed()
+    setup: [
+      {
+        when: ["keyboard"],
+        steps: () => [
+          /* { type: "keypress", target: "input", key: "Escape" } */
+        ]
+      },
+      {
+        when: ["pointer"],
+        steps: () => [
+          /* { type: "click", target: "button" } */
+        ]
+      }
+    ],
+    assertion: isComboboxClosed
   },
   "input.focused": {
-    setup: focusInput(),
-    assertion: [
-      ...isInputFocused()
-    ]
+    setup: [
+      {
+        when: ["keyboard"],
+        steps: () => [
+          { type: "focus", target: "input" }
+        ]
+      }
+    ],
+    assertion: isInputFocused
   },
   "input.filled": {
-    setup: fillInput(),
-    assertion: [
-      ...isInputFilled()
-    ]
+    setup: [
+      {
+        when: ["keyboard", "textInput"],
+        steps: () => [
+          { type: "type", target: "input", value: "test" }
+        ]
+      }
+    ],
+    assertion: isInputFilled
   },
   "activeOption.first": {
     requires: ["listbox.open"],
     setup: [
-      { type: "keypress", target: "input", key: "ArrowDown" }
+      {
+        when: ["keyboard"],
+        steps: () => [
+          { type: "keypress", target: "input", key: "ArrowDown" }
+        ]
+      }
     ],
-    assertion: [
-      ...isActiveDescendantNotEmpty()
-    ]
+    assertion: isActiveDescendantNotEmpty
   },
   "activeOption.last": {
     requires: ["activeOption.first"],
     setup: [
-      { type: "keypress", target: "input", key: "ArrowUp" }
+      {
+        when: ["keyboard"],
+        steps: () => [
+          { type: "keypress", target: "input", key: "ArrowUp" }
+        ]
+      }
     ],
-    assertion: [
-      ...isActiveDescendantNotEmpty()
-    ]
+    assertion: isActiveDescendantNotEmpty
   },
   "selectedOption.first": {
     requires: ["listbox.open"],
     setup: [
-      { type: "click", target: "relative", relativeTarget: "first" }
+      {
+        when: ["pointer"],
+        steps: () => [
+          { type: "click", target: "relative", relativeTarget: "first" }
+        ]
+      }
     ],
-    assertion: [
-      ...isAriaSelected("first")
-    ]
+    assertion: () => isAriaSelected("first")
   },
   "selectedOption.last": {
     requires: ["listbox.open"],
     setup: [
-      { type: "click", target: "relative", relativeTarget: "last" }
+      {
+        when: ["pointer"],
+        steps: () => [
+          { type: "click", target: "relative", relativeTarget: "last" }
+        ]
+      }
     ],
-    assertion: [
-      ...isAriaSelected("first")
-    ]
+    assertion: () => isAriaSelected("last")
   }
 };
-function openCombobox() {
-  return [
-    { type: "keypress", target: "input", key: "ArrowDown" }
-  ];
-}
-function closeCombobox() {
-  return [
-    { type: "keypress", target: "input", key: "Escape" }
-  ];
-}
-function focusInput() {
-  return [
-    { type: "focus", target: "input" }
-  ];
-}
-function fillInput() {
-  return [
-    { type: "type", target: "input", value: "test" }
-  ];
-}
 function isComboboxOpen() {
   return [
     {
       target: "listbox",
       assertion: "toBeVisible",
       failureMessage: "Expected listbox to be visible"
+    },
+    {
+      target: "input",
+      assertion: "toHaveAttribute",
+      attribute: "aria-expanded",
+      expectedValue: "true",
+      failureMessage: "Expect combobox input to have aria-expanded='true'"
     }
   ];
 }
@@ -3854,6 +3864,13 @@ function isComboboxClosed() {
       target: "listbox",
       assertion: "notToBeVisible",
       failureMessage: "Expected listbox to be closed"
+    },
+    {
+      target: "input",
+      assertion: "toHaveAttribute",
+      attribute: "aria-expanded",
+      expectedValue: "false",
+      failureMessage: "Expect combobox input to have aria-expanded='false'"
     }
   ];
 }
@@ -3876,7 +3893,7 @@ function isAriaSelected(index) {
       assertion: "toHaveAttribute",
       attribute: "aria-selected",
       expectedValue: "true",
-      failureMessage: `Expected aria-selected on ${index} option to be true`
+      failureMessage: `Expected ${index} option to have aria-selected='true'`
     }
   ];
 }
@@ -3902,7 +3919,7 @@ function isInputFilled() {
 
 // src/utils/test/dsl/src/contractBuilder.ts
 var STATE_PACKS = {
-  "combobox.listbox": COMBOBOX_STATES
+  "combobox": COMBOBOX_STATES
   // Add more mappings as needed
 };
 var FluentContract = class {
@@ -3936,11 +3953,13 @@ var ContractBuilder = class {
     const api = {
       ariaReference: (from, attribute, to) => ({
         required: () => this.relationshipInvariants.push({ type: "aria-reference", from, attribute, to, level: "required" }),
-        optional: () => this.relationshipInvariants.push({ type: "aria-reference", from, attribute, to, level: "optional" })
+        optional: () => this.relationshipInvariants.push({ type: "aria-reference", from, attribute, to, level: "optional" }),
+        recommended: () => this.relationshipInvariants.push({ type: "aria-reference", from, attribute, to, level: "recommended" })
       }),
       contains: (parent, child) => ({
         required: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "required" }),
-        optional: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "optional" })
+        optional: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "optional" }),
+        recommended: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "recommended" })
       })
     };
     fn(api);
@@ -3951,7 +3970,8 @@ var ContractBuilder = class {
       target: (target) => ({
         has: (attribute, expectedValue) => ({
           required: () => this.staticAssertions.push({ target, attribute, expectedValue, failureMessage: "", level: "required" }),
-          optional: () => this.staticAssertions.push({ target, attribute, expectedValue, failureMessage: "", level: "optional" })
+          optional: () => this.staticAssertions.push({ target, attribute, expectedValue, failureMessage: "", level: "optional" }),
+          recommended: () => this.staticAssertions.push({ target, attribute, expectedValue, failureMessage: "", level: "recommended" })
         })
       })
     };
@@ -4022,7 +4042,17 @@ var DynamicTestBuilder = class {
     return this.parent;
   }
   _finalize() {
-    const resolveSetup = (stateName, visited = /* @__PURE__ */ new Set()) => {
+    const capabilityMap = {
+      keypress: "keyboard",
+      click: "pointer",
+      type: "textInput",
+      focus: "keyboard",
+      hover: "pointer"
+      // add more mappings as needed
+    };
+    const capability = capabilityMap[this._as || "keyboard"] || (this._as || "keyboard");
+    const ctx = { capabilities: [capability] };
+    const resolveAllSetups = (stateName, visited = /* @__PURE__ */ new Set()) => {
       if (visited.has(stateName)) return [];
       visited.add(stateName);
       const s = this.statePack[stateName];
@@ -4030,22 +4060,30 @@ var DynamicTestBuilder = class {
       let actions = [];
       if (Array.isArray(s.requires)) {
         for (const req of s.requires) {
-          actions = actions.concat(resolveSetup(req, visited));
+          actions = actions.concat(resolveAllSetups(req, visited));
         }
       }
-      if (s.setup) actions = actions.concat(s.setup);
+      if (s.setup) actions = actions.concat(resolveSetup(s.setup, ctx));
       return actions;
     };
     const setup = [];
     for (const state of this._given) {
-      setup.push(...resolveSetup(state));
+      setup.push(...resolveAllSetups(state));
     }
     const assertions = [];
     for (const state of this._then) {
       const s = this.statePack[state];
-      if (s && s.assertion) {
-        if (Array.isArray(s.assertion)) assertions.push(...s.assertion);
-        else assertions.push(s.assertion);
+      if (s && s.assertion !== void 0) {
+        let value = s.assertion;
+        if (typeof value === "function") {
+          try {
+            value = value();
+          } catch (e) {
+            throw new Error(`Error calling assertion function for state '${state}': ${e.message}`);
+          }
+        }
+        if (Array.isArray(value)) assertions.push(...value);
+        else assertions.push(value);
       }
     }
     const action = [
@@ -4074,21 +4112,16 @@ function createContract(componentName, define) {
 var import_jest_axe = require("jest-axe");
 
 // src/utils/test/src/contractTestRunner.ts
-init_contract();
 var import_promises = __toESM(require("fs/promises"), 1);
 init_ContractReporter();
 init_strictness();
-var import_meta = {};
-async function runContractTests(componentName, component, strictness) {
+async function runContractTests(contractPath, componentName, component, strictness) {
   const reporter = new ContractReporter(false);
   const strictnessMode = normalizeStrictness(strictness);
-  const contractTyped = contract_default;
-  const contractPath = contractTyped[componentName]?.path;
   if (!contractPath) {
-    throw new Error(`No contract found for component: ${componentName}`);
+    throw new Error(`No contract path provided for component: ${componentName}`);
   }
-  const resolvedPath = new URL(contractPath, import_meta.url).pathname;
-  const contractData = await import_promises.default.readFile(resolvedPath, "utf-8");
+  const contractData = await import_promises.default.readFile(contractPath, "utf-8");
   const componentContract = JSON.parse(contractData);
   const totalTests = (componentContract.relationships?.length || 0) + (componentContract.static[0]?.assertions.length || 0) + componentContract.dynamic.length;
   reporter.start(componentName, totalTests);
@@ -4322,7 +4355,16 @@ Please start your dev server and try again.`
       }
     } else if (component) {
       console.log(`\u{1F3AD} Running component contract tests in JSDOM mode`);
-      contract = await runContractTests(componentName, component, strictness);
+      const contractPath = config.test?.components?.find((comp) => comp?.name === componentName)?.contractPath;
+      if (!contractPath) {
+        throw new Error(`\u274C No contract path found for component: ${componentName}`);
+      }
+      contract = await runContractTests(
+        import_path6.default.resolve(configBaseDir, contractPath),
+        componentName,
+        component,
+        strictness
+      );
     } else {
       throw new Error("\u274C Either component or URL must be provided");
     }

package/dist/index.d.cts

@@ -288,10 +288,12 @@ declare class ContractBuilder {
         ariaReference: (from: string, attribute: string, to: string) => {
             required: () => void;
             optional: () => void;
+            recommended: () => void;
         };
         contains: (parent: string, child: string) => {
             required: () => void;
             optional: () => void;
+            recommended: () => void;
         };
     }) => void): this;
     static(fn: (s: {
@@ -299,6 +301,7 @@ declare class ContractBuilder {
             has: (attribute: string, expectedValue: string) => {
                 required: () => void;
                 optional: () => void;
+                recommended: () => void;
             };
         };
     }) => void): this;

package/dist/index.d.ts

@@ -288,10 +288,12 @@ declare class ContractBuilder {
         ariaReference: (from: string, attribute: string, to: string) => {
             required: () => void;
             optional: () => void;
+            recommended: () => void;
         };
         contains: (parent: string, child: string) => {
             required: () => void;
             optional: () => void;
+            recommended: () => void;
         };
     }) => void): this;
     static(fn: (s: {
@@ -299,6 +301,7 @@ declare class ContractBuilder {
             has: (attribute: string, expectedValue: string) => {
                 required: () => void;
                 optional: () => void;
+                recommended: () => void;
             };
         };
     }) => void): this;