aria-ease 6.9.1 → 6.11.0

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

@@ -1,4 +1,206 @@
-// src/utils/test/dsl/index.ts
+// 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: [
+      {
+        when: ["keyboard", "textInput"],
+        steps: () => [
+          { type: "keypress", target: "input", key: "ArrowDown" }
+        ]
+      },
+      {
+        when: ["pointer"],
+        steps: () => [
+          { type: "click", target: "button" }
+        ]
+      }
+    ],
+    assertion: isComboboxOpen
+  },
+  "listbox.closed": {
+    setup: [
+      {
+        when: ["keyboard"],
+        steps: () => [
+          /* { type: "keypress", target: "input", key: "Escape" } */
+        ]
+      },
+      {
+        when: ["pointer"],
+        steps: () => [
+          /* { type: "click", target: "button" } */
+        ]
+      }
+    ],
+    assertion: isComboboxClosed
+  },
+  "input.focused": {
+    setup: [
+      {
+        when: ["keyboard"],
+        steps: () => [
+          { type: "focus", target: "input" }
+        ]
+      }
+    ],
+    assertion: isInputFocused
+  },
+  "input.filled": {
+    setup: [
+      {
+        when: ["keyboard", "textInput"],
+        steps: () => [
+          { type: "type", target: "input", value: "test" }
+        ]
+      }
+    ],
+    assertion: isInputFilled
+  },
+  "activeOption.first": {
+    requires: ["listbox.open"],
+    setup: [
+      {
+        when: ["keyboard"],
+        steps: () => [
+          { type: "keypress", target: "input", key: "ArrowDown" }
+        ]
+      }
+    ],
+    assertion: isActiveDescendantNotEmpty
+  },
+  "activeOption.last": {
+    requires: ["activeOption.first"],
+    setup: [
+      {
+        when: ["keyboard"],
+        steps: () => [
+          { type: "keypress", target: "input", key: "ArrowUp" }
+        ]
+      }
+    ],
+    assertion: isActiveDescendantNotEmpty
+  },
+  "selectedOption.first": {
+    requires: ["listbox.open"],
+    setup: [
+      {
+        when: ["pointer"],
+        steps: () => [
+          { type: "click", target: "relative", relativeTarget: "first" }
+        ]
+      }
+    ],
+    assertion: () => isAriaSelected("first")
+  },
+  "selectedOption.last": {
+    requires: ["listbox.open"],
+    setup: [
+      {
+        when: ["pointer"],
+        steps: () => [
+          { type: "click", target: "relative", relativeTarget: "last" }
+        ]
+      }
+    ],
+    assertion: () => isAriaSelected("last")
+  }
+};
+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'"
+    }
+  ];
+}
+function isComboboxClosed() {
+  return [
+    {
+      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'"
+    }
+  ];
+}
+function isActiveDescendantNotEmpty() {
+  return [
+    {
+      target: "input",
+      assertion: "toHaveAttribute",
+      attribute: "aria-activedescendant",
+      expectedValue: "!empty",
+      failureMessage: "Expected aria-activedescendant to not be empty"
+    }
+  ];
+}
+function isAriaSelected(index) {
+  return [
+    {
+      target: "relative",
+      relativeTarget: index,
+      assertion: "toHaveAttribute",
+      attribute: "aria-selected",
+      expectedValue: "true",
+      failureMessage: `Expected ${index} option to have aria-selected='true'`
+    }
+  ];
+}
+function isInputFocused() {
+  return [
+    {
+      target: "input",
+      assertion: "toHaveFocus",
+      failureMessage: "Expected input to be focused"
+    }
+  ];
+}
+function isInputFilled() {
+  return [
+    {
+      target: "input",
+      assertion: "toHaveValue",
+      expectedValue: "test",
+      failureMessage: "Expected input to have the value 'test'"
+    }
+  ];
+}
+
+// src/utils/test/dsl/src/contractBuilder.ts
+var STATE_PACKS = {
+  "combobox.listbox": COMBOBOX_STATES
+  // Add more mappings as needed
+};
 var FluentContract = class {
   constructor(jsonContract) {
     this.jsonContract = jsonContract;
@@ -7,306 +209,173 @@ var FluentContract = class {
     return this.jsonContract;
   }
 };
-var StaticTargetBuilder = class {
-  constructor(targetName, sink) {
-    this.targetName = targetName;
-    this.sink = sink;
-  }
-  has(attribute, expectedValue) {
-    const create = (level) => {
-      this.sink.push({
-        target: this.targetName,
-        attribute,
-        expectedValue,
-        failureMessage: `Expected ${this.targetName} to have ${attribute}${expectedValue !== void 0 ? `=${expectedValue}` : ""}.`,
-        level
-      });
-    };
-    return {
-      required: () => create("required"),
-      recommended: () => create("recommended"),
-      optional: () => create("optional")
-    };
-  }
-};
-var StaticBuilder = class {
-  constructor(sink) {
-    this.sink = sink;
-  }
-  target(targetName) {
-    return new StaticTargetBuilder(targetName, this.sink);
-  }
-};
-var DynamicChain = class {
-  constructor(key, testsSink, selectors) {
-    this.key = key;
-    this.testsSink = testsSink;
-    this.selectors = selectors;
-  }
-  selectorTarget = "";
-  actions = [];
-  assertions = [];
-  explicitDescription = "";
-  on(target) {
-    this.selectorTarget = target;
-    this.actions.push({ type: "keypress", target, key: this.key });
-    return this;
-  }
-  describe(description) {
-    this.explicitDescription = description;
-    return this;
+var ContractBuilder = class {
+  constructor(componentName) {
+    this.componentName = componentName;
+    this.statePack = STATE_PACKS[componentName] || {};
   }
-  focus(targetExpression) {
-    const parsed = this.parseRelativeExpression(targetExpression);
-    if (parsed) {
-      if (!this.selectors[parsed.selectorKey]) {
-        const availableSelectors = Object.keys(this.selectors).sort().join(", ") || "(none)";
-        throw new Error(
-          `Invalid focus target expression "${targetExpression}": selector "${parsed.selectorKey}" is not defined. Available selectors: ${availableSelectors}`
-        );
-      }
-      if (!this.selectors.relative && this.selectors[parsed.selectorKey]) {
-        this.selectors.relative = this.selectors[parsed.selectorKey];
-      }
-      this.assertions.push({
-        target: "relative",
-        assertion: "toHaveFocus",
-        relativeTarget: parsed.relativeTarget
-      });
-    } else {
-      this.assertions.push({
-        target: targetExpression,
-        assertion: "toHaveFocus"
-      });
-    }
+  metaValue = {};
+  selectorsValue = {};
+  relationshipInvariants = [];
+  staticAssertions = [];
+  dynamicTests = [];
+  statePack;
+  meta(meta) {
+    this.metaValue = meta;
     return this;
   }
-  visible(target) {
-    this.assertions.push({ target, assertion: "toBeVisible" });
+  selectors(selectors) {
+    this.selectorsValue = selectors;
     return this;
   }
-  hidden(target) {
-    this.assertions.push({ target, assertion: "notToBeVisible" });
+  relationships(fn) {
+    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" })
+      }),
+      contains: (parent, child) => ({
+        required: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "required" }),
+        optional: () => this.relationshipInvariants.push({ type: "contains", parent, child, level: "optional" })
+      })
+    };
+    fn(api);
     return this;
   }
-  has(target, attribute, expectedValue) {
-    this.assertions.push({
-      target,
-      assertion: "toHaveAttribute",
-      attribute,
-      expectedValue
-    });
+  static(fn) {
+    const api = {
+      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" })
+        })
+      })
+    };
+    fn(api);
     return this;
   }
-  required() {
-    this.finalize("required");
+  when(event) {
+    return new DynamicTestBuilder(this, this.statePack, event);
   }
-  recommended() {
-    this.finalize("recommended");
+  addDynamicTest(test) {
+    this.dynamicTests.push(test);
   }
-  optional() {
-    this.finalize("optional");
-  }
-  finalize(level) {
-    if (!this.selectorTarget) {
-      throw new Error("Dynamic contract chain requires .on(<selectorKey>) before level terminator.");
-    }
-    const description = this.explicitDescription || `Pressing ${this.key} on ${this.selectorTarget} satisfies expected behavior.`;
-    this.testsSink.push({
-      description,
-      level,
-      action: this.actions,
-      assertions: this.assertions.map((a) => ({ ...a, level }))
-    });
-  }
-  parseRelativeExpression(input) {
-    const match = input.match(/^(next|previous|first|last)\(([^)]+)\)$/);
-    if (!match) return null;
-    const relativeTarget = match[1];
-    const selectorKey = match[2].trim();
-    return { relativeTarget, selectorKey };
+  build() {
+    return {
+      meta: this.metaValue,
+      selectors: this.selectorsValue,
+      relationships: this.relationshipInvariants.length ? this.relationshipInvariants : void 0,
+      static: this.staticAssertions.length ? [{ assertions: this.staticAssertions }] : [],
+      dynamic: this.dynamicTests
+    };
   }
 };
-var ContractBuilder = class {
-  constructor(componentName) {
-    this.componentName = componentName;
+var DynamicTestBuilder = class {
+  constructor(parent, statePack, event) {
+    this.parent = parent;
+    this.statePack = statePack;
+    this.event = event;
   }
-  metaValue = {};
-  selectorsValue = {};
-  relationshipInvariants = [];
-  staticAssertions = [];
-  dynamicTests = [];
-  meta(meta) {
-    this.metaValue = { ...this.metaValue, ...meta };
+  _as;
+  _on;
+  _given = [];
+  _then = [];
+  _desc = "";
+  _level = "required";
+  as(actionType) {
+    this._as = actionType;
     return this;
   }
-  selectors(selectors) {
-    this.selectorsValue = { ...this.selectorsValue, ...selectors };
+  on(target) {
+    this._on = target;
     return this;
   }
-  relationship(invariant) {
-    this.relationshipInvariants.push(invariant);
+  given(states) {
+    this._given = Array.isArray(states) ? states : [states];
     return this;
   }
-  relationships(builderFn) {
-    builderFn({
-      ariaReference: (from, attribute, to) => {
-        const create = (level) => {
-          this.relationshipInvariants.push({
-            type: "aria-reference",
-            from,
-            attribute,
-            to,
-            level
-          });
-        };
-        return {
-          required: () => create("required"),
-          recommended: () => create("recommended"),
-          optional: () => create("optional")
-        };
-      },
-      contains: (parent, child) => {
-        const create = (level) => {
-          this.relationshipInvariants.push({
-            type: "contains",
-            parent,
-            child,
-            level
-          });
-        };
-        return {
-          required: () => create("required"),
-          recommended: () => create("recommended"),
-          optional: () => create("optional")
-        };
-      }
-    });
+  then(states) {
+    this._then = Array.isArray(states) ? states : [states];
     return this;
   }
-  static(builderFn) {
-    builderFn(new StaticBuilder(this.staticAssertions));
+  describe(desc) {
+    this._desc = desc;
     return this;
   }
-  when(key) {
-    return new DynamicChain(key, this.dynamicTests, this.selectorsValue);
+  required() {
+    this._level = "required";
+    this._finalize();
+    return this.parent;
   }
-  validateRelationshipInvariants() {
-    if (this.relationshipInvariants.length === 0) {
-      return;
-    }
-    const selectorKeys = new Set(Object.keys(this.selectorsValue));
-    const available = Object.keys(this.selectorsValue).sort().join(", ");
-    const errors = [];
-    this.relationshipInvariants.forEach((invariant, index) => {
-      const prefix = `relationships[${index}] (${invariant.type})`;
-      if (invariant.type === "aria-reference") {
-        if (!selectorKeys.has(invariant.from)) {
-          errors.push(`${prefix}: "from" references unknown selector "${invariant.from}"`);
-        }
-        if (!selectorKeys.has(invariant.to)) {
-          errors.push(`${prefix}: "to" references unknown selector "${invariant.to}"`);
+  optional() {
+    this._level = "optional";
+    this._finalize();
+    return this.parent;
+  }
+  recommended() {
+    this._level = "recommended";
+    this._finalize();
+    return this.parent;
+  }
+  _finalize() {
+    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];
+      if (!s) return [];
+      let actions = [];
+      if (Array.isArray(s.requires)) {
+        for (const req of s.requires) {
+          actions = actions.concat(resolveAllSetups(req, visited));
         }
       }
-      if (invariant.type === "contains") {
-        if (!selectorKeys.has(invariant.parent)) {
-          errors.push(`${prefix}: "parent" references unknown selector "${invariant.parent}"`);
-        }
-        if (!selectorKeys.has(invariant.child)) {
-          errors.push(`${prefix}: "child" references unknown selector "${invariant.child}"`);
+      if (s.setup) actions = actions.concat(resolveSetup(s.setup, ctx));
+      return actions;
+    };
+    const setup = [];
+    for (const state of this._given) {
+      setup.push(...resolveAllSetups(state));
+    }
+    const assertions = [];
+    for (const state of this._then) {
+      const s = this.statePack[state];
+      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);
       }
-    });
-    if (errors.length > 0) {
-      const availableSelectorsMessage = available.length > 0 ? available : "(none)";
-      throw new Error(
-        [
-          `Contract invariant validation failed for component "${this.componentName}".`,
-          ...errors.map((error) => `- ${error}`),
-          `Available selectors: ${availableSelectorsMessage}`
-        ].join("\n")
-      );
     }
-  }
-  validateStaticTargets() {
-    const selectorKeys = new Set(Object.keys(this.selectorsValue));
-    const available = Object.keys(this.selectorsValue).sort().join(", ") || "(none)";
-    const errors = [];
-    this.staticAssertions.forEach((assertion, index) => {
-      if (!selectorKeys.has(assertion.target)) {
-        errors.push(`static.assertions[${index}]: target "${assertion.target}" is not defined in selectors`);
+    const action = [
+      {
+        type: this._as,
+        target: this._on,
+        key: this._as === "keypress" ? this.event : void 0
       }
+    ];
+    this.parent.addDynamicTest({
+      description: this._desc || "",
+      level: this._level,
+      action,
+      assertions,
+      ...setup.length ? { setup } : {}
     });
-    if (errors.length > 0) {
-      throw new Error(
-        [
-          `Contract static target validation failed for component "${this.componentName}".`,
-          ...errors.map((error) => `- ${error}`),
-          `Available selectors: ${available}`
-        ].join("\n")
-      );
-    }
-  }
-  validateDynamicTargets() {
-    const selectorKeys = new Set(Object.keys(this.selectorsValue));
-    const available = Object.keys(this.selectorsValue).sort().join(", ") || "(none)";
-    const errors = [];
-    const isValidActionTarget = (target) => {
-      return selectorKeys.has(target) || target === "document" || target === "relative";
-    };
-    const isValidAssertionTarget = (target) => {
-      return selectorKeys.has(target) || target === "relative";
-    };
-    this.dynamicTests.forEach((test, testIndex) => {
-      test.action.forEach((action, actionIndex) => {
-        if (!isValidActionTarget(action.target)) {
-          errors.push(
-            `dynamic[${testIndex}].action[${actionIndex}]: target "${action.target}" is not defined in selectors`
-          );
-        }
-      });
-      test.assertions.forEach((assertion, assertionIndex) => {
-        if (!isValidAssertionTarget(assertion.target)) {
-          errors.push(
-            `dynamic[${testIndex}].assertions[${assertionIndex}]: target "${assertion.target}" is not defined in selectors`
-          );
-        }
-        if (assertion.target === "relative" && !this.selectorsValue.relative) {
-          errors.push(
-            `dynamic[${testIndex}].assertions[${assertionIndex}]: target "relative" requires selectors.relative to be defined`
-          );
-        }
-      });
-    });
-    if (errors.length > 0) {
-      throw new Error(
-        [
-          `Contract dynamic target validation failed for component "${this.componentName}".`,
-          ...errors.map((error) => `- ${error}`),
-          `Available selectors: ${available}`,
-          `Allowed special targets: document, relative`
-        ].join("\n")
-      );
-    }
-  }
-  build() {
-    this.validateRelationshipInvariants();
-    this.validateStaticTargets();
-    this.validateDynamicTargets();
-    const fallbackId = this.metaValue.id || `aria-ease.contract.${this.componentName}`;
-    return {
-      meta: {
-        id: fallbackId,
-        version: this.metaValue.version || "1.0.0",
-        description: this.metaValue.description || `Fluent contract for ${this.componentName}`,
-        source: this.metaValue.source,
-        W3CName: this.metaValue.W3CName
-      },
-      selectors: this.selectorsValue,
-      relationships: this.relationshipInvariants,
-      static: [{ assertions: this.staticAssertions }],
-      dynamic: this.dynamicTests
-    };
   }
 };
 function createContract(componentName, define) {