aria-ease 6.7.0 → 6.9.0

package/bin/buildContracts-GBOY7UXG.js

@@ -0,0 +1,437 @@
+import "./chunk-I2KLQ2HA.js";
+
+// src/utils/cli/buildContracts.ts
+import path from "path";
+import fs from "fs-extra";
+import { glob } from "fs/promises";
+import chalk from "chalk";
+
+// src/utils/cli/contractValidator.ts
+function validateContractSchema(contract) {
+  const errors = [];
+  if (!contract || typeof contract !== "object") {
+    return {
+      valid: false,
+      errors: [{ path: "$", message: "Contract must be an object" }]
+    };
+  }
+  const c = contract;
+  if (!c.selectors) {
+    errors.push({ path: "$.selectors", message: "selectors is required" });
+  } else if (typeof c.selectors !== "object" || c.selectors === null || Array.isArray(c.selectors)) {
+    errors.push({ path: "$.selectors", message: "selectors must be an object" });
+  } else {
+    const selectors = c.selectors;
+    Object.entries(selectors).forEach(([key, value]) => {
+      if (typeof value !== "string") {
+        errors.push({ path: `$.selectors['${key}']`, message: "All selectors must be strings" });
+      }
+    });
+  }
+  if (!Array.isArray(c.static)) {
+    errors.push({ path: "$.static", message: "static must be an array" });
+  } else {
+    c.static.forEach((item, idx) => {
+      if (typeof item !== "object" || item === null) {
+        errors.push({ path: `$.static[${idx}]`, message: "static item must be an object" });
+        return;
+      }
+      const staticItem = item;
+      if (!Array.isArray(staticItem.assertions)) {
+        errors.push({
+          path: `$.static[${idx}].assertions`,
+          message: "assertions must be an array"
+        });
+        return;
+      }
+      staticItem.assertions.forEach((assertion, assertIdx) => {
+        if (typeof assertion !== "object" || assertion === null) {
+          errors.push({
+            path: `$.static[${idx}].assertions[${assertIdx}]`,
+            message: "assertion must be an object"
+          });
+          return;
+        }
+        const a = assertion;
+        if (typeof a.target !== "string") {
+          errors.push({
+            path: `$.static[${idx}].assertions[${assertIdx}].target`,
+            message: "target is required and must be a string"
+          });
+        }
+        if (typeof a.attribute !== "string") {
+          errors.push({
+            path: `$.static[${idx}].assertions[${assertIdx}].attribute`,
+            message: "attribute is required and must be a string"
+          });
+        }
+        if (typeof a.failureMessage !== "string") {
+          errors.push({
+            path: `$.static[${idx}].assertions[${assertIdx}].failureMessage`,
+            message: "failureMessage is required and must be a string"
+          });
+        }
+        if (a.level !== void 0 && !["required", "recommended", "optional"].includes(a.level)) {
+          errors.push({
+            path: `$.static[${idx}].assertions[${assertIdx}].level`,
+            message: "level must be one of: required, recommended, optional"
+          });
+        }
+      });
+    });
+  }
+  if (!Array.isArray(c.dynamic)) {
+    errors.push({ path: "$.dynamic", message: "dynamic must be an array" });
+  } else {
+    c.dynamic.forEach((item, idx) => {
+      if (typeof item !== "object" || item === null) {
+        errors.push({ path: `$.dynamic[${idx}]`, message: "dynamic item must be an object" });
+        return;
+      }
+      const dynamicItem = item;
+      if (typeof dynamicItem.description !== "string") {
+        errors.push({
+          path: `$.dynamic[${idx}].description`,
+          message: "description is required and must be a string"
+        });
+      }
+      if (!Array.isArray(dynamicItem.action)) {
+        errors.push({
+          path: `$.dynamic[${idx}].action`,
+          message: "action is required and must be an array"
+        });
+      } else {
+        dynamicItem.action.forEach((action, actIdx) => {
+          if (typeof action !== "object" || action === null) {
+            errors.push({
+              path: `$.dynamic[${idx}].action[${actIdx}]`,
+              message: "action item must be an object"
+            });
+            return;
+          }
+          const a = action;
+          if (typeof a.type !== "string") {
+            errors.push({
+              path: `$.dynamic[${idx}].action[${actIdx}].type`,
+              message: "type is required and must be a string"
+            });
+          }
+          if (typeof a.target !== "string") {
+            errors.push({
+              path: `$.dynamic[${idx}].action[${actIdx}].target`,
+              message: "target is required and must be a string"
+            });
+          }
+        });
+      }
+      if (!Array.isArray(dynamicItem.assertions)) {
+        errors.push({
+          path: `$.dynamic[${idx}].assertions`,
+          message: "assertions is required and must be an array"
+        });
+      } else {
+        dynamicItem.assertions.forEach((assertion, assertIdx) => {
+          if (typeof assertion !== "object" || assertion === null) {
+            errors.push({
+              path: `$.dynamic[${idx}].assertions[${assertIdx}]`,
+              message: "assertion must be an object"
+            });
+            return;
+          }
+          const a = assertion;
+          if (typeof a.target !== "string") {
+            errors.push({
+              path: `$.dynamic[${idx}].assertions[${assertIdx}].target`,
+              message: "target is required and must be a string"
+            });
+          }
+          if (typeof a.assertion !== "string") {
+            errors.push({
+              path: `$.dynamic[${idx}].assertions[${assertIdx}].assertion`,
+              message: "assertion is required and must be a string"
+            });
+          }
+          if (a.level !== void 0 && !["required", "recommended", "optional"].includes(a.level)) {
+            errors.push({
+              path: `$.dynamic[${idx}].assertions[${assertIdx}].level`,
+              message: "level must be one of: required, recommended, optional"
+            });
+          }
+        });
+      }
+    });
+  }
+  if (c.relationships !== void 0) {
+    if (!Array.isArray(c.relationships)) {
+      errors.push({ path: "$.relationships", message: "relationships must be an array" });
+    } else {
+      c.relationships.forEach((rel, idx) => {
+        if (typeof rel !== "object" || rel === null) {
+          errors.push({ path: `$.relationships[${idx}]`, message: "relationship must be an object" });
+          return;
+        }
+        const r = rel;
+        const type = r.type;
+        if (!["aria-reference", "contains"].includes(type)) {
+          errors.push({
+            path: `$.relationships[${idx}].type`,
+            message: "type must be one of: aria-reference, contains"
+          });
+        }
+        if (type === "aria-reference") {
+          if (typeof r.from !== "string") {
+            errors.push({
+              path: `$.relationships[${idx}].from`,
+              message: "from is required for aria-reference and must be a string"
+            });
+          }
+          if (typeof r.attribute !== "string") {
+            errors.push({
+              path: `$.relationships[${idx}].attribute`,
+              message: "attribute is required for aria-reference and must be a string"
+            });
+          }
+          if (typeof r.to !== "string") {
+            errors.push({
+              path: `$.relationships[${idx}].to`,
+              message: "to is required for aria-reference and must be a string"
+            });
+          }
+        } else if (type === "contains") {
+          if (typeof r.parent !== "string") {
+            errors.push({
+              path: `$.relationships[${idx}].parent`,
+              message: "parent is required for contains and must be a string"
+            });
+          }
+          if (typeof r.child !== "string") {
+            errors.push({
+              path: `$.relationships[${idx}].child`,
+              message: "child is required for contains and must be a string"
+            });
+          }
+        }
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function validateRelationshipReferences(contract, selectorKeys) {
+  const errors = [];
+  if (!contract || typeof contract !== "object") {
+    return errors;
+  }
+  const c = contract;
+  const relationships = c.relationships;
+  if (!Array.isArray(relationships)) {
+    return errors;
+  }
+  relationships.forEach((rel, idx) => {
+    const type = rel.type;
+    if (type === "aria-reference") {
+      const from = rel.from;
+      const to = rel.to;
+      if (from && !selectorKeys.has(from)) {
+        errors.push({
+          path: `$.relationships[${idx}].from`,
+          message: `Selector '${from}' not found in selectors`
+        });
+      }
+      if (to && !selectorKeys.has(to)) {
+        errors.push({
+          path: `$.relationships[${idx}].to`,
+          message: `Selector '${to}' not found in selectors`
+        });
+      }
+    } else if (type === "contains") {
+      const parent = rel.parent;
+      const child = rel.child;
+      if (parent && !selectorKeys.has(parent)) {
+        errors.push({
+          path: `$.relationships[${idx}].parent`,
+          message: `Selector '${parent}' not found in selectors`
+        });
+      }
+      if (child && !selectorKeys.has(child)) {
+        errors.push({
+          path: `$.relationships[${idx}].child`,
+          message: `Selector '${child}' not found in selectors`
+        });
+      }
+    }
+  });
+  return errors;
+}
+function validateTargetReferences(contract, selectorKeys) {
+  const errors = [];
+  if (!contract || typeof contract !== "object") {
+    return errors;
+  }
+  const c = contract;
+  const staticItems = c.static;
+  if (Array.isArray(staticItems)) {
+    staticItems.forEach((item, itemIdx) => {
+      const assertions = item.assertions;
+      if (Array.isArray(assertions)) {
+        assertions.forEach((assertion, assertIdx) => {
+          const target = assertion.target;
+          if (target && !selectorKeys.has(target)) {
+            errors.push({
+              path: `$.static[${itemIdx}].assertions[${assertIdx}].target`,
+              message: `Selector '${target}' not found in selectors`
+            });
+          }
+        });
+      }
+    });
+  }
+  const dynamicItems = c.dynamic;
+  if (Array.isArray(dynamicItems)) {
+    dynamicItems.forEach((item, itemIdx) => {
+      const actions = item.action;
+      if (Array.isArray(actions)) {
+        actions.forEach((action, actIdx) => {
+          const target = action.target;
+          if (target && target !== "document" && !selectorKeys.has(target)) {
+            errors.push({
+              path: `$.dynamic[${itemIdx}].action[${actIdx}].target`,
+              message: `Selector '${target}' not found in selectors (or use 'document')`
+            });
+          }
+        });
+      }
+      const assertions = item.assertions;
+      if (Array.isArray(assertions)) {
+        assertions.forEach((assertion, assertIdx) => {
+          const target = assertion.target;
+          if (target && target !== "relative" && !selectorKeys.has(target)) {
+            errors.push({
+              path: `$.dynamic[${itemIdx}].assertions[${assertIdx}].target`,
+              message: `Selector '${target}' not found in selectors (or use 'relative')`
+            });
+          }
+        });
+      }
+    });
+  }
+  return errors;
+}
+
+// src/utils/cli/buildContracts.ts
+async function buildContracts(cwd, config) {
+  const errors = [];
+  const built = [];
+  if (!config.contracts || config.contracts.length === 0) {
+    console.log(chalk.yellow('\u2139\uFE0F  No contracts configured. Add "contracts" array to ariaease.config.js'));
+    return { success: true, built, errors };
+  }
+  try {
+    console.log(chalk.cyanBright("\n\u{1F3D7}\uFE0F  Building contracts...\n"));
+    for (const contractSource of config.contracts) {
+      const srcPattern = path.resolve(cwd, contractSource.src);
+      const outDir = contractSource.out ? path.resolve(cwd, contractSource.out) : void 0;
+      console.log(chalk.gray(`   Pattern: ${contractSource.src}`));
+      if (outDir) {
+        console.log(chalk.gray(`   Output:  ${contractSource.out}
+`));
+      } else {
+        console.log(chalk.gray(`   Output:  Same directory as source
+`));
+      }
+      const contractFiles = [];
+      for await (const file of glob(srcPattern, { cwd })) {
+        contractFiles.push(file);
+      }
+      if (contractFiles.length === 0) {
+        console.log(chalk.yellow(`\u26A0\uFE0F  No contract files found matching pattern: ${contractSource.src}`));
+        continue;
+      }
+      if (outDir) {
+        await fs.ensureDir(outDir);
+      }
+      for (const contractFile of contractFiles) {
+        try {
+          const absolutePath = contractFile.startsWith("/") ? contractFile : path.resolve(cwd, contractFile);
+          const module = await import(`file://${absolutePath}`);
+          let contract = module.default;
+          if (!contract) {
+            const namedExports = Object.entries(module).find(
+              ([, value]) => value && typeof value === "object" && "toJSON" in value
+            );
+            if (namedExports) {
+              contract = namedExports[1];
+            }
+          }
+          if (!contract || typeof contract.toJSON !== "function") {
+            errors.push(`${path.basename(contractFile)}: No contract with toJSON() method found`);
+            continue;
+          }
+          const json = contract.toJSON();
+          const schemaValidation = validateContractSchema(json);
+          if (!schemaValidation.valid) {
+            const errorLines = schemaValidation.errors.map((err) => `     ${chalk.red("\u2717")} ${err.path}: ${err.message}`).join("\n");
+            const errorMsg = `Schema validation failed:
+${errorLines}`;
+            errors.push(`${path.basename(contractFile)}: ${errorMsg}`);
+            console.log(chalk.red(`\u274C ${path.basename(contractFile)}`));
+            console.log(chalk.red(`   ${errorMsg}`));
+            continue;
+          }
+          const selectorKeys = /* @__PURE__ */ new Set();
+          if (json && typeof json === "object" && "selectors" in json) {
+            const selectors = json.selectors;
+            Object.keys(selectors).forEach((key) => selectorKeys.add(key));
+          }
+          const refErrors = [
+            ...validateRelationshipReferences(json, selectorKeys),
+            ...validateTargetReferences(json, selectorKeys)
+          ];
+          if (refErrors.length > 0) {
+            const errorLines = refErrors.map((err) => `     ${chalk.red("\u2717")} ${err.path}: ${err.message}`).join("\n");
+            const errorMsg = `Reference validation failed:
+${errorLines}`;
+            errors.push(`${path.basename(contractFile)}: ${errorMsg}`);
+            console.log(chalk.red(`\u274C ${path.basename(contractFile)}`));
+            console.log(chalk.red(`   ${errorMsg}`));
+            continue;
+          }
+          const contractName = path.basename(contractFile, path.extname(contractFile));
+          const outputFile = outDir ? path.join(outDir, `${contractName}.json`) : path.join(path.dirname(absolutePath), `${contractName}.json`);
+          await fs.writeFile(outputFile, JSON.stringify(json, null, 2) + "\n", "utf-8");
+          const relativePath = path.relative(cwd, outputFile);
+          built.push(relativePath);
+          console.log(chalk.green(`\u2705 ${path.basename(contractFile)} \u2192 ${path.basename(outputFile)}`));
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          const filename = path.basename(contractFile);
+          errors.push(`${filename}: ${errorMsg}`);
+          console.log(chalk.red(`\u274C ${filename}`));
+          console.log(chalk.red(`   Error: ${errorMsg}`));
+        }
+      }
+    }
+    console.log("");
+    if (errors.length === 0) {
+      console.log(chalk.green(`\u2705 Built ${built.length} contract${built.length !== 1 ? "s" : ""} successfully
+`));
+      return { success: true, built, errors };
+    } else {
+      console.log(chalk.yellow(`\u26A0\uFE0F  Built ${built.length} contracts with ${errors.length} error${errors.length !== 1 ? "s" : ""}
+`));
+      return { success: false, built, errors };
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    const msg = `Failed to build contracts: ${errorMsg}`;
+    errors.push(msg);
+    console.log(chalk.red(`\u274C ${msg}
+`));
+    return { success: false, built, errors };
+  }
+}
+export {
+  buildContracts
+};

package/bin/{chunk-VPBHLMAS.js → chunk-LMSKLN5O.js}

@@ -54,6 +54,9 @@ function validateConfig(config) {
               if (comp.path !== void 0 && typeof comp.path !== "string") {
                 errors.push(`test.components[${idx}].path 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`);
+              }
               if (comp.strictness !== void 0 && !["minimal", "balanced", "strict", "paranoid"].includes(comp.strictness)) {
                 errors.push(`test.components[${idx}].strictness must be one of: minimal, balanced, strict, paranoid`);
               }
@@ -68,6 +71,24 @@ function validateConfig(config) {
       }
     }
   }
+  if (cfg.contracts !== void 0) {
+    if (!Array.isArray(cfg.contracts)) {
+      errors.push("contracts must be an array");
+    } else {
+      cfg.contracts.forEach((contract, idx) => {
+        if (typeof contract !== "object" || contract === null) {
+          errors.push(`contracts[${idx}] must be an object`);
+        } else {
+          if (typeof contract.src !== "string") {
+            errors.push(`contracts[${idx}].src is required and must be a string`);
+          }
+          if (contract.out !== void 0 && typeof contract.out !== "string") {
+            errors.push(`contracts[${idx}].out must be a string`);
+          }
+        }
+      });
+    }
+  }
   return { valid: errors.length === 0, errors };
 }
 async function loadConfigFile(filePath) {

package/bin/chunk-PK5L2SAF.js

@@ -0,0 +1,17 @@
+import {
+  __export,
+  __reExport
+} from "./chunk-I2KLQ2HA.js";
+
+// 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";
+
+export {
+  test_exports
+};

package/bin/{chunk-2TOYEY5L.js → chunk-XERMSYEH.js}

@@ -30,11 +30,13 @@ var ContractReporter = class {
   skipped = 0;
   warnings = 0;
   isPlaywright = false;
+  isCustomContract = false;
   apgUrl = "https://www.w3.org/WAI/ARIA/apg/";
   hasPrintedStaticSection = false;
   hasPrintedDynamicSection = false;
-  constructor(isPlaywright = false) {
+  constructor(isPlaywright = false, isCustomContract = false) {
     this.isPlaywright = isPlaywright;
+    this.isCustomContract = isCustomContract;
   }
   log(message) {
     process.stderr.write(message + "\n");
@@ -195,6 +197,13 @@ ${"\u2500".repeat(60)}`);
     const totalPasses = this.staticPasses + dynamicPasses;
     const totalFailures = this.staticFailures + dynamicFailures;
     const totalRun = totalPasses + totalFailures + this.warnings;
+    const getComponentMessage = () => {
+      const componentDisplayName = `${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)}`;
+      if (this.isCustomContract) {
+        return `${componentDisplayName} component validates against your custom accessibility policy \u2713`;
+      }
+      return `${componentDisplayName} component meets Aria-Ease baseline WAI-ARIA expectations \u2713`;
+    };
     if (failures.length > 0) {
       this.reportFailures(failures);
     }
@@ -206,7 +215,7 @@ ${"\u2550".repeat(60)}`);
 `);
     if (totalFailures === 0 && this.skipped === 0 && this.warnings === 0) {
       this.log(`\u2705 All ${totalRun} tests passed!`);
-      this.log(`   ${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)} component meets WAI-ARIA expectations for Roles, States, Properties, and Keyboard Interactions \u2713`);
+      this.log(`   ${getComponentMessage()}`);
     } else if (totalFailures === 0) {
       this.log(`\u2705 ${totalPasses}/${totalRun} tests passed`);
       if (this.skipped > 0) {
@@ -215,7 +224,7 @@ ${"\u2550".repeat(60)}`);
       if (this.warnings > 0) {
         this.log(`\u26A0\uFE0F ${this.warnings} warning${this.warnings > 1 ? "s" : ""}`);
       }
-      this.log(`   ${this.componentName.charAt(0).toUpperCase()}${this.componentName.slice(1)} component meets WAI-ARIA expectations for Roles, States, Properties, and Keyboard Interactions \u2713`);
+      this.log(`   ${getComponentMessage()}`);
     } else {
       this.log(`\u274C ${totalFailures} test${totalFailures > 1 ? "s" : ""} failed`);
       this.log(`\u2705 ${totalPasses} test${totalPasses > 1 ? "s" : ""} passed`);