@fragments-sdk/cli 0.2.2

package/dist/test-SQ5ZHXWU.js

@@ -0,0 +1,1067 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  discoverSegmentFiles,
+  parseSegmentFile
+} from "./chunk-OAENNG3G.js";
+import "./chunk-XHNKNI6J.js";
+
+// src/test/index.ts
+import { resolve as resolve2, join as join2 } from "path";
+import { mkdir as mkdir3 } from "fs/promises";
+import pc3 from "picocolors";
+
+// src/test/discovery.ts
+import { readFile } from "fs/promises";
+async function discoverTests(config, configDir, options = {}) {
+  const files = await discoverSegmentFiles(config, configDir);
+  const variants = [];
+  for (const file of files) {
+    try {
+      const content = await readFile(file.absolutePath, "utf-8");
+      const parsed = parseSegmentFile(content, file.relativePath);
+      if (!parsed.meta.name) continue;
+      if (options.component) {
+        const componentMatch = parsed.meta.name.toLowerCase().includes(options.component.toLowerCase());
+        if (!componentMatch) continue;
+      }
+      const componentTags = parsed.meta.tags || [];
+      for (const variant of parsed.variants) {
+        const hasPlay = hasPlayFunctionInSource(content, variant.name);
+        if (!hasPlay) continue;
+        if (options.tags && options.tags.length > 0) {
+          const hasMatchingTag = options.tags.some(
+            (tag) => componentTags.some((ct) => ct.toLowerCase().includes(tag.toLowerCase()))
+          );
+          if (!hasMatchingTag) continue;
+        }
+        if (options.grep) {
+          const pattern = new RegExp(options.grep, "i");
+          const matchesName = pattern.test(variant.name);
+          const matchesComponent = pattern.test(parsed.meta.name);
+          if (!matchesName && !matchesComponent) continue;
+        }
+        if (options.exclude) {
+          const pattern = new RegExp(options.exclude, "i");
+          const excludeName = pattern.test(variant.name);
+          const excludeComponent = pattern.test(parsed.meta.name);
+          if (excludeName || excludeComponent) continue;
+        }
+        variants.push({
+          component: parsed.meta.name,
+          variant: variant.name,
+          tags: componentTags,
+          hasPlayFunction: true,
+          storyId: void 0,
+          // Not available from static parsing
+          sourceFile: file.relativePath
+        });
+      }
+    } catch {
+      continue;
+    }
+  }
+  return variants.map((v) => ({
+    id: `${v.component}--${v.variant}`.replace(/\s+/g, "-").toLowerCase(),
+    component: v.component,
+    variant: v.variant,
+    tags: v.tags,
+    play: null,
+    // Play function loaded at runtime in browser
+    sourceFile: v.sourceFile,
+    storyId: v.storyId
+  }));
+}
+function hasPlayFunctionInSource(content, variantName) {
+  const patterns = [
+    // Export const VariantName = { ... play: ... }
+    new RegExp(`export\\s+const\\s+${escapeRegExp(variantName)}\\s*=\\s*\\{[^}]*\\bplay\\s*:`, "s"),
+    // variants: [{ name: 'VariantName', ... play: ... }]
+    new RegExp(`name\\s*:\\s*['"\`]${escapeRegExp(variantName)}['"\`][^}]*\\bplay\\s*:`, "s"),
+    // In case the variant has play in its definition object
+    new RegExp(`['"\`]${escapeRegExp(variantName)}['"\`]\\s*:\\s*\\{[^}]*\\bplay\\s*:`, "s")
+  ];
+  return patterns.some((pattern) => pattern.test(content));
+}
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function groupTestsByComponent(testCases) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const test of testCases) {
+    const existing = groups.get(test.component) || [];
+    existing.push(test);
+    groups.set(test.component, existing);
+  }
+  return groups;
+}
+function getUniqueTags(testCases) {
+  const tags = /* @__PURE__ */ new Set();
+  for (const test of testCases) {
+    for (const tag of test.tags) {
+      tags.add(tag);
+    }
+  }
+  return Array.from(tags).sort();
+}
+function getUniqueComponents(testCases) {
+  const components = /* @__PURE__ */ new Set();
+  for (const test of testCases) {
+    components.add(test.component);
+  }
+  return Array.from(components).sort();
+}
+
+// src/test/runner.ts
+async function runTests(testCases, options, reporters = []) {
+  const startTime = /* @__PURE__ */ new Date();
+  const results = [];
+  for (const reporter of reporters) {
+    reporter.onRunStart?.(testCases.length);
+  }
+  let playwright;
+  try {
+    playwright = await import("playwright");
+  } catch {
+    throw new Error(
+      "Playwright is required for running tests. Install it with: npm install -D playwright"
+    );
+  }
+  const browserType = playwright[options.browser];
+  const browser = await browserType.launch({
+    headless: options.headless
+  });
+  const pool = await createBrowserPool(browser, options.parallel);
+  try {
+    const serverUrl = options.serverUrl || `http://localhost:${options.port}`;
+    if (options.parallel > 1) {
+      await runTestsParallel(
+        testCases,
+        pool,
+        serverUrl,
+        options,
+        reporters,
+        results
+      );
+    } else {
+      await runTestsSequential(
+        testCases,
+        pool.contexts[0],
+        serverUrl,
+        options,
+        reporters,
+        results
+      );
+    }
+  } finally {
+    await cleanupBrowserPool(pool);
+  }
+  const endTime = /* @__PURE__ */ new Date();
+  const suites = aggregateResults(results);
+  const runResult = {
+    suites,
+    totalTests: results.length,
+    totalPassed: results.filter((r) => r.status === "passed").length,
+    totalFailed: results.filter((r) => r.status === "failed").length,
+    totalSkipped: results.filter((r) => r.status === "skipped").length,
+    totalDuration: endTime.getTime() - startTime.getTime(),
+    startTime,
+    endTime,
+    totalA11yViolations: options.a11y ? results.reduce((sum, r) => sum + (r.accessibility?.violations.length || 0), 0) : void 0
+  };
+  for (const reporter of reporters) {
+    await reporter.onRunComplete(runResult);
+  }
+  return runResult;
+}
+async function createBrowserPool(browser, parallelism) {
+  const contexts = [];
+  for (let i = 0; i < parallelism; i++) {
+    const context = await browser.newContext({
+      viewport: { width: 1280, height: 720 }
+    });
+    const page = await context.newPage();
+    contexts.push({ id: i, context, page, busy: false });
+  }
+  return { browser, contexts };
+}
+async function cleanupBrowserPool(pool) {
+  for (const entry of pool.contexts) {
+    await entry.page.close();
+    await entry.context.close();
+  }
+  await pool.browser.close();
+}
+async function runTestsSequential(testCases, ctx, serverUrl, options, reporters, results) {
+  for (const testCase of testCases) {
+    for (const reporter of reporters) {
+      reporter.onTestStart?.(testCase);
+    }
+    const result = await runSingleTest(testCase, ctx, serverUrl, options);
+    results.push(result);
+    for (const reporter of reporters) {
+      reporter.onTestComplete?.(result);
+    }
+    if (options.bail && result.status === "failed") {
+      break;
+    }
+  }
+}
+async function runTestsParallel(testCases, pool, serverUrl, options, reporters, results) {
+  const queue = [...testCases];
+  const inFlight = [];
+  let bailTriggered = false;
+  const acquireContext = () => {
+    const available = pool.contexts.find((c) => !c.busy);
+    if (available) {
+      available.busy = true;
+      return available;
+    }
+    return null;
+  };
+  const releaseContext = (ctx) => {
+    ctx.busy = false;
+  };
+  const runNext = async () => {
+    if (bailTriggered || queue.length === 0) return;
+    const ctx = acquireContext();
+    if (!ctx) return;
+    const testCase = queue.shift();
+    for (const reporter of reporters) {
+      reporter.onTestStart?.(testCase);
+    }
+    try {
+      const result = await runSingleTest(testCase, ctx, serverUrl, options);
+      results.push(result);
+      for (const reporter of reporters) {
+        reporter.onTestComplete?.(result);
+      }
+      if (options.bail && result.status === "failed") {
+        bailTriggered = true;
+      }
+    } finally {
+      releaseContext(ctx);
+      if (!bailTriggered && queue.length > 0) {
+        const nextPromise = runNext();
+        inFlight.push(nextPromise);
+      }
+    }
+  };
+  const initialBatch = Math.min(pool.contexts.length, queue.length);
+  for (let i = 0; i < initialBatch; i++) {
+    inFlight.push(runNext());
+  }
+  await Promise.all(inFlight);
+}
+async function runSingleTest(testCase, ctx, serverUrl, options) {
+  const { page } = ctx;
+  const startTime = performance.now();
+  const steps = [];
+  let error;
+  let status = "passed";
+  let retryAttempt = 0;
+  const maxAttempts = options.retries + 1;
+  while (retryAttempt < maxAttempts) {
+    try {
+      const url = buildVariantUrl(serverUrl, testCase);
+      await page.goto(url, { waitUntil: "networkidle" });
+      await page.waitForSelector('[data-preview-container="true"]', {
+        timeout: options.timeout
+      });
+      const playResult = await executePlayFunction(page, testCase, options.timeout);
+      if (playResult.error) {
+        error = playResult.error;
+        status = "failed";
+        steps.push(...playResult.steps);
+        if (retryAttempt < maxAttempts - 1) {
+          retryAttempt++;
+          continue;
+        }
+      } else {
+        status = "passed";
+        steps.push(...playResult.steps);
+      }
+      break;
+    } catch (e) {
+      error = {
+        message: e instanceof Error ? e.message : String(e),
+        stack: e instanceof Error ? e.stack : void 0
+      };
+      status = "failed";
+      if (retryAttempt < maxAttempts - 1) {
+        retryAttempt++;
+        continue;
+      }
+      break;
+    }
+  }
+  const duration = performance.now() - startTime;
+  let accessibility;
+  if (options.a11y && status === "passed") {
+    accessibility = await runA11yChecks(page);
+  }
+  let screenshotPath;
+  if (options.visual) {
+    screenshotPath = await captureScreenshot(page, testCase, options.outputDir);
+  }
+  return {
+    testCase,
+    status,
+    duration,
+    steps,
+    error,
+    accessibility,
+    screenshotPath,
+    retryAttempt: retryAttempt > 0 ? retryAttempt : void 0
+  };
+}
+function buildVariantUrl(serverUrl, testCase) {
+  const params = new URLSearchParams({
+    component: testCase.component,
+    variant: testCase.variant,
+    isolated: "true"
+  });
+  return `${serverUrl}?${params.toString()}`;
+}
+async function executePlayFunction(page, testCase, timeout) {
+  const result = await page.evaluate(
+    async ({ component, variant, timeout: timeout2 }) => {
+      const registry = window.__SEGMENTS_REGISTRY__;
+      if (!registry) {
+        return {
+          steps: [],
+          error: { message: "Segments registry not found. Make sure the viewer is loaded." }
+        };
+      }
+      const segment = registry.get(component);
+      if (!segment) {
+        return {
+          steps: [],
+          error: { message: `Component "${component}" not found in registry` }
+        };
+      }
+      const variantDef = segment.variants?.find((v) => v.name === variant);
+      if (!variantDef || !variantDef.play) {
+        return {
+          steps: [],
+          error: { message: `Variant "${variant}" not found or has no play function` }
+        };
+      }
+      const canvasElement = document.querySelector('[data-preview-container="true"]');
+      if (!canvasElement) {
+        return {
+          steps: [],
+          error: { message: "Preview container not found" }
+        };
+      }
+      const steps = [];
+      const step = async (name, fn) => {
+        const stepStart = performance.now();
+        try {
+          await fn();
+          steps.push({
+            name,
+            status: "passed",
+            duration: performance.now() - stepStart
+          });
+        } catch (e) {
+          steps.push({
+            name,
+            status: "failed",
+            duration: performance.now() - stepStart,
+            error: { message: e instanceof Error ? e.message : String(e) }
+          });
+          throw e;
+        }
+      };
+      const timeoutPromise = new Promise((_, reject) => {
+        setTimeout(() => reject(new Error(`Test timed out after ${timeout2}ms`)), timeout2);
+      });
+      try {
+        await Promise.race([
+          variantDef.play({
+            canvasElement,
+            args: {},
+            step
+          }),
+          timeoutPromise
+        ]);
+        if (steps.length === 0) {
+          steps.push({
+            name: "Play function",
+            status: "passed",
+            duration: 0
+          });
+        }
+        return { steps, error: void 0 };
+      } catch (e) {
+        if (!steps.some((s) => s.status === "failed")) {
+          steps.push({
+            name: "Play function",
+            status: "failed",
+            duration: 0,
+            error: { message: e instanceof Error ? e.message : String(e) }
+          });
+        }
+        return {
+          steps,
+          error: { message: e instanceof Error ? e.message : String(e) }
+        };
+      }
+    },
+    { component: testCase.component, variant: testCase.variant, timeout }
+  );
+  return result;
+}
+async function runA11yChecks(page) {
+  try {
+    await page.evaluate(() => {
+      if (window.axe) return;
+      return new Promise((resolve3, reject) => {
+        const script = document.createElement("script");
+        script.src = "https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.8.2/axe.min.js";
+        script.onload = () => resolve3();
+        script.onerror = () => reject(new Error("Failed to load axe-core"));
+        document.head.appendChild(script);
+      });
+    });
+    const results = await page.evaluate(async () => {
+      const axe = window.axe;
+      const container = document.querySelector('[data-preview-container="true"]');
+      if (!container) {
+        return { violations: [], passes: 0 };
+      }
+      const axeResults = await axe.run(container);
+      return {
+        violations: axeResults.violations,
+        passes: axeResults.passes.length
+      };
+    });
+    return {
+      violations: results.violations,
+      passes: results.passes
+    };
+  } catch {
+    return { violations: [], passes: 0 };
+  }
+}
+async function captureScreenshot(page, testCase, outputDir) {
+  const { mkdir: mkdir4, writeFile: writeFile3 } = await import("fs/promises");
+  const { join: join3 } = await import("path");
+  const screenshotsDir = join3(outputDir, "screenshots");
+  await mkdir4(screenshotsDir, { recursive: true });
+  const filename = `${testCase.component}--${testCase.variant}.png`.replace(/\s+/g, "-").toLowerCase();
+  const filepath = join3(screenshotsDir, filename);
+  const container = await page.$('[data-preview-container="true"]');
+  if (container) {
+    const screenshot = await container.screenshot();
+    await writeFile3(filepath, screenshot);
+  }
+  return filepath;
+}
+function aggregateResults(results) {
+  const grouped = groupTestsByComponent(results.map((r) => r.testCase));
+  const suites = [];
+  for (const [componentName, testCases] of grouped) {
+    const componentResults = results.filter((r) => r.testCase.component === componentName);
+    suites.push({
+      name: componentName,
+      tests: componentResults,
+      duration: componentResults.reduce((sum, r) => sum + r.duration, 0),
+      passed: componentResults.filter((r) => r.status === "passed").length,
+      failed: componentResults.filter((r) => r.status === "failed").length,
+      skipped: componentResults.filter((r) => r.status === "skipped").length
+    });
+  }
+  return suites;
+}
+
+// src/test/reporters/console.ts
+import pc from "picocolors";
+function createConsoleReporter(options = {}) {
+  const { verbose = false, showTiming = true } = options;
+  let startTime;
+  let testCount;
+  let currentIndex;
+  return {
+    onRunStart(count) {
+      testCount = count;
+      currentIndex = 0;
+      startTime = Date.now();
+      console.log();
+      console.log(pc.cyan(pc.bold("Segments Test Runner")));
+      console.log(pc.dim(`Running ${count} test${count === 1 ? "" : "s"}...`));
+      console.log();
+    },
+    onTestStart(testCase) {
+      currentIndex++;
+      if (verbose) {
+        const progress = pc.dim(`[${currentIndex}/${testCount}]`);
+        console.log(`${progress} ${pc.dim("Running")} ${testCase.component} \u203A ${testCase.variant}`);
+      }
+    },
+    onTestComplete(result) {
+      const { testCase, status, duration, steps, error, accessibility } = result;
+      const timing = showTiming ? pc.dim(` (${formatDuration(duration)})`) : "";
+      const statusIcon = getStatusIcon(status);
+      const testName = `${testCase.component} \u203A ${testCase.variant}`;
+      if (status === "passed") {
+        console.log(`  ${statusIcon} ${testName}${timing}`);
+        if (accessibility && accessibility.violations.length > 0) {
+          console.log(
+            pc.yellow(`    \u26A0 ${accessibility.violations.length} accessibility violation(s)`)
+          );
+        }
+      } else if (status === "failed") {
+        console.log(`  ${statusIcon} ${pc.red(testName)}${timing}`);
+        if (error) {
+          console.log(pc.red(`    ${error.message}`));
+          if (verbose && error.stack) {
+            console.log(pc.dim(`    ${error.stack.split("\n").slice(1, 4).join("\n    ")}`));
+          }
+        }
+        if (verbose || steps.some((s) => s.status === "failed")) {
+          for (const step of steps) {
+            if (step.status === "failed") {
+              console.log(pc.red(`    \u2717 ${step.name}`));
+              if (step.error) {
+                console.log(pc.red(`      ${step.error.message}`));
+              }
+            } else if (verbose && step.status === "passed") {
+              console.log(pc.dim(`    \u2713 ${step.name}`));
+            }
+          }
+        }
+        if (result.retryAttempt) {
+          console.log(pc.dim(`    (failed after ${result.retryAttempt + 1} attempts)`));
+        }
+      } else if (status === "skipped") {
+        console.log(`  ${statusIcon} ${pc.dim(testName)} ${pc.dim("(skipped)")}`);
+      }
+      if (verbose && status === "passed" && steps.length > 0) {
+        for (const step of steps) {
+          const stepTiming = showTiming ? pc.dim(` ${formatDuration(step.duration)}`) : "";
+          console.log(pc.dim(`    \u2713 ${step.name}${stepTiming}`));
+        }
+      }
+    },
+    onRunComplete(result) {
+      const { totalTests, totalPassed, totalFailed, totalSkipped, totalDuration, suites } = result;
+      console.log();
+      console.log(pc.dim("\u2500".repeat(50)));
+      console.log();
+      if (suites.length > 1) {
+        console.log(pc.bold("Test Suites:"));
+        for (const suite of suites) {
+          const statusIcon = suite.failed > 0 ? pc.red("\u2717") : pc.green("\u2713");
+          const failedText = suite.failed > 0 ? pc.red(`${suite.failed} failed, `) : "";
+          const passedText = suite.passed > 0 ? pc.green(`${suite.passed} passed`) : "";
+          const skippedText = suite.skipped > 0 ? pc.dim(`, ${suite.skipped} skipped`) : "";
+          console.log(`  ${statusIcon} ${suite.name} (${failedText}${passedText}${skippedText})`);
+        }
+        console.log();
+      }
+      console.log(pc.bold("Tests:"));
+      const parts = [];
+      if (totalFailed > 0) {
+        parts.push(pc.red(`${totalFailed} failed`));
+      }
+      if (totalPassed > 0) {
+        parts.push(pc.green(`${totalPassed} passed`));
+      }
+      if (totalSkipped > 0) {
+        parts.push(pc.dim(`${totalSkipped} skipped`));
+      }
+      parts.push(`${totalTests} total`);
+      console.log(`  ${parts.join(", ")}`);
+      console.log(`  ${pc.dim("Time:")} ${formatDuration(totalDuration)}`);
+      if (result.totalA11yViolations !== void 0) {
+        if (result.totalA11yViolations > 0) {
+          console.log(
+            `  ${pc.yellow("Accessibility:")} ${result.totalA11yViolations} violation(s)`
+          );
+        } else {
+          console.log(`  ${pc.green("Accessibility:")} All checks passed`);
+        }
+      }
+      console.log();
+      if (totalFailed > 0) {
+        console.log(pc.red(pc.bold("Test run failed")));
+      } else {
+        console.log(pc.green(pc.bold("Test run passed")));
+      }
+      console.log();
+    }
+  };
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "passed":
+      return pc.green("\u2713");
+    case "failed":
+      return pc.red("\u2717");
+    case "skipped":
+      return pc.dim("\u25CB");
+    default:
+      return " ";
+  }
+}
+function formatDuration(ms) {
+  if (ms < 1e3) {
+    return `${Math.round(ms)}ms`;
+  }
+  if (ms < 6e4) {
+    return `${(ms / 1e3).toFixed(2)}s`;
+  }
+  const minutes = Math.floor(ms / 6e4);
+  const seconds = (ms % 6e4 / 1e3).toFixed(1);
+  return `${minutes}m ${seconds}s`;
+}
+
+// src/test/reporters/junit.ts
+import { writeFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+function createJUnitReporter(options) {
+  const { outputPath, suiteName = "Segments Tests", includeProperties = true } = options;
+  return {
+    async onRunComplete(result) {
+      const xml = generateJUnitXml(result, suiteName, includeProperties);
+      await mkdir(dirname(outputPath), { recursive: true });
+      await writeFile(outputPath, xml, "utf-8");
+    }
+  };
+}
+function generateJUnitXml(result, suiteName, includeProperties) {
+  const lines = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push(
+    `<testsuites name="${escapeXml(suiteName)}" tests="${result.totalTests}" failures="${result.totalFailed}" skipped="${result.totalSkipped}" time="${(result.totalDuration / 1e3).toFixed(3)}">`
+  );
+  for (const suite of result.suites) {
+    lines.push(generateTestSuiteXml(suite, includeProperties));
+  }
+  lines.push("</testsuites>");
+  return lines.join("\n");
+}
+function generateTestSuiteXml(suite, includeProperties) {
+  const lines = [];
+  lines.push(
+    `  <testsuite name="${escapeXml(suite.name)}" tests="${suite.tests.length}" failures="${suite.failed}" skipped="${suite.skipped}" time="${(suite.duration / 1e3).toFixed(3)}">`
+  );
+  if (includeProperties) {
+    lines.push("    <properties>");
+    lines.push(`      <property name="component" value="${escapeXml(suite.name)}"/>`);
+    lines.push("    </properties>");
+  }
+  for (const test of suite.tests) {
+    lines.push(generateTestCaseXml(test));
+  }
+  lines.push("  </testsuite>");
+  return lines.join("\n");
+}
+function generateTestCaseXml(result) {
+  const { testCase, status, duration, error, steps, accessibility } = result;
+  const lines = [];
+  const testName = testCase.variant;
+  const className = testCase.component;
+  const time = (duration / 1e3).toFixed(3);
+  if (status === "passed" && !accessibility?.violations.length) {
+    lines.push(`    <testcase name="${escapeXml(testName)}" classname="${escapeXml(className)}" time="${time}"/>`);
+  } else {
+    lines.push(`    <testcase name="${escapeXml(testName)}" classname="${escapeXml(className)}" time="${time}">`);
+    if (status === "failed") {
+      const message = error?.message || "Test failed";
+      lines.push(`      <failure message="${escapeXml(message)}" type="AssertionError">`);
+      const details = [];
+      const failedSteps = steps.filter((s) => s.status === "failed");
+      if (failedSteps.length > 0) {
+        details.push("Failed steps:");
+        for (const step of failedSteps) {
+          details.push(`  - ${step.name}: ${step.error?.message || "Failed"}`);
+        }
+      }
+      if (error?.stack) {
+        details.push("");
+        details.push("Stack trace:");
+        details.push(error.stack);
+      }
+      if (details.length > 0) {
+        lines.push(escapeXml(details.join("\n")));
+      }
+      lines.push("      </failure>");
+    } else if (status === "skipped") {
+      lines.push("      <skipped/>");
+    }
+    if (accessibility?.violations.length) {
+      lines.push("      <system-out>");
+      lines.push(`Accessibility violations (${accessibility.violations.length}):`);
+      for (const violation of accessibility.violations) {
+        lines.push(`  [${violation.impact}] ${violation.id}: ${violation.description}`);
+        lines.push(`    Help: ${violation.help}`);
+        for (const node of violation.nodes.slice(0, 3)) {
+          lines.push(`    Element: ${node.html.substring(0, 100)}`);
+        }
+        if (violation.nodes.length > 3) {
+          lines.push(`    ... and ${violation.nodes.length - 3} more elements`);
+        }
+      }
+      lines.push("      </system-out>");
+    }
+    lines.push("    </testcase>");
+  }
+  return lines.join("\n");
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;").replace(/[\x00-\x08\x0B\x0C\x0E-\x1F]/g, "");
+}
+
+// src/test/reporters/json.ts
+import { writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+function createJsonReporter(options) {
+  const { outputPath, pretty = true, includeSteps = true, includeStacks = false } = options;
+  return {
+    async onRunComplete(result) {
+      const report = generateJsonReport(result, includeSteps, includeStacks);
+      await mkdir2(dirname2(outputPath), { recursive: true });
+      const json = pretty ? JSON.stringify(report, null, 2) : JSON.stringify(report);
+      await writeFile2(outputPath, json, "utf-8");
+    }
+  };
+}
+function generateJsonReport(result, includeSteps, includeStacks) {
+  const { suites, totalTests, totalPassed, totalFailed, totalSkipped, totalDuration, startTime, endTime } = result;
+  return {
+    meta: {
+      version: "1.0.0",
+      startTime: startTime.toISOString(),
+      endTime: endTime.toISOString(),
+      duration: totalDuration
+    },
+    summary: {
+      total: totalTests,
+      passed: totalPassed,
+      failed: totalFailed,
+      skipped: totalSkipped,
+      passRate: totalTests > 0 ? Math.round(totalPassed / totalTests * 100) : 0,
+      a11yViolations: result.totalA11yViolations
+    },
+    suites: suites.map((suite) => ({
+      name: suite.name,
+      tests: suite.tests.length,
+      passed: suite.passed,
+      failed: suite.failed,
+      skipped: suite.skipped,
+      duration: suite.duration,
+      results: suite.tests.map((test) => {
+        const resultObj = {
+          id: test.testCase.id,
+          component: test.testCase.component,
+          variant: test.testCase.variant,
+          status: test.status,
+          duration: test.duration
+        };
+        if (includeSteps && test.steps.length > 0) {
+          resultObj.steps = test.steps.map((step) => ({
+            name: step.name,
+            status: step.status,
+            duration: step.duration,
+            error: step.error?.message
+          }));
+        }
+        if (test.error) {
+          resultObj.error = {
+            message: test.error.message,
+            stack: includeStacks ? test.error.stack : void 0
+          };
+        }
+        if (test.accessibility) {
+          resultObj.accessibility = {
+            violations: test.accessibility.violations.length,
+            passes: test.accessibility.passes,
+            details: test.accessibility.violations.map((v) => ({
+              id: v.id,
+              impact: v.impact,
+              description: v.description,
+              elements: v.nodes.length
+            }))
+          };
+        }
+        if (test.retryAttempt) {
+          resultObj.retryAttempt = test.retryAttempt;
+        }
+        return resultObj;
+      })
+    }))
+  };
+}
+
+// src/test/watch.ts
+import { watch } from "fs";
+import { resolve, relative } from "path";
+import pc2 from "picocolors";
+async function startWatchMode(config, configDir, runnerOptions, reporters, options = {}) {
+  const { debounceMs = 300, clearConsole = true, runOnStart = true } = options;
+  let debounceTimer = null;
+  let isRunning = false;
+  let pendingFiles = /* @__PURE__ */ new Set();
+  const segmentFiles = await discoverSegmentFiles(config, configDir);
+  const watchPaths = /* @__PURE__ */ new Set();
+  for (const file of segmentFiles) {
+    watchPaths.add(file.absolutePath);
+  }
+  const watchDirs = /* @__PURE__ */ new Set();
+  for (const path of watchPaths) {
+    const dir = resolve(path, "..");
+    watchDirs.add(dir);
+  }
+  console.log();
+  console.log(pc2.cyan(pc2.bold("Segments Test Runner - Watch Mode")));
+  console.log(pc2.dim(`Watching ${watchPaths.size} files in ${watchDirs.size} directories`));
+  console.log(pc2.dim("Press Ctrl+C to stop"));
+  console.log();
+  const runTestsForFiles = async (changedFiles) => {
+    if (isRunning) {
+      for (const file of changedFiles) {
+        pendingFiles.add(file);
+      }
+      return;
+    }
+    isRunning = true;
+    try {
+      if (clearConsole) {
+        console.clear();
+      }
+      console.log(pc2.cyan("Changes detected, running tests..."));
+      console.log(pc2.dim(`Changed: ${changedFiles.map((f) => relative(configDir, f)).join(", ")}`));
+      console.log();
+      const allTests = await discoverTests(config, configDir, {});
+      const changedRelativePaths = changedFiles.map((f) => relative(configDir, f));
+      const testsToRun = changedRelativePaths.length > 0 ? allTests.filter((t) => changedRelativePaths.some((p) => t.sourceFile.includes(p))) : allTests;
+      if (testsToRun.length === 0) {
+        console.log(pc2.yellow("No tests found in changed files"));
+        console.log();
+        return;
+      }
+      await runTests(testsToRun, runnerOptions, reporters);
+    } catch (error) {
+      console.error(pc2.red("Error running tests:"), error);
+    } finally {
+      isRunning = false;
+      if (pendingFiles.size > 0) {
+        const files = Array.from(pendingFiles);
+        pendingFiles.clear();
+        await runTestsForFiles(files);
+      }
+    }
+  };
+  if (runOnStart) {
+    const allTests = await discoverTests(config, configDir, {});
+    if (allTests.length > 0) {
+      await runTests(allTests, runnerOptions, reporters);
+    } else {
+      console.log(pc2.yellow("No tests with play functions found"));
+    }
+    console.log();
+    console.log(pc2.dim("Watching for changes..."));
+    console.log();
+  }
+  const watchers = [];
+  for (const dir of watchDirs) {
+    try {
+      const watcher = watch(dir, { recursive: false }, (eventType, filename) => {
+        if (!filename) return;
+        const fullPath = resolve(dir, filename);
+        if (!watchPaths.has(fullPath)) return;
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        pendingFiles.add(fullPath);
+        debounceTimer = setTimeout(() => {
+          const files = Array.from(pendingFiles);
+          pendingFiles.clear();
+          runTestsForFiles(files);
+        }, debounceMs);
+      });
+      watchers.push(watcher);
+    } catch (error) {
+      console.warn(pc2.yellow(`Warning: Could not watch directory ${dir}`), error);
+    }
+  }
+  const cleanup = () => {
+    console.log();
+    console.log(pc2.dim("Stopping watch mode..."));
+    for (const watcher of watchers) {
+      watcher.close();
+    }
+    if (debounceTimer) {
+      clearTimeout(debounceTimer);
+    }
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  await new Promise(() => {
+  });
+}
+
+// src/test/index.ts
+var DEFAULT_OPTIONS = {
+  parallel: 4,
+  timeout: 3e4,
+  retries: 0,
+  bail: false,
+  browser: "chromium",
+  headless: true,
+  a11y: false,
+  visual: false,
+  updateSnapshots: false,
+  watch: false,
+  reporters: "console",
+  output: "./test-results",
+  port: 6006,
+  ci: false
+};
+async function runTestCommand(config, configDir, options) {
+  const opts = {
+    ...DEFAULT_OPTIONS,
+    ...options
+  };
+  const discoveryOptions = {
+    component: opts.component,
+    tags: opts.tags ? opts.tags.split(",").map((t) => t.trim()) : void 0,
+    grep: opts.grep,
+    exclude: opts.exclude
+  };
+  const runnerOptions = {
+    parallel: opts.parallel,
+    timeout: opts.timeout,
+    retries: opts.retries,
+    bail: opts.bail,
+    a11y: opts.a11y,
+    visual: opts.visual,
+    updateSnapshots: opts.updateSnapshots,
+    outputDir: resolve2(configDir, opts.output),
+    browser: opts.browser,
+    headless: opts.headless,
+    serverUrl: opts.serverUrl,
+    port: opts.port
+  };
+  if (opts.ci) {
+    runnerOptions.headless = true;
+  }
+  console.log(pc3.cyan("\nDiscovering tests..."));
+  const testCases = await discoverTests(config, configDir, discoveryOptions);
+  if (testCases.length === 0) {
+    console.log(pc3.yellow("No tests with play functions found"));
+    const components = getUniqueComponents(testCases);
+    const tags = getUniqueTags(testCases);
+    if (discoveryOptions.component) {
+      console.log(pc3.dim(`  Filtered by component: ${discoveryOptions.component}`));
+    }
+    if (discoveryOptions.tags?.length) {
+      console.log(pc3.dim(`  Filtered by tags: ${discoveryOptions.tags.join(", ")}`));
+    }
+    if (discoveryOptions.grep) {
+      console.log(pc3.dim(`  Filtered by pattern: ${discoveryOptions.grep}`));
+    }
+    console.log();
+    console.log(pc3.dim("Add play functions to your segment variants to enable testing."));
+    console.log();
+    return opts.ci ? 0 : 0;
+  }
+  console.log(pc3.dim(`Found ${testCases.length} test(s)`));
+  await mkdir3(runnerOptions.outputDir, { recursive: true });
+  const reporters = createReporters(opts.reporters, runnerOptions.outputDir, opts.ci);
+  if (opts.watch && !opts.ci) {
+    await startWatchMode(config, configDir, runnerOptions, reporters);
+    return 0;
+  }
+  let result;
+  try {
+    result = await runTests(testCases, runnerOptions, reporters);
+  } catch (error) {
+    console.error(pc3.red("Error running tests:"), error);
+    return 1;
+  }
+  if (opts.ci && result.totalFailed > 0) {
+    return 1;
+  }
+  return result.totalFailed > 0 ? 1 : 0;
+}
+function createReporters(reporterNames, outputDir, ci) {
+  const reporters = [];
+  const names = reporterNames.split(",").map((n) => n.trim().toLowerCase());
+  for (const name of names) {
+    switch (name) {
+      case "console":
+        reporters.push(
+          createConsoleReporter({
+            verbose: !ci,
+            showTiming: true
+          })
+        );
+        break;
+      case "junit":
+        reporters.push(
+          createJUnitReporter({
+            outputPath: join2(outputDir, "junit.xml"),
+            suiteName: "Segments Tests"
+          })
+        );
+        break;
+      case "json":
+        reporters.push(
+          createJsonReporter({
+            outputPath: join2(outputDir, "results.json"),
+            pretty: true,
+            includeSteps: true,
+            includeStacks: !ci
+          })
+        );
+        break;
+      default:
+        console.warn(pc3.yellow(`Unknown reporter: ${name}`));
+    }
+  }
+  if (!names.includes("console") && reporters.length === 0) {
+    reporters.push(createConsoleReporter({ verbose: !ci }));
+  }
+  return reporters;
+}
+async function listTests(config, configDir, options) {
+  const discoveryOptions = {
+    component: options.component,
+    tags: options.tags ? options.tags.split(",").map((t) => t.trim()) : void 0,
+    grep: options.grep,
+    exclude: options.exclude
+  };
+  const testCases = await discoverTests(config, configDir, discoveryOptions);
+  console.log();
+  console.log(pc3.cyan(pc3.bold("Available Tests")));
+  console.log();
+  if (testCases.length === 0) {
+    console.log(pc3.yellow("No tests with play functions found"));
+    return;
+  }
+  const byComponent = /* @__PURE__ */ new Map();
+  for (const test of testCases) {
+    const existing = byComponent.get(test.component) || [];
+    existing.push(test);
+    byComponent.set(test.component, existing);
+  }
+  for (const [component, tests] of byComponent) {
+    console.log(pc3.bold(component));
+    for (const test of tests) {
+      const tags = test.tags.length > 0 ? pc3.dim(` [${test.tags.join(", ")}]`) : "";
+      console.log(`  ${pc3.green("\u203A")} ${test.variant}${tags}`);
+    }
+    console.log();
+  }
+  console.log(pc3.dim(`Total: ${testCases.length} test(s) in ${byComponent.size} component(s)`));
+  console.log();
+}
+export {
+  listTests,
+  runTestCommand
+};
+//# sourceMappingURL=test-SQ5ZHXWU.js.map