@testspectra/react 1.1.8-rc.24 → 1.1.8-rc.28

package/dist/cli.js

@@ -10,6 +10,11 @@ import { createRequire } from "node:module";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+function resolveEsmUrl(specifier, packageDir) {
+  const cjsPath = createRequire(path.join(packageDir, "package.json")).resolve(specifier);
+  const esmPath = cjsPath.replace(/\.cjs$/, ".js");
+  return pathToFileURL(existsSync(esmPath) ? esmPath : cjsPath).href;
+}
 function buildAutoImportManifest(root) {
   function scanEntityDir(subdir, filePattern) {
     const dir = path.join(root, subdir);
@@ -42,15 +47,17 @@ function buildAutoImportManifest(root) {
   };
 }
 function generateVitestConfig(opts) {
-  const req = createRequire(path.join(opts.packageDir, "package.json"));
-  const reactPluginUrl = pathToFileURL(req.resolve("@vitejs/plugin-react")).href;
-  const vitestConfigUrl = pathToFileURL(req.resolve("vitest/config")).href;
+  const reactPluginUrl = resolveEsmUrl("@vitejs/plugin-react", opts.packageDir);
+  const vitestConfigUrl = resolveEsmUrl("vitest/config", opts.packageDir);
   const manifest = buildAutoImportManifest(opts.testRoot);
   const setupFile = path.join(opts.packageDir, "dist/setup.js").replace(/\\/g, "/");
+  const reporterFile = path.join(opts.packageDir, "dist/vitest_reporter.js").replace(/\\/g, "/");
+  const reporterUrl = pathToFileURL(reporterFile).href;
   const normalizedPackageDir = opts.packageDir.replace(/\\/g, "/");
   const normalizedTestRoot = opts.testRoot.replace(/\\/g, "/");
   const configContent = `import react from '${reactPluginUrl}';
 import { defineConfig } from '${vitestConfigUrl}';
+${opts.semanticReporter ? `import { SpectraVitestReporter } from '${reporterUrl}';` : ""}
 
 export default defineConfig({
   root: ${JSON.stringify(normalizedPackageDir)},
@@ -80,7 +87,10 @@ export default defineConfig({
   test: {
     globals: true,
     setupFiles: [${JSON.stringify(setupFile)}],
-    reporters: ${opts.semanticReporter ? "[]" : "'default'"},
+    reporters: ${opts.semanticReporter ? `[
+      new SpectraVitestReporter({ testRoot: ${JSON.stringify(normalizedTestRoot)} }),
+      ${opts.outputFile ? `['json', { outputFile: ${JSON.stringify(opts.outputFile)} }],` : ""}
+    ]` : opts.outputFile ? `['default', ['json', { outputFile: ${JSON.stringify(opts.outputFile)} }]]` : "'default'"},
     dir: ${JSON.stringify(normalizedTestRoot)},
     include: ['specs/**/web.test.tsx', 'specs/**/*.test.tsx'],
     browser: {
@@ -110,6 +120,12 @@ export default defineConfig({
 
 // src/cli.ts
 async function runComponentTests(options = {}) {
+  const runner = options.runner ?? "vitest";
+  if (runner === "spectra") {
+    console.log("TestSpectra native component testing is orchestrated by the Rust Core Engine.");
+    console.log("Use `spectra test` to run tests with full parallel CDP orchestration.");
+    return true;
+  }
   const rawCwd = options.cwd ?? process.cwd();
   const cwd = path2.resolve(rawCwd);
   const packageDir = fileURLToPath(new URL("..", import.meta.url));
@@ -125,12 +141,10 @@ async function runComponentTests(options = {}) {
     stepDelayMs: options.stepDelayMs ?? 0,
     semanticReporter,
     fileParallelism: options.concurrency !== 1,
-    browserExecutable: options.browserExecutablePath
+    browserExecutable: options.browserExecutablePath,
+    outputFile: options.outputFile
   });
   const args = ["run", "--config", configPath];
-  if (options.outputFile) {
-    args.push("--reporter=default", "--reporter=json", `--outputFile.json=${options.outputFile}`);
-  }
   if (options.spec) {
     let specPattern = options.spec.replace(/\\/g, "/");
     if (path2.isAbsolute(options.spec)) {
@@ -167,8 +181,18 @@ async function runComponentTests(options = {}) {
   });
 }
 function getFlagValue(argv, ...names) {
-  const index = argv.findIndex((a) => names.includes(a));
-  return index !== -1 ? argv[index + 1] : void 0;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    for (const name of names) {
+      if (arg === name) {
+        return argv[i + 1];
+      }
+      if (arg.startsWith(`${name}=`)) {
+        return arg.slice(name.length + 1);
+      }
+    }
+  }
+  return void 0;
 }
 async function runCli(argv = process.argv.slice(2)) {
   const [command] = argv;
@@ -179,7 +203,9 @@ async function runCli(argv = process.argv.slice(2)) {
   let headless = true;
   if (argv.includes("--headed") || argv.includes("--no-headless")) headless = false;
   else if (argv.includes("--headless")) headless = true;
-  const rawDelay = getFlagValue(argv, "--step-delay", "--delay");
+  const rawRunner = getFlagValue(argv, "--runner", "-r");
+  const runner = rawRunner === "vitest" ? "vitest" : "spectra";
+  const rawDelay = getFlagValue(argv, "--step-delay", "--delay", "-d");
   let stepDelayMs;
   if (rawDelay !== void 0) {
     const parsed = parseInt(String(rawDelay), 10);
@@ -188,8 +214,11 @@ async function runCli(argv = process.argv.slice(2)) {
   let spec = getFlagValue(argv, "--spec", "-s");
   if (!spec) {
     const flagsWithValues = /* @__PURE__ */ new Set([
+      "--runner",
+      "-r",
       "--step-delay",
       "--delay",
+      "-d",
       "--spec",
       "-s",
       "--output",
@@ -216,7 +245,15 @@ async function runCli(argv = process.argv.slice(2)) {
     if (!isNaN(parsed) && parsed >= 1) concurrency = parsed;
   }
   const browserExecutablePath = getFlagValue(argv, "--browser-executable");
-  const ok = await runComponentTests({ headless, stepDelayMs, spec, outputFile, concurrency, browserExecutablePath });
+  const ok = await runComponentTests({
+    runner,
+    headless,
+    stepDelayMs,
+    spec,
+    outputFile,
+    concurrency,
+    browserExecutablePath
+  });
   process.exit(ok ? 0 : 1);
 }
 export {

package/dist/index.d.ts

@@ -7,6 +7,7 @@ export declare class DomDriverBridge implements PlatformDriverBridge {
 export declare function mount<P = any>(element: any): Promise<any>;
 
 export interface RunComponentTestsOptions {
+  runner?: 'spectra' | 'vitest';
   cwd?: string;
   headless?: boolean;
   stepDelayMs?: number;
@@ -17,6 +18,37 @@ export interface RunComponentTestsOptions {
   onLine?: (line: string) => void;
 }
 
+export interface BundleServer {
+  url: string;
+  stop(): void;
+}
+
+export interface BundleServerOptions {
+  testRoot?: string;
+  packageDir?: string;
+  manifest?: any;
+  stepDelayMs?: number;
+}
+
+export declare function startBundleServer(opts?: BundleServerOptions): Promise<BundleServer>;
 export declare function runComponentTests(options?: RunComponentTestsOptions): Promise<boolean>;
 export declare function runCli(argv?: string[]): Promise<void>;
-export type { ExpectStatic } from 'vitest';
+export declare function sanitizeError(err: unknown): string;
+export declare function sanitizeErrorMessage(msg: string): string;
+export declare function sanitizeViteUrl(text: string): string;
+export declare function sanitizeStackTrace(stack: string): string;
+export declare function isVitestNoise(line: string): boolean;
+
+export interface AssertionMatchers<T = unknown> {
+  toBe(expected: T): void;
+  toEqual(expected: unknown): void;
+  toBeTruthy(): void;
+  toBeFalsy(): void;
+  toBeNull(): void;
+  toBeUndefined(): void;
+  toBeDefined(): void;
+  toContain(item: unknown): void;
+  not: AssertionMatchers<T>;
+}
+
+export type ExpectStatic = <T = unknown>(actual: T) => AssertionMatchers<T>;